1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
package seq
import (
"bytes"
"sort"
"testing"
"github.com/cznic/sortutil"
)
func TestBases2AmbBase(t *testing.T) {
type Test struct {
bases []byte
ambase byte
err error
}
tests := []Test{
{[]byte{'A'}, 'A', nil},
{[]byte{'c'}, 'C', nil},
{[]byte{'t'}, 'T', nil},
{[]byte{'u'}, 'T', nil},
{[]byte{'g'}, 'G', nil},
{[]byte{'a', 'c'}, 'M', nil},
{[]byte{'c', 'a'}, 'M', nil},
{[]byte{'a', 'g'}, 'R', nil},
{[]byte{'g', 'a'}, 'R', nil},
{[]byte{'a', 't'}, 'W', nil},
{[]byte{'t', 'a'}, 'W', nil},
{[]byte{'c', 'g'}, 'S', nil},
{[]byte{'g', 'c'}, 'S', nil},
{[]byte{'c', 't'}, 'Y', nil},
{[]byte{'t', 'c'}, 'Y', nil},
{[]byte{'g', 't'}, 'K', nil},
{[]byte{'t', 'g'}, 'K', nil},
{[]byte{'a', 'c', 'g'}, 'V', nil},
{[]byte{'a', 'c', 't'}, 'H', nil},
{[]byte{'a', 'G', 't'}, 'D', nil},
{[]byte{'C', 'g', 't'}, 'B', nil},
{[]byte{'C', 'g', 't', 'a'}, 'N', nil},
{[]byte{'j'}, 'N', ErrInvalidDNABase},
}
var amb byte
var err error
for _, test := range tests {
amb, err = Bases2AmbBase(test.bases)
if err != nil {
if err != ErrInvalidDNABase {
t.Errorf("error should be: %s, got: %s", ErrInvalidDNABase, err)
} else {
continue
}
}
if amb != test.ambase {
t.Errorf("Test Bases2AmbBase Err: %s, need: %c, got: %c\n", test.bases, test.ambase, amb)
}
}
}
type _AmbBase2BasesTest struct {
ambase byte
bases []byte
err error
}
var tests4AmbBase2Bases = []_AmbBase2BasesTest{
{'A', []byte{'A'}, nil},
{'C', []byte{'C'}, nil},
{'G', []byte{'G'}, nil},
{'T', []byte{'T'}, nil},
{'M', []byte{'A', 'C', 'M'}, nil},
{'R', []byte{'A', 'G', 'R'}, nil},
{'W', []byte{'A', 'T', 'W'}, nil},
{'S', []byte{'C', 'G', 'S'}, nil},
{'Y', []byte{'C', 'T', 'Y'}, nil},
{'K', []byte{'G', 'T', 'K'}, nil},
{'V', []byte{'A', 'C', 'G', 'M', 'R', 'S', 'V'}, nil},
{'H', []byte{'A', 'C', 'T', 'M', 'W', 'Y', 'H'}, nil},
{'D', []byte{'A', 'G', 'T', 'R', 'W', 'K', 'D'}, nil},
{'B', []byte{'C', 'G', 'T', 'S', 'Y', 'K', 'B'}, nil},
{'N', []byte{'A', 'C', 'M', 'G', 'R', 'S', 'V', 'T', 'W', 'Y', 'H', 'K', 'D', 'B', 'N'}, nil},
}
func TestAmbBase2Bases(t *testing.T) {
var bases []byte
var err error
var b1, b2 sortutil.ByteSlice
for _, test := range tests4AmbBase2Bases {
bases, err = AmbBase2Bases0(test.ambase)
if err != nil {
if err != ErrInvalidDNABase {
t.Errorf("error should be: %s, got: %s", ErrInvalidDNABase, err)
} else {
continue
}
}
b1 = sortutil.ByteSlice(bases)
b2 = sortutil.ByteSlice(test.bases)
sort.Sort(b1)
sort.Sort(b2)
if !bytes.Equal(b1, b2) {
t.Errorf("Test AmbBase2Bases0 Err: %c, need: %s, got: %s\n", test.ambase, b2, b1)
}
}
}
var RESULT [][]byte
func BenchmarkAmbBase2Bases0(b *testing.B) {
for i := 0; i < b.N; i++ {
var err error
result := [][]byte{}
for _, test := range tests4AmbBase2Bases {
var bases []byte
bases, err = AmbBase2Bases0(test.ambase)
if err != nil {
b.Errorf("Bench AmbBase2Bases0 Err")
}
result = append(result, bases)
}
RESULT = result
}
}
func BenchmarkAmbBase2Bases(b *testing.B) {
for i := 0; i < b.N; i++ {
var ok bool
result := [][]byte{}
for _, test := range tests4AmbBase2Bases {
var bases []byte
if bases, ok = AmbBase2Bases[test.ambase]; ok {
result = append(result, bases)
}
}
RESULT = result
}
}
|
