github.com/biogo/biogo@v1.0.4/align/pals/filter/filter_test.go (about)

     1  // Copyright ©2011-2012 The bíogo Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package filter
     6  
     7  import (
     8  	"sort"
     9  	"testing"
    10  
    11  	"gopkg.in/check.v1"
    12  
    13  	"github.com/biogo/biogo/alphabet"
    14  	"github.com/biogo/biogo/index/kmerindex"
    15  	"github.com/biogo/biogo/morass"
    16  	"github.com/biogo/biogo/seq/linear"
    17  	"github.com/biogo/biogo/util"
    18  )
    19  
    20  var k byte = 6
    21  
    22  // Tests
    23  func Test(t *testing.T) { check.TestingT(t) }
    24  
    25  type S struct{}
    26  
    27  var _ = check.Suite(&S{})
    28  
    29  func (s *S) TestFilterAndMerge(c *check.C) {
    30  	l := [...]byte{'A', 'C', 'G', 'T'}
    31  	Q := len(l)
    32  	a := &linear.Seq{Seq: make(alphabet.Letters, 0, util.Pow(Q, k))}
    33  	a.Alpha = alphabet.DNA
    34  	for _, i := range util.DeBruijn(byte(Q), k) {
    35  		a.Seq = append(a.Seq, alphabet.Letter(l[i]))
    36  	}
    37  	b := &linear.Seq{Seq: make(alphabet.Letters, 0, util.Pow(Q, k-1))}
    38  	// b.Alpha = alphabet.DNA // Not actually required for this use.
    39  	for _, i := range util.DeBruijn(byte(Q), k-1) {
    40  		b.Seq = append(b.Seq, alphabet.Letter(l[i]))
    41  	}
    42  	i, err := kmerindex.New(int(k), a)
    43  	if err != nil {
    44  		c.Fatalf("Failed to create kmerindex: %v", err)
    45  	}
    46  	i.Build()
    47  	p := &Params{WordSize: int(k), MinMatch: 50, MaxError: 4, TubeOffset: 32}
    48  	f := New(i, p)
    49  	var sorter *morass.Morass
    50  	if sorter, err = morass.New(Hit{}, "", "", 2<<20, false); err != nil {
    51  		c.Fatalf("Failed to create morass: %v", err)
    52  	}
    53  	f.Filter(b, false, false, sorter)
    54  	c.Check(sorter.Len(), check.Equals, int64(12))
    55  	r := make([]Hit, 1, sorter.Len())
    56  	for {
    57  		err = sorter.Pull(&r[len(r)-1])
    58  		if err != nil {
    59  			r = r[:len(r)-1]
    60  			break
    61  		}
    62  		r = append(r, Hit{})
    63  	}
    64  	want := map[Hit]bool{
    65  		{From: 0, To: 163, Diagonal: 32}:      true,
    66  		{From: 141, To: 247, Diagonal: 64}:    true,
    67  		{From: 237, To: 433, Diagonal: 1120}:  true,
    68  		{From: 241, To: 347, Diagonal: 96}:    true,
    69  		{From: 341, To: 452, Diagonal: 128}:   true,
    70  		{From: 447, To: 565, Diagonal: 1952}:  true,
    71  		{From: 542, To: 628, Diagonal: 1984}:  true,
    72  		{From: 627, To: 814, Diagonal: 2592}:  true,
    73  		{From: 786, To: 898, Diagonal: 2624}:  true,
    74  		{From: 868, To: 939, Diagonal: 2880}:  true,
    75  		{From: 938, To: 997, Diagonal: 3040}:  true,
    76  		{From: 938, To: 1024, Diagonal: 3072}: true,
    77  	}
    78  	got := make(map[Hit]bool)
    79  	for _, h := range r {
    80  		got[h] = true
    81  	}
    82  	c.Check(got, check.DeepEquals, want)
    83  	c.Check(sort.IsSorted(hits(r)), check.Equals, true)
    84  	m := NewMerger(i, b, p, 5, false)
    85  	for _, h := range r {
    86  		m.MergeFilterHit(&h)
    87  	}
    88  	t := m.FinaliseMerge()
    89  	sorter.CleanUp()
    90  	c.Check(len(t), check.Equals, 6)
    91  	la, lb := t.Sum()
    92  	c.Check(la, check.Equals, 1257)
    93  	c.Check(lb, check.Equals, 402)
    94  	c.Check(t, check.DeepEquals, Trapezoids{
    95  		{Top: 452, Bottom: 0, Left: -128, Right: 3},
    96  		{Top: 433, Bottom: 237, Left: -1120, Right: -1085},
    97  		{Top: 628, Bottom: 447, Left: -1984, Right: -1917},
    98  		{Top: 898, Bottom: 627, Left: -2624, Right: -2557},
    99  		{Top: 939, Bottom: 868, Left: -2880, Right: -2845},
   100  		{Top: 1024, Bottom: 938, Left: -3072, Right: -3005},
   101  	})
   102  }
   103  
   104  type hits []Hit
   105  
   106  func (h hits) Len() int           { return len(h) }
   107  func (h hits) Less(i, j int) bool { return h[i].Less(h[j]) }
   108  func (h hits) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }