Пример #1
0
    def test_symmetric_difference_update(self):
        syn_1 = 'a'
        syn_2 = 'b'
        syn_3 = 'c'

        syns_1 = core.SynonymSet([syn_1, syn_2])
        syns_2 = core.SynonymSet([syn_1, syn_3])
        syns_1.symmetric_difference_update(syns_2)
        self.assertEqual(syns_1, core.SynonymSet([syn_2, syn_3]))

        syns_1 = core.SynonymSet([syn_1, syn_2])
        syns_2 = set([syn_1, syn_3])
        syns_1.symmetric_difference_update(syns_2)
        self.assertEqual(syns_1, core.SynonymSet([syn_2, syn_3]))

        with self.assertRaises(TypeError):
            syns_1.symmetric_difference_update(0)
Пример #2
0
 def test_synonyms_setter(self):
     base = core.Base()
     base.synonyms = core.SynonymSet()
     base.synonyms = set(['A'])
     base.synonyms = ['A']
     with self.assertRaises(ValueError):
         base.synonyms = None
     with self.assertRaises(ValueError):
         base.synonyms = 'A'
Пример #3
0
    def test_update(self):
        syn_1 = 'a'
        syn_2 = 'b'
        syn_3 = 'c'

        syns = core.SynonymSet()
        syns.update([syn_1, syn_2])
        self.assertEqual(len(syns), 2)

        with self.assertRaises(ValueError):
            syns.update([0])
Пример #4
0
    def test_add(self):
        syn_1 = 'a'
        syn_2 = 'b'
        syn_3 = 'c'

        syns = core.SynonymSet()
        syns.add(syn_1)
        syns.add(syn_2)
        syns.add(syn_3)
        self.assertEqual(len(syns), 3)

        with self.assertRaises(ValueError):
            syns.add(0)
        with self.assertRaises(ValueError):
            syns.add(None)
        with self.assertRaises(ValueError):
            syns.add('')
Пример #5
0
    def test_constructor(self):
        syn_1 = 'a'
        syn_2 = 'b'
        syn_3 = 'c'

        syns = core.SynonymSet()
        self.assertEqual(len(syns), 0)

        syns = core.SynonymSet([syn_1, syn_2, syn_3])
        self.assertEqual(len(syns), 3)

        with self.assertRaises(ValueError):
            core.SynonymSet('')
        with self.assertRaises(ValueError):
            core.SynonymSet('a')
        with self.assertRaises(ValueError):
            core.SynonymSet([''])
        with self.assertRaises(ValueError):
            core.SynonymSet([0])
        with self.assertRaises(ValueError):
            core.SynonymSet([None])
Пример #6
0
    def test_from_str(self):
        self.assertTrue(dna.DnaForm.from_str('AAA').is_equal(dna.DnaForm([
            dna.dna_alphabet.A, dna.dna_alphabet.A, dna.dna_alphabet.A,
        ])))

        self.assertTrue(dna.DnaForm.from_str('ACTG').is_equal(dna.DnaForm([
            dna.dna_alphabet.A, dna.dna_alphabet.C, dna.dna_alphabet.T, dna.dna_alphabet.G,
        ])))

        with self.assertRaisesRegex(ValueError, 'not in alphabet'):
            self.assertTrue(dna.DnaForm.from_str('UAA').is_equal(dna.DnaForm([
                dna.dna_alphabet.A, dna.dna_alphabet.A, dna.dna_alphabet.A,
            ])))

        self.assertTrue(dna.DnaForm.from_str(
            'AA[id: "dI"'
            + ' | name: "2\'-deoxyinosine"'
            + ' | synonym: "2\'-deoxyinosine, 9-[(2R,4S,5R)-4-hydroxy-5-(hydroxymethyl)tetrahydrofuran-2-yl]-9H-purin-6-ol"'
            + ' | identifier: chebi/CHEBI:28997'
            + ' | structure: ' + dIMP_inchi
            + ' | delta-mass: -2.5'
            + ' | delta-charge: 3'
            + ' | position: 3-5'
            + ' | comments: "A purine 2\'-deoxyribonucleoside that is inosine ..."]A').is_equal(dna.DnaForm([
                dna.dna_alphabet.A,
                dna.dna_alphabet.A,
                core.Base(
                    id='dI',
                    name="2'-deoxyinosine",
                    synonyms=core.SynonymSet(
                        ["2'-deoxyinosine, 9-[(2R,4S,5R)-4-hydroxy-5-(hydroxymethyl)tetrahydrofuran-2-yl]-9H-purin-6-ol"]),
                    identifiers=core.IdentifierSet([core.Identifier('chebi', 'CHEBI:28997')]),
                    structure=dIMP_inchi,
                    delta_mass=-2.5,
                    delta_charge=3,
                    start_position=3,
                    end_position=5,
                    comments="A purine 2'-deoxyribonucleoside that is inosine ...",
                ),
                dna.dna_alphabet.A,
            ])))

        self.assertTrue(dna.DnaForm.from_str(
            'AA[id: "dI"'
            ' | position: 3-]A').is_equal(dna.DnaForm([
                dna.dna_alphabet.A,
                dna.dna_alphabet.A,
                core.Base(
                    id='dI',
                    start_position=3,
                    end_position=None,
                ),
                dna.dna_alphabet.A,
            ])))

        self.assertTrue(dna.DnaForm.from_str(
            'AA[id: "dI"'
            ' | position: -5]A').is_equal(dna.DnaForm([
                dna.dna_alphabet.A,
                dna.dna_alphabet.A,
                core.Base(
                    id='dI',
                    start_position=None,
                    end_position=5,
                ),
                dna.dna_alphabet.A,
            ])))

        with self.assertRaisesRegex(ValueError, 'cannot be repeated'):
            dna.DnaForm.from_str(
                'AA[id: "dI"'
                ' | name: "2\'-deoxyinosine"'
                ' | name: "2\'-deoxyinosine"]A')