#! /usr/bin/env python

##############################################################################
##  DendroPy Phylogenetic Computing Library.
##
##  Copyright 2010-2015 Jeet Sukumaran and Mark T. Holder.
##  All rights reserved.
##
##  See "LICENSE.rst" for terms and conditions of usage.
##
##  If you use this work or any portion thereof in published work,
##  please cite it as:
##
##     Sukumaran, J. and M. T. Holder. 2010. DendroPy: a Python library
##     for phylogenetic computing. Bioinformatics 26: 1569-1571.
##
##############################################################################

"""
Tests creation, reading, update, deletion of Taxon and TaxonNamespace objects.
"""

import collections
import unittest
import copy
from dendropy import Taxon, TaxonNamespace
from dendropy.test.support import compare_and_validate

class TaxonIdentity(compare_and_validate.Comparator, unittest.TestCase):

    def setUp(self):
        self.t1 = Taxon("a")
        self.t2 = Taxon("a")

    def test_equal(self):
        # two distinct |Taxon| objects are never equal, even if all
        # member values are the same.
        self.assertNotEqual(self.t1, self.t2)

    def test_hash_dict_membership(self):
        k = {}
        k[self.t1] = 1
        k[self.t2] = 2
        self.assertEqual(len(k), 2)
        self.assertEqual(k[self.t1], 1)
        self.assertEqual(k[self.t2], 2)
        self.assertIn(self.t1, k)
        self.assertIn(self.t2, k)
        del k[self.t1]
        self.assertNotIn(self.t1, k)
        self.assertIn(self.t2, k)
        self.assertEqual(len(k), 1)
        k1 = {self.t1: 1}
        k2 = {self.t2: 1}
        self.assertIn(self.t1, k1)
        self.assertIn(self.t2, k2)
        self.assertNotIn(self.t2, k1)
        self.assertNotIn(self.t1, k2)

    def test_hash_set_membership(self):
        k = set()
        k.add(self.t1)
        k.add(self.t2)
        self.assertEqual(len(k), 2)
        self.assertIn(self.t1, k)
        self.assertIn(self.t2, k)
        k.discard(self.t1)
        self.assertNotIn(self.t1, k)
        self.assertIn(self.t2, k)
        self.assertEqual(len(k), 1)
        k1 = {self.t1: 1}
        k2 = {self.t2: 1}
        self.assertIn(self.t1, k1)
        self.assertIn(self.t2, k2)
        self.assertNotIn(self.t2, k1)
        self.assertNotIn(self.t1, k2)

# note that compare_and_validate.Comparator must be listed first,
# otherwise setUp will not be called
class TaxonCloning(compare_and_validate.Comparator, unittest.TestCase):

    def test_construct_from_another(self):
        t1 = Taxon("a")
        for t2 in (Taxon(t1), copy.deepcopy(t1), t1.clone(2)):
            self.assertIsNot(t1, t2)
            self.assertNotEqual(t1, t2)
            self.assertEqual(t1.label, t2.label)

    def test_construct_from_another_with_simple_annotations(self):
        t1 = Taxon("a")
        t1.annotations.add_new("a", 0)
        t1.annotations.add_new("b", 1)
        t1.annotations.add_new("c", 3)
        for t2 in (Taxon(t1), copy.deepcopy(t1), t1.clone(2)):
            self.assertIsNot(t1, t2)
            self.assertNotEqual(t1, t2)
            self.assertEqual(t1.label, t2.label)
            self.assertTrue(hasattr(t1, "annotations"))
            self.assertTrue(hasattr(t2, "annotations"))
            self.assertEqual(len(t1.annotations), len(t2.annotations))
            self.compare_distinct_annotables(t1, t2)

    def test_construct_from_another_with_complex_annotations(self):
        t1 = Taxon("a")
        t1.annotations.add_new("a", 0)
        b = t1.annotations.add_new("b", (t1, "label"), is_attribute=True)
        b.annotations.add_new("c", 3)
        for t2 in (Taxon(t1), copy.deepcopy(t1), t1.clone(2)):
            self.assertIsNot(t1, t2)
            self.assertNotEqual(t1, t2)
            self.assertEqual(t1.label, t2.label)
            self.assertTrue(hasattr(t1, "annotations"))
            self.assertTrue(hasattr(t2, "annotations"))
            self.assertEqual(len(t1.annotations), len(t2.annotations))
            self.compare_distinct_annotables(t1, t2)
            t1.label = "x"
            self.assertEqual(t1.annotations[1].value, "x")
            self.assertEqual(t2.annotations[1].value, "a")
            t2.label = "z"
            self.assertEqual(t1.annotations[1].value, "x")
            self.assertEqual(t2.annotations[1].value, "z")
            t1.label = "a"

    def test_simple_copy(self):
        t1 = Taxon("a")
        with self.assertRaises(TypeError):
            copy.copy(t1)
        with self.assertRaises(TypeError):
            t1.clone(0)

    def test_taxon_namespace_scoped_copy(self):
        t1 = Taxon("a")
        for t2 in (t1.clone(1), t1.taxon_namespace_scoped_copy()):
            self.assertIs(t2, t1)

