mirror of
https://github.com/biopython/biopython.git
synced 2025-10-20 21:53:47 +08:00
Cleaning up the SCOP tests
This commit is contained in:
mdehoon
@ -1,20 +0,0 @@
|
||||
# dir.cla.scop.txt
|
||||
# SCOP release 1.55 (July 2001) [File format version 1.00]
|
||||
# http://scop.mrc-lmb.cam.ac.uk/scop/
|
||||
# Copyright (c) 1994-2001 the scop authors; see http://scop.mrc-lmb.cam.ac.uk/scop/lic/copy.html
|
||||
d1dlwa_ 1dlw A: a.1.1.1 14982 cl=46456,cf=46457,sf=46458,fa=46459,dm=46460,sp=46461,px=14982
|
||||
d1dlya_ 1dly A: a.1.1.1 14983 cl=46456,cf=46457,sf=46458,fa=46459,dm=46460,sp=46462,px=14983
|
||||
d3sdha_ 3sdh A: a.1.1.2 14984 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14984
|
||||
d3sdhb_ 3sdh B: a.1.1.2 14985 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14985
|
||||
d3hbia_ 3hbi A: a.1.1.2 14986 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14986
|
||||
d3hbib_ 3hbi B: a.1.1.2 14987 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14987
|
||||
d4sdha_ 4sdh A: a.1.1.2 14988 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14988
|
||||
d4sdhb_ 4sdh B: a.1.1.2 14989 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14989
|
||||
d4hbia_ 4hbi A: a.1.1.2 14990 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14990
|
||||
d4hbib_ 4hbi B: a.1.1.2 14991 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14991
|
||||
d5hbia_ 5hbi A: a.1.1.2 14992 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14992
|
||||
d5hbib_ 5hbi B: a.1.1.2 14993 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14993
|
||||
d7hbia_ 7hbi A: a.1.1.2 14994 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14994
|
||||
d7hbib_ 7hbi B: a.1.1.2 14995 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14995
|
||||
d1hbia_ 1hbi A: a.1.1.2 14996 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14996
|
||||
d1hbib_ 1hbi B: a.1.1.2 14997 cl=46456,cf=46457,sf=46458,fa=46463,dm=46464,sp=46465,px=14997
|
||||
@ -6,8 +6,6 @@
|
||||
"""Unit test for Astral"""
|
||||
|
||||
import unittest
|
||||
from StringIO import *
|
||||
|
||||
from Bio.SCOP import *
|
||||
|
||||
|
||||
@ -16,54 +14,54 @@ class AstralTests(unittest.TestCase):
|
||||
|
||||
|
||||
def setUp(self):
|
||||
self.scop = Scop(dir_path="SCOP", version="test" )
|
||||
self.scop = Scop(dir_path="SCOP", version="test")
|
||||
self.astral = Astral(scop=self.scop, dir_path="SCOP", version="test")
|
||||
|
||||
|
||||
def testGetSeq(self):
|
||||
assert self.astral.getSeqBySid('d3sdha_').data == "AAAAA"
|
||||
assert self.astral.getSeqBySid('d4hbib_').data == "KKKKK"
|
||||
self.assertEqual(self.astral.getSeqBySid('d3sdha_').data, "AAAAA")
|
||||
self.assertEqual(self.astral.getSeqBySid('d4hbib_').data, "KKKKK")
|
||||
|
||||
dom = self.scop.getDomainBySid('d3sdha_')
|
||||
assert self.astral.getSeq(dom).data == "AAAAA"
|
||||
self.assertEqual(self.astral.getSeq(dom).data, "AAAAA")
|
||||
|
||||
|
||||
|
||||
|
||||
def testConstructWithCustomFile(self):
|
||||
scop = Scop(dir_path="SCOP", version="test" )
|
||||
scop = Scop(dir_path="SCOP", version="test")
|
||||
astral = Astral(scop=scop, astral_file="SCOP/scopseq-test/astral-scopdom-seqres-all-test.fa")
|
||||
assert astral.getSeqBySid('d3sdha_').data == "AAAAA"
|
||||
assert astral.getSeqBySid('d4hbib_').data == "KKKKK"
|
||||
self.assertEqual(astral.getSeqBySid('d3sdha_').data, "AAAAA")
|
||||
self.assertEqual(astral.getSeqBySid('d4hbib_').data, "KKKKK")
|
||||
|
||||
|
||||
def testGetDomainsFromFile(self):
|
||||
filename = "SCOP/scopseq-test/astral-scopdom-seqres-sel-gs-bib-20-test.id"
|
||||
domains = self.astral.getAstralDomainsFromFile(filename)
|
||||
|
||||
assert len(domains)==3
|
||||
assert domains[0].sid == "d3sdha_"
|
||||
assert domains[1].sid == "d4hbib_"
|
||||
assert domains[2].sid == "d5hbia_"
|
||||
self.assertEqual(len(domains), 3)
|
||||
self.assertEqual(domains[0].sid, "d3sdha_")
|
||||
self.assertEqual(domains[1].sid, "d4hbib_")
|
||||
self.assertEqual(domains[2].sid, "d5hbia_")
|
||||
|
||||
def testGetDomainsClustered(self):
|
||||
domains1 = self.astral.domainsClusteredById(20)
|
||||
assert len(domains1) == 3
|
||||
assert domains1[0].sid == "d3sdha_"
|
||||
assert domains1[1].sid == "d4hbib_"
|
||||
assert domains1[2].sid == "d5hbia_"
|
||||
self.assertEqual(len(domains1), 3)
|
||||
self.assertEqual(domains1[0].sid, "d3sdha_")
|
||||
self.assertEqual(domains1[1].sid, "d4hbib_")
|
||||
self.assertEqual(domains1[2].sid, "d5hbia_")
|
||||
|
||||
domains2 = self.astral.domainsClusteredByEv(1e-15)
|
||||
assert len(domains2) == 1
|
||||
self.assertEqual(len(domains2), 1)
|
||||
|
||||
#d1 = scop.getDomainBySid("d3sdha_")
|
||||
#assert d1.isIn(astral.getHashedDomainsClusteredByPercentId(20))
|
||||
#assert d1.isIn(astral.getHashedDomainsClusteredByEv(-15))
|
||||
#self.assertEqual(d1.isIn(astral.getHashedDomainsClusteredByPercentId(20))
|
||||
#self.assertEqual(d1.isIn(astral.getHashedDomainsClusteredByEv(-15))
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__=='__main__':
|
||||
runner = unittest.TextTestRunner(verbosity = 2)
|
||||
unittest.main(testRunner=runner)
|
||||
|
||||
@ -9,7 +9,6 @@
|
||||
import unittest
|
||||
|
||||
from Bio.SCOP import Cla
|
||||
from Bio.SCOP.Residues import Residues
|
||||
|
||||
|
||||
|
||||
@ -20,60 +19,63 @@ class ClaTests(unittest.TestCase):
|
||||
self.filename = './SCOP/dir.cla.scop.txt_test'
|
||||
|
||||
def testParse(self):
|
||||
"""Can we parse a CLA file?"""
|
||||
"""Test if all records in a CLA file are being read"""
|
||||
f=open(self.filename)
|
||||
try:
|
||||
count = 0
|
||||
records = Cla.parse(f)
|
||||
for record in records:
|
||||
count +=1
|
||||
assert count == 14, "Wrong number of records?!"
|
||||
self.assertEqual(count, 14)
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
def testStr(self):
|
||||
"""Test if we can convert each record to a string correctly"""
|
||||
f = open(self.filename)
|
||||
try:
|
||||
for line in f:
|
||||
record = Cla.Record(line)
|
||||
#End of line is platform dependent. Strip it off
|
||||
assert str(record).rstrip() == line.rstrip()
|
||||
self.assertEqual(str(record).rstrip(), line.rstrip())
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
def testError(self):
|
||||
"""Test if a corrupt record raises the appropriate exception"""
|
||||
corruptRec = "49268\tsp\tb.1.2.1\t-\n"
|
||||
|
||||
try:
|
||||
record = Cla.Record(corruptRec)
|
||||
assert False, "Should never get here"
|
||||
except ValueError, e:
|
||||
pass
|
||||
self.assertRaises(ValueError, Cla.Record, corruptRec)
|
||||
|
||||
def testRecord(self):
|
||||
"""Test one record in detail"""
|
||||
recLine = 'd1dan.1\t1dan\tT:,U:91-106\tb.1.2.1\t21953\tcl=48724,cf=48725,sf=49265,fa=49266,dm=49267,sp=49268,px=21953'
|
||||
|
||||
record = Cla.Record(recLine)
|
||||
assert record.sid =='d1dan.1'
|
||||
assert record.residues.pdbid =='1dan'
|
||||
assert record.residues.fragments ==(('T','',''),('U','91','106'))
|
||||
assert record.sccs == 'b.1.2.1'
|
||||
assert record.sunid == 21953
|
||||
assert record.hierarchy == [['cl',48724],['cf',48725],['sf',49265],
|
||||
['fa',49266],['dm',49267],['sp',49268],
|
||||
['px',21953]], record.hierarchy
|
||||
self.assertEqual(record.sid, 'd1dan.1')
|
||||
self.assertEqual(record.residues.pdbid, '1dan')
|
||||
self.assertEqual(record.residues.fragments, (('T','',''),('U','91','106')))
|
||||
self.assertEqual(record.sccs, 'b.1.2.1')
|
||||
self.assertEqual(record.sunid, 21953)
|
||||
self.assertEqual(record.hierarchy, [['cl',48724],
|
||||
['cf',48725],
|
||||
['sf',49265],
|
||||
['fa',49266],
|
||||
['dm',49267],
|
||||
['sp',49268],
|
||||
['px',21953]])
|
||||
|
||||
def testIndex(self):
|
||||
"""Test CLA file indexing"""
|
||||
index = Cla.Index(self.filename)
|
||||
|
||||
assert len(index)==14
|
||||
assert index.has_key('d4hbia_')
|
||||
self.assertEqual(len(index), 14)
|
||||
self.assertTrue(index.has_key('d4hbia_'))
|
||||
|
||||
rec = index['d1hbia_']
|
||||
assert rec.sunid == 14996
|
||||
self.assertEqual(rec.sunid, 14996)
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__=='__main__':
|
||||
runner = unittest.TextTestRunner(verbosity = 2)
|
||||
unittest.main(testRunner=runner)
|
||||
|
||||
@ -9,7 +9,6 @@
|
||||
import unittest
|
||||
|
||||
from Bio.SCOP import Des
|
||||
from Bio.SCOP.Residues import Residues
|
||||
|
||||
|
||||
|
||||
@ -19,47 +18,47 @@ class DesTests(unittest.TestCase):
|
||||
self.filename = './SCOP/dir.des.scop.txt_test'
|
||||
|
||||
def testParse(self):
|
||||
f = open(self.filename)
|
||||
try:
|
||||
count = 0
|
||||
records = Des.parse(f)
|
||||
for record in records:
|
||||
count +=1
|
||||
assert count == 20, "Wrong number of records?!"
|
||||
finally:
|
||||
f.close()
|
||||
"""Test if all records in a DES file are being read"""
|
||||
f = open(self.filename)
|
||||
try:
|
||||
count = 0
|
||||
records = Des.parse(f)
|
||||
for record in records:
|
||||
count +=1
|
||||
self.assertEqual(count, 20)
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
def testStr(self):
|
||||
f = open(self.filename)
|
||||
try:
|
||||
for line in f:
|
||||
record = Des.Record(line)
|
||||
#End of line is plateform dependant. Strip it off
|
||||
assert str(record).rstrip() == line.rstrip()
|
||||
finally:
|
||||
f.close()
|
||||
"""Test if we can convert each record to a string correctly"""
|
||||
f = open(self.filename)
|
||||
try:
|
||||
for line in f:
|
||||
record = Des.Record(line)
|
||||
#End of line is platform dependent. Strip it off
|
||||
self.assertEqual(str(record).rstrip(), line.rstrip())
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
def testError(self):
|
||||
"""Test if a corrupt record raises the appropriate exception"""
|
||||
corruptRec = "49268\tsp\tb.1.2.1\t-\n"
|
||||
try:
|
||||
record = Des.Record(corruptRec)
|
||||
assert False, "Should never get here"
|
||||
except ValueError, e:
|
||||
pass
|
||||
self.assertRaises(ValueError, Des.Record, corruptRec)
|
||||
|
||||
def testRecord(self):
|
||||
"""Test one record in detail"""
|
||||
recLine = '49268\tsp\tb.1.2.1\t-\tHuman (Homo sapiens) \n'
|
||||
recFields = (49268,'sp','b.1.2.1','','Human (Homo sapiens)')
|
||||
|
||||
record = Des.Record(recLine)
|
||||
assert record.sunid == recFields[0]
|
||||
assert record.nodetype == recFields[1]
|
||||
assert record.sccs == recFields[2]
|
||||
assert record.name == recFields[3]
|
||||
assert record.description == recFields[4]
|
||||
self.assertEqual(record.sunid, recFields[0])
|
||||
self.assertEqual(record.nodetype, recFields[1])
|
||||
self.assertEqual(record.sccs, recFields[2])
|
||||
self.assertEqual(record.name, recFields[3])
|
||||
self.assertEqual(record.description, recFields[4])
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__=='__main__':
|
||||
runner = unittest.TextTestRunner(verbosity = 2)
|
||||
unittest.main(testRunner=runner)
|
||||
|
||||
@ -12,7 +12,6 @@ This test requires the mini DOM file 'testDom.txt'
|
||||
import unittest
|
||||
|
||||
from Bio.SCOP import Dom
|
||||
from Bio.SCOP.Residues import Residues
|
||||
|
||||
|
||||
|
||||
@ -22,31 +21,35 @@ class DomTests(unittest.TestCase):
|
||||
self.filename = './SCOP/testDom.txt'
|
||||
|
||||
def testParse(self):
|
||||
f = open(self.filename)
|
||||
try:
|
||||
count = 0
|
||||
for record in Dom.parse(f):
|
||||
count +=1
|
||||
self.assertEquals(count,10)
|
||||
finally:
|
||||
f.close()
|
||||
"""Test if all records in a DOM file are being read"""
|
||||
f = open(self.filename)
|
||||
try:
|
||||
count = 0
|
||||
for record in Dom.parse(f):
|
||||
count +=1
|
||||
self.assertEquals(count,10)
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
def testStr(self):
|
||||
f = open(self.filename)
|
||||
try:
|
||||
for line in f:
|
||||
record = Dom.Record(line)
|
||||
#End of line is platform dependent. Strip it off
|
||||
self.assertEquals(str(record).rstrip(),line.rstrip())
|
||||
finally:
|
||||
f.close()
|
||||
"""Test if we can convert each record to a string correctly"""
|
||||
f = open(self.filename)
|
||||
try:
|
||||
for line in f:
|
||||
record = Dom.Record(line)
|
||||
#End of line is platform dependent. Strip it off
|
||||
self.assertEquals(str(record).rstrip(),line.rstrip())
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
def testError(self):
|
||||
"""Test if a corrupt record raises the appropriate exception"""
|
||||
corruptDom = "49xxx268\tsp\tb.1.2.1\t-\n"
|
||||
self.assertRaises(ValueError, Dom.Record, corruptDom)
|
||||
|
||||
|
||||
def testRecord(self):
|
||||
"""Test one record in detail"""
|
||||
recLine = 'd7hbib_\t7hbi\tb:\t1.001.001.001.001.001'
|
||||
|
||||
rec = Dom.Record(recLine)
|
||||
|
||||
@ -9,7 +9,6 @@
|
||||
import unittest
|
||||
|
||||
from Bio.SCOP import Hie
|
||||
from Bio.SCOP.Residues import Residues
|
||||
|
||||
|
||||
|
||||
@ -20,33 +19,31 @@ class HieTests(unittest.TestCase):
|
||||
self.filename = './SCOP/dir.hie.scop.txt_test'
|
||||
|
||||
def testParse(self):
|
||||
f = open(self.filename)
|
||||
try:
|
||||
count = 0
|
||||
for record in Hie.parse(f):
|
||||
count +=1
|
||||
assert count == 21, "Wrong number of records?! "+str(count)
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
"""Test if all records in a HIE file are being read"""
|
||||
f = open(self.filename)
|
||||
try:
|
||||
count = 0
|
||||
for record in Hie.parse(f):
|
||||
count +=1
|
||||
self.assertEqual(count, 21)
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
def testStr(self):
|
||||
f = open(self.filename)
|
||||
try:
|
||||
for line in f:
|
||||
record = Hie.Record(line)
|
||||
#End of line is platform dependent. Strip it off
|
||||
assert str(record).rstrip() == line.rstrip()
|
||||
finally:
|
||||
f.close()
|
||||
"""Test if we can convert each record to a string correctly"""
|
||||
f = open(self.filename)
|
||||
try:
|
||||
for line in f:
|
||||
record = Hie.Record(line)
|
||||
#End of line is platform dependent. Strip it off
|
||||
self.assertEqual(str(record).rstrip(), line.rstrip())
|
||||
finally:
|
||||
f.close()
|
||||
|
||||
def testError(self):
|
||||
"""Test if a corrupt record raises the appropriate exception"""
|
||||
corruptRec = "4926sdfhjhfgyjdfyg"
|
||||
|
||||
try:
|
||||
rec = Hie.Record(corruptRec)
|
||||
assert False, "Should never get here"
|
||||
except ValueError, e:
|
||||
pass
|
||||
self.assertRaises(ValueError, Hie.Record, corruptRec)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@ -20,21 +20,21 @@ class RafTests(unittest.TestCase):
|
||||
"""Can we parse a RAF record?"""
|
||||
r = Raf.SeqMap(self.rafLine)
|
||||
|
||||
assert r.pdbid == "101m"
|
||||
assert r.pdb_datestamp =="010301"
|
||||
assert r.flags =="111011"
|
||||
self.assertEqual(r.pdbid, "101m")
|
||||
self.assertEqual(r.pdb_datestamp, "010301")
|
||||
self.assertEqual(r.flags, "111011")
|
||||
|
||||
i = r.index("143")
|
||||
res = r.res[i]
|
||||
assert res.chainid =="_"
|
||||
assert res.resid =="143"
|
||||
assert res.seqres =="A"
|
||||
assert res.atom =="A"
|
||||
self.assertEqual(res.chainid, "_")
|
||||
self.assertEqual(res.resid, "143")
|
||||
self.assertEqual(res.seqres, "A")
|
||||
self.assertEqual(res.atom, "A")
|
||||
|
||||
r = Raf.SeqMap(self.rafLine2)
|
||||
res = r.res[r.index("6A", chainid="A")]
|
||||
assert res.resid =="6A"
|
||||
assert res.atom=="E"
|
||||
self.assertEqual(res.resid, "6A")
|
||||
self.assertEqual(res.atom, "E")
|
||||
|
||||
def testSeqMapAdd(self):
|
||||
r2 = Raf.SeqMap(self.rafLine2)
|
||||
@ -42,23 +42,23 @@ class RafTests(unittest.TestCase):
|
||||
|
||||
l = len(r2.res) + len(r3.res)
|
||||
r2 += r3
|
||||
assert len(r2.res) == l
|
||||
self.assertEqual(len(r2.res), l)
|
||||
|
||||
|
||||
r2.extend(r2)
|
||||
assert len(r2.res) == l*2
|
||||
self.assertEqual(len(r2.res), l*2)
|
||||
|
||||
r4 = r2 + r2
|
||||
assert len(r4.res) == l*4
|
||||
self.assertEqual(len(r4.res), l*4)
|
||||
|
||||
r4.append(Raf.Res())
|
||||
assert len(r4.res) == (l*4)+1
|
||||
self.assertEqual(len(r4.res), (l*4)+1)
|
||||
|
||||
|
||||
def testSeqMapSlice(self):
|
||||
r = Raf.SeqMap(self.rafLine)
|
||||
r = r[ r.index("124"): r.index("135")+1]
|
||||
assert len(r.res) ==12
|
||||
self.assertEqual(len(r.res), 12)
|
||||
|
||||
|
||||
def testSeqMapIndex(self):
|
||||
@ -66,29 +66,29 @@ class RafTests(unittest.TestCase):
|
||||
|
||||
index = Raf.SeqMapIndex(filename)
|
||||
r = index.getSeqMap("103m")
|
||||
assert r.pdbid == "103m", r.pdbid
|
||||
assert len(r.res) ==154, len(r.res)
|
||||
assert r.pdb_datestamp =="010301"
|
||||
assert r.flags =="111011"
|
||||
self.assertEqual(r.pdbid, "103m")
|
||||
self.assertEqual(len(r.res), 154)
|
||||
self.assertEqual(r.pdb_datestamp, "010301")
|
||||
self.assertEqual(r.flags, "111011")
|
||||
|
||||
r = index.getSeqMap("103m 1-10")
|
||||
assert r.pdbid == "103m", r.pdbid
|
||||
assert len(r.res) ==10, len(r.res)
|
||||
assert r.pdb_datestamp =="010301"
|
||||
assert r.flags =="111011"
|
||||
self.assertEqual(r.pdbid, "103m",)
|
||||
self.assertEqual(len(r.res), 10)
|
||||
self.assertEqual(r.pdb_datestamp, "010301")
|
||||
self.assertEqual(r.flags, "111011")
|
||||
|
||||
r = index.getSeqMap("104l A:")
|
||||
assert r.pdbid == "104l", r.pdbid
|
||||
self.assertEqual(r.pdbid, "104l")
|
||||
|
||||
r = index.getSeqMap("104l A:112-113")
|
||||
assert r.pdbid == "104l", r.pdbid
|
||||
assert len(r.res)== 2
|
||||
self.assertEqual(r.pdbid, "104l")
|
||||
self.assertEqual(len(r.res), 2)
|
||||
|
||||
r = index.getSeqMap("104l A:112-113,B:146-148")
|
||||
assert r.pdbid == "104l", r.pdbid
|
||||
assert len(r.res)== 5
|
||||
self.assertEqual(r.pdbid, "104l")
|
||||
self.assertEqual(len(r.res), 5)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__=='__main__':
|
||||
runner = unittest.TextTestRunner(verbosity = 2)
|
||||
unittest.main(testRunner=runner)
|
||||
|
||||
@ -31,53 +31,47 @@ class ResiduesTests(unittest.TestCase):
|
||||
def testParse(self):
|
||||
for loc in self.res:
|
||||
r = Residues(loc[0])
|
||||
assert r.fragments == loc[1], str(r.locations)
|
||||
self.assertEqual(r.fragments, loc[1])
|
||||
|
||||
def testStr(self):
|
||||
for loc in self.res:
|
||||
r = Residues(loc[0])
|
||||
assert str(r) == loc[0], str(r)+" is not "+loc[0]
|
||||
self.assertEqual(str(r), loc[0])
|
||||
|
||||
def testAstralParse(self):
|
||||
"""Astral encloses residue subsets in brackets. Lets make sure we
|
||||
can parse those too.
|
||||
"""
|
||||
"""Test if we can parse residue subsets enclosed in brackets"""
|
||||
for loc in self.res:
|
||||
r = Residues("("+loc[0]+")")
|
||||
assert r.fragments == loc[1], str(r.locations)
|
||||
self.assertEqual(r.fragments, loc[1])
|
||||
|
||||
def testPdbId(self):
|
||||
pdbid ="1ddf"
|
||||
for loc in self.res:
|
||||
r = Residues("\t 1ddf \t"+loc[0]+"\t\n\n\n")
|
||||
assert r.pdbid == pdbid
|
||||
assert str(r) == pdbid+" "+loc[0]
|
||||
self.assertEqual(r.pdbid, pdbid)
|
||||
self.assertEqual(str(r), pdbid+" "+loc[0])
|
||||
|
||||
r = Residues(pdbid+" "+loc[0])
|
||||
assert r.pdbid == pdbid
|
||||
assert str(r) == pdbid+" "+loc[0]
|
||||
self.assertEqual(r.pdbid, pdbid)
|
||||
self.assertEqual(str(r), pdbid+" "+loc[0])
|
||||
|
||||
|
||||
r = Residues("104l A:112-113")
|
||||
assert r.pdbid == "104l"
|
||||
assert r.fragments == (('A', '112', '113'),)
|
||||
self.assertEqual(r.pdbid, "104l")
|
||||
self.assertEqual(r.fragments, (('A', '112', '113'),))
|
||||
|
||||
|
||||
def testJustPdbId(self):
|
||||
r = Residues("1sds")
|
||||
assert r.pdbid == "1sds"
|
||||
assert not r.fragments
|
||||
self.assertEqual(r.pdbid, "1sds")
|
||||
self.assertFalse(r.fragments)
|
||||
|
||||
|
||||
def testParseError(self):
|
||||
try:
|
||||
r = Residues("09324923423hh./;,.389")
|
||||
assert 0, "Should never get here: "+str(r)
|
||||
except ValueError, e:
|
||||
pass
|
||||
self.assertRaises(ValueError, Residues, "09324923423hh./;,.389")
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
if __name__=='__main__':
|
||||
runner = unittest.TextTestRunner(verbosity = 2)
|
||||
unittest.main(testRunner=runner)
|
||||
|
||||
@ -35,77 +35,73 @@ class ScopTests(unittest.TestCase):
|
||||
|
||||
cla_out = StringIO()
|
||||
scop.write_cla(cla_out)
|
||||
assert cla_out.getvalue() == cla, cla_out.getvalue()
|
||||
self.assertEqual(cla_out.getvalue(), cla)
|
||||
|
||||
des_out = StringIO()
|
||||
scop.write_des(des_out)
|
||||
assert des_out.getvalue() == des, des_out.getvalue()
|
||||
self.assertEqual(des_out.getvalue(), des)
|
||||
|
||||
hie_out = StringIO()
|
||||
scop.write_hie(hie_out)
|
||||
assert hie_out.getvalue() == hie, hie_out.getvalue()
|
||||
self.assertEqual(hie_out.getvalue(), hie)
|
||||
|
||||
domain = scop.getDomainBySid("d1hbia_")
|
||||
assert domain.sunid == 14996
|
||||
self.assertEqual(domain.sunid, 14996)
|
||||
|
||||
domains = scop.getDomains()
|
||||
assert len(domains)==14
|
||||
assert domains[4].sunid == 14988
|
||||
self.assertEqual(len(domains), 14)
|
||||
self.assertEqual(domains[4].sunid, 14988)
|
||||
|
||||
|
||||
dom = scop.getNodeBySunid(-111)
|
||||
assert dom == None
|
||||
self.assertEqual(dom, None)
|
||||
dom = scop.getDomainBySid("no such domain")
|
||||
assert dom == None
|
||||
self.assertEqual(dom, None)
|
||||
|
||||
|
||||
|
||||
def testSccsOrder(self):
|
||||
assert cmp_sccs("a.1.1.1", "a.1.1.1") == 0
|
||||
assert cmp_sccs("a.1.1.2", "a.1.1.1") == 1
|
||||
assert cmp_sccs("a.1.1.2", "a.1.1.11") == -1
|
||||
assert cmp_sccs("a.1.2.2", "a.1.1.11") == 1
|
||||
assert cmp_sccs("a.1.2.2", "a.5.1.11") == -1
|
||||
assert cmp_sccs("b.1.2.2", "a.5.1.11") == 1
|
||||
assert cmp_sccs("b.1.2.2", "b.1.2") == 1
|
||||
self.assertEqual(cmp_sccs("a.1.1.1", "a.1.1.1"), 0)
|
||||
self.assertEqual(cmp_sccs("a.1.1.2", "a.1.1.1"), 1)
|
||||
self.assertEqual(cmp_sccs("a.1.1.2", "a.1.1.11"), -1)
|
||||
self.assertEqual(cmp_sccs("a.1.2.2", "a.1.1.11"), 1)
|
||||
self.assertEqual(cmp_sccs("a.1.2.2", "a.5.1.11"), -1)
|
||||
self.assertEqual(cmp_sccs("b.1.2.2", "a.5.1.11"), 1)
|
||||
self.assertEqual(cmp_sccs("b.1.2.2", "b.1.2"), 1)
|
||||
|
||||
def testParseDomain(self):
|
||||
s=">d1tpt_1 a.46.2.1 (1-70) Thymidine phosphorylase {Escherichia coli}"
|
||||
dom = parse_domain(s)
|
||||
|
||||
assert dom.sid == 'd1tpt_1'
|
||||
assert dom.sccs == 'a.46.2.1'
|
||||
assert dom.residues.pdbid == '1tpt'
|
||||
assert dom.description == 'Thymidine phosphorylase {Escherichia coli}'
|
||||
self.assertEqual(dom.sid, 'd1tpt_1')
|
||||
self.assertEqual(dom.sccs, 'a.46.2.1')
|
||||
self.assertEqual(dom.residues.pdbid, '1tpt')
|
||||
self.assertEqual(dom.description, 'Thymidine phosphorylase {Escherichia coli}')
|
||||
|
||||
s2="d1tpt_1 a.46.2.1 (1tpt 1-70) Thymidine phosphorylase {E. coli}"
|
||||
assert s2 == str(parse_domain(s2)), str(parse_domain(s2))
|
||||
self.assertEqual(s2, str(parse_domain(s2)))
|
||||
|
||||
|
||||
|
||||
#Genetic domains (See Astral release notes)
|
||||
s3="g1cph.1 g.1.1.1 (1cph B:,A:) Insulin {Cow (Bos taurus)}"
|
||||
assert s3 == str(parse_domain(s3)), str(parse_domain(s3))
|
||||
self.assertEqual(s3, str(parse_domain(s3)))
|
||||
|
||||
s4="e1cph.1a g.1.1.1 (1cph A:) Insulin {Cow (Bos taurus)}"
|
||||
assert s4 == str(parse_domain(s4))
|
||||
self.assertEqual(s4, str(parse_domain(s4)))
|
||||
|
||||
#Raw Astral header
|
||||
s5=">e1cph.1a g.1.1.1 (A:) Insulin {Cow (Bos taurus)}"
|
||||
assert s4 == str(parse_domain(s5))
|
||||
self.assertEqual(s4, str(parse_domain(s5)))
|
||||
|
||||
try:
|
||||
dom = parse_domain("Totally wrong")
|
||||
assert False, "Should never get here"
|
||||
except ValueError, e:
|
||||
pass
|
||||
self.assertRaises(ValueError, parse_domain, "Totally wrong")
|
||||
|
||||
def testConstructFromDirectory(self):
|
||||
scop = Scop (dir_path="SCOP", version="test")
|
||||
assert isinstance(scop, Scop)
|
||||
scop = Scop (dir_path="SCOP", version="test")
|
||||
self.assertTrue(isinstance(scop, Scop))
|
||||
|
||||
domain = scop.getDomainBySid("d1hbia_")
|
||||
assert domain.sunid == 14996
|
||||
domain = scop.getDomainBySid("d1hbia_")
|
||||
self.assertEqual(domain.sunid, 14996)
|
||||
|
||||
def testGetAscendent(self):
|
||||
scop = Scop (dir_path="SCOP", version="test")
|
||||
@ -113,19 +109,19 @@ class ScopTests(unittest.TestCase):
|
||||
|
||||
# get the fold
|
||||
fold = domain.getAscendent('cf')
|
||||
assert fold.sunid == 46457
|
||||
self.assertEqual(fold.sunid, 46457)
|
||||
|
||||
#get the superfamily
|
||||
sf = domain.getAscendent('superfamily')
|
||||
assert sf.sunid == 46458
|
||||
self.assertEqual(sf.sunid, 46458)
|
||||
|
||||
# px has no px ascendent
|
||||
px = domain.getAscendent('px')
|
||||
assert px == None
|
||||
self.assertEqual(px, None)
|
||||
|
||||
# an sf has no px ascendent
|
||||
px2 = sf.getAscendent('px')
|
||||
assert px2 == None
|
||||
self.assertEqual(px2, None)
|
||||
|
||||
|
||||
def test_get_descendents(self):
|
||||
@ -135,22 +131,22 @@ class ScopTests(unittest.TestCase):
|
||||
|
||||
# get px descendents
|
||||
domains = fold.getDescendents('px')
|
||||
assert len(domains) == 14
|
||||
self.assertEqual(len(domains), 14)
|
||||
for d in domains:
|
||||
assert d.type == 'px'
|
||||
self.assertEqual(d.type, 'px')
|
||||
|
||||
sfs = fold.getDescendents('superfamily')
|
||||
assert len(sfs) == 1
|
||||
self.assertEqual(len(sfs), 1)
|
||||
for d in sfs:
|
||||
assert d.type == 'sf'
|
||||
self.assertEqual(d.type, 'sf')
|
||||
|
||||
# cl has no cl descendent
|
||||
cl = fold.getDescendents('cl')
|
||||
assert cl == []
|
||||
self.assertEqual(cl, [])
|
||||
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if __name__=='__main__':
|
||||
runner = unittest.TextTestRunner(verbosity = 2)
|
||||
unittest.main(testRunner=runner)
|
||||
|
||||
Reference in New Issue
Block a user