cobot-0.1.1.8: test/JuliaSpec.hs
module JuliaSpec where
import Bio.Chain.Alignment
import Bio.Chain.Alignment.Scoring
import Test.Hspec
juliaBasedTests :: Spec
juliaBasedTests = do
juliaGlobal
juliaSemiglobal
juliaLocal
juliaGlobal :: Spec
juliaGlobal = do
describe "Global Alignment, Simple Gap" $ do
let testAlign = align (GlobalAlignment nuc44 (-9 :: Int))
let resBig1 = testAlign (bigA :: String) (bigB :: String)
resBig2 = testAlign (bigB :: String) (bigA :: String)
resMed1 = testAlign (bigA :: String) (bigB :: String)
resMed2 = testAlign (bigB :: String) (bigA :: String)
resSmall1 = testAlign (bigA :: String) (bigB :: String)
resSmall2 = testAlign (bigB :: String) (bigA :: String)
it "Is symmetric (big): " $ score resBig1 `shouldBe` score resBig2
it "Is symmetric (med): " $ score resMed1 `shouldBe` score resMed2
it "Is symmetric (small): " $ score resSmall1 `shouldBe` score resSmall2
-- scoremodel = AffineGapScoreModel(EDNAFULL, gap_open=0, gap_extend=-9);
-- pairalign(GlobalAlignment(), a, b, scoremodel)
let aAns = "CTCTGCAAGCATAGAGATATTTCACCGGCAATATTTTTCGTTGAAGTGTATTTGTCCCTATTATCACACC\
\AGTCATTCCGATGTCGTTAGGGCCGCCTGTTTTACTGGAGTTCCCGTTCGATGTACCCTCCTCCATAGA\
\GATTTAGGGGTATAGACCGCGACGGACGGGGCTTGCGAAAGCTGCCCGATAATGGACTTTGACAATAGA\
\CGTAATCCGTGAACGGCTGGCGTTTCACACTCAACCGCATTGAACAGCCATGCCATCCGCAGGATGCGC\
\CAGGGAAAAGCCACCCCCAAGAACGACTCCAGGGGCCCAAGTATGATGATAGCGTTAGGCTTGCTCGAA\
\GGCAAACAACTCCGAGGATGCTTAGCAGGCCACAACGTGCTCGATAGCACGAGCGTAAGATGCGAACGC\
\AGTAGTACCTAATGCGGGCGAGACATTTCGGGCCGTTGAAGCCCTGTCTGTTTTTTCGTACAGAGGGTGGTTTGAAGTATCGCCC"
bAns = "-T--G-AAGCA--GC-AT-TCG-ACT--CACTCATGT-CGCCTA-GAG-A---GAA--T-TTAT-A----\
\-GTCAA----ATGAC-TT-GTG--GC--GTTCT--TGGACTT----TTAGA-G--CCGAAATGCAT-G-\
\GA----GG---A-A-AC----A----------TT---AA-G--G----ATG-T--A-TTTG----T---\
\--TA--C--TGA--G-C---------A---T-----G-ATT-AA--GC-A----AT--------TGC-C\
\-AGGTAAA--C----------------T---G---CC-A-G---G-T--T----T--GG--------A-\
\--C---CAA-TC------T--T--G--GG--A----G--CT---TAGTAC---C-TAA-A-GA-AA-G-\
\A--AGT-C--A-TGCA--C-AGTCA---CG--CCGC--A--CC----------------A-A-----T------A--TA-CAC--"
res = testAlign (bigA :: String) (bigB :: String)
(a', b') = viewAlignment res
score1 = score res
it "first sequence" $ a' `shouldBe` aAns
it "second sequence" $ b' `shouldBe` bAns
it "score" $ score1 `shouldBe` (-1605)
let a2Ans = "-GT-TTGGG-CATATTC-AAG-ATCA-GAC-C-A----ATCGGTC-GAT-G--TGAAACAAGT--TA-\
\---ATAATGCTA-CACAGTGTTC--GCTG-T-TTT-A-CTTCGG-GT-CCTCCTGCCCCTTGAGG-A\
\--TATGAT--A--CAC----AACCG--CT--CTCTAGACA-GGAAGAAA-ACTGCACCGGATA--"
b2Ans = "AGCATTAGCTCACATAATAAGGATTGTGGGGCTACGGCATTTGTATGATAGCCTGACCGAGGTGGTAG\
\GGCATTAAGGTATCGTCGTCCTCCAGCTGGTGTTTTATCTGCCGCGCACCTCAAGTCGACTACGGTA\
\ACTATGGTTTATGCACGTGCAAACGTACTAACACTGGAGGCGGAATAATGATTAGAGTGGCCCGT"
res2 = testAlign (medA :: String) (medB :: String)
(a2', b2') = viewAlignment res2
score2 = score res2
it "first sequence" $ a2' `shouldBe` a2Ans
it "second sequence" $ b2' `shouldBe` b2Ans
it "score" $ score2 `shouldBe` (-168)
let a3Ans = "ATCATCTCGGACTATGGTTGGGGATCTAAGACGTCCTCTTGGCTCTCGCC"
b3Ans = "AAGAGATCGT--TATCGC-GCGGAT-TAAT---TCCGAGTCG-TC-CAC-"
res3 = testAlign (smallA :: String) (smallB :: String)
(a3', b3') = viewAlignment res3
score3 = score res3
it "first sequence" $ a3' `shouldBe` a3Ans
it "second sequence" $ b3' `shouldBe` b3Ans
it "score" $ score3 `shouldBe` (-16)
describe "GlobalAlignment. AffineGap" $ do
let testAlign = align (GlobalAlignment nuc44 (AffineGap (-5) (-1)))
res1 = testAlign "AGGT" "CAAT"
res2 = testAlign "AGGTACC" "CAATG"
-- Честно посчитано руками в тетради
it "score" $ score res1 `shouldBe` (-2)
it "score" $ score res2 `shouldBe` (-8)
it "alignment" $ viewAlignment res1 `shouldBe` ("--AGGT", "CAA--T")
it "alignment" $ viewAlignment res2 `shouldBe` ("--AGGTACC","CAATG----")
describe "GlobalAlignment. Sanity test" $ do
let resBig1 = align (GlobalAlignment nuc44 (AffineGap (-5) (-5))) (bigA :: String) (bigB :: String)
resBig2 = align (GlobalAlignment nuc44 (-5 :: Int)) (bigB :: String) (bigA :: String)
resMed1 = align (GlobalAlignment nuc44 (AffineGap (-5) (-5))) (medA :: String) (medB :: String)
resMed2 = align (GlobalAlignment nuc44 (-5 :: Int)) (medB :: String) (medA :: String)
resSmall1 = align (GlobalAlignment nuc44 (AffineGap (-5) (-5))) (smallA :: String) (smallB :: String)
resSmall2 = align (GlobalAlignment nuc44 (-5 :: Int)) (smallB :: String) (smallA :: String)
it "SimpleGap is a special case of AffineGap (big)" $ score resBig1 `shouldBe` score resBig2
it "SimpleGap is a special case of AffineGap (med)" $ score resMed1 `shouldBe` score resMed2
it "SimpleGap is a special case of AffineGap (small)" $ score resSmall1 `shouldBe` score resSmall2
juliaSemiglobal :: Spec
juliaSemiglobal = do
describe "Semiglobal Alignment, Simple Gap" $ do
let testAlign = align (SemiglobalAlignment nuc44 (-3 :: Int))
let resBig1 = testAlign (bigA :: String) (bigB :: String)
resBig2 = testAlign (bigB :: String) (bigA :: String)
resMed1 = testAlign (bigA :: String) (bigB :: String)
resMed2 = testAlign (bigB :: String) (bigA :: String)
resSmall1 = testAlign (bigA :: String) (bigB :: String)
resSmall2 = testAlign (bigB :: String) (bigA :: String)
it "Is symmetric (big): " $ score resBig1 `shouldBe` score resBig2
it "Is symmetric (med): " $ score resMed1 `shouldBe` score resMed2
it "Is symmetric (small): " $ score resSmall1 `shouldBe` score resSmall2
-- scoremodel = AffineGapScoreModel(EDNAFULL, gap_open=0, gap_extend=-3);
-- pairalign(OverlapAlignment(), a, b, scoremodel)
let aAns = "CTCTGCAAGCATAGAGATATTTCACCGGCAATATTTTTCGTTGAAGTGTATTTGTCCCTATTATCACACC\
\AGTCATTCCGATGTCGTTAGGGCCGCCTGTTTTACTG--G-AG--TTC--C-CGTTCGATGTACCCTCC\
\TCCATAGAGA-TTTAGGGGTA-T-AGACCGCGACGGACGGGGCTTGCGAAAGCTGCCCGATAATGGACT\
\TTGACAATAGACGTAATCCGTGAACGGC-TGGCGTTTCACACTCAACCGCATTGAACAGCCATGCCATC\
\CGC-AGGATGCGCCAGGGAA-AAGCCACCCCCAAG-AACGACT-CCAGG---GGCCCAAGTATGATGAT\
\AGCGTTAGGCTTGCTCGAAGGCAAACAACTCCGAGGATGCTTAG-CAGGCCACAACGTGC--TCGATAG\
\CACGAGCGTAAGATGCGAACGCAGTAGTACCTAATGCGGGCGAGACATTTCGGGCCGTTGAAGCCCTGT\
\CTGTTTTTTCGTACAGAGGGTGGTTTGAAGTATCGCCC"
bAns = "----------------------------------------------------------------------\
\-----------------------------------TGAAGCAGCATTCGACTCACTC-ATGT-CGC-C-\
\T--AGAGAGAATTTA----TAGTCA-A-----ATG-AC-----TTGTG---GC-GTTC--T--TGGACT\
\TT-----TAGA-G----CCGA-AATG-CATGGAGG---A-A---A-C---ATT-AAG-G--ATGT-ATT\
\TGTTAC--TGAGC-ATG-ATTAAGCAATTGCCAGGTAA--ACTGCCAGGTTTGGACCAA-TCT--TGGG\
\AGC-TTAG--TACCTA-AAG--AAAGAAGTC--A---TGCACAGTCACGCCGCA-C---CAAT--ATA-\
\CAC------------------------------------------------------------------\
\--------------------------------------"
res = testAlign (bigA :: String) (bigB :: String)
(a', b') = viewAlignment res
score1 = score res
it "first sequence" $ a' `shouldBe` aAns
it "second sequence" $ b' `shouldBe` bAns
it "score" $ score1 `shouldBe` 358
let a2Ans = "---------------------G-TT-TGGG-C-AT---ATTCA-A-GATCAGACCAATCGGTCGATGT\
\GAAA---CAAGTTAA--TAAT-G-C-TACAC-AG-TGTTCGCTGTTTTACTTCGGGTCCTCCTGCCC\
\CTTGAG--GA-TATGATACACAACCGCTCTCTA-G-ACAG-G-AA--G-A--AA-ACTGCAC-CGGA\
\-TA------------------"
b2Ans = "AGCATTAGCTCACATAATAAGGATTGTGGGGCTACGGCATTTGTATGAT-AG-CC--T-GACCGAGGT\
\GGTAGGGCA--TTAAGGTA-TCGTCGTCCTCCAGCTG---G-TGTTTTA-T-CTG--CCGC--GCAC\
\CTCAAGTCGACTACGGTA-ACTATGG-T-T-TATGCAC-GTGCAAACGTACTAACACTGGAGGCGGA\
\ATAATGATTAGAGTGGCCCGT"
res2 = testAlign (medA :: String) (medB :: String)
(a2', b2') = viewAlignment res2
score2 = score res2
it "first sequence" $ a2' `shouldBe` a2Ans
it "second sequence" $ b2' `shouldBe` b2Ans
it "score" $ score2 `shouldBe` 266
let a3Ans = "ATCATCTCG--GACTATGGTT---G-G-GGATCTAA----GA--CGTCCTCTTGGCTCTCGCC"
b3Ans = "---------AAGAG-ATCGTTATCGCGCGGAT-TAATTCCGAGTCGTCCAC------------"
res3 = testAlign (smallA :: String) (smallB :: String)
(a3', b3') = viewAlignment res3
score3 = score res3
it "first sequence" $ a3' `shouldBe` a3Ans
it "second sequence" $ b3' `shouldBe` b3Ans
it "score" $ score3 `shouldBe` 63
describe "SemiglobalAlignment. Sanity test" $ do
let resBig1 = align (SemiglobalAlignment nuc44 (AffineGap (-3) (-3))) (bigA :: String) (bigB :: String)
resBig2 = align (SemiglobalAlignment nuc44 (-3 :: Int)) (bigB :: String) (bigA :: String)
resMed1 = align (SemiglobalAlignment nuc44 (AffineGap (-3) (-3))) (medA :: String) (medB :: String)
resMed2 = align (SemiglobalAlignment nuc44 (-3 :: Int)) (medB :: String) (medA :: String)
resSmall1 = align (SemiglobalAlignment nuc44 (AffineGap (-3) (-3))) (smallA :: String) (smallB :: String)
resSmall2 = align (SemiglobalAlignment nuc44 (-3 :: Int)) (smallB :: String) (smallA :: String)
it "SimpleGap is a special case of AffineGap (big)" $ score resBig1 `shouldBe` score resBig2
it "SimpleGap is a special case of AffineGap (med)" $ score resMed1 `shouldBe` score resMed2
it "SimpleGap is a special case of AffineGap (small)" $ score resSmall1 `shouldBe` score resSmall2
juliaLocal :: Spec
juliaLocal = do
describe "Local Alignment, Simple Gap" $ do
let testAlign = align (LocalAlignment nuc44 (-7 :: Int))
let resBig1 = testAlign (bigA :: String) (bigB :: String)
resBig2 = testAlign (bigB :: String) (bigA :: String)
resMed1 = testAlign (bigA :: String) (bigB :: String)
resMed2 = testAlign (bigB :: String) (bigA :: String)
resSmall1 = testAlign (bigA :: String) (bigB :: String)
resSmall2 = testAlign (bigB :: String) (bigA :: String)
it "Is symmetric (big): " $ score resBig1 `shouldBe` score resBig2
it "Is symmetric (med): " $ score resMed1 `shouldBe` score resMed2
it "Is symmetric (small): " $ score resSmall1 `shouldBe` score resSmall2
-- scoremodel = AffineGapScoreModel(EDNAFULL, gap_open=0, gap_extend=-7);
-- pairalign(LocalAlignment(), a, b, scoremodel)
let aAns = "TGAA-CAGCCATGCCA-TC-CGCAGGATGCGCC-AGGGAAAAGCCACCCCCAAGAACGACTCCA\
\GGGGCCCAAGTATGATGATAGC-GTTAGGCTTGCTCGAAGGCAAACAACTCCGAGG-ATGC-T\
\TAGCAGGCCACAACGTGCTCGATAGCACGAGCGTAAGATGCGAACGCAGTAGTACCTAATGCGGGCGAGACATT"
bAns = "TGAAGCAGC-ATTCGACTCACTCATG-T-CGCCTAGAGAGAATTTATAGTCAA-AT-GACTTGT\
\GGCGTTCTTGGACTTTTAGAGCCGAAATGCATG---GA-GG-AAACATTAAGGATGTATTTGT\
\TA-CTGAGCATGAT-TAAGCAATTGC-C-AG-GTAAACTGCCAG-GTT-TGG-ACC-AATCTTGG-GAG-C-TT"
res = testAlign (bigA :: String) (bigB :: String)
(a', b') = viewAlignment res
score1 = score res
it "first sequence" $ a' `shouldBe` aAns
it "second sequence" $ b' `shouldBe` bAns
it "score" $ score1 `shouldBe` 108
let a2Ans = "GGCATATTCAAGATCAGACCAATCG-GTCGAT-GTGAAACAAGTTAATAATGCTACACAGTGT\
\TCGCTGTTTTA-CTTCGG-GT-CCTCCTGCCCCTTGAGG-A--TATGATACACAACCGCTCT\
\CTAGACAGGAAGAAAACTGCAC-CGGA-TA"
b2Ans = "GGCATTTGTATGAT-AGCCTGACCGAGGTGGTAGGGCATTAAGGTA-TCGTCGTCCTCCA-GC\
\TGG-TGTTTTATCTGCCGCGCACCTCAAGTCGACTACGGTAACTATGGTTTATGCACG-TG-\
\CAA-AC-GTACTAACACTGGAGGCGGAATA"
res2 = testAlign (medA :: String) (medB :: String)
(a2', b2') = viewAlignment res2
score2 = score res2
it "first sequence" $ a2' `shouldBe` a2Ans
it "second sequence" $ b2' `shouldBe` b2Ans
it "score" $ score2 `shouldBe` 91
let a3Ans = "TCTAAGACGTCCTC"
b3Ans = "TCCGAGTCGTCCAC"
res3 = testAlign (smallA :: String) (smallB :: String)
(a3', b3') = viewAlignment res3
score3 = score res3
it "first sequence" $ a3' `shouldBe` a3Ans
it "second sequence" $ b3' `shouldBe` b3Ans
it "score" $ score3 `shouldBe` 34
describe "LocalAlignment. Sanity test" $ do
let resBig1 = align (LocalAlignment nuc44 (AffineGap (-7) (-7))) (bigA :: String) (bigB :: String)
resBig2 = align (LocalAlignment nuc44 (-7 :: Int)) (bigB :: String) (bigA :: String)
resMed1 = align (LocalAlignment nuc44 (AffineGap (-7) (-7))) (medA :: String) (medB :: String)
resMed2 = align (LocalAlignment nuc44 (-7 :: Int)) (medB :: String) (medA :: String)
resSmall1 = align (LocalAlignment nuc44 (AffineGap (-7) (-7))) (smallA :: String) (smallB :: String)
resSmall2 = align (LocalAlignment nuc44 (-7 :: Int)) (smallB :: String) (smallA :: String)
it "SimpleGap is a special case of AffineGap (big)" $ score resBig1 `shouldBe` score resBig2
it "SimpleGap is a special case of AffineGap (med)" $ score resMed1 `shouldBe` score resMed2
it "SimpleGap is a special case of AffineGap (small)" $ score resSmall1 `shouldBe` score resSmall2
bigA :: String
bigA = "CTCTGCAAGCATAGAGATATTTCACCGGCAATATTTTTCGTTGAAGTGTATTTGTCCCTATTATCACACCAG\
\TCATTCCGATGTCGTTAGGGCCGCCTGTTTTACTGGAGTTCCCGTTCGATGTACCCTCCTCCATAGAGATT\
\TAGGGGTATAGACCGCGACGGACGGGGCTTGCGAAAGCTGCCCGATAATGGACTTTGACAATAGACGTAAT\
\CCGTGAACGGCTGGCGTTTCACACTCAACCGCATTGAACAGCCATGCCATCCGCAGGATGCGCCAGGGAAA\
\AGCCACCCCCAAGAACGACTCCAGGGGCCCAAGTATGATGATAGCGTTAGGCTTGCTCGAAGGCAAACAAC\
\TCCGAGGATGCTTAGCAGGCCACAACGTGCTCGATAGCACGAGCGTAAGATGCGAACGCAGTAGTACCTAA\
\TGCGGGCGAGACATTTCGGGCCGTTGAAGCCCTGTCTGTTTTTTCGTACAGAGGGTGGTTTGAAGTATCGCCC"
bigB :: String
bigB = "TGAAGCAGCATTCGACTCACTCATGTCGCCTAGAGAGAATTTATAGTCAAATGACTTGTGGCGTTCTTGGACT\
\TTTAGAGCCGAAATGCATGGAGGAAACATTAAGGATGTATTTGTTACTGAGCATGATTAAGCAATTGCCAGG\
\TAAACTGCCAGGTTTGGACCAATCTTGGGAGCTTAGTACCTAAAGAAAGAAGTCATGCACAGTCACGCCGCACCAATATACAC"
medA :: String
medA = "GTTTGGGCATATTCAAGATCAGACCAATCGGTCGATGTGAAACAAGTTAATAATGCTACACAGTGTTCGCTG\
\TTTTACTTCGGGTCCTCCTGCCCCTTGAGGATATGATACACAACCGCTCTCTAGACAGGAAGAAAACTGCACCGGATA"
medB :: String
medB = "AGCATTAGCTCACATAATAAGGATTGTGGGGCTACGGCATTTGTATGATAGCCTGACCGAGGTGGTAGGGCA\
\TTAAGGTATCGTCGTCCTCCAGCTGGTGTTTTATCTGCCGCGCACCTCAAGTCGACTACGGTAACTATGGT\
\TTATGCACGTGCAAACGTACTAACACTGGAGGCGGAATAATGATTAGAGTGGCCCGT"
smallA :: String
smallA = "ATCATCTCGGACTATGGTTGGGGATCTAAGACGTCCTCTTGGCTCTCGCC"
smallB :: String
smallB = "AAGAGATCGTTATCGCGCGGATTAATTCCGAGTCGTCCAC"