class TaxonNamespaceTaxonManagement(unittest.TestCase):

    def setUp(self):
        self.str_labels = ["a", "a", "b", "c", "d", "e", "_", "_", "_", "z", "z", "z"]
        self.taxa = [
                Taxon("t1"), Taxon("t2"), Taxon("t3"),
                ]
        self.taxa_labels = [t.label for t in self.taxa]

    def validate_taxon_concepts(self, tns, labels, respect_order=False):
        expected_labels = labels
        discovered_labels = []
        for t in tns._taxa:
            discovered_labels.append(t.label)
        self.assertEqual(len(discovered_labels), len(expected_labels))
        if respect_order:
            for x1, x2 in zip(discovered_labels, expected_labels):
                self.assertEqual(x1, x2)
        else:
            c1 = collections.Counter(discovered_labels)
            c2 = collections.Counter(expected_labels)
            self.assertEqual(c1, c2)

    ### initialization ###

    def test_initialize_from_str_list(self):
        tns = TaxonNamespace(self.str_labels)
        self.validate_taxon_concepts(tns, self.str_labels)

    def test_initialize_from_taxon_list(self):
        tns = TaxonNamespace(self.taxa)
        self.validate_taxon_concepts(tns, self.taxa_labels)
        for t in self.taxa:
            self.assertIn(t, tns._taxa)

    def test_initialize_other_taxon_namespace(self):
        tns1 = TaxonNamespace(self.taxa)
        tns2 = TaxonNamespace(tns1)
        self.assertIsNot(tns1, tns2)
        self.validate_taxon_concepts(tns1, self.taxa_labels)
        self.validate_taxon_concepts(tns2, self.taxa_labels)
        for t in self.taxa:
            self.assertIn(t, tns1._taxa)
            self.assertIn(t, tns2._taxa)
        for t1, t2 in zip(tns1, tns2):
            self.assertIs(t1, t2)
        # self.assertEqual(tns1, tns2)

    ### adding ###

    def test_basic_adding(self):
        tns = TaxonNamespace()
        self.assertEqual(len(tns), 0)
        for idx, label in enumerate(self.str_labels):
            tns.add_taxon(Taxon(label=label))
            self.assertEqual(len(tns), idx+1)
        self.validate_taxon_concepts(tns, self.str_labels)

    def test_basic_adding_to_immutable(self):
        tns = TaxonNamespace()
        self.assertEqual(len(tns), 0)
        tns.is_mutable = False
        for idx, label in enumerate(self.str_labels):
            with self.assertRaises(TypeError):
                tns.add_taxon(Taxon(label=label))
            self.assertEqual(len(tns), 0)

    def test_add_taxon(self):
        tns = TaxonNamespace()
        for t in self.taxa:
            tns.add_taxon(t)
        self.validate_taxon_concepts(tns, self.taxa_labels)
        for t in self.taxa:
            self.assertIn(t, tns._taxa)

    def test_add_taxa(self):
        tns = TaxonNamespace()
        tns.add_taxa(self.taxa)
        self.validate_taxon_concepts(tns, self.taxa_labels)
        for t in self.taxa:
            self.assertIn(t, tns._taxa)

    def test_add_taxon_duplicate(self):
        tns = TaxonNamespace(self.taxa)
        self.validate_taxon_concepts(tns, self.taxa_labels)
        tns.add_taxon(self.taxa[0])
        self.assertEqual(len(tns), len(self.taxa))
        for t1, t2 in zip(tns, self.taxa):
            self.assertIs(t1, t2)

    def test_add_taxa_duplicate(self):
        tns = TaxonNamespace(self.taxa)
        self.validate_taxon_concepts(tns, self.taxa_labels)
        tns.add_taxa(self.taxa)
        self.assertEqual(len(tns), len(self.taxa))
        for t1, t2 in zip(tns, self.taxa):
            self.assertIs(t1, t2)

    def test_new_taxon(self):
        tns = TaxonNamespace()
        for idx, label in enumerate(self.str_labels):
            t = tns.new_taxon(label)
            self.assertTrue(isinstance(t, Taxon))
            self.assertEqual(t.label, label)
            self.assertEqual(len(tns), idx+1)
        self.validate_taxon_concepts(tns, self.str_labels)

    def test_new_taxa(self):
        tns = TaxonNamespace()
        tns.new_taxa(self.str_labels)
        self.validate_taxon_concepts(tns, self.str_labels)

    def test_new_taxon_to_immutable(self):
        tns = TaxonNamespace()
        tns.is_mutable = False
        for idx, label in enumerate(self.str_labels):
            with self.assertRaises(TypeError):
                t = tns.new_taxon(label)
            self.assertEqual(len(tns), 0)

    def test_new_taxa_to_immutable(self):
        tns = TaxonNamespace()
        tns.is_mutable = False
        with self.assertRaises(TypeError):
            tns.new_taxa(self.str_labels)
        self.assertEqual(len(tns), 0)

    ### access ###

    def test_len(self):
        tns = TaxonNamespace(self.str_labels)
        self.assertEqual(len(tns), len(self.str_labels))

    def test_getitem_by_index(self):
        tns = TaxonNamespace(self.str_labels)
        for index, label in enumerate(self.str_labels):
            t = tns[index]
            self.assertEqual(t.label, label)

    def test_getitem_by_index_error(self):
        tns = TaxonNamespace(self.str_labels)
        with self.assertRaises(IndexError):
            t = tns[len(self.str_labels)+1]

    def test_getitem_slices(self):
        tns = TaxonNamespace(self.str_labels)
        slices = [
                (-1,1,-1),
                (2,4),
                (1,),
                (None,1)
                ]
        for s in slices:
            labels = self.str_labels[slice(*s)]
            taxa = tns[slice(*s)]
            taxa_labels = [t.label for t in taxa]
            self.assertEqual(taxa_labels, labels)

    def test_getitem_by_label_error(self):
        tns = TaxonNamespace(self.str_labels)
        with self.assertRaises(ValueError):
            tns[self.str_labels[0]]

