From: "Ken L." <lists@...>
Date: 2012-09-06T03:16:05+09:00
Subject: Re: Newbie needs help

7stud -- wrote in post #1074810:
> Where are your tests?


Here are my tests for the SeqRead class that I wrote.


require 'test/unit'

class SeqReadTesting < Test::Unit::TestCase

  def test_basic

    seqRead1 = SeqRead.new(
      "AGTCAGAGTCGCCACCTGTTCTCCCTACATCAAATGTCTATCCCCGCACCAAGTGGAGATTCCATGAGGATGAGGACGCTGACTCCGGCAAGATCGGAAG",
      "@@@FFFFFHGHHHGHIGHHIIII+<9?CFCGF@B*111:?90*0?0@A--86(7@77@G#########################################",
      "@HWI-ST577:156:D16VVACXX:7:1101:1374:2212"
      )
    pL = DNA.new("TGC CGG AGT CAG CGT") # 5' -> 3' left primer
    pR = DNA.new("AGT CAG AGT CGC CAC") # 5' -> 3' right primer

    assert_equal(seqRead1.dna_seq, seqRead1.stripPrimer(pR,
false).dna_seq)
    assert_equal(seqRead1.dna_seq, seqRead1.stripPrimer(pL,
true).dna_seq)
    assert_equal(seqRead1.qscore, seqRead1.stripPrimer(pR,
false).qscore)
    assert_equal(seqRead1.qscore, seqRead1.stripPrimer(pL, true).qscore)

    assert_equal("CTGTTCTCCCTACATCAAATGTCTATCCCCGCACCAAGTGGAGATTCCATGAGGATGAGGACGCTGACTCCGGCAAGATCGGAAG",
      seqRead1.stripPrimer(pR, true).dna_seq)
    assert_equal("IGHHIIII+<9?CFCGF@B*111:?90*0?0@A--86(7@77@G#########################################",
      seqRead1.stripPrimer(pR, true).qscore)
    assert_equal("AGTCAGAGTCGCCACCTGTTCTCCCTACATCAAATGTCTATCCCCGCACCAAGTGGAGATTCCATGAGGATGAGG",
      seqRead1.stripPrimer(pL, false).dna_seq)
    assert_equal("@@@FFFFFHGHHHGHIGHHIIII+<9?CFCGF@B*111:?90*0?0@A--86(7@77@G################",
      seqRead1.stripPrimer(pL, false).qscore)

    assert_equal("IGHHIIII+<9?CFCGF@B*111:?90*0?0@A--86(7@77@G################",
      seqRead1.stripPrimers(pL, pR).qscore)
    assert_equal("CTGTTCTCCCTACATCAAATGTCTATCCCCGCACCAAGTGGAGATTCCATGAGGATGAGG",
      seqRead1.stripPrimers(pL, pR).dna_seq)
  end

end



Here are my tests for the DNA class that I wrote.  It is called from
SeqRead.rb

require 'test/unit'

class DNATesting < Test::Unit::TestCase

  def test_basic
    @testBasic = DNA.new("ACGTMKRYBVDHXN")
    assert_equal("TGCAKMYRVBHDXN", @testBasic.rev_comp.dna_seq)
    assert_equal("R", @testBasic.rev_comp.direction)
    assert_equal("TGCAKMYRVBHDXN", @testBasic.comp.dna_seq)
    assert_equal("F", @testBasic.comp.direction)
  end

  def test_codons
    @testCodons = DNA.new("TTT TTT CTT ATC GTC GTC ATC TTT GTA GTC AGT
CAG AGT CGC CAC")
    assert_equal("TTT TTT CTT ATC GTC GTC ATC TTT GTA GTC AGT CAG AGT
CGC CAC",
      @testCodons.split_by_codon(0))
    assert_equal("T TTT TTC TTA TCG TCG TCA TCT TTG TAG TCA GTC AGA GTC
GCC AC ",
      @testCodons.split_by_codon(1))
    assert_equal("TT TTT TCT TAT CGT CGT CAT CTT TGT AGT CAG TCA GAG TCG
CCA C  ",
      @testCodons.split_by_codon(2))
    assert_equal("TTT TTT CTT ATC GTC GTC ATC TTT GTA GTC AGT CAG AGT
CGC CAC",
      @testCodons.split_by_codon(3))
  end

  def test_translation
    @testTrans = DNA.new("ATG GCG TGC CGT GAA TAG")
    assert_equal("MACRE*", @testTrans.translate(0, false).aa_seq)
    assert_equal("WRAVN",  @testTrans.translate(1, false).aa_seq)
    assert_equal("GVP*I",  @testTrans.translate(2, false).aa_seq)
    assert_equal("MACRE*", @testTrans.translate(3, false).aa_seq)
    @testTrans2 = DNA.new("GAT AAG TGC CGT GCG GTA", "R")
    assert_equal("MACRE*", @testTrans2.translate(0, false).aa_seq)
    assert_equal("WRAVN",  @testTrans2.translate(1, false).aa_seq)
    assert_equal("GVP*I",  @testTrans2.translate(2, false).aa_seq)
    assert_equal("MACRE*", @testTrans2.translate(3, false).aa_seq)
  end

  def test_stripPrimers
    @seq = DNA.new("CCGCCCA AGACCC CGTACCGTTTGGCGTGTCGAGCCCG CTCATC
GGAATG")
    @seq1 = DNA.new(
"CCGCCCAAGACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATCGGAATG")
    @seq2 = DNA.new(
"AGACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATCGGAATG")
    @seq3 = DNA.new(
"GACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATCGGAATG")
    @seq4 = DNA.new(
"ACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATCGGAATG")
    @seq5 = DNA.new(
"CCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATCGGAATG")
    @seq6 = DNA.new( "CCGCCCAAGACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATC")
    @seq7 = DNA.new( "CCGCCCAAGACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCAT")
    @seq8 = DNA.new( "CCGCCCAAGACCCCGTACCGTTTGGCGTGTCGAGCCCGCTCA")
    @seq9 = DNA.new( "CCGCCCAAGACCCCGTACCGTTTGGCGTGTCGAGCCCGCTC")
    @seq10 = DNA.new("GTA AGG CTA CTC GCC CGA GCT GTG CGG TTT GCC ATG
CCC CAG AAC CCG", "R")

    @primer_for = DNA.new("AGACCC")   # 5' -> 3'
    @primer_rev = DNA.new("GATGAG")   # 5' -> 3'

    assert_equal("CGTACCGTTTGGCGTGTCGAGCCCG",
@seq.stripPrimers(@primer_for, @primer_rev).dna_seq)
    assert_equal("CGTACCGTTTGGCGTGTCGAGCCCG",
@seq10.stripPrimers(@primer_for, @primer_rev).dna_seq)
    assert_equal("CGTACCGTTTGGCGTGTCGAGCCCG",
@seq1.stripPrimers(@primer_for, @primer_rev).dna_seq)
    assert_equal("CGTACCGTTTGGCGTGTCGAGCCCG",
@seq2.stripPrimers(@primer_for, @primer_rev).dna_seq)
    assert_equal("CGTACCGTTTGGCGTGTCGAGCCCG",
@seq3.stripPrimers(@primer_for, @primer_rev).dna_seq)
    assert_equal("ACCCCGTACCGTTTGGCGTGTCGAGCCCG",
@seq4.stripPrimers(@primer_for, @primer_rev).dna_seq)
    assert_equal("CCCCGTACCGTTTGGCGTGTCGAGCCCG",
@seq5.stripPrimers(@primer_for, @primer_rev).dna_seq)
    assert_equal("CGTACCGTTTGGCGTGTCGAGCCCG",
@seq6.stripPrimers(@primer_for, @primer_rev).dna_seq)
    assert_equal("CGTACCGTTTGGCGTGTCGAGCCCG",
@seq7.stripPrimers(@primer_for, @primer_rev).dna_seq)
    assert_equal("CGTACCGTTTGGCGTGTCGAGCCCGCTCA",
@seq8.stripPrimers(@primer_for, @primer_rev).dna_seq)
    assert_equal("CGTACCGTTTGGCGTGTCGAGCCCGCTC",
@seq9.stripPrimers(@primer_for, @primer_rev).dna_seq)

    @primer_for = DNA.new("")
    assert_equal("CCCCGTACCGTTTGGCGTGTCGAGCCCGCTCATCGGAATG",
@seq5.stripPrimer(@primer_for, true).dna_seq)
  end
end

class PeptideTesting < Test::Unit::TestCase


  def test_private_combination
    a = ["A","B"]
    b = ["C","D"]
    c = ["E"]
    d = "F"
    e = []
    temp = Peptide.new("MACRE")
    assert_equal([["A","C"],["B","C"],["A","D"],["B","D"]],
      temp.send(:combination, a, b))
    assert_equal([["C","A"],["D","A"],["C","B"],["D","B"]],
      temp.send(:combination, b, a))
    assert_equal([["A","E"],["B","E"]],
      temp.send(:combination, a, c))
    assert_equal([["E","A"],["E","B"]],
      temp.send(:combination, c, a))
    assert_equal([["A","F"],["B","F"]],
      temp.send(:combination, a, d))
    assert_equal([["F","A"],["F","B"]],
      temp.send(:combination, d, a))
    assert_equal([["E"]], temp.send(:combination, e, c))
    assert_equal([["E"]], temp.send(:combination, c, e))
    assert_equal(temp.send(:combination, d, e),
      temp.send(:combination, e, d))
  end
end



What is really weird to me is that the problem only shows itself when I 
specify the range of lines to use.  When I do this,

ruby ~/Ruby_code/SeqRead.rb

Run options:

# Running tests:

......

Finished tests in 0.013596s, 441.3063 tests/s, 3456.8991 assertions/s.

6 tests, 47 assertions, 0 failures, 0 errors, 0 skips

or

ruby ~/Ruby_code/DNA_Class.rb

Run options:

# Running tests:

.....

Finished tests in 0.005082s, 983.8646 tests/s, 7280.5982 assertions/s.

5 tests, 37 assertions, 0 failures, 0 errors, 0 skips

So it seems that the classes are ok, just somehow interacting with ARGV 
gives me a problem.  I am so lost.

Thanks for helping!

-- 
Posted via http://www.ruby-forum.com/.