libsequence  1.9.5
PolyTableConversions.cc
1 #include <Sequence/PolySites.hpp>
2 #include <Sequence/SimpleSNP.hpp>
3 #include <Sequence/SimData.hpp>
4 #include <Sequence/Fasta.hpp>
5 #include <Sequence/Alignment.hpp>
7 #include <boost/test/unit_test.hpp>
8 #include <cstdio>
9 #include <cstdlib>
10 #include <iostream>
11 
12 BOOST_AUTO_TEST_SUITE(PolyTableConversionsTest)
13 
14 BOOST_AUTO_TEST_CASE( make_a_table_from_strings )
15 {
16  std::vector< std::string >
17  data = { ("AATAG"),
18  ("ATTAC") };
19 
20  BOOST_REQUIRE( !data.empty() );
21  BOOST_REQUIRE_EQUAL( data.size(), 2 );
22  BOOST_REQUIRE_EQUAL( data[0].size(),5 );
23  BOOST_REQUIRE_EQUAL( data[0].length(),5 );
24  BOOST_REQUIRE( Sequence::Alignment::IsAlignment(data) );
25  Sequence::PolySites ps(data);
26  BOOST_REQUIRE_EQUAL( ps.numsites(), 2 );
27 }
28 
29 BOOST_AUTO_TEST_CASE( make_a_table_from_Fasta )
30 {
31  std::vector< Sequence::Fasta >
32  data = { Sequence::Fasta("seq1","AATAG"),
33  Sequence::Fasta("seq2","ATTAC") };
34 
35  BOOST_REQUIRE( !data.empty() );
36  BOOST_REQUIRE_EQUAL( data.size(), 2 );
37  BOOST_REQUIRE_EQUAL( data[0].length(),5 );
38  BOOST_REQUIRE( Sequence::Alignment::IsAlignment(data) );
39  Sequence::PolySites ps(data);
40  BOOST_REQUIRE_EQUAL( ps.numsites(), 2 );
41 }
42 
43 BOOST_AUTO_TEST_CASE( conversion1 )
44 {
45  std::vector< Sequence::Fasta >
46  data = { Sequence::Fasta("seq1","AATAG"),
47  Sequence::Fasta("seq2","ATTAC") };
48 
49  Sequence::PolySites ps(data);
50 
52  ps2.assign(ps.sbegin(),ps.send());
53 
54  BOOST_REQUIRE( ps == ps2 );
55 
56  ps.assign(ps2.sbegin(),ps2.send());
57 
58  BOOST_REQUIRE( ps == ps2 );
59 }
60 
61 BOOST_AUTO_TEST_CASE( conversion2 )
62 {
63  std::vector< Sequence::Fasta >
64  data = { Sequence::Fasta("seq1","AATAG"),
65  Sequence::Fasta("seq2","ATTAC"),
66  Sequence::Fasta("seq3","AATAC") };
67 
68  Sequence::PolySites ps(data);
69  ps = Sequence::polyTableToBinary(ps);
70  //ps.Binary();
71  Sequence::SimData sd(ps.sbegin(),ps.send());
72 
73  BOOST_REQUIRE(ps == sd);
74 }
75 
76 BOOST_AUTO_TEST_CASE( conversion3 )
77 {
78  std::vector< Sequence::Fasta >
79  data = { Sequence::Fasta("seq1","AATAG"),
80  Sequence::Fasta("seq2","ATTAC"),
81  Sequence::Fasta("seq3","AATAC") };
82 
83  Sequence::PolySites ps(data);
85  ss.assign(ps.sbegin(),ps.send());
86  BOOST_REQUIRE( ss.label(0) != "anc" );
87  ss.set_outgroup(true);
88 
89  BOOST_REQUIRE_EQUAL( ss.label(0) , "anc" );
90 
91  BOOST_REQUIRE_THROW( ss.label(ss.size()), std::out_of_range );
92 }
93 
94 BOOST_AUTO_TEST_CASE( conversion2_throw )
95 {
96  std::vector< Sequence::Fasta >
97  data = { Sequence::Fasta("seq1","AATAG"),
98  Sequence::Fasta("seq2","ATTAC"),
99  Sequence::Fasta("seq3","AATAC") };
100 
101  //This must not throw, even though our data are not 0/1.
102  //Checking what is read in is left up to the programmer
103  Sequence::PolySites ps(data);
104  BOOST_REQUIRE_NO_THROW(Sequence::SimData sd(ps.sbegin(),ps.send()));
105 }
106 
107 BOOST_AUTO_TEST_CASE( const_construction_1 )
108 {
109  std::vector< Sequence::Fasta >
110  data = { Sequence::Fasta("seq1","AATAG"),
111  Sequence::Fasta("seq2","ATTAC"),
112  Sequence::Fasta("seq3","AATAC") };
113 
114  Sequence::PolySites ps(data);
115  std::vector<double> pos;
116  std::vector<std::string> snps;
117  std::copy( ps.pbegin(), ps.pend(),
118  std::back_inserter(pos) );
119  std::copy( ps.begin(), ps.end(),
120  std::back_inserter(snps) );
121 
122  Sequence::PolySites ps2(pos,snps);
123 
124  BOOST_CHECK_EQUAL( pos.size(), ps2.numsites() );
125  BOOST_CHECK_EQUAL( snps.size(), ps2.size() );
126  BOOST_REQUIRE_EQUAL( ps.numsites() , ps2.numsites() );
127  BOOST_REQUIRE_EQUAL( ps.size() , ps2.size() );
128  BOOST_REQUIRE( ps == ps2 );
129 }
130 
131 BOOST_AUTO_TEST_CASE( const_construction_2 )
132 {
133  std::vector< Sequence::Fasta >
134  data = { Sequence::Fasta("seq1","AATAG"),
135  Sequence::Fasta("seq2","ATTAC"),
136  Sequence::Fasta("seq3","AATAC") };
137 
138  Sequence::PolySites ps(data);
139  std::vector<double> pos;
140  std::vector<std::string> snps;
141  std::copy( ps.pbegin(), ps.pend(),
142  std::back_inserter(pos) );
143  std::copy( ps.begin(), ps.end(),
144  std::back_inserter(snps) );
145 
146  //These next two represent IQ test failures by a user
147 
148  //Is this picking the const constructor,
149  //or the move constructor?
150  //It should pick the const
151  Sequence::PolySites ps2(pos,
152  snps);
153 
154  BOOST_CHECK_EQUAL( pos.size(), ps2.numsites() );
155  BOOST_CHECK_EQUAL( snps.size(), ps2.size() );
156  BOOST_REQUIRE_EQUAL( ps.numsites() , ps2.numsites() );
157  BOOST_REQUIRE_EQUAL( ps.size() , ps2.size() );
158  BOOST_REQUIRE( ps == ps2 );
159 
160  //Test the reverse
161  ps2 = Sequence::PolySites(std::move(pos),
162  std::move(snps));
163 
164  BOOST_CHECK_EQUAL( pos.size(), 0 );
165  BOOST_CHECK_EQUAL( snps.size(), 0 );
166  BOOST_REQUIRE_EQUAL( ps.numsites() , ps2.numsites() );
167  BOOST_REQUIRE_EQUAL( ps.size() , ps2.size() );
168  BOOST_REQUIRE( ps == ps2 );
169 
170 }
171 
172 BOOST_AUTO_TEST_CASE( move_construction_1 )
173 {
174  std::vector< Sequence::Fasta >
175  data = { Sequence::Fasta("seq1","AATAG"),
176  Sequence::Fasta("seq2","ATTAC"),
177  Sequence::Fasta("seq3","AATAC") };
178 
179  Sequence::PolySites ps(data);
180  std::vector<double> pos;
181  std::vector<std::string> snps;
182  std::copy( ps.pbegin(), ps.pend(),
183  std::back_inserter(pos) );
184  std::copy( ps.begin(), ps.end(),
185  std::back_inserter(snps) );
186 
187  //This should pick the && constructor
188  Sequence::PolySites ps2(std::move(pos),
189  std::move(snps));
190 
191  BOOST_CHECK_EQUAL( pos.size(), 0 );
192  BOOST_CHECK_EQUAL( snps.size(), 0 );
193  BOOST_REQUIRE_EQUAL( ps.numsites() , ps2.numsites() );
194  BOOST_REQUIRE_EQUAL( ps.size() , ps2.size() );
195  BOOST_REQUIRE( ps == ps2 );
196 }
197 
198 BOOST_AUTO_TEST_CASE( move_construction_2 )
199 {
200  std::vector< Sequence::Fasta >
201  data = { Sequence::Fasta("seq1","AATAG"),
202  Sequence::Fasta("seq2","ATTAC"),
203  Sequence::Fasta("seq3","AATAC") };
204 
205  //Accessing ps any further is undefined behavior,
206  //and is likely to crash this program
207  Sequence::PolySites ps(data);
208  Sequence::PolySites ps2(std::move(ps));
209  BOOST_CHECK(ps.empty());
210 }
211 
212 BOOST_AUTO_TEST_CASE( move_construction_3 )
213 {
214  std::vector< Sequence::Fasta >
215  data = { Sequence::Fasta("seq1","AATAG"),
216  Sequence::Fasta("seq2","ATTAC"),
217  Sequence::Fasta("seq3","AATAC") };
218 
219  //Accessing ps any further is undefined behavior,
220  //and is likely to crash this program
221  Sequence::PolySites ps(data);
222 
223  Sequence::PolySites ps2 = std::move(ps);
224 
225  BOOST_CHECK(ps.empty());
226 }
227 
228 BOOST_AUTO_TEST_CASE( move_construction_4 )
229 {
230  std::ifstream in("data/single_ms.txt");
232  in >> d >> std::ws;
233  Sequence::SimData d2(std::move(d));
234  BOOST_CHECK(d.empty());
235 }
236 
237 BOOST_AUTO_TEST_CASE( move_construction_5 )
238 {
239  std::ifstream in("data/single_ms.txt");
241  in >> d >> std::ws;
242  Sequence::SimData d2 = std::move(d);
243  BOOST_CHECK(d.empty());
244 }
245 
246 BOOST_AUTO_TEST_CASE(test_swap)
247 {
248  std::vector< Sequence::Fasta >
249  data = { Sequence::Fasta("seq1","AATAG"),
250  Sequence::Fasta("seq2","ATTAC"),
251  Sequence::Fasta("seq3","AATAC") };
252 
253  //Accessing ps any further is undefined behavior,
254  //and is likely to crash this program
255  Sequence::PolySites ps(data),ps2;
256  ps.swap(ps2);
257  BOOST_CHECK(ps.empty());
258  BOOST_CHECK(!ps2.empty());
259 }
260 
261 BOOST_AUTO_TEST_SUITE_END()
Polymorphism tables for sequence data.
Definition: PolySites.hpp:33
FASTA sequence stream.
Definition: Fasta.hpp:49
Declaration of namespace Sequence::Alignment.
Declaration of Sequence::SimpleSNP, a polymorphism table stream in a "spreadsheet" format...
Sequence::PolySites, generates polymorphism tables from data.
SNP table data format.
Declaration of Sequence::Fasta streams.
Declaration of Sequence::SimData, a class representing polymorphism data from coalescent simulations ...
Data from coalescent simulations.
Operations on non-const Sequence::PolyTable objects.