#     def test_getitem_by_label_error(self):
#         tns = TaxonNamespace(self.str_labels)
#         check = ["u", "x", "y",]
#         for label in check:
#             assert label not in self.str_labels
#             with self.assertRaises(LookupError):
#                 t = tns[label]

    def test_contains_taxa(self):
        tns = TaxonNamespace(self.taxa)
        for taxon in self.taxa:
            self.assertIn(taxon, tns)

    def test_no_contains_taxa(self):
        tns = TaxonNamespace(self.taxa)
        taxa2 = [Taxon(label=t.label) for t in self.taxa]
        for taxon in taxa2:
            self.assertNotIn(taxon, tns)

    def test_has_label(self):
        tns = TaxonNamespace(self.str_labels)
        for label in self.str_labels:
            self.assertTrue(tns.has_taxon_label(label))

    def test_no_has_label(self):
        tns = TaxonNamespace(self.str_labels)
        check = ["u", "x", "y",]
        for label in check:
            assert label not in self.str_labels
            self.assertFalse(tns.has_taxon_label(label))

    def test_has_label_case_sensitivity(self):
        tns = TaxonNamespace(self.str_labels)
        labels_upper = [label.upper() for label in self.str_labels if label.upper() != label]
        assert labels_upper
        for label in labels_upper:
            tns.is_case_sensitive = True
            self.assertFalse(tns.has_taxon_label(label))
            tns.is_case_sensitive = False
            self.assertTrue(tns.has_taxon_label(label))

    def test_has_labels(self):
        tns = TaxonNamespace(self.str_labels)
        self.assertTrue(tns.has_taxa_labels(self.str_labels))

    def test_no_has_labels(self):
        tns = TaxonNamespace(self.str_labels)
        check = ["u", "x", "y",]
        for label in check:
            assert label not in self.str_labels
        self.assertFalse(tns.has_taxa_labels(check))
        self.assertFalse(tns.has_taxa_labels(check + self.str_labels))

    def test_has_labels_case_sensitivity(self):
        tns = TaxonNamespace(self.str_labels)
        labels_upper = [label.upper() for label in self.str_labels if label.upper() != label]
        assert labels_upper
        tns.is_case_sensitive = True
        self.assertFalse(tns.has_taxa_labels(labels_upper))
        tns.is_case_sensitive = False
        self.assertTrue(tns.has_taxa_labels(labels_upper))

    def test_findall_multiple(self):
        tns = TaxonNamespace(self.str_labels)
        multilabels= ["_", "z"]
        for label in multilabels:
            tns.is_case_sensitive=True
            taxa = tns.findall(label=label)
            self.assertTrue(isinstance(taxa, collections.Iterable))
            self.assertEqual(len(taxa), len([s for s in self.str_labels if s == label]))
            for t in taxa:
                self.assertEqual(t.label, label)

    def test_findall_not_found(self):
        tns = TaxonNamespace(self.str_labels)
        tns.is_case_sensitive=True
        taxa = tns.findall(label="x")
        self.assertEqual(taxa, [])

    def test_get_taxon_by_label(self):
        tns = TaxonNamespace(self.str_labels)
        for label in self.str_labels:
            t = tns.get_taxon(label)
            self.assertEqual(t.label, label)

    def test_get_nonexistant_taxon_by_label(self):
        tns = TaxonNamespace(self.str_labels)
        check = ["u", "x", "y",]
        for label in check:
            assert label not in self.str_labels
            t = tns.get_taxon(check)
            self.assertIs(t, None)

    def test_case_insensitive_get_taxon_by_label(self):
        tns = TaxonNamespace(self.str_labels)
        labels_upper = [label.upper() for label in self.str_labels if label.upper() != label]
        assert labels_upper
        # default: case insensitive
        for label in labels_upper:
            t = tns.get_taxon(label)
            self.assertIsNot(t, None)
            self.assertEqual(t.label.lower(), label.lower())
        # test: case sensitive
        tns.is_case_sensitive = True
        for label in labels_upper:
            t = tns.get_taxon(label)
            self.assertIs(t, None)

    def test_require_taxon_by_label_noadd(self):
        tns = TaxonNamespace(self.str_labels)
        for label in self.str_labels:
            t = tns.get_taxon(label)
            self.assertEqual(t.label, label)
        self.assertEqual(len(tns), len(self.str_labels))
        self.validate_taxon_concepts(tns, self.str_labels)

    def test_require_taxon_by_label_add(self):
        tns = TaxonNamespace(self.str_labels)
        check = ["u", "x", "y",]
        for label in check:
            assert label not in self.str_labels
            t = tns.require_taxon(label)
            self.assertTrue(isinstance(t, Taxon))
            self.assertEqual(t.label, label)
        total = self.str_labels + check
        self.assertEqual(len(tns), len(total))
        self.validate_taxon_concepts(tns, total)

    def test_case_insensitive_require_taxon_by_label1(self):
        tns = TaxonNamespace(self.str_labels)
        labels_upper = [label.upper() for label in self.str_labels if label.upper() != label]
        assert labels_upper
        for label in labels_upper:
            tns.is_case_sensitive = False
            t = tns.require_taxon(label)
            self.assertEqual(t.label.lower(), label.lower())
            self.assertEqual(len(tns), len(self.str_labels))
        self.validate_taxon_concepts(tns, self.str_labels)

    def test_case_insensitive_require_taxon_by_label2(self):
        tns = TaxonNamespace(self.str_labels)
        labels_upper = [label.upper() for label in self.str_labels if label.upper() != label]
        labels_upper = list(set(labels_upper))
        assert labels_upper
        for label in labels_upper:
            tns.is_case_sensitive = True
            t = tns.require_taxon(label)
            self.assertEqual(t.label, label)
        self.validate_taxon_concepts(tns, self.str_labels + labels_upper)

    def test_require_taxon_by_label_add_to_immutable(self):
        tns = TaxonNamespace(self.str_labels)
        tns.is_mutable = False
        check = ["u", "x", "y",]
        for label in check:
            assert label not in self.str_labels
            with self.assertRaises(TypeError):
                t = tns.require_taxon(label)

    def test_get_taxa_by_label(self):
        tns = TaxonNamespace(self.str_labels)
        # label_set = set(self.str_labels)
        # taxa = tns.get_taxa(label_set)
        taxa = tns.get_taxa(self.str_labels + ["u", "x", "y"])
        self.assertEqual(len(taxa), len(self.str_labels))
        tx = [t.label for t in taxa]
        self.assertEqual(tx, self.str_labels)

    def test_get_nonexistant_taxa_by_label(self):
        tns = TaxonNamespace(self.str_labels)
        check = ["u", "x", "y",]
        taxa = tns.get_taxa(check)
        self.assertEqual(len(taxa), 0)

    def test_case_insensitive_get_taxa_by_label(self):
        tns = TaxonNamespace(self.str_labels)
        labels_upper = [label.upper() for label in self.str_labels if label.upper() != label]
        assert labels_upper
        # default: case-insensitive
        t2 = tns.get_taxa(labels_upper)
        self.assertEqual(len(t2), len(labels_upper))
        for t, label in zip(t2, labels_upper):
            self.assertEqual(t.label.lower(), label.lower())
        # test: case sensitive
        tns.is_case_sensitive = True
        t1 = tns.get_taxa(labels_upper)
        self.assertEqual(len(t1), 0)

    ### iteration ###

    def test_iter1(self):
        tns = TaxonNamespace(self.str_labels)
        for t1, label in zip(tns, self.str_labels):
            self.assertEqual(t1.label, label)

    def test_iter2(self):
        tns = TaxonNamespace(self.str_labels)
        for idx, t1 in enumerate(tns):
            self.assertEqual(t1.label, self.str_labels[idx])

    def test_reverse_iter(self):
        tns = TaxonNamespace(self.str_labels)
        r = self.str_labels[:]
        r.reverse()
        assert r != self.str_labels
        for idx, t1 in enumerate(reversed(tns)):
            self.assertEqual(t1.label, r[idx])

    ### sorting ###

    def test_sort(self):
        r = self.str_labels[:]
        r.sort()
        r.reverse()
        tns = TaxonNamespace(r)
        tns.sort()
        r2 = sorted(r)
        assert r != r2
        for idx, t1 in enumerate(tns):
            self.assertEqual(t1.label, r2[idx])

    def test_reverse(self):
        r = self.str_labels[:]
        r.sort()
        tns = TaxonNamespace(r)
        tns.reverse()
        r2 = r[:]
        r2.reverse()
        assert r != r2
        for idx, t1 in enumerate(tns):
            self.assertEqual(t1.label, r2[idx])

    def test_sorted(self):
        r = self.str_labels[:]
        r.sort()
        r.reverse()
        tns = TaxonNamespace(r)
        r2 = sorted(r)
        assert r != r2
        for idx, t1 in enumerate(sorted(tns)):
            self.assertEqual(t1.label, r2[idx])

    def test_reversed(self):
        r = self.str_labels[:]
        r.sort()
        tns = TaxonNamespace(r)
        r2 = r[:]
        r2.reverse()
        assert r != r2
        for idx, t1 in enumerate(reversed(tns)):
            self.assertEqual(t1.label, r2[idx])

    ### deletion ###

    def test_delete_by_index(self):
        for idx in range(len(self.taxa)):
            tns = TaxonNamespace(self.taxa)
            del tns[idx]
            for idx2, taxon in enumerate(self.taxa):
                if idx2 == idx:
                    self.assertNotIn(taxon, tns)
                else:
                    self.assertIn(taxon, tns)

    def test_remove_taxon(self):
        taxa = [Taxon(s) for s in self.str_labels]
        tns = TaxonNamespace(taxa)
        expected = taxa[:]
        for idx, taxon in enumerate(taxa):
            tns.remove_taxon(taxon)
            expected.remove(taxon)
            self.assertEqual(len(tns), len(expected))
            for idx2, taxon2 in enumerate(expected):
                if taxon2 in expected:
                    self.assertIn(taxon2, tns)
                elif taxon2 not in expected:
                    self.assertNotIn(taxon2, tns)

    def test_remove_taxon_error(self):
        tns = TaxonNamespace(self.str_labels)
        with self.assertRaises(ValueError):
            tns.remove_taxon(self.taxa[0])

    def test_remove_taxon_label(self):
        taxa = [Taxon(s) for s in self.str_labels]
        tns = TaxonNamespace(taxa)
        expected = taxa[:]
        for idx, label in enumerate(set(self.str_labels)):
            tns.remove_taxon_label(label)
            for t in taxa:
                if t.label == label and t in expected:
                    expected.remove(t)
            self.assertEqual(len(tns), len(expected))
            for t1, t2 in zip(tns, expected):
                self.assertIs(t1, t2)

    def test_remove_taxon_label_error(self):
        tns = TaxonNamespace(self.str_labels)
        key = "zzz"
        assert key not in self.str_labels
        with self.assertRaises(LookupError):
            tns.remove_taxon_label(key)

    def test_remove_taxon_label_case_insensitive(self):
        ucase_labels = [s.upper() for s in self.str_labels]
        assert ucase_labels
        assert ucase_labels != self.str_labels
        taxa = [Taxon(s) for s in self.str_labels]
        tns = TaxonNamespace(taxa)
        expected = taxa[:]
        for idx, label in enumerate(set(ucase_labels)):
            if label != label.lower():
                with self.assertRaises(LookupError):
                    tns.is_case_sensitive = True
                    tns.remove_taxon_label(label)
            tns.is_case_sensitive = False
            tns.remove_taxon_label(label)
            for t in taxa:
                if t.label.upper() == label.upper() and t in expected:
                    expected.remove(t)
            self.assertEqual(len(tns), len(expected))
            for t1, t2 in zip(tns, expected):
                self.assertIs(t1, t2)

    def test_discard_taxon_label(self):
        taxa = [Taxon(s) for s in self.str_labels]
        tns = TaxonNamespace(taxa)
        expected = taxa[:]
        for idx, label in enumerate(set(self.str_labels)):
            tns.discard_taxon_label(label)
            for t in taxa:
                if t.label == label and t in expected:
                    expected.remove(t)
            self.assertEqual(len(tns), len(expected))
            for t1, t2 in zip(tns, expected):
                self.assertIs(t1, t2)

    def test_discard_taxon_label_error(self):
        tns = TaxonNamespace(self.str_labels)
        key = "zzz"
        assert key not in self.str_labels
        try:
            tns.discard_taxon_label(key)
        except LookupError:
            self.fail()
        else:
            self.validate_taxon_concepts(tns, self.str_labels)

    def test_discard_taxon_label_case_insensitive(self):
        ucase_labels = [s.upper() for s in self.str_labels]
        assert ucase_labels
        assert ucase_labels != self.str_labels
        taxa = [Taxon(s) for s in self.str_labels]
        tns = TaxonNamespace(taxa)
        expected = taxa[:]
        # default: case-insensitive
        for idx, label in enumerate(set(ucase_labels)):
            tns.discard_taxon_label(label)
            for t in taxa:
                if t.label.upper() == label.upper() and t in expected:
                    expected.remove(t)
            self.assertEqual(len(tns), len(expected))
            for t1, t2 in zip(tns, expected):
                self.assertIs(t1, t2)

    def test_discard_taxon_label_case_sensitive(self):
        ucase_labels = [s.upper() for s in self.str_labels]
        assert ucase_labels
        assert ucase_labels != self.str_labels
        taxa = [Taxon(s) for s in self.str_labels]
        tns = TaxonNamespace(taxa)
        expected = taxa[:]
        # test: case sensitive
        tns.is_case_sensitive = True
        for idx, label in enumerate(set(ucase_labels)):
            if label != label.lower():
                x1 = len(tns)
                try:
                    tns.discard_taxon_label(label)
                except LookupError:
                    self.fail()
                else:
                    self.assertEqual(len(tns), x1)

    def test_clear(self):
        tns = TaxonNamespace(self.str_labels)
        self.assertEqual(len(tns), len(self.str_labels))
        tns.clear()
        self.assertEqual(len(tns), 0)
        x = []
        for t in tns:
            x.append(t)
        self.assertEqual(len(x), 0)

class TaxonNamespaceIdentity(unittest.TestCase):

    def setUp(self):
        self.str_labels = ["a", "a", "b", "c", "d", "e", "_", "_", "_", "z", "z", "z"]
        self.taxa = [ Taxon(label) for label in self.str_labels ]
        self.tns1 = TaxonNamespace(self.taxa)
        self.tns2 = TaxonNamespace(self.taxa)

    # def test_separate_but_equal(self):
    #     self.assertIsNot(self.tns1, self.tns2)
    #     self.assertEqual(self.tns1, self.tns2)

    # def test_different_labels(self):
    #     self.assertIsNot(self.tns1, self.tns2)
    #     self.assertEqual(self.tns1, self.tns2)
    #     self.tns1.label = "hello"
    #     self.tns2.label = "goodbye"
    #     self.assertNotEqual(self.tns1, self.tns2)
    #     self.tns1.label = self.tns2.label
    #     self.assertIsNot(self.tns1, self.tns2)
    #     self.assertEqual(self.tns1, self.tns2)

    # def test_same_annotations(self):
    #     self.assertIsNot(self.tns1, self.tns2)
    #     self.assertEqual(self.tns1, self.tns2)
    #     self.tns1.annotations.add_new("hello", 0)
    #     self.tns2.annotations.add_new("hello", 0)
    #     # not equal because each |AnnotationSet| has a ``target``
    #     # attribute that holds reference to the object being annotated. As
    #     # these the target objects are necessarily different (even if they
    #     # evaluate being equal), the |AnnotationSet| objects are not
    #     # considered equal, and thus the target objects that have the
    #     # AnnotationSets are not equal.
    #     self.assertNotEqual(self.tns1, self.tns2)

    # def test_different_annotations1(self):
    #     self.assertIsNot(self.tns1, self.tns2)
    #     self.assertEqual(self.tns1, self.tns2)
    #     self.tns1.annotations.add_new("hello", 0)
    #     self.assertNotEqual(self.tns1, self.tns2)

    def test_hash_dict_membership(self):
        k = {}
        k[self.tns1] = 1
        k[self.tns2] = 2
        self.assertEqual(len(k), 2)
        self.assertEqual(k[self.tns1], 1)
        self.assertEqual(k[self.tns2], 2)
        self.assertIn(self.tns1, k)
        self.assertIn(self.tns2, k)
        del k[self.tns1]
        self.assertNotIn(self.tns1, k)
        self.assertIn(self.tns2, k)
        self.assertEqual(len(k), 1)
        k1 = {self.tns1: 1}
        k2 = {self.tns2: 1}
        self.assertIn(self.tns1, k1)
        self.assertIn(self.tns2, k2)
        self.assertNotIn(self.tns2, k1)
        self.assertNotIn(self.tns1, k2)

    def test_hash_set_membership(self):
        k = set()
        k.add(self.tns1)
        k.add(self.tns2)
        self.assertEqual(len(k), 2)
        self.assertIn(self.tns1, k)
        self.assertIn(self.tns2, k)
        k.discard(self.tns1)
        self.assertNotIn(self.tns1, k)
        self.assertIn(self.tns2, k)
        self.assertEqual(len(k), 1)
        k1 = {self.tns1: 1}
        k2 = {self.tns2: 1}
        self.assertIn(self.tns1, k1)
        self.assertIn(self.tns2, k2)
        self.assertNotIn(self.tns2, k1)
        self.assertNotIn(self.tns1, k2)

# note that compare_and_validate.Comparator must be listed first,
# otherwise setUp will not be called
class TaxonNamespaceCloning(compare_and_validate.Comparator, unittest.TestCase):

    def setUp(self):
        self.str_labels = ["a", "a", "b", "c", "d", "e", "_", "_", "_", "z", "z", "z"]
        self.taxa = [ Taxon(label) for label in self.str_labels ]
        self.tns1 = TaxonNamespace(self.taxa, label="T1")

    def test_taxon_namespace_scoped_copy(self):
        for tns2 in (self.tns1.clone(1),
                self.tns1.taxon_namespace_scoped_copy()):
            self.assertIs(tns2, self.tns1)

    def test_construct_from_another(self):
        tns2 = TaxonNamespace(self.tns1)
        for tns2 in (TaxonNamespace(self.tns1),
                self.tns1.clone(0),
                copy.copy(self.tns1)):
            self.assertIsNot(tns2, self.tns1)
            self.assertEqual(tns2.label, self.tns1.label)
            self.assertEqual(tns2._taxa, self.tns1._taxa)
            for t1, t2 in zip(self.tns1, tns2):
                self.assertIs(t1, t2)
            self.compare_distinct_annotables(tns2, self.tns1)

    def test_construct_from_another_different_label(self):
        tns2 = TaxonNamespace(self.tns1, label="T2")
        self.assertIsNot(tns2, self.tns1)
        self.assertNotEqual(tns2.label, self.tns1.label)
        self.assertEqual(self.tns1.label, "T1")
        self.assertEqual(tns2.label, "T2")
        self.assertEqual(tns2._taxa, self.tns1._taxa)
        for t1, t2 in zip(self.tns1, tns2):
            self.assertIs(t1, t2)
        self.compare_distinct_annotables(tns2, self.tns1)

    def test_construct_from_changed_label(self):
        for tns2 in (TaxonNamespace(self.tns1),
                self.tns1.clone(0),
                copy.copy(self.tns1)):
            tns2.label = "T2"
            self.assertNotEqual(tns2.label, self.tns1.label)
            self.assertEqual(self.tns1.label, "T1")
            self.assertEqual(tns2.label, "T2")
            self.assertEqual(tns2._taxa, self.tns1._taxa)
            for t1, t2 in zip(self.tns1, tns2):
                self.assertIs(t1, t2)
            self.compare_distinct_annotables(tns2, self.tns1)

    def test_construct_from_another_with_simple_annotations(self):
        self.tns1.annotations.add_new("A", 1)
        self.tns1.annotations.add_new("B", 2)
        self.tns1.annotations.add_new("C", 3)
        for tns2 in (TaxonNamespace(self.tns1),
                self.tns1.clone(0),
                copy.copy(self.tns1)):
            self.assertIsNot(tns2, self.tns1)
            self.assertEqual(tns2._taxa, self.tns1._taxa)
            for t1, t2 in zip(tns2, self.tns1):
                self.assertIs(t1, t2)
            self.compare_distinct_annotables(tns2, self.tns1)

    def test_construct_from_another_with_complex_annotations(self):
        self.tns1.annotations.add_new("a", 0)
        b = self.tns1.annotations.add_new("b", (self.tns1, "label"), is_attribute=True)
        b.annotations.add_new("c", 3)
        self.tns1.annotations.add_new("A", 1)
        self.tns1.annotations.add_new("B", 2)
        self.tns1.annotations.add_new("C", 3)
        for tns2 in (TaxonNamespace(self.tns1), self.tns1.clone(0), copy.copy(self.tns1)):
            self.assertIsNot(tns2, self.tns1)
            self.assertEqual(tns2._taxa, self.tns1._taxa)
            for t1, t2 in zip(tns2, self.tns1):
                self.assertIs(t1, t2)
            self.compare_distinct_annotables(tns2, self.tns1)

    def test_deepcopy_from_another(self):
        for tns2 in (copy.deepcopy(self.tns1),
                self.tns1.clone(2)):
            self.assertIsNot(tns2, self.tns1)
            self.assertEqual(tns2.label, self.tns1.label)
            self.assertEqual(len(tns2), len(self.tns1))
            for t1, t2 in zip(self.tns1, tns2):
                self.assertIsNot(t1, t2)
                self.assertEqual(t1.label, t2.label)
                self.compare_distinct_annotables(t1, t2)
            self.compare_distinct_annotables(tns2, self.tns1)

    def test_deepcopy_from_another_with_simple_annotations(self):
        self.tns1.annotations.add_new("a", 0)
        self.tns1.annotations.add_new("b", 1)
        self.tns1.annotations.add_new("c", 3)
        for tns2 in (copy.deepcopy(self.tns1),
                self.tns1.clone(2)):
            self.assertIsNot(tns2, self.tns1)
            self.assertEqual(tns2.label, self.tns1.label)
            self.assertEqual(len(tns2), len(self.tns1))
            for t1, t2 in zip(self.tns1, tns2):
                self.assertIsNot(t1, t2)
                self.assertEqual(t1.label, t2.label)
                self.compare_distinct_annotables(t1, t2)
            self.compare_distinct_annotables(tns2, self.tns1)

    def test_deepcopy_from_another_with_complex_annotations(self):
        self.tns1.annotations.add_new("a", 0)
        b = self.tns1.annotations.add_new("b", (self.tns1, "label"), is_attribute=True)
        b.annotations.add_new("c", 3)
        for tns2 in (copy.deepcopy(self.tns1),
                self.tns1.clone(2)):
            self.assertIsNot(tns2, self.tns1)
            self.assertEqual(tns2.label, self.tns1.label)
            self.assertEqual(len(tns2), len(self.tns1))
            for t1, t2 in zip(self.tns1, tns2):
                self.assertIsNot(t1, t2)
                self.assertEqual(t1.label, t2.label)
                self.compare_distinct_annotables(t1, t2)
            self.compare_distinct_annotables(tns2, self.tns1)
            self.tns1.label = "x"
            tns2.label = "y"
            self.assertEqual(self.tns1.annotations[1].value, "x")
            self.assertEqual(tns2.annotations[1].value, "y")
            self.tns1.label = "T1"

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