1 /* $Id: unit_test_seq_loc_util.cpp 607114 2020-04-30 12:41:34Z grichenk $
2 * ===========================================================================
3 *
4 * PUBLIC DOMAIN NOTICE
5 * National Center for Biotechnology Information
6 *
7 * This software/database is a "United States Government Work" under the
8 * terms of the United States Copyright Act. It was written as part of
9 * the author's official duties as a United States Government employee and
10 * thus cannot be copyrighted. This software/database is freely available
11 * to the public for use. The National Library of Medicine and the U.S.
12 * Government have not placed any restriction on its use or reproduction.
13 *
14 * Although all reasonable efforts have been taken to ensure the accuracy
15 * and reliability of the software and data, the NLM and the U.S.
16 * Government do not and cannot warrant the performance or results that
17 * may be obtained by using this software or data. The NLM and the U.S.
18 * Government disclaim all warranties, express or implied, including
19 * warranties of performance, merchantability or fitness for any particular
20 * purpose.
21 *
22 * Please cite the author in any work or product based on this material.
23 *
24 * ===========================================================================
25 *
26 * Author: Aleksey Grichenko
27 *
28 * File Description:
29 * Unit tests for seq_loc_util functions.
30 *
31 * ===========================================================================
32 */
33
34 #include <ncbi_pch.hpp>
35
36 #include <corelib/ncbi_system.hpp>
37
38 // This macro should be defined before inclusion of test_boost.hpp in all
39 // "*.cpp" files inside executable except one. It is like function main() for
40 // non-Boost.Test executables is defined only in one *.cpp file - other files
41 // should not include it. If NCBI_BOOST_NO_AUTO_TEST_MAIN will not be defined
42 // then test_boost.hpp will define such "main()" function for tests.
43 //
44 // Usually if your unit tests contain only one *.cpp file you should not
45 // care about this macro at all.
46 //
47 //#define NCBI_BOOST_NO_AUTO_TEST_MAIN
48
49
50 // This header must be included before all Boost.Test headers if there are any
51 #include <corelib/test_boost.hpp>
52
53 #include <objects/seqloc/seqloc__.hpp>
54 #include <objects/general/general__.hpp>
55 #include <objects/seqfeat/Feat_id.hpp>
56 #include <objmgr/object_manager.hpp>
57 #include <objmgr/util/seq_loc_util.hpp>
58 #include <objmgr/util/sequence.hpp>
59 #include <objmgr/seq_vector.hpp>
60 #include <objects/misc/sequence_macros.hpp>
61
62
63 USING_NCBI_SCOPE;
64 USING_SCOPE(objects);
65 USING_SCOPE(sequence);
66
67
68 extern const char* sc_TestEntry;
69
GetScope()70 CScope& GetScope()
71 {
72 static CScope s_Scope(*CObjectManager::GetInstance());
73 static CRef<CSeq_entry> s_Entry;
74 if (!s_Entry) {
75 s_Entry.Reset(new CSeq_entry);
76 CNcbiIstrstream istr(sc_TestEntry);
77 istr >> MSerial_AsnText >> *s_Entry;
78 s_Scope.AddTopLevelSeqEntry(*s_Entry);
79 }
80 return s_Scope;
81 }
82
83
MakeBond(TIntId giA,TSeqPos posA,TIntId giB=0,TSeqPos posB=0)84 CRef<CSeq_loc> MakeBond(TIntId giA, TSeqPos posA, TIntId giB = 0, TSeqPos posB = 0)
85 {
86 CRef<CSeq_loc> ret(new CSeq_loc);
87 ret->SetBond().SetA().SetId().SetGi(GI_FROM(TIntId, giA));
88 ret->SetBond().SetA().SetPoint(posA);
89 if (giB > 0) {
90 ret->SetBond().SetB().SetId().SetGi(GI_FROM(TIntId, giB));
91 ret->SetBond().SetB().SetPoint(posB);
92 }
93 return ret;
94 }
95
96
MakeInterval(TIntId gi,TSeqPos from,TSeqPos to,ENa_strand strand=eNa_strand_unknown)97 CRef<CSeq_loc> MakeInterval(TIntId gi,
98 TSeqPos from,
99 TSeqPos to,
100 ENa_strand strand = eNa_strand_unknown)
101 {
102 CRef<CSeq_loc> ret(new CSeq_loc);
103 ret->SetInt().SetId().SetGi(GI_FROM(TIntId, gi));
104 ret->SetInt().SetFrom(from);
105 ret->SetInt().SetTo(to);
106 if (strand != eNa_strand_unknown) {
107 ret->SetInt().SetStrand(strand);
108 }
109 return ret;
110 }
111
112
MakeInterval(CRef<CSeq_id> id,TSeqPos from,TSeqPos to,ENa_strand strand=eNa_strand_unknown)113 CRef<CSeq_loc> MakeInterval(CRef<CSeq_id> id,
114 TSeqPos from,
115 TSeqPos to,
116 ENa_strand strand = eNa_strand_unknown)
117 {
118 CRef<CSeq_loc> ret(new CSeq_loc);
119 ret->SetInt().SetId(*id);
120 ret->SetInt().SetFrom(from);
121 ret->SetInt().SetTo(to);
122 if (strand != eNa_strand_unknown) {
123 ret->SetInt().SetStrand(strand);
124 }
125 return ret;
126 }
127
128
MakePoint(TIntId gi,TSeqPos pos)129 CRef<CSeq_loc> MakePoint(TIntId gi, TSeqPos pos)
130 {
131 CRef<CSeq_loc> ret(new CSeq_loc);
132 ret->SetPnt().SetId().SetGi(GI_FROM(TIntId, gi));
133 ret->SetPnt().SetPoint(pos);
134 return ret;
135 }
136
137
138 template<class C>
s_Parse(const char * asn)139 CRef<C> s_Parse(const char* asn)
140 {
141 CRef<C> obj(new C());
142 CNcbiIstrstream istr(asn);
143 istr >> MSerial_AsnText >> *obj;
144 return obj;
145 }
146
147 template<class C>
s_Equals(const C & obj1,const C & obj2)148 bool s_Equals(const C& obj1, const C& obj2)
149 {
150 if ( obj1.Equals(obj2) ) {
151 return true;
152 }
153 NcbiCout << "Objects differ:\n";
154 NcbiCout << "obj1: " << MSerial_AsnText << obj1;
155 NcbiCout << "obj2: " << MSerial_AsnText << obj2;
156 return false;
157 }
158
159
BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_whole)160 BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_whole)
161 {
162 CScope* scope = &GetScope();
163
164 CSeq_loc wg2, wg3, wl2, wl3;
165 wg2.SetWhole().SetGi(GI_CONST(2));
166 wg3.SetWhole().SetGi(GI_CONST(3));
167 wl2.SetWhole().SetLocal().SetStr("local2");
168 wl3.SetWhole().SetLocal().SetStr("local3");
169
170 BOOST_CHECK_EQUAL(Compare(wg2, wg2, scope, fCompareOverlapping), eSame);
171 BOOST_CHECK_EQUAL(Compare(wg2, wl2, scope, fCompareOverlapping), eSame);
172 BOOST_CHECK_EQUAL(Compare(wg2, wg3, scope, fCompareOverlapping), eNoOverlap);
173 BOOST_CHECK_EQUAL(Compare(wg2, wl3, scope, fCompareOverlapping), eNoOverlap);
174 }
175
176
BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_interval)177 BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_interval)
178 {
179 CScope* scope = &GetScope();
180
181 CSeq_loc wg2, wg3;
182 wg2.SetWhole().SetGi(GI_CONST(2));
183 wg3.SetWhole().SetGi(GI_CONST(3));
184
185 // Partial overlap
186 CRef<CSeq_loc> i = MakeInterval(2, 10, 20);
187 BOOST_CHECK_EQUAL(Compare(wg2, *i, scope, fCompareOverlapping), eContains);
188 BOOST_CHECK_EQUAL(Compare(*i, wg2, scope, fCompareOverlapping), eContained);
189 BOOST_CHECK_EQUAL(Compare(wg3, *i, scope, fCompareOverlapping), eNoOverlap);
190 BOOST_CHECK_EQUAL(Compare(*i, wg3, scope, fCompareOverlapping), eNoOverlap);
191
192 // Full bioseq
193 i = MakeInterval(2, 0, 1441);
194 BOOST_CHECK_EQUAL(Compare(wg2, *i, scope, fCompareOverlapping), eSame);
195 BOOST_CHECK_EQUAL(Compare(*i, wg2, scope, fCompareOverlapping), eSame);
196 }
197
198
BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_packed_interval)199 BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_packed_interval)
200 {
201 CScope* scope = &GetScope();
202
203 CSeq_loc wg2, wg3;
204 wg2.SetWhole().SetGi(GI_CONST(2));
205 wg3.SetWhole().SetGi(GI_CONST(3));
206
207 CSeq_id gi2("gi|2");
208 CSeq_id gi3("gi|3");
209
210 CSeq_loc pki;
211 pki.SetPacked_int().AddInterval(gi2, 10, 20);
212 BOOST_CHECK_EQUAL(Compare(wg2, pki, scope, fCompareOverlapping), eContains);
213 BOOST_CHECK_EQUAL(Compare(pki, wg2, scope, fCompareOverlapping), eContained);
214 BOOST_CHECK_EQUAL(Compare(wg3, pki, scope, fCompareOverlapping), eNoOverlap);
215 BOOST_CHECK_EQUAL(Compare(pki, wg3, scope, fCompareOverlapping), eNoOverlap);
216
217 pki.SetPacked_int().AddInterval(gi3, 30, 40);
218 BOOST_CHECK_EQUAL(Compare(wg2, pki, scope, fCompareOverlapping), eOverlap);
219 BOOST_CHECK_EQUAL(Compare(pki, wg2, scope, fCompareOverlapping), eOverlap);
220 BOOST_CHECK_EQUAL(Compare(wg3, pki, scope, fCompareOverlapping), eOverlap);
221 BOOST_CHECK_EQUAL(Compare(pki, wg3, scope, fCompareOverlapping), eOverlap);
222
223 pki.SetPacked_int().Set().clear();
224 pki.SetPacked_int().AddInterval(gi2, 0, 1441);
225 pki.SetPacked_int().AddInterval(gi3, 0, 374);
226 BOOST_CHECK_EQUAL(Compare(wg2, pki, scope, fCompareOverlapping), eContained);
227 BOOST_CHECK_EQUAL(Compare(pki, wg2, scope, fCompareOverlapping), eContains);
228 BOOST_CHECK_EQUAL(Compare(wg3, pki, scope, fCompareOverlapping), eContained);
229 BOOST_CHECK_EQUAL(Compare(pki, wg3, scope, fCompareOverlapping), eContains);
230 }
231
232
BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_point)233 BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_point)
234 {
235 CScope* scope = &GetScope();
236
237 CSeq_loc wg2, wg3;
238 wg2.SetWhole().SetGi(GI_CONST(2));
239 wg3.SetWhole().SetGi(GI_CONST(3));
240
241 CRef<CSeq_loc> pt = MakePoint(2, 10);
242 BOOST_CHECK_EQUAL(Compare(wg2, *pt, scope, fCompareOverlapping), eContains);
243 BOOST_CHECK_EQUAL(Compare(*pt, wg2, scope, fCompareOverlapping), eContained);
244 BOOST_CHECK_EQUAL(Compare(wg3, *pt, scope, fCompareOverlapping), eNoOverlap);
245 BOOST_CHECK_EQUAL(Compare(*pt, wg3, scope, fCompareOverlapping), eNoOverlap);
246 }
247
248
BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_packed_point)249 BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_packed_point)
250 {
251 CScope* scope = &GetScope();
252
253 CSeq_loc wg2, wg3, wl2, wl3;
254 wg2.SetWhole().SetGi(GI_CONST(2));
255 wg3.SetWhole().SetGi(GI_CONST(3));
256 wl2.SetWhole().SetLocal().SetStr("local2");
257 wl3.SetWhole().SetLocal().SetStr("local3");
258
259 CSeq_loc pp;
260 pp.SetPacked_pnt().SetId().SetGi(GI_CONST(2));
261 pp.SetPacked_pnt().AddPoint(10);
262 pp.SetPacked_pnt().AddPoint(20);
263 pp.SetPacked_pnt().AddPoint(30);
264 BOOST_CHECK_EQUAL(Compare(wg2, pp, scope, fCompareOverlapping), eContains);
265 BOOST_CHECK_EQUAL(Compare(pp, wg2, scope, fCompareOverlapping), eContained);
266 BOOST_CHECK_EQUAL(Compare(wl3, pp, scope, fCompareOverlapping), eNoOverlap);
267 BOOST_CHECK_EQUAL(Compare(pp, wl3, scope, fCompareOverlapping), eNoOverlap);
268 }
269
270
BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_mix)271 BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_mix)
272 {
273 CScope* scope = &GetScope();
274
275 CSeq_loc w;
276 w.SetWhole().SetGi(GI_CONST(2));
277
278 // Check some basic cases
279 CSeq_loc mix;
280 mix.SetMix().Set().push_back(MakeInterval(3, 10, 20));
281 BOOST_CHECK_EQUAL(Compare(w, mix, scope, fCompareOverlapping), eNoOverlap);
282
283 mix.SetMix().Set().clear();
284 mix.SetMix().Set().push_back(MakeInterval(2, 10, 20));
285 BOOST_CHECK_EQUAL(Compare(w, mix, scope, fCompareOverlapping), eContains);
286 BOOST_CHECK_EQUAL(Compare(mix, w, scope, fCompareOverlapping), eContained);
287
288 mix.SetMix().Set().clear();
289 mix.SetMix().Set().push_back(MakeInterval(2, 10, 20));
290 mix.SetMix().Set().push_back(MakeInterval(2, 30, 40));
291 BOOST_CHECK_EQUAL(Compare(w, mix, scope, fCompareOverlapping), eContains);
292 BOOST_CHECK_EQUAL(Compare(mix, w, scope, fCompareOverlapping), eContained);
293
294 mix.SetMix().Set().clear();
295 mix.SetMix().Set().push_back(MakeInterval(2, 10, 20));
296 mix.SetMix().Set().push_back(MakeInterval(3, 30, 40));
297 BOOST_CHECK_EQUAL(Compare(w, mix, scope, fCompareOverlapping), eOverlap);
298 BOOST_CHECK_EQUAL(Compare(mix, w, scope, fCompareOverlapping), eOverlap);
299
300 mix.SetMix().Set().clear();
301 mix.SetMix().Set().push_back(MakeInterval(2, 0, 1441));
302 mix.SetMix().Set().push_back(MakeInterval(3, 30, 40));
303 BOOST_CHECK_EQUAL(Compare(w, mix, scope, fCompareOverlapping), eContained);
304 BOOST_CHECK_EQUAL(Compare(mix, w, scope, fCompareOverlapping), eContains);
305
306 mix.SetMix().Set().clear();
307 mix.SetMix().Set().push_back(MakeInterval(2, 0, 1441));
308 CRef<CSeq_loc> sub(new CSeq_loc);
309 sub->SetWhole().SetGi(GI_CONST(2));
310 mix.SetMix().Set().push_back(sub);
311 BOOST_CHECK_EQUAL(Compare(w, mix, scope, fCompareOverlapping), eContains);
312 BOOST_CHECK_EQUAL(Compare(mix, w, scope, fCompareOverlapping), eContains);
313 }
314
315
BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_bond)316 BOOST_AUTO_TEST_CASE(Test_Compare_whole_vs_bond)
317 {
318 CScope* scope = &GetScope();
319
320 CSeq_loc wg2, wg3;
321 wg2.SetWhole().SetGi(GI_CONST(2));
322 wg3.SetWhole().SetGi(GI_CONST(3));
323
324 // B not set
325 CRef<CSeq_loc> bond = MakeBond(2, 10);
326 BOOST_CHECK_EQUAL(Compare(wg2, *bond, scope, fCompareOverlapping), eContains);
327 BOOST_CHECK_EQUAL(Compare(*bond, wg2, scope, fCompareOverlapping), eContained);
328 BOOST_CHECK_EQUAL(Compare(wg3, *bond, scope, fCompareOverlapping), eNoOverlap);
329 BOOST_CHECK_EQUAL(Compare(*bond, wg3, scope, fCompareOverlapping), eNoOverlap);
330
331 // A and B on different bioseqs
332 bond = MakeBond(2, 10, 3, 20);
333 BOOST_CHECK_EQUAL(Compare(wg2, *bond, scope, fCompareOverlapping), eOverlap);
334 BOOST_CHECK_EQUAL(Compare(*bond, wg2, scope, fCompareOverlapping), eOverlap);
335 BOOST_CHECK_EQUAL(Compare(wg3, *bond, scope, fCompareOverlapping), eOverlap);
336 BOOST_CHECK_EQUAL(Compare(*bond, wg3, scope, fCompareOverlapping), eOverlap);
337
338 // A and B on the same bioseq
339 bond = MakeBond(2, 10, 2, 20);
340 BOOST_CHECK_EQUAL(Compare(wg2, *bond, scope, fCompareOverlapping), eContains);
341 BOOST_CHECK_EQUAL(Compare(*bond, wg2, scope, fCompareOverlapping), eContained);
342 BOOST_CHECK_EQUAL(Compare(wg3, *bond, scope, fCompareOverlapping), eNoOverlap);
343 BOOST_CHECK_EQUAL(Compare(*bond, wg3, scope, fCompareOverlapping), eNoOverlap);
344 }
345
346
BOOST_AUTO_TEST_CASE(Test_Compare_interval_vs_interval)347 BOOST_AUTO_TEST_CASE(Test_Compare_interval_vs_interval)
348 {
349 CScope* scope = &GetScope();
350
351 CRef<CSeq_loc> i2 = MakeInterval(2, 10, 20);
352 CRef<CSeq_loc> i3 = MakeInterval(3, 10, 20);
353
354 CRef<CSeq_loc> i = MakeInterval(2, 25, 35);
355 // No overlap
356 BOOST_CHECK_EQUAL(Compare(*i2, *i, scope, fCompareOverlapping), eNoOverlap);
357
358 // Abutting but not overlapping
359 i = MakeInterval(2, 0, 22);
360 i2 = MakeInterval(2, 23, 40);
361 BOOST_CHECK_EQUAL(Compare(*i2, *i, scope, fCompareOverlapping), eNoOverlap);
362 BOOST_CHECK_EQUAL(Compare(*i, *i2, scope, fCompareOverlapping), eNoOverlap);
363
364 i2 = MakeInterval(2, 10, 20);
365 i = MakeInterval(2, 5, 15);
366 // Partial overlap
367 BOOST_CHECK_EQUAL(Compare(*i2, *i, scope, fCompareOverlapping), eOverlap);
368 BOOST_CHECK_EQUAL(Compare(*i, *i2, scope, fCompareOverlapping), eOverlap);
369 BOOST_CHECK_EQUAL(Compare(*i3, *i, scope, fCompareOverlapping), eNoOverlap);
370
371 i = MakeInterval(2, 5, 25);
372 // Contained/contains
373 BOOST_CHECK_EQUAL(Compare(*i2, *i, scope, fCompareOverlapping), eContained);
374 BOOST_CHECK_EQUAL(Compare(*i, *i2, scope, fCompareOverlapping), eContains);
375 i = MakeInterval(2, 10, 25); // same on the right
376 BOOST_CHECK_EQUAL(Compare(*i2, *i, scope, fCompareOverlapping), eContained);
377 BOOST_CHECK_EQUAL(Compare(*i, *i2, scope, fCompareOverlapping), eContains);
378 i = MakeInterval(2, 5, 20); // same on the left
379 BOOST_CHECK_EQUAL(Compare(*i2, *i, scope, fCompareOverlapping), eContained);
380 BOOST_CHECK_EQUAL(Compare(*i, *i2, scope, fCompareOverlapping), eContains);
381
382 i = MakeInterval(2, 10, 20);
383 // Same
384 BOOST_CHECK_EQUAL(Compare(*i2, *i, scope, fCompareOverlapping), eSame);
385 BOOST_CHECK_EQUAL(Compare(*i, *i2, scope, fCompareOverlapping), eSame);
386 }
387
388
BOOST_AUTO_TEST_CASE(Test_Compare_interval_vs_packed_interval)389 BOOST_AUTO_TEST_CASE(Test_Compare_interval_vs_packed_interval)
390 {
391 CScope* scope = &GetScope();
392
393 CRef<CSeq_loc> i2 = MakeInterval(2, 10, 20);
394 CRef<CSeq_loc> i3 = MakeInterval(3, 30, 40);
395
396 CSeq_id gi2("gi|2");
397 CSeq_id gi3("gi|3");
398
399 CSeq_loc pki;
400 // Check different combinations of overlaps. Make sure the order
401 // of ranges does not affect the result.
402
403 // eNoOverlap + eNoOverlap = eNoOverlap
404 pki.SetPacked_int().AddInterval(gi2, 25, 35);
405 pki.SetPacked_int().AddInterval(gi2, 35, 45);
406 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eNoOverlap);
407 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eNoOverlap);
408
409 // eNoOverlap + eContained = eOverlap
410 pki.SetPacked_int().Set().clear();
411 pki.SetPacked_int().AddInterval(gi2, 1, 5);
412 pki.SetPacked_int().AddInterval(gi2, 11, 19);
413 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eOverlap);
414 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eOverlap);
415 pki.SetPacked_int().Set().reverse();
416 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eOverlap);
417 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eOverlap);
418
419 // eNoOverlap + eContains = eContains
420 pki.SetPacked_int().Set().clear();
421 pki.SetPacked_int().AddInterval(gi2, 1, 5);
422 pki.SetPacked_int().AddInterval(gi2, 9, 21);
423 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
424 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
425 pki.SetPacked_int().Set().reverse();
426 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
427 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
428
429 // eNoOverlap + eSame = eContains
430 pki.SetPacked_int().Set().clear();
431 pki.SetPacked_int().AddInterval(gi2, 1, 5);
432 pki.SetPacked_int().AddInterval(gi2, 10, 20);
433 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
434 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
435 pki.SetPacked_int().Set().reverse();
436 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
437 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
438
439 // eNoOverlap + eOverlap = eOverlap
440 pki.SetPacked_int().Set().clear();
441 pki.SetPacked_int().AddInterval(gi2, 1, 5);
442 pki.SetPacked_int().AddInterval(gi2, 15, 22);
443 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eOverlap);
444 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eOverlap);
445 pki.SetPacked_int().Set().reverse();
446 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eOverlap);
447 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eOverlap);
448
449 // eContained + eContained = eContained
450 pki.SetPacked_int().Set().clear();
451 pki.SetPacked_int().AddInterval(gi2, 11, 13);
452 pki.SetPacked_int().AddInterval(gi2, 15, 18);
453 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContained);
454 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContains);
455 pki.SetPacked_int().Set().reverse();
456 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContained);
457 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContains);
458
459 // eContained + eContains = eContains
460 pki.SetPacked_int().Set().clear();
461 pki.SetPacked_int().AddInterval(gi2, 11, 13);
462 pki.SetPacked_int().AddInterval(gi2, 9, 21);
463 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
464 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
465 pki.SetPacked_int().Set().reverse();
466 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
467 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
468
469 // eContained + eSame = eContains
470 pki.SetPacked_int().Set().clear();
471 pki.SetPacked_int().AddInterval(gi2, 11, 13);
472 pki.SetPacked_int().AddInterval(gi2, 10, 20);
473 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
474 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContains);
475 pki.SetPacked_int().Set().reverse();
476 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
477 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContains);
478
479 // eContained + eOverlap = eOverlap
480 pki.SetPacked_int().Set().clear();
481 pki.SetPacked_int().AddInterval(gi2, 11, 13);
482 pki.SetPacked_int().AddInterval(gi2, 15, 22);
483 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eOverlap);
484 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eOverlap);
485 pki.SetPacked_int().Set().reverse();
486 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eOverlap);
487 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eOverlap);
488
489 // eContains + eContains = eContains
490 pki.SetPacked_int().Set().clear();
491 pki.SetPacked_int().AddInterval(gi2, 9, 21);
492 pki.SetPacked_int().AddInterval(gi2, 5, 25);
493 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
494 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
495 pki.SetPacked_int().Set().reverse();
496 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
497 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
498
499 // eContains + eSame = eContains
500 pki.SetPacked_int().Set().clear();
501 pki.SetPacked_int().AddInterval(gi2, 9, 21);
502 pki.SetPacked_int().AddInterval(gi2, 10, 20);
503 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
504 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
505 pki.SetPacked_int().Set().reverse();
506 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
507 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
508
509 // eContains + eOverlap = eContains
510 pki.SetPacked_int().Set().clear();
511 pki.SetPacked_int().AddInterval(gi2, 9, 21);
512 pki.SetPacked_int().AddInterval(gi2, 15, 22);
513 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
514 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
515 pki.SetPacked_int().Set().reverse();
516 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
517 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
518
519 // eSame + eSame = eContains
520 pki.SetPacked_int().Set().clear();
521 pki.SetPacked_int().AddInterval(gi2, 10, 20);
522 pki.SetPacked_int().AddInterval(gi2, 10, 20);
523 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
524 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContains);
525
526 // eSame + eOverlap = eContains
527 pki.SetPacked_int().Set().clear();
528 pki.SetPacked_int().AddInterval(gi2, 10, 20);
529 pki.SetPacked_int().AddInterval(gi2, 15, 22);
530 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
531 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
532 pki.SetPacked_int().Set().reverse();
533 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
534 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
535
536 // eOverlap + eOverlap = eOverlap
537 pki.SetPacked_int().Set().clear();
538 pki.SetPacked_int().AddInterval(gi2, 8, 13);
539 pki.SetPacked_int().AddInterval(gi2, 16, 22);
540 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eOverlap);
541 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eOverlap);
542 pki.SetPacked_int().Set().reverse();
543 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eOverlap);
544 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eOverlap);
545
546 // eNoOverlap + eContains = eContains
547 pki.SetPacked_int().Set().clear();
548 pki.SetPacked_int().AddInterval(gi2, 10, 20);
549 pki.SetPacked_int().AddInterval(gi2, 11, 19);
550 pki.SetPacked_int().AddInterval(gi2, 25, 35);
551 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
552 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
553 pki.SetPacked_int().Set().reverse();
554 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
555 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
556
557 // eContained + eContains = eContains
558 pki.SetPacked_int().Set().clear();
559 pki.SetPacked_int().AddInterval(gi2, 10, 20);
560 pki.SetPacked_int().AddInterval(gi2, 11, 19);
561 pki.SetPacked_int().AddInterval(gi2, 12, 18);
562 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
563 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContains);
564 pki.SetPacked_int().Set().reverse();
565 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
566 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContains);
567
568 // eContains + eContains = eContains
569 pki.SetPacked_int().Set().clear();
570 pki.SetPacked_int().AddInterval(gi2, 10, 20);
571 pki.SetPacked_int().AddInterval(gi2, 11, 19);
572 pki.SetPacked_int().AddInterval(gi2, 9, 21);
573 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
574 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
575 pki.SetPacked_int().Set().reverse();
576 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
577 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
578
579 // eSame + eContains = eContains
580 pki.SetPacked_int().Set().clear();
581 pki.SetPacked_int().AddInterval(gi2, 10, 20);
582 pki.SetPacked_int().AddInterval(gi2, 11, 19);
583 pki.SetPacked_int().AddInterval(gi2, 10, 20);
584 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
585 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContains);
586
587 // eOverlap + eContains = eContains
588 pki.SetPacked_int().Set().clear();
589 pki.SetPacked_int().AddInterval(gi2, 10, 20);
590 pki.SetPacked_int().AddInterval(gi2, 11, 19);
591 pki.SetPacked_int().AddInterval(gi2, 15, 25);
592 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
593 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
594 pki.SetPacked_int().Set().reverse();
595 BOOST_CHECK_EQUAL(Compare(pki, *i2, scope, fCompareOverlapping), eContains);
596 BOOST_CHECK_EQUAL(Compare(*i2, pki, scope, fCompareOverlapping), eContained);
597 }
598
599
BOOST_AUTO_TEST_CASE(Test_Compare_interval_vs_point)600 BOOST_AUTO_TEST_CASE(Test_Compare_interval_vs_point)
601 {
602 CScope* scope = &GetScope();
603
604 CRef<CSeq_loc> i2 = MakeInterval(2, 10, 20);
605 CRef<CSeq_loc> i3 = MakeInterval(3, 10, 20);
606
607 CRef<CSeq_loc> pt = MakePoint(2, 5);
608 // No overlap
609 BOOST_CHECK_EQUAL(Compare(*i2, *pt, scope, fCompareOverlapping), eNoOverlap);
610 pt = MakePoint(2, 15);
611 BOOST_CHECK_EQUAL(Compare(*i3, *pt, scope, fCompareOverlapping), eNoOverlap);
612
613 // Overlap
614 BOOST_CHECK_EQUAL(Compare(*i2, *pt, scope, fCompareOverlapping), eContains);
615 BOOST_CHECK_EQUAL(Compare(*pt, *i2, scope, fCompareOverlapping), eContained);
616
617 // Same - interval of length 1
618 CRef<CSeq_loc> i1 = MakeInterval(2, 15, 15);
619 BOOST_CHECK_EQUAL(Compare(*pt, *i1, scope, fCompareOverlapping), eSame);
620 BOOST_CHECK_EQUAL(Compare(*i1, *pt, scope, fCompareOverlapping), eSame);
621 }
622
623
BOOST_AUTO_TEST_CASE(Test_Compare_interval_vs_packed_point)624 BOOST_AUTO_TEST_CASE(Test_Compare_interval_vs_packed_point)
625 {
626 CScope* scope = &GetScope();
627
628 CRef<CSeq_loc> i2 = MakeInterval(2, 10, 20);
629 CRef<CSeq_loc> i3 = MakeInterval(3, 10, 20);
630
631 CSeq_loc pp;
632 pp.SetPacked_pnt().SetId().SetGi(GI_CONST(2));
633 pp.SetPacked_pnt().AddPoint(5);
634
635 // No overlap
636 BOOST_CHECK_EQUAL(Compare(*i2, pp, scope, fCompareOverlapping), eNoOverlap);
637 pp.SetPacked_pnt().SetPoints().front() = 15;
638 BOOST_CHECK_EQUAL(Compare(*i3, pp, scope, fCompareOverlapping), eNoOverlap);
639
640 // Contained in the interval
641 BOOST_CHECK_EQUAL(Compare(*i2, pp, scope, fCompareOverlapping), eContains);
642 BOOST_CHECK_EQUAL(Compare(pp, *i2, scope, fCompareOverlapping), eContained);
643
644 // Overlap
645 pp.SetPacked_pnt().AddPoint(5);
646 pp.SetPacked_pnt().AddPoint(25);
647 BOOST_CHECK_EQUAL(Compare(*i2, pp, scope, fCompareOverlapping), eOverlap);
648 BOOST_CHECK_EQUAL(Compare(pp, *i2, scope, fCompareOverlapping), eOverlap);
649 }
650
651
BOOST_AUTO_TEST_CASE(Test_Compare_interval_vs_mix)652 BOOST_AUTO_TEST_CASE(Test_Compare_interval_vs_mix)
653 {
654 CScope* scope = &GetScope();
655
656 CRef<CSeq_loc> i = MakeInterval(2, 20, 80);
657
658 CSeq_loc mix;
659 CRef<CSeq_loc> sub, sub2;
660
661 mix.SetMix().Set().push_back(MakeInterval(3, 10, 90));
662 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eNoOverlap);
663 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eNoOverlap);
664
665 // Whole
666 mix.SetMix().Set().clear();
667 sub.Reset(new CSeq_loc);
668 sub->SetWhole().SetGi(GI_CONST(2));
669 mix.SetMix().Set().push_back(sub);
670 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eContained);
671 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eContains);
672
673 // Points
674 mix.SetMix().Set().clear();
675 mix.SetMix().Set().push_back(MakePoint(2, 50));
676 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eContains);
677 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eContained);
678 mix.SetMix().Set().push_back(MakePoint(2, 60));
679 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eContains);
680 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eContained);
681 mix.SetMix().Set().push_back(MakePoint(2, 150));
682 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eOverlap);
683 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eOverlap);
684
685 // Packed points - some more complicated cases
686 mix.SetMix().Set().clear();
687 sub.Reset(new CSeq_loc);
688 sub->SetPacked_pnt().SetId().SetGi(GI_CONST(2));
689 sub->SetPacked_pnt().AddPoint(30);
690 sub->SetPacked_pnt().AddPoint(60);
691 mix.SetMix().Set().push_back(sub);
692 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eContains);
693 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eContained);
694 sub2.Reset(new CSeq_loc);
695 sub2->SetPacked_pnt().SetId().SetGi(GI_CONST(2));
696 sub2->SetPacked_pnt().AddPoint(10);
697 sub2->SetPacked_pnt().AddPoint(50);
698 mix.SetMix().Set().push_back(sub2);
699 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eOverlap);
700 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eOverlap);
701
702 // Intervals
703 mix.SetMix().Set().clear();
704 mix.SetMix().Set().push_back(MakeInterval(2, 10, 15));
705 mix.SetMix().Set().push_back(MakeInterval(2, 85, 90));
706 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eNoOverlap);
707 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eNoOverlap);
708
709 mix.SetMix().Set().clear();
710 mix.SetMix().Set().push_back(MakeInterval(2, 20, 25));
711 mix.SetMix().Set().push_back(MakeInterval(2, 55, 70));
712 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eContains);
713 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eContained);
714
715 mix.SetMix().Set().clear();
716 mix.SetMix().Set().push_back(MakeInterval(2, 10, 35));
717 mix.SetMix().Set().push_back(MakeInterval(2, 70, 90));
718 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eOverlap);
719 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eOverlap);
720
721 // This results in eOverlap although the mix covers the whole interval.
722 mix.SetMix().Set().clear();
723 mix.SetMix().Set().push_back(MakeInterval(2, 10, 55));
724 mix.SetMix().Set().push_back(MakeInterval(2, 50, 90));
725 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eOverlap);
726 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eOverlap);
727
728 mix.SetMix().Set().clear();
729 mix.SetMix().Set().push_back(MakeInterval(2, 10, 30));
730 mix.SetMix().Set().push_back(MakeInterval(2, 10, 90));
731 mix.SetMix().Set().push_back(MakeInterval(2, 70, 90));
732 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eContained);
733 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eContains);
734
735 mix.SetMix().Set().clear();
736 mix.SetMix().Set().push_back(MakeInterval(2, 20, 30));
737 mix.SetMix().Set().push_back(MakeInterval(2, 20, 80));
738 mix.SetMix().Set().push_back(MakeInterval(2, 70, 80));
739 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eContains);
740 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eContains);
741
742 // Packed intervals
743 mix.SetMix().Set().clear();
744 sub.Reset(new CSeq_loc);
745 sub->SetPacked_int().Set().push_back(
746 Ref(&MakeInterval(2, 10, 30)->SetInt()));
747 sub->SetPacked_int().Set().push_back(
748 Ref(&MakeInterval(2, 40, 60)->SetInt()));
749 sub->SetPacked_int().Set().push_back(
750 Ref(&MakeInterval(2, 70, 90)->SetInt()));
751 mix.SetMix().Set().push_back(sub);
752 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eOverlap);
753 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eOverlap);
754
755 mix.SetMix().Set().clear();
756 sub.Reset(new CSeq_loc);
757 sub->SetPacked_int().Set().push_back(
758 Ref(&MakeInterval(3, 10, 30)->SetInt()));
759 sub->SetPacked_int().Set().push_back(
760 Ref(&MakeInterval(2, 10, 90)->SetInt()));
761 sub->SetPacked_int().Set().push_back(
762 Ref(&MakeInterval(2, 70, 90)->SetInt()));
763 mix.SetMix().Set().push_back(sub);
764 try {
765 Compare(*i, mix, scope, fCompareOverlapping);
766 }
767 catch (...) {
768 }
769 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eContained);
770 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eContains);
771
772 // Mixed sub-location types
773 mix.SetMix().Set().clear();
774 sub.Reset(new CSeq_loc);
775 sub->SetPnt().SetId().SetGi(GI_CONST(2));
776 sub->SetPnt().SetPoint(30);
777 mix.SetMix().Set().push_back(MakePoint(2, 30));
778 mix.SetMix().Set().push_back(MakeInterval(2, 35, 40));
779 sub.Reset(new CSeq_loc);
780 sub->SetPacked_int().Set().push_back(
781 Ref(&MakeInterval(2, 45, 50)->SetInt()));
782 sub->SetPacked_int().Set().push_back(
783 Ref(&MakeInterval(2, 50, 55)->SetInt()));
784 mix.SetMix().Set().push_back(sub);
785 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eContains);
786 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eContained);
787
788 mix.SetMix().Set().clear();
789 mix.SetMix().Set().push_back(MakeInterval(2, 10, 90));
790 sub.Reset(new CSeq_loc);
791 sub->SetPacked_int().Set().push_back(
792 Ref(&MakeInterval(2, 40, 50)->SetInt()));
793 sub->SetPacked_int().Set().push_back(
794 Ref(&MakeInterval(2, 50, 85)->SetInt()));
795 mix.SetMix().Set().push_back(sub);
796 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eContained);
797 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eContains);
798
799 mix.SetMix().Set().clear();
800 sub.Reset(new CSeq_loc);
801 mix.SetMix().Set().push_back(MakeInterval(2, 40, 50));
802 mix.SetMix().Set().push_back(MakeInterval(2, 60, 70));
803 mix.SetMix().Set().push_back(sub);
804 mix.SetMix().Set().push_back(MakeBond(2, 50, 3, 40));
805 BOOST_CHECK_EQUAL(Compare(*i, mix, scope, fCompareOverlapping), eOverlap);
806 BOOST_CHECK_EQUAL(Compare(mix, *i, scope, fCompareOverlapping), eOverlap);
807 }
808
809
BOOST_AUTO_TEST_CASE(Test_Compare_interval_vs_bond)810 BOOST_AUTO_TEST_CASE(Test_Compare_interval_vs_bond)
811 {
812 CScope* scope = &GetScope();
813
814 CRef<CSeq_loc> bA2 = MakeBond(2, 10);
815 CRef<CSeq_loc> bA3 = MakeBond(3, 10);
816 CRef<CSeq_loc> bA2B3 = MakeBond(2, 10, 3, 20);
817 CRef<CSeq_loc> bA3B2 = MakeBond(3, 20, 2, 10);
818 CRef<CSeq_loc> bA2B2 = MakeBond(2, 10, 2, 20);
819
820 CRef<CSeq_loc> i = MakeInterval(2, 15, 25);
821 // No overlap
822 BOOST_CHECK_EQUAL(Compare(*bA2, *i, scope, fCompareOverlapping), eNoOverlap);
823
824 i = MakeInterval(2, 5, 15);
825 // Overlap with one point (no B)
826 BOOST_CHECK_EQUAL(Compare(*bA2, *i, scope, fCompareOverlapping), eContained);
827 BOOST_CHECK_EQUAL(Compare(*i, *bA2, scope, fCompareOverlapping), eContains);
828 // Overlap with only one of A or B
829 BOOST_CHECK_EQUAL(Compare(*bA2B3, *i, scope, fCompareOverlapping), eOverlap);
830 BOOST_CHECK_EQUAL(Compare(*i, *bA2B3, scope, fCompareOverlapping), eOverlap);
831 BOOST_CHECK_EQUAL(Compare(*bA3B2, *i, scope, fCompareOverlapping), eOverlap);
832 BOOST_CHECK_EQUAL(Compare(*i, *bA3B2, scope, fCompareOverlapping), eOverlap);
833 // B is on the same bioseq but out of range
834 BOOST_CHECK_EQUAL(Compare(*bA2B2, *i, scope, fCompareOverlapping), eOverlap);
835 BOOST_CHECK_EQUAL(Compare(*i, *bA2B2, scope, fCompareOverlapping), eOverlap);
836
837 i = MakeInterval(2, 5, 25);
838 // Overlap with both A and B
839 BOOST_CHECK_EQUAL(Compare(*bA2B2, *i, scope, fCompareOverlapping), eContained);
840 BOOST_CHECK_EQUAL(Compare(*i, *bA2B2, scope, fCompareOverlapping), eContains);
841 }
842
843
BOOST_AUTO_TEST_CASE(Test_Compare_packed_interval_vs_packed_interval)844 BOOST_AUTO_TEST_CASE(Test_Compare_packed_interval_vs_packed_interval)
845 {
846 CScope* scope = &GetScope();
847
848 CSeq_id gi2("gi|2");
849 CSeq_id gi3("gi|3");
850 CSeq_id lcl2;
851 lcl2.SetLocal().SetStr("local2");
852
853 CSeq_loc pk1, pk2;
854
855 // Complicated case: although different seq-ids are used in both
856 // locations and the order is wrong, eSame should be returned.
857 pk1.SetPacked_int().AddInterval(gi2, 10, 20);
858 pk1.SetPacked_int().AddInterval(lcl2, 30, 40);
859 pk2.SetPacked_int().AddInterval(gi2, 30, 40);
860 pk2.SetPacked_int().AddInterval(lcl2, 10, 20);
861 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eSame);
862 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eSame);
863
864 pk1.SetPacked_int().Set().clear();
865 pk1.SetPacked_int().AddInterval(gi2, 10, 20);
866 pk1.SetPacked_int().AddInterval(gi2, 30, 40);
867 pk2.SetPacked_int().Set().clear();
868 pk2.SetPacked_int().AddInterval(gi3, 10, 20);
869 pk2.SetPacked_int().AddInterval(gi2, 50, 60);
870 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eNoOverlap);
871
872 pk1.SetPacked_int().Set().clear();
873 pk1.SetPacked_int().AddInterval(gi2, 15, 20);
874 pk1.SetPacked_int().AddInterval(gi2, 60, 70);
875 pk2.SetPacked_int().Set().clear();
876 pk2.SetPacked_int().AddInterval(gi2, 5, 10);
877 pk2.SetPacked_int().AddInterval(gi2, 50, 55);
878 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eNoOverlap);
879
880 pk1.SetPacked_int().Set().clear();
881 pk1.SetPacked_int().AddInterval(gi2, 10, 40);
882 pk1.SetPacked_int().AddInterval(gi2, 60, 90);
883 pk2.SetPacked_int().Set().clear();
884 pk2.SetPacked_int().AddInterval(gi2, 20, 30);
885 pk2.SetPacked_int().AddInterval(gi2, 70, 80);
886 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eContains);
887 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eContained);
888 pk2.SetPacked_int().Set().reverse();
889 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eContains);
890 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eContained);
891
892 pk1.SetPacked_int().Set().clear();
893 pk1.SetPacked_int().AddInterval(gi2, 10, 40);
894 pk1.SetPacked_int().AddInterval(gi3, 60, 90);
895 pk2.SetPacked_int().Set().clear();
896 pk2.SetPacked_int().AddInterval(gi2, 20, 30);
897 pk2.SetPacked_int().AddInterval(gi3, 70, 80);
898 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eContains);
899 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eContained);
900 pk2.SetPacked_int().Set().reverse();
901 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eContains);
902 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eContained);
903
904 pk1.SetPacked_int().Set().clear();
905 pk1.SetPacked_int().AddInterval(gi2, 10, 40);
906 pk1.SetPacked_int().AddInterval(gi2, 50, 70);
907 pk2.SetPacked_int().Set().clear();
908 pk2.SetPacked_int().AddInterval(gi2, 20, 30);
909 pk2.SetPacked_int().AddInterval(gi2, 60, 80);
910 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eOverlap);
911 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eOverlap);
912 pk2.SetPacked_int().Set().reverse();
913 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eOverlap);
914 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eOverlap);
915
916 pk1.SetPacked_int().Set().clear();
917 pk1.SetPacked_int().AddInterval(gi2, 10, 20);
918 pk1.SetPacked_int().AddInterval(gi2, 50, 70);
919 pk2.SetPacked_int().Set().clear();
920 pk2.SetPacked_int().AddInterval(gi2, 10, 20);
921 pk2.SetPacked_int().AddInterval(gi2, 60, 80);
922 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eOverlap);
923 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eOverlap);
924 pk2.SetPacked_int().Set().reverse();
925 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eOverlap);
926 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eOverlap);
927
928 pk1.SetPacked_int().Set().clear();
929 pk1.SetPacked_int().AddInterval(gi2, 10, 20);
930 pk1.SetPacked_int().AddInterval(gi2, 30, 40);
931 pk2.SetPacked_int().Set().clear();
932 pk2.SetPacked_int().AddInterval(gi2, 10, 20);
933 pk2.SetPacked_int().AddInterval(gi2, 30, 40);
934 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eSame);
935 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eSame);
936 // The order does not matter.
937 pk2.SetPacked_int().Set().reverse();
938 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eSame);
939 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eSame);
940
941 pk1.SetPacked_int().Set().clear();
942 pk1.SetPacked_int().AddInterval(gi2, 10, 20);
943 pk1.SetPacked_int().AddInterval(gi2, 10, 90);
944 pk1.SetPacked_int().AddInterval(gi2, 80, 90);
945 pk2.SetPacked_int().Set().clear();
946 pk2.SetPacked_int().AddInterval(gi2, 10, 90);
947 pk2.SetPacked_int().AddInterval(gi2, 50, 60);
948 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eContains);
949 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eContains);
950 pk2.SetPacked_int().Set().reverse();
951 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eContains);
952 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eContains);
953
954 pk1.SetPacked_int().Set().clear();
955 pk1.SetPacked_int().AddInterval(gi2, 10, 19);
956 pk1.SetPacked_int().AddInterval(gi3, 20, 29);
957 pk2.SetPacked_int().Set().clear();
958 pk2.SetPacked_int().AddInterval(gi2, 20, 29);
959 pk2.SetPacked_int().AddInterval(gi3, 10, 19);
960 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eNoOverlap);
961 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eNoOverlap);
962 pk2.SetPacked_int().Set().reverse();
963 BOOST_CHECK_EQUAL(Compare(pk1, pk2, scope, fCompareOverlapping), eNoOverlap);
964 BOOST_CHECK_EQUAL(Compare(pk2, pk1, scope, fCompareOverlapping), eNoOverlap);
965 }
966
967
BOOST_AUTO_TEST_CASE(Test_Compare_packed_interval_vs_point)968 BOOST_AUTO_TEST_CASE(Test_Compare_packed_interval_vs_point)
969 {
970 CScope* scope = &GetScope();
971
972 CRef<CSeq_loc> pt = MakePoint(2, 15);
973
974 CSeq_id gi2("gi|2");
975 CSeq_loc pki;
976
977 pki.SetPacked_int().AddInterval(gi2, 1, 5);
978 BOOST_CHECK_EQUAL(Compare(pki, *pt, scope, fCompareOverlapping), eNoOverlap);
979 BOOST_CHECK_EQUAL(Compare(*pt, pki, scope, fCompareOverlapping), eNoOverlap);
980 pki.SetPacked_int().AddInterval(gi2, 20, 25);
981 BOOST_CHECK_EQUAL(Compare(pki, *pt, scope, fCompareOverlapping), eNoOverlap);
982 BOOST_CHECK_EQUAL(Compare(*pt, pki, scope, fCompareOverlapping), eNoOverlap);
983
984 pki.SetPacked_int().Set().clear();
985 pki.SetPacked_int().AddInterval(gi2, 10, 20);
986 BOOST_CHECK_EQUAL(Compare(pki, *pt, scope, fCompareOverlapping), eContains);
987 BOOST_CHECK_EQUAL(Compare(*pt, pki, scope, fCompareOverlapping), eContained);
988
989 pki.SetPacked_int().Set().clear();
990 pki.SetPacked_int().AddInterval(gi2, 15, 15);
991 BOOST_CHECK_EQUAL(Compare(pki, *pt, scope, fCompareOverlapping), eSame);
992 BOOST_CHECK_EQUAL(Compare(*pt, pki, scope, fCompareOverlapping), eSame);
993
994 pki.SetPacked_int().AddInterval(gi2, 15, 15);
995 BOOST_CHECK_EQUAL(Compare(pki, *pt, scope, fCompareOverlapping), eContains);
996 BOOST_CHECK_EQUAL(Compare(*pt, pki, scope, fCompareOverlapping), eContains);
997 }
998
999
BOOST_AUTO_TEST_CASE(Test_Compare_packed_interval_vs_packed_point)1000 BOOST_AUTO_TEST_CASE(Test_Compare_packed_interval_vs_packed_point)
1001 {
1002 CScope* scope = &GetScope();
1003
1004 CSeq_loc pkp;
1005 pkp.SetPacked_pnt().SetId().SetGi(GI_CONST(2));
1006 pkp.SetPacked_pnt().AddPoint(15);
1007
1008 CSeq_id gi2("gi|2");
1009 CSeq_id gi3("gi|3");
1010
1011 CSeq_loc pki;
1012
1013 pki.SetPacked_int().AddInterval(gi2, 1, 5);
1014 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eNoOverlap);
1015 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eNoOverlap);
1016 pki.SetPacked_int().AddInterval(gi2, 20, 25);
1017 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eNoOverlap);
1018 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eNoOverlap);
1019
1020 pki.SetPacked_int().Set().clear();
1021 pki.SetPacked_int().AddInterval(gi2, 10, 20);
1022 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eContains);
1023 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eContained);
1024
1025 pki.SetPacked_int().Set().clear();
1026 pki.SetPacked_int().AddInterval(gi2, 15, 15);
1027 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eSame);
1028 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eSame);
1029
1030 pki.SetPacked_int().AddInterval(gi2, 15, 15);
1031 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eContains);
1032 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eContains);
1033
1034 pki.SetPacked_int().AddInterval(gi2, 25, 25);
1035 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eContains);
1036 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eContained);
1037
1038 pkp.SetPacked_pnt().AddPoint(25);
1039
1040 pki.SetPacked_int().Set().clear();
1041 pki.SetPacked_int().AddInterval(gi2, 17, 23);
1042 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eNoOverlap);
1043 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eNoOverlap);
1044
1045 pki.SetPacked_int().Set().clear();
1046 pki.SetPacked_int().AddInterval(gi2, 10, 30);
1047 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eContains);
1048 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eContained);
1049
1050 pki.SetPacked_int().Set().clear();
1051 pki.SetPacked_int().AddInterval(gi2, 10, 20);
1052 pki.SetPacked_int().AddInterval(gi2, 30, 40);
1053 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eOverlap);
1054 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eOverlap);
1055
1056 pki.SetPacked_int().Set().clear();
1057 pki.SetPacked_int().AddInterval(gi2, 5, 10);
1058 pki.SetPacked_int().AddInterval(gi2, 20, 30);
1059 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eOverlap);
1060 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eOverlap);
1061
1062 // Complicated case: each interval contains just one of the
1063 // points.
1064 pki.SetPacked_int().Set().clear();
1065 pki.SetPacked_int().AddInterval(gi2, 10, 20);
1066 pki.SetPacked_int().AddInterval(gi2, 21, 30);
1067 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eContains);
1068 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eContained);
1069
1070 pki.SetPacked_int().Set().clear();
1071 pki.SetPacked_int().AddInterval(gi2, 10, 20);
1072 pki.SetPacked_int().AddInterval(gi2, 20, 30);
1073 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eContains);
1074 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eContained);
1075
1076 pki.SetPacked_int().Set().clear();
1077 pki.SetPacked_int().AddInterval(gi2, 10, 20);
1078 pki.SetPacked_int().AddInterval(gi3, 20, 30);
1079 BOOST_CHECK_EQUAL(Compare(pki, pkp, scope, fCompareOverlapping), eOverlap);
1080 BOOST_CHECK_EQUAL(Compare(pkp, pki, scope, fCompareOverlapping), eOverlap);
1081 }
1082
1083
BOOST_AUTO_TEST_CASE(Test_Compare_packed_interval_vs_mix)1084 BOOST_AUTO_TEST_CASE(Test_Compare_packed_interval_vs_mix)
1085 {
1086 CScope* scope = &GetScope();
1087
1088 CSeq_id gi2("gi|2");
1089 CSeq_id gi3("gi|3");
1090
1091 CSeq_loc pki;
1092 pki.SetPacked_int().AddInterval(gi2, 20, 80);
1093
1094 CSeq_loc mix;
1095 CRef<CSeq_loc> sub, sub2;
1096
1097 mix.SetMix().Set().push_back(MakeInterval(3, 10, 90));
1098 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eNoOverlap);
1099 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eNoOverlap);
1100
1101 // Whole
1102 mix.SetMix().Set().clear();
1103 sub.Reset(new CSeq_loc);
1104 sub->SetWhole().SetGi(GI_CONST(2));
1105 mix.SetMix().Set().push_back(sub);
1106 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eContained);
1107 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eContains);
1108
1109 pki.SetPacked_int().Set().clear();
1110 pki.SetPacked_int().AddInterval(gi2, 0, 1441);
1111 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eSame);
1112 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eSame);
1113
1114 // Points
1115 pki.SetPacked_int().Set().clear();
1116 pki.SetPacked_int().AddInterval(gi2, 10, 20);
1117 pki.SetPacked_int().AddInterval(gi2, 30, 40);
1118 mix.SetMix().Set().clear();
1119 mix.SetMix().Set().push_back(MakePoint(2, 15));
1120 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eContains);
1121 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eContained);
1122 mix.SetMix().Set().push_back(MakePoint(2, 35));
1123 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eContains);
1124 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eContained);
1125 mix.SetMix().Set().push_back(MakePoint(2, 150));
1126 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eOverlap);
1127 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eOverlap);
1128
1129 // Packed points - some more complicated cases
1130 mix.SetMix().Set().clear();
1131 sub.Reset(new CSeq_loc);
1132 sub->SetPacked_pnt().SetId().SetGi(GI_CONST(2));
1133 sub->SetPacked_pnt().AddPoint(15);
1134 sub->SetPacked_pnt().AddPoint(33);
1135 mix.SetMix().Set().push_back(sub);
1136 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eContains);
1137 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eContained);
1138 sub2.Reset(new CSeq_loc);
1139 sub2->SetPacked_pnt().SetId().SetGi(GI_CONST(2));
1140 sub2->SetPacked_pnt().AddPoint(5);
1141 sub2->SetPacked_pnt().AddPoint(37);
1142 mix.SetMix().Set().push_back(sub2);
1143 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eOverlap);
1144 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eOverlap);
1145
1146 // Intervals
1147 pki.SetPacked_int().Set().clear();
1148 pki.SetPacked_int().AddInterval(gi2, 20, 80);
1149 mix.SetMix().Set().clear();
1150 mix.SetMix().Set().push_back(MakeInterval(2, 10, 15));
1151 mix.SetMix().Set().push_back(MakeInterval(2, 85, 90));
1152 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eNoOverlap);
1153 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eNoOverlap);
1154
1155 mix.SetMix().Set().clear();
1156 mix.SetMix().Set().push_back(MakeInterval(2, 20, 25));
1157 mix.SetMix().Set().push_back(MakeInterval(2, 55, 70));
1158 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eContains);
1159 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eContained);
1160
1161 mix.SetMix().Set().clear();
1162 mix.SetMix().Set().push_back(MakeInterval(2, 10, 35));
1163 mix.SetMix().Set().push_back(MakeInterval(2, 70, 90));
1164 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eOverlap);
1165 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eOverlap);
1166
1167 // This results in eOverlap although the mix covers the whole interval.
1168 mix.SetMix().Set().clear();
1169 mix.SetMix().Set().push_back(MakeInterval(2, 10, 55));
1170 mix.SetMix().Set().push_back(MakeInterval(2, 50, 90));
1171 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eOverlap);
1172 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eOverlap);
1173
1174 // The same problem here.
1175 pki.SetPacked_int().Set().clear();
1176 pki.SetPacked_int().AddInterval(gi2, 10, 60);
1177 pki.SetPacked_int().AddInterval(gi2, 56, 90);
1178 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eOverlap);
1179 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eOverlap);
1180
1181 pki.SetPacked_int().Set().clear();
1182 pki.SetPacked_int().AddInterval(gi2, 20, 80);
1183 pki.SetPacked_int().AddInterval(gi2, 30, 70);
1184 mix.SetMix().Set().clear();
1185 mix.SetMix().Set().push_back(MakeInterval(2, 10, 30));
1186 mix.SetMix().Set().push_back(MakeInterval(2, 10, 90));
1187 mix.SetMix().Set().push_back(MakeInterval(2, 70, 90));
1188 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eContained);
1189 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eContains);
1190
1191 mix.SetMix().Set().clear();
1192 mix.SetMix().Set().push_back(MakeInterval(2, 20, 30));
1193 mix.SetMix().Set().push_back(MakeInterval(2, 20, 80));
1194 mix.SetMix().Set().push_back(MakeInterval(2, 70, 80));
1195 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eContains);
1196 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eContains);
1197
1198 // Packed intervals
1199 pki.SetPacked_int().Set().clear();
1200 pki.SetPacked_int().AddInterval(gi2, 20, 40);
1201 pki.SetPacked_int().AddInterval(gi2, 50, 70);
1202 mix.SetMix().Set().clear();
1203 sub.Reset(new CSeq_loc);
1204 sub->SetPacked_int().Set().push_back(
1205 Ref(&MakeInterval(2, 10, 30)->SetInt()));
1206 sub->SetPacked_int().Set().push_back(
1207 Ref(&MakeInterval(2, 50, 60)->SetInt()));
1208 sub->SetPacked_int().Set().push_back(
1209 Ref(&MakeInterval(2, 70, 90)->SetInt()));
1210 mix.SetMix().Set().push_back(sub);
1211 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eOverlap);
1212 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eOverlap);
1213
1214 mix.SetMix().Set().clear();
1215 sub.Reset(new CSeq_loc);
1216 sub->SetPacked_int().Set().push_back(
1217 Ref(&MakeInterval(3, 10, 30)->SetInt()));
1218 sub->SetPacked_int().Set().push_back(
1219 Ref(&MakeInterval(2, 10, 90)->SetInt()));
1220 sub->SetPacked_int().Set().push_back(
1221 Ref(&MakeInterval(2, 70, 90)->SetInt()));
1222 mix.SetMix().Set().push_back(sub);
1223 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eContained);
1224 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eContains);
1225
1226 // Mixed sub-location types
1227 mix.SetMix().Set().clear();
1228 sub.Reset(new CSeq_loc);
1229 sub->SetPnt().SetId().SetGi(GI_CONST(2));
1230 sub->SetPnt().SetPoint(30);
1231 mix.SetMix().Set().push_back(MakePoint(2, 30));
1232 mix.SetMix().Set().push_back(MakeInterval(2, 35, 40));
1233 sub.Reset(new CSeq_loc);
1234 sub->SetPacked_int().Set().push_back(
1235 Ref(&MakeInterval(2, 55, 60)->SetInt()));
1236 sub->SetPacked_int().Set().push_back(
1237 Ref(&MakeInterval(2, 60, 65)->SetInt()));
1238 mix.SetMix().Set().push_back(sub);
1239 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eContains);
1240 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eContained);
1241
1242 mix.SetMix().Set().clear();
1243 mix.SetMix().Set().push_back(MakeInterval(2, 10, 40));
1244 sub.Reset(new CSeq_loc);
1245 sub->SetPacked_int().Set().push_back(
1246 Ref(&MakeInterval(2, 40, 50)->SetInt()));
1247 sub->SetPacked_int().Set().push_back(
1248 Ref(&MakeInterval(2, 50, 85)->SetInt()));
1249 mix.SetMix().Set().push_back(sub);
1250 BOOST_CHECK_EQUAL(Compare(pki, mix, scope, fCompareOverlapping), eContained);
1251 BOOST_CHECK_EQUAL(Compare(mix, pki, scope, fCompareOverlapping), eContains);
1252 }
1253
1254
BOOST_AUTO_TEST_CASE(Test_Compare_packed_interval_vs_bond)1255 BOOST_AUTO_TEST_CASE(Test_Compare_packed_interval_vs_bond)
1256 {
1257 CScope* scope = &GetScope();
1258
1259 CRef<CSeq_loc> b = MakeBond(2, 15);
1260
1261 CSeq_id gi2("gi|2");
1262 CSeq_id gi3("gi|3");
1263
1264 CSeq_loc pki;
1265
1266 pki.SetPacked_int().AddInterval(gi2, 1, 5);
1267 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eNoOverlap);
1268 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eNoOverlap);
1269 pki.SetPacked_int().AddInterval(gi2, 20, 25);
1270 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eNoOverlap);
1271 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eNoOverlap);
1272
1273 pki.SetPacked_int().Set().clear();
1274 pki.SetPacked_int().AddInterval(gi2, 10, 20);
1275 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eContains);
1276 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eContained);
1277
1278 // For bonds we only detect no-overlap/overlap/contained, not same.
1279 pki.SetPacked_int().Set().clear();
1280 pki.SetPacked_int().AddInterval(gi2, 15, 15);
1281 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eSame);
1282 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eSame);
1283
1284 pki.SetPacked_int().AddInterval(gi2, 15, 15);
1285 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eContains);
1286 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eContains);
1287
1288 b->SetBond().SetB().SetId().SetGi(GI_CONST(2));
1289 b->SetBond().SetB().SetPoint(25);
1290
1291 pki.SetPacked_int().Set().clear();
1292 pki.SetPacked_int().AddInterval(gi2, 17, 23);
1293 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eNoOverlap);
1294 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eNoOverlap);
1295
1296 pki.SetPacked_int().Set().clear();
1297 pki.SetPacked_int().AddInterval(gi2, 10, 30);
1298 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eContains);
1299 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eContained);
1300
1301 pki.SetPacked_int().Set().clear();
1302 pki.SetPacked_int().AddInterval(gi2, 10, 20);
1303 pki.SetPacked_int().AddInterval(gi2, 30, 40);
1304 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eOverlap);
1305 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eOverlap);
1306
1307 pki.SetPacked_int().Set().clear();
1308 pki.SetPacked_int().AddInterval(gi2, 5, 10);
1309 pki.SetPacked_int().AddInterval(gi2, 20, 30);
1310 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eOverlap);
1311 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eOverlap);
1312
1313 pki.SetPacked_int().Set().clear();
1314 pki.SetPacked_int().AddInterval(gi2, 10, 20);
1315 pki.SetPacked_int().AddInterval(gi2, 20, 30);
1316 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eContains);
1317 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eContained);
1318
1319 b->SetBond().SetB().SetId().SetGi(GI_CONST(3));
1320
1321 pki.SetPacked_int().Set().clear();
1322 pki.SetPacked_int().AddInterval(gi2, 20, 30);
1323 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eNoOverlap);
1324 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eNoOverlap);
1325
1326 pki.SetPacked_int().Set().clear();
1327 pki.SetPacked_int().AddInterval(gi2, 10, 30);
1328 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eOverlap);
1329 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eOverlap);
1330
1331 pki.SetPacked_int().Set().clear();
1332 pki.SetPacked_int().AddInterval(gi2, 10, 20);
1333 pki.SetPacked_int().AddInterval(gi2, 20, 30);
1334 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eOverlap);
1335 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eOverlap);
1336
1337 pki.SetPacked_int().Set().clear();
1338 pki.SetPacked_int().AddInterval(gi2, 10, 20);
1339 pki.SetPacked_int().AddInterval(gi3, 20, 30);
1340 BOOST_CHECK_EQUAL(Compare(pki, *b, scope, fCompareOverlapping), eContains);
1341 BOOST_CHECK_EQUAL(Compare(*b, pki, scope, fCompareOverlapping), eContained);
1342 }
1343
1344
BOOST_AUTO_TEST_CASE(Test_Compare_point_vs_point)1345 BOOST_AUTO_TEST_CASE(Test_Compare_point_vs_point)
1346 {
1347 CScope* scope = &GetScope();
1348
1349 CRef<CSeq_loc> p2a = MakePoint(2, 10);
1350 CRef<CSeq_loc> p2b = MakePoint(2, 15);
1351 CRef<CSeq_loc> p3 = MakePoint(3, 20);
1352
1353 BOOST_CHECK_EQUAL(Compare(*p2a, *p2a, scope, fCompareOverlapping), eSame);
1354 BOOST_CHECK_EQUAL(Compare(*p2a, *p2b, scope, fCompareOverlapping), eNoOverlap);
1355 BOOST_CHECK_EQUAL(Compare(*p2a, *p3, scope, fCompareOverlapping), eNoOverlap);
1356 }
1357
1358
BOOST_AUTO_TEST_CASE(Test_Compare_point_vs_packed_point)1359 BOOST_AUTO_TEST_CASE(Test_Compare_point_vs_packed_point)
1360 {
1361 CScope* scope = &GetScope();
1362
1363 CRef<CSeq_loc> p = MakePoint(2, 5);
1364
1365 CSeq_loc pp;
1366 pp.SetPacked_pnt().SetId().SetGi(GI_CONST(2));
1367 pp.SetPacked_pnt().AddPoint(10);
1368
1369 // No overlap
1370 BOOST_CHECK_EQUAL(Compare(*p, pp, scope, fCompareOverlapping), eNoOverlap);
1371 BOOST_CHECK_EQUAL(Compare(pp, *p, scope, fCompareOverlapping), eNoOverlap);
1372
1373 p = MakePoint(2, 10);
1374 // Single entry in packed points
1375 BOOST_CHECK_EQUAL(Compare(*p, pp, scope, fCompareOverlapping), eSame);
1376 BOOST_CHECK_EQUAL(Compare(pp, *p, scope, fCompareOverlapping), eSame);
1377
1378 pp.SetPacked_pnt().AddPoint(20);
1379 pp.SetPacked_pnt().AddPoint(30);
1380 // Multiple points
1381 BOOST_CHECK_EQUAL(Compare(*p, pp, scope, fCompareOverlapping), eContained);
1382 BOOST_CHECK_EQUAL(Compare(pp, *p, scope, fCompareOverlapping), eContains);
1383
1384 // Special case: all packed points are the same.
1385 // The first seq-loc contains the second one in any direction.
1386 pp.Reset();
1387 pp.SetPacked_pnt().SetId().SetGi(GI_CONST(2));
1388 pp.SetPacked_pnt().AddPoint(10);
1389 pp.SetPacked_pnt().AddPoint(10);
1390 BOOST_CHECK_EQUAL(Compare(*p, pp, scope, fCompareOverlapping), eContains);
1391 BOOST_CHECK_EQUAL(Compare(pp, *p, scope, fCompareOverlapping), eContains);
1392 }
1393
1394
BOOST_AUTO_TEST_CASE(Test_Compare_point_vs_mix)1395 BOOST_AUTO_TEST_CASE(Test_Compare_point_vs_mix)
1396 {
1397 CScope* scope = &GetScope();
1398
1399 CRef<CSeq_loc> p = MakePoint(2, 50);
1400
1401 CSeq_loc mix;
1402
1403 mix.SetMix().Set().push_back(MakeInterval(3, 10, 90));
1404 BOOST_CHECK_EQUAL(Compare(*p, mix, scope, fCompareOverlapping), eNoOverlap);
1405
1406 mix.SetMix().Set().clear();
1407 mix.SetMix().Set().push_back(MakeInterval(2, 10, 40));
1408 mix.SetMix().Set().push_back(MakeInterval(2, 60, 90));
1409 BOOST_CHECK_EQUAL(Compare(*p, mix, scope, fCompareOverlapping), eNoOverlap);
1410 mix.SetMix().Set().push_back(MakeInterval(2, 40, 60));
1411 BOOST_CHECK_EQUAL(Compare(*p, mix, scope, fCompareOverlapping), eContained);
1412 BOOST_CHECK_EQUAL(Compare(mix, *p, scope, fCompareOverlapping), eContains);
1413
1414 mix.SetMix().Set().clear();
1415 mix.SetMix().Set().push_back(MakePoint(2, 50));
1416 BOOST_CHECK_EQUAL(Compare(*p, mix, scope, fCompareOverlapping), eSame);
1417 BOOST_CHECK_EQUAL(Compare(mix, *p, scope, fCompareOverlapping), eSame);
1418 mix.SetMix().Set().push_back(MakePoint(2, 50));
1419 BOOST_CHECK_EQUAL(Compare(*p, mix, scope, fCompareOverlapping), eContains);
1420 BOOST_CHECK_EQUAL(Compare(mix, *p, scope, fCompareOverlapping), eContains);
1421 }
1422
1423
BOOST_AUTO_TEST_CASE(Test_Compare_point_vs_bond)1424 BOOST_AUTO_TEST_CASE(Test_Compare_point_vs_bond)
1425 {
1426 CScope* scope = &GetScope();
1427
1428 CRef<CSeq_loc> bA2 = MakeBond(2, 10);
1429 CRef<CSeq_loc> bA2B3 = MakeBond(2, 10, 3, 20);
1430 CRef<CSeq_loc> bA2B2 = MakeBond(2, 10, 2, 20);
1431 CRef<CSeq_loc> bA2B2eq = MakeBond(2, 10, 2, 10);
1432
1433 CRef<CSeq_loc> p = MakePoint(2, 5);
1434 // No overlap
1435 BOOST_CHECK_EQUAL(Compare(*bA2, *p, scope, fCompareOverlapping), eNoOverlap);
1436
1437 p = MakePoint(2, 10);
1438 // Overlap with A
1439 BOOST_CHECK_EQUAL(Compare(*bA2, *p, scope, fCompareOverlapping), eSame);
1440 BOOST_CHECK_EQUAL(Compare(*bA2B3, *p, scope, fCompareOverlapping), eContains);
1441 BOOST_CHECK_EQUAL(Compare(*p, *bA2B3, scope, fCompareOverlapping), eContained);
1442 BOOST_CHECK_EQUAL(Compare(*bA2B2, *p, scope, fCompareOverlapping), eContains);
1443 BOOST_CHECK_EQUAL(Compare(*p, *bA2B2, scope, fCompareOverlapping), eContained);
1444
1445 // Special case - A==B, contains in both directions.
1446 BOOST_CHECK_EQUAL(Compare(*bA2B2eq, *p, scope, fCompareOverlapping), eContains);
1447 BOOST_CHECK_EQUAL(Compare(*p, *bA2B2eq, scope, fCompareOverlapping), eContains);
1448 }
1449
1450
BOOST_AUTO_TEST_CASE(Test_Compare_packed_point_vs_packed_point)1451 BOOST_AUTO_TEST_CASE(Test_Compare_packed_point_vs_packed_point)
1452 {
1453 CScope* scope = &GetScope();
1454
1455 CSeq_loc pp1;
1456 pp1.SetPacked_pnt().SetId().SetGi(GI_CONST(2));
1457 pp1.SetPacked_pnt().AddPoint(10);
1458
1459 CSeq_loc pp2;
1460 pp2.SetPacked_pnt().SetId().SetGi(GI_CONST(3));
1461 pp2.SetPacked_pnt().AddPoint(10);
1462
1463 // No overlap for different bioseqs
1464 BOOST_CHECK_EQUAL(Compare(pp1, pp2, scope, fCompareOverlapping), eNoOverlap);
1465 pp1.SetPacked_pnt().AddPoint(20);
1466 pp2.SetPacked_pnt().SetId().SetGi(GI_CONST(2));
1467 pp2.SetPacked_pnt().SetPoints().front() = 5;
1468 pp2.SetPacked_pnt().AddPoint(15);
1469 BOOST_CHECK_EQUAL(Compare(pp1, pp2, scope, fCompareOverlapping), eNoOverlap);
1470 pp1.SetPacked_pnt().AddPoint(30);
1471 BOOST_CHECK_EQUAL(Compare(pp1, pp2, scope, fCompareOverlapping), eNoOverlap);
1472
1473 // Same
1474 pp2.Assign(pp1);
1475 BOOST_CHECK_EQUAL(Compare(pp1, pp2, scope, fCompareOverlapping), eSame);
1476
1477 // Overlap
1478 pp2.SetPacked_pnt().SetPoints().clear();
1479 pp2.SetPacked_pnt().AddPoint(5);
1480 pp2.SetPacked_pnt().AddPoint(10);
1481 pp2.SetPacked_pnt().AddPoint(15);
1482 BOOST_CHECK_EQUAL(Compare(pp1, pp2, scope, fCompareOverlapping), eOverlap);
1483 BOOST_CHECK_EQUAL(Compare(pp2, pp1, scope, fCompareOverlapping), eOverlap);
1484
1485 // Contained/contains
1486 pp1.SetPacked_pnt().AddPoint(40); // 10, 20, 30, 40
1487 pp2.SetPacked_pnt().SetPoints().clear();
1488 pp2.SetPacked_pnt().AddPoint(20); // 20
1489 BOOST_CHECK_EQUAL(Compare(pp1, pp2, scope, fCompareOverlapping), eContains);
1490 BOOST_CHECK_EQUAL(Compare(pp2, pp1, scope, fCompareOverlapping), eContained);
1491 pp2.SetPacked_pnt().AddPoint(30); // 20, 30
1492 BOOST_CHECK_EQUAL(Compare(pp1, pp2, scope, fCompareOverlapping), eContains);
1493 BOOST_CHECK_EQUAL(Compare(pp2, pp1, scope, fCompareOverlapping), eContained);
1494 // Wrong order of points should still work
1495 pp2.SetPacked_pnt().AddPoint(10); // 20, 30, 10
1496 BOOST_CHECK_EQUAL(Compare(pp1, pp2, scope, fCompareOverlapping), eContains);
1497 BOOST_CHECK_EQUAL(Compare(pp2, pp1, scope, fCompareOverlapping), eContained);
1498 // Duplicate points - same result
1499 pp2.SetPacked_pnt().AddPoint(20); // 20, 30, 10, 20
1500 BOOST_CHECK_EQUAL(Compare(pp1, pp2, scope, fCompareOverlapping), eContains);
1501 BOOST_CHECK_EQUAL(Compare(pp2, pp1, scope, fCompareOverlapping), eContained);
1502
1503 // Special case - due to duplicate points both sets contain each other
1504 // but are not equal
1505 pp2.SetPacked_pnt().AddPoint(40); // 20, 30, 10, 20, 40
1506 BOOST_CHECK_EQUAL(Compare(pp1, pp2, scope, fCompareOverlapping), eContains);
1507 BOOST_CHECK_EQUAL(Compare(pp2, pp1, scope, fCompareOverlapping), eContains);
1508
1509 // Now they just overlap
1510 pp1.SetPacked_pnt().AddPoint(45);
1511 pp2.SetPacked_pnt().AddPoint(5);
1512 BOOST_CHECK_EQUAL(Compare(pp1, pp2, scope, fCompareOverlapping), eOverlap);
1513 BOOST_CHECK_EQUAL(Compare(pp2, pp1, scope, fCompareOverlapping), eOverlap);
1514 }
1515
1516
BOOST_AUTO_TEST_CASE(Test_Compare_packed_point_vs_mix)1517 BOOST_AUTO_TEST_CASE(Test_Compare_packed_point_vs_mix)
1518 {
1519 CScope* scope = &GetScope();
1520
1521 CSeq_loc pp;
1522 pp.SetPacked_pnt().SetId().SetGi(GI_CONST(2));
1523 pp.SetPacked_pnt().AddPoint(25);
1524 pp.SetPacked_pnt().AddPoint(85);
1525
1526 CSeq_loc mix;
1527
1528 // Each point is contained in a separate sub-location.
1529 mix.SetMix().Set().push_back(MakeInterval(2, 30, 70));
1530 BOOST_CHECK_EQUAL(Compare(pp, mix, scope, fCompareOverlapping), eNoOverlap);
1531 pp.SetPacked_pnt().AddPoint(50);
1532 BOOST_CHECK_EQUAL(Compare(pp, mix, scope, fCompareOverlapping), eOverlap);
1533 BOOST_CHECK_EQUAL(Compare(pp, mix, scope, fCompareOverlapping), eOverlap);
1534 mix.SetMix().Set().push_back(MakeInterval(2, 20, 30));
1535 mix.SetMix().Set().push_back(MakeInterval(2, 70, 90));
1536 BOOST_CHECK_EQUAL(Compare(pp, mix, scope, fCompareOverlapping), eContained);
1537 BOOST_CHECK_EQUAL(Compare(mix, pp, scope, fCompareOverlapping), eContains);
1538 }
1539
1540
BOOST_AUTO_TEST_CASE(Test_Compare_packed_point_vs_bond)1541 BOOST_AUTO_TEST_CASE(Test_Compare_packed_point_vs_bond)
1542 {
1543 CScope* scope = &GetScope();
1544
1545 CSeq_loc pp;
1546 pp.SetPacked_pnt().SetId().SetGi(GI_CONST(2));
1547 pp.SetPacked_pnt().AddPoint(10);
1548
1549 CRef<CSeq_loc> b = MakeBond(3, 10);
1550 // No overlap
1551 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eNoOverlap);
1552 b = MakeBond(2, 20);
1553 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eNoOverlap);
1554
1555 b = MakeBond(2, 10);
1556 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eSame);
1557 b = MakeBond(2, 10, 3, 10);
1558 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContained);
1559 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContains);
1560 b = MakeBond(2, 10, 2, 20);
1561 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContained);
1562 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContains);
1563 b = MakeBond(3, 10, 2, 10);
1564 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContained);
1565 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContains);
1566 b = MakeBond(2, 10, 2, 10);
1567 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContains);
1568 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContains);
1569
1570 pp.SetPacked_pnt().AddPoint(20);
1571 b = MakeBond(2, 10);
1572 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContains);
1573 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContained);
1574 b = MakeBond(2, 10, 2, 20);
1575 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eSame);
1576 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eSame);
1577 // The order of points does not matter.
1578 b = MakeBond(2, 20, 2, 10);
1579 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eSame);
1580 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eSame);
1581 b = MakeBond(2, 10, 3, 10);
1582 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eOverlap);
1583 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eOverlap);
1584 b = MakeBond(3, 10, 2, 10);
1585 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eOverlap);
1586 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eOverlap);
1587 b = MakeBond(2, 10, 2, 10);
1588 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContains);
1589 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContained);
1590 b = MakeBond(2, 20, 2, 20);
1591 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContains);
1592 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContained);
1593 b = MakeBond(2, 10, 2, 40);
1594 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eOverlap);
1595 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eOverlap);
1596
1597 pp.SetPacked_pnt().AddPoint(30);
1598 b = MakeBond(2, 10);
1599 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContains);
1600 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContained);
1601 b = MakeBond(2, 10, 2, 30);
1602 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContains);
1603 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContained);
1604 b = MakeBond(2, 30, 2, 10);
1605 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContains);
1606 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContained);
1607 b = MakeBond(2, 10, 3, 10);
1608 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eOverlap);
1609 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eOverlap);
1610 b = MakeBond(3, 10, 2, 10);
1611 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eOverlap);
1612 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eOverlap);
1613 b = MakeBond(2, 10, 2, 10);
1614 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContains);
1615 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContained);
1616 b = MakeBond(2, 10, 2, 40);
1617 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eOverlap);
1618 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eOverlap);
1619
1620 pp.SetPacked_pnt().SetPoints().clear();
1621 pp.SetPacked_pnt().AddPoint(10);
1622 pp.SetPacked_pnt().AddPoint(20);
1623 pp.SetPacked_pnt().AddPoint(20);
1624 b = MakeBond(2, 10);
1625 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContains);
1626 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContained);
1627 b = MakeBond(2, 10, 2, 20);
1628 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContains);
1629 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContains);
1630 b = MakeBond(2, 10, 2, 30);
1631 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eOverlap);
1632 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eOverlap);
1633 b = MakeBond(2, 30, 2, 10);
1634 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eOverlap);
1635 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eOverlap);
1636 b = MakeBond(2, 10, 2, 20);
1637 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContains);
1638 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContains);
1639 b = MakeBond(2, 20, 2, 10);
1640 BOOST_CHECK_EQUAL(Compare(pp, *b, scope, fCompareOverlapping), eContains);
1641 BOOST_CHECK_EQUAL(Compare(*b, pp, scope, fCompareOverlapping), eContains);
1642 }
1643
1644
BOOST_AUTO_TEST_CASE(Test_Compare_mix_vs_mix)1645 BOOST_AUTO_TEST_CASE(Test_Compare_mix_vs_mix)
1646 {
1647 CScope* scope = &GetScope();
1648
1649 CSeq_loc mix1, mix2;
1650
1651 mix1.SetMix().Set().push_back(MakeInterval(2, 10, 20));
1652 mix1.SetMix().Set().push_back(MakeInterval(2, 50, 60));
1653 mix2.SetMix().Set().push_back(MakeInterval(2, 30, 40));
1654 mix2.SetMix().Set().push_back(MakeInterval(2, 70, 80));
1655 BOOST_CHECK_EQUAL(Compare(mix1, mix2, scope, fCompareOverlapping), eNoOverlap);
1656 mix1.SetMix().Set().push_back(MakeInterval(3, 30, 40));
1657 BOOST_CHECK_EQUAL(Compare(mix1, mix2, scope, fCompareOverlapping), eNoOverlap);
1658 mix2.SetMix().Set().push_front(MakeInterval(3, 20, 35));
1659 BOOST_CHECK_EQUAL(Compare(mix1, mix2, scope, fCompareOverlapping), eOverlap);
1660
1661 mix1.SetMix().Set().clear();
1662 mix1.SetMix().Set().push_back(MakeInterval(2, 10, 30));
1663 mix1.SetMix().Set().push_back(MakeInterval(2, 50, 70));
1664 mix2.SetMix().Set().clear();
1665 mix2.SetMix().Set().push_back(MakeInterval(2, 60, 65));
1666 mix2.SetMix().Set().push_back(MakeInterval(2, 20, 25));
1667 BOOST_CHECK_EQUAL(Compare(mix1, mix2, scope, fCompareOverlapping), eContains);
1668 BOOST_CHECK_EQUAL(Compare(mix2, mix1, scope, fCompareOverlapping), eContained);
1669
1670 mix2.SetMix().Set().push_back(MakeInterval(2, 50, 70));
1671 mix2.SetMix().Set().push_back(MakeInterval(2, 10, 30));
1672 BOOST_CHECK_EQUAL(Compare(mix1, mix2, scope, fCompareOverlapping), eContains);
1673 BOOST_CHECK_EQUAL(Compare(mix2, mix1, scope, fCompareOverlapping), eContains);
1674
1675 // Empty should not change anything (?)
1676 CRef<CSeq_loc> sub(new CSeq_loc);
1677 sub->SetEmpty().SetGi(GI_CONST(2));
1678 mix2.SetMix().Set().push_back(sub);
1679 BOOST_CHECK_EQUAL(Compare(mix1, mix2, scope, fCompareOverlapping), eContains);
1680 BOOST_CHECK_EQUAL(Compare(mix2, mix1, scope, fCompareOverlapping), eContains);
1681
1682 mix2.SetMix().Set().push_back(MakePoint(3, 100));
1683 BOOST_CHECK_EQUAL(Compare(mix1, mix2, scope, fCompareOverlapping), eContained);
1684 BOOST_CHECK_EQUAL(Compare(mix2, mix1, scope, fCompareOverlapping), eContains);
1685
1686 mix1.SetMix().Set().push_back(MakePoint(2, 110));
1687 BOOST_CHECK_EQUAL(Compare(mix1, mix2, scope, fCompareOverlapping), eOverlap);
1688 BOOST_CHECK_EQUAL(Compare(mix2, mix1, scope, fCompareOverlapping), eOverlap);
1689 }
1690
1691
BOOST_AUTO_TEST_CASE(Test_Compare_mix_vs_bond)1692 BOOST_AUTO_TEST_CASE(Test_Compare_mix_vs_bond)
1693 {
1694 CScope* scope = &GetScope();
1695
1696 CRef<CSeq_loc> b = MakeBond(2, 50);
1697
1698 CSeq_loc mix;
1699
1700 // Each point is contained in a separate sub-location.
1701 mix.SetMix().Set().push_back(MakeInterval(2, 10, 30));
1702 BOOST_CHECK_EQUAL(Compare(*b, mix, scope, fCompareOverlapping), eNoOverlap);
1703 mix.SetMix().Set().push_back(MakeInterval(2, 70, 90));
1704 BOOST_CHECK_EQUAL(Compare(*b, mix, scope, fCompareOverlapping), eNoOverlap);
1705 mix.SetMix().Set().push_back(MakeInterval(2, 40, 60));
1706 BOOST_CHECK_EQUAL(Compare(*b, mix, scope, fCompareOverlapping), eContained);
1707 BOOST_CHECK_EQUAL(Compare(mix, *b, scope, fCompareOverlapping), eContains);
1708
1709 b = MakeBond(2, 20, 3, 40);
1710 BOOST_CHECK_EQUAL(Compare(*b, mix, scope, fCompareOverlapping), eOverlap);
1711 BOOST_CHECK_EQUAL(Compare(mix, *b, scope, fCompareOverlapping), eOverlap);
1712
1713 mix.SetMix().Set().push_back(MakeInterval(3, 30, 50));
1714 BOOST_CHECK_EQUAL(Compare(*b, mix, scope, fCompareOverlapping), eContained);
1715 BOOST_CHECK_EQUAL(Compare(mix, *b, scope, fCompareOverlapping), eContains);
1716
1717 mix.SetMix().Set().clear();
1718 mix.SetMix().Set().push_back(MakePoint(2, 20));
1719 BOOST_CHECK_EQUAL(Compare(*b, mix, scope, fCompareOverlapping), eContains);
1720 BOOST_CHECK_EQUAL(Compare(mix, *b, scope, fCompareOverlapping), eContained);
1721
1722 mix.SetMix().Set().push_back(MakePoint(3, 40));
1723 BOOST_CHECK_EQUAL(Compare(*b, mix, scope, fCompareOverlapping), eSame);
1724 BOOST_CHECK_EQUAL(Compare(mix, *b, scope, fCompareOverlapping), eSame);
1725 mix.SetMix().Set().reverse();
1726 BOOST_CHECK_EQUAL(Compare(*b, mix, scope, fCompareOverlapping), eSame);
1727 BOOST_CHECK_EQUAL(Compare(mix, *b, scope, fCompareOverlapping), eSame);
1728
1729 mix.SetMix().Set().clear();
1730 mix.SetMix().Set().push_back(MakeInterval(2, 20, 20));
1731 mix.SetMix().Set().push_back(MakeInterval(3, 40, 40));
1732 BOOST_CHECK_EQUAL(Compare(*b, mix, scope, fCompareOverlapping), eSame);
1733 BOOST_CHECK_EQUAL(Compare(mix, *b, scope, fCompareOverlapping), eSame);
1734 mix.SetMix().Set().reverse();
1735 BOOST_CHECK_EQUAL(Compare(*b, mix, scope, fCompareOverlapping), eSame);
1736 BOOST_CHECK_EQUAL(Compare(mix, *b, scope, fCompareOverlapping), eSame);
1737 mix.SetMix().Set().push_back(MakeInterval(3, 40, 40));
1738 mix.SetMix().Set().reverse();
1739 BOOST_CHECK_EQUAL(Compare(*b, mix, scope, fCompareOverlapping), eContains);
1740 BOOST_CHECK_EQUAL(Compare(mix, *b, scope, fCompareOverlapping), eContains);
1741 }
1742
1743
BOOST_AUTO_TEST_CASE(Test_Compare_bond_vs_bond)1744 BOOST_AUTO_TEST_CASE(Test_Compare_bond_vs_bond)
1745 {
1746 CScope* scope = &GetScope();
1747
1748 CRef<CSeq_loc> b1 = MakeBond(2, 10);
1749 CRef<CSeq_loc> b2 = MakeBond(3, 10);
1750 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eNoOverlap);
1751
1752 b2 = MakeBond(2, 20);
1753 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eNoOverlap);
1754
1755 b2 = MakeBond(2, 10);
1756 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eSame);
1757
1758 b2 = MakeBond(2, 10, 3, 20);
1759 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eContained);
1760 BOOST_CHECK_EQUAL(Compare(*b2, *b1, scope, fCompareOverlapping), eContains);
1761 b1 = MakeBond(2, 10, 3, 25);
1762 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eOverlap);
1763 BOOST_CHECK_EQUAL(Compare(*b2, *b1, scope, fCompareOverlapping), eOverlap);
1764 b1 = MakeBond(2, 10, 3, 20);
1765 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eSame);
1766 BOOST_CHECK_EQUAL(Compare(*b2, *b1, scope, fCompareOverlapping), eSame);
1767
1768 b2 = MakeBond(2, 15, 3, 20);
1769 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eOverlap);
1770 BOOST_CHECK_EQUAL(Compare(*b2, *b1, scope, fCompareOverlapping), eOverlap);
1771 b2 = MakeBond(2, 10, 3, 20);
1772 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eSame);
1773 BOOST_CHECK_EQUAL(Compare(*b2, *b1, scope, fCompareOverlapping), eSame);
1774 // The order or ranges is not important
1775 b2 = MakeBond(3, 20, 2, 10);
1776 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eSame);
1777 BOOST_CHECK_EQUAL(Compare(*b2, *b1, scope, fCompareOverlapping), eSame);
1778
1779 b1 = MakeBond(2, 10, 2, 10);
1780 b2 = MakeBond(2, 10, 2, 10);
1781 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eSame);
1782 BOOST_CHECK_EQUAL(Compare(*b2, *b1, scope, fCompareOverlapping), eSame);
1783
1784 b1 = MakeBond(2, 10, 3, 20);
1785 b2 = MakeBond(3, 20);
1786 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eContains);
1787 BOOST_CHECK_EQUAL(Compare(*b2, *b1, scope, fCompareOverlapping), eContained);
1788 b2 = MakeBond(3, 20, 2, 15);
1789 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eOverlap);
1790 BOOST_CHECK_EQUAL(Compare(*b2, *b1, scope, fCompareOverlapping), eOverlap);
1791
1792 b1 = MakeBond(2, 10, 2, 10);
1793 b2 = MakeBond(2, 10);
1794 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eContains);
1795 BOOST_CHECK_EQUAL(Compare(*b2, *b1, scope, fCompareOverlapping), eContains);
1796 b2 = MakeBond(2, 10, 3, 15);
1797 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eContained);
1798 BOOST_CHECK_EQUAL(Compare(*b2, *b1, scope, fCompareOverlapping), eContains);
1799
1800 b1 = MakeBond(2, 15, 3, 20);
1801 b2 = MakeBond(3, 20, 3, 20);
1802 BOOST_CHECK_EQUAL(Compare(*b1, *b2, scope, fCompareOverlapping), eContains);
1803 BOOST_CHECK_EQUAL(Compare(*b2, *b1, scope, fCompareOverlapping), eContained);
1804 }
1805
1806
BOOST_AUTO_TEST_CASE(Test_TestForOverlap)1807 BOOST_AUTO_TEST_CASE(Test_TestForOverlap)
1808 {
1809 CScope* scope = &GetScope();
1810 CRef<CSeq_id> id2(new CSeq_id);
1811 id2->SetLocal().SetStr("local2");
1812
1813 // No overlap
1814 CRef<CSeq_loc> loc1 = MakeInterval(2, 10, 20);
1815 CRef<CSeq_loc> loc2 = MakeInterval(3, 10, 20);
1816 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), -1);
1817 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
1818 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
1819 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
1820 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
1821 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
1822 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
1823 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), -1);
1824
1825 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), -1);
1826 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
1827 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
1828 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
1829 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
1830 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
1831 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
1832 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), -1);
1833
1834 // Same
1835 loc1 = MakeInterval(2, 10, 20);
1836 loc2 = MakeInterval(id2, 10, 20);
1837 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 0);
1838 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 0);
1839 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), 0);
1840 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 0);
1841 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), 0);
1842 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 0);
1843 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), 0);
1844 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 0);
1845
1846 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 0);
1847 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), 0);
1848 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 0);
1849 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), 0);
1850 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 0);
1851 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), 0);
1852 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 0);
1853 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 0);
1854
1855 // Overlap
1856 loc1 = MakeInterval(2, 10, 30);
1857 loc2 = MakeInterval(id2, 20, 40);
1858 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
1859 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
1860 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
1861 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
1862 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
1863 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
1864 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
1865 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
1866
1867 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
1868 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
1869 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
1870 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
1871 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
1872 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
1873 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
1874 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
1875
1876 // Contained
1877 loc1 = MakeInterval(2, 10, 40);
1878 loc2 = MakeInterval(id2, 20, 30);
1879 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
1880 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 20);
1881 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
1882 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 20);
1883 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
1884 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 20);
1885 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
1886 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
1887
1888 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
1889 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
1890 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 20);
1891 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
1892 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 20);
1893 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
1894 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 20);
1895 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
1896
1897 // Multirange, same
1898 loc1.Reset(new CSeq_loc);
1899 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 20));
1900 loc1->SetMix().Set().push_back(MakeInterval(2, 30, 40));
1901 loc2.Reset(new CSeq_loc);
1902 loc2->SetMix().Set().push_back(MakeInterval(id2, 10, 20));
1903 loc2->SetMix().Set().push_back(MakeInterval(id2, 30, 40));
1904 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 0);
1905 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 0);
1906 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), 0);
1907 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 0);
1908 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), 0);
1909 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 0);
1910 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), 0);
1911 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 0);
1912
1913 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 0);
1914 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), 0);
1915 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 0);
1916 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), 0);
1917 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 0);
1918 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), 0);
1919 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 0);
1920 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 0);
1921
1922 // Multirange, simple (by total range only)
1923 loc1->SetMix().Set().clear();
1924 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 20));
1925 loc1->SetMix().Set().push_back(MakeInterval(2, 50, 60));
1926 loc2->SetMix().Set().clear();
1927 loc2->SetMix().Set().push_back(MakeInterval(id2, 30, 40));
1928 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
1929 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 40);
1930 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
1931 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
1932 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
1933 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
1934 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
1935 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), -1);
1936
1937 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
1938 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
1939 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 40);
1940 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
1941 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
1942 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
1943 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
1944 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), -1);
1945
1946 // Multirange, overlap
1947 loc1->SetMix().Set().clear();
1948 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 30));
1949 loc1->SetMix().Set().push_back(MakeInterval(2, 50, 70));
1950 loc2->SetMix().Set().clear();
1951 loc2->SetMix().Set().push_back(MakeInterval(id2, 20, 40));
1952 loc2->SetMix().Set().push_back(MakeInterval(id2, 60, 80));
1953 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
1954 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
1955 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
1956 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
1957 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
1958 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
1959 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
1960 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
1961
1962 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
1963 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
1964 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
1965 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
1966 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
1967 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
1968 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
1969 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
1970
1971 // Multirange, contained. Contained/contains only check the
1972 // extremes, not each range.
1973 loc1->SetMix().Set().clear();
1974 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 30));
1975 loc1->SetMix().Set().push_back(MakeInterval(2, 60, 80));
1976 loc2->SetMix().Set().clear();
1977 loc2->SetMix().Set().push_back(MakeInterval(id2, 20, 40));
1978 loc2->SetMix().Set().push_back(MakeInterval(id2, 50, 70));
1979 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
1980 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 20);
1981 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
1982 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
1983 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
1984 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
1985 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
1986 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
1987
1988 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
1989 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
1990 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 20);
1991 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
1992 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
1993 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
1994 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
1995 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
1996
1997 // Multirange, subset
1998 loc1->SetMix().Set().clear();
1999 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 40));
2000 loc1->SetMix().Set().push_back(MakeInterval(2, 50, 80));
2001 loc2->SetMix().Set().clear();
2002 loc2->SetMix().Set().push_back(MakeInterval(id2, 20, 30));
2003 loc2->SetMix().Set().push_back(MakeInterval(id2, 60, 70));
2004 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
2005 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 20);
2006 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2007 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 40);
2008 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2009 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2010 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2011 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
2012
2013 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
2014 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2015 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 20);
2016 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2017 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 40);
2018 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2019 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2020 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
2021
2022 // CheckIntervals - extra intervals before/after
2023 loc1->SetMix().Set().clear();
2024 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 30));
2025 loc1->SetMix().Set().push_back(MakeInterval(2, 40, 50));
2026 loc1->SetMix().Set().push_back(MakeInterval(2, 60, 80));
2027 loc2->SetMix().Set().clear();
2028 loc2->SetMix().Set().push_back(MakeInterval(id2, 40, 50));
2029 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 60);
2030 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 60);
2031 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2032 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 42);
2033 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2034 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 42);
2035 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2036 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 60);
2037
2038 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 60);
2039 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2040 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 60);
2041 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2042 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 42);
2043 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2044 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 42);
2045 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 60);
2046
2047 // Check intervals fails - the first interval boundaries do not match
2048 loc2->SetMix().Set().clear();
2049 loc2->SetMix().Set().push_back(MakeInterval(id2, 20, 25));
2050 loc2->SetMix().Set().push_back(MakeInterval(id2, 40, 50));
2051 loc2->SetMix().Set().push_back(MakeInterval(id2, 60, 70));
2052 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
2053 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 20);
2054 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2055 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 25);
2056 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2057 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2058 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2059 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
2060
2061 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
2062 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2063 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 20);
2064 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2065 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 25);
2066 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2067 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2068 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
2069
2070 // Check intervals fails - the second interval boundaries do not match
2071 loc2->SetMix().Set().clear();
2072 loc2->SetMix().Set().push_back(MakeInterval(id2, 20, 30));
2073 loc2->SetMix().Set().push_back(MakeInterval(id2, 40, 45));
2074 loc2->SetMix().Set().push_back(MakeInterval(id2, 60, 70));
2075 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
2076 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 20);
2077 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2078 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 25);
2079 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2080 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2081 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2082 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
2083
2084 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
2085 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2086 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 20);
2087 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2088 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 25);
2089 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2090 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2091 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
2092
2093 // Check intervals fails - the second interval boundaries do not match
2094 loc2->SetMix().Set().clear();
2095 loc2->SetMix().Set().push_back(MakeInterval(id2, 20, 30));
2096 loc2->SetMix().Set().push_back(MakeInterval(id2, 45, 50));
2097 loc2->SetMix().Set().push_back(MakeInterval(id2, 60, 70));
2098 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
2099 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 20);
2100 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2101 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 25);
2102 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2103 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2104 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2105 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
2106
2107 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
2108 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2109 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 20);
2110 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2111 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 25);
2112 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2113 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2114 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
2115
2116 // Check intervals fails - the last interval boundaries do not match
2117 loc2->SetMix().Set().clear();
2118 loc2->SetMix().Set().push_back(MakeInterval(id2, 20, 30));
2119 loc2->SetMix().Set().push_back(MakeInterval(id2, 40, 50));
2120 loc2->SetMix().Set().push_back(MakeInterval(id2, 65, 70));
2121 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
2122 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 20);
2123 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2124 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 25);
2125 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2126 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2127 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2128 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
2129
2130 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
2131 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2132 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 20);
2133 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2134 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 25);
2135 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2136 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2137 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
2138
2139 // Check intervals, extra-ranges in the first/last intervals
2140 loc2->SetMix().Set().clear();
2141 loc2->SetMix().Set().push_back(MakeInterval(id2, 20, 30));
2142 loc2->SetMix().Set().push_back(MakeInterval(id2, 40, 50));
2143 loc2->SetMix().Set().push_back(MakeInterval(id2, 60, 70));
2144 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
2145 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 20);
2146 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2147 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 20);
2148 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2149 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 20);
2150 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2151 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
2152
2153 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
2154 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2155 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 20);
2156 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2157 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 20);
2158 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2159 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 20);
2160 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
2161
2162 // Subset - two intervals whithin a single interval
2163 loc2->SetMix().Set().push_back(MakeInterval(id2, 73, 78));
2164 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 12);
2165 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 12);
2166 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2167 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 14);
2168 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2169 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2170 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2171 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 12);
2172
2173 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 12);
2174 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2175 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 12);
2176 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2177 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 14);
2178 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2179 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2180 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 12);
2181
2182 // Subset - overlapping ranges whithin the same location (loc2)
2183 loc2->SetMix().Set().clear();
2184 loc2->SetMix().Set().push_back(MakeInterval(id2, 20, 25));
2185 loc2->SetMix().Set().push_back(MakeInterval(id2, 20, 30));
2186 loc2->SetMix().Set().push_back(MakeInterval(id2, 40, 50));
2187 loc2->SetMix().Set().push_back(MakeInterval(id2, 60, 70));
2188 loc2->SetMix().Set().push_back(MakeInterval(id2, 65, 70));
2189 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
2190 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 20);
2191 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2192 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 20);
2193 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2194 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2195 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2196 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
2197
2198 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
2199 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2200 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 20);
2201 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2202 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 20);
2203 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2204 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2205 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
2206 }
2207
2208
BOOST_AUTO_TEST_CASE(Test_TestForOverlap_Multiseq)2209 BOOST_AUTO_TEST_CASE(Test_TestForOverlap_Multiseq)
2210 {
2211 CScope* scope = &GetScope();
2212 CRef<CSeq_id> gi2(new CSeq_id("gi|2"));
2213 CRef<CSeq_id> gi3(new CSeq_id("gi|3"));
2214 CRef<CSeq_id> lcl2(new CSeq_id);
2215 lcl2->SetLocal().SetStr("local2");
2216 CRef<CSeq_id> lcl3(new CSeq_id);
2217 lcl3->SetLocal().SetStr("local3");
2218
2219 CRef<CSeq_loc> loc1(new CSeq_loc);
2220 CRef<CSeq_loc> loc2(new CSeq_loc);
2221
2222 // Overlap
2223 loc1->SetMix().Set().push_back(MakeInterval(gi2, 10, 30));
2224 loc1->SetMix().Set().push_back(MakeInterval(gi3, 50, 70));
2225 loc2->SetMix().Set().push_back(MakeInterval(lcl2, 20, 40));
2226 loc2->SetMix().Set().push_back(MakeInterval(lcl3, 60, 80));
2227
2228 // Invalid combination of arguments.
2229 BOOST_CHECK_THROW(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple,
2230 scope, fOverlap_NoMultiSeq), CObjmgrUtilException);
2231 BOOST_CHECK_THROW(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
2232 1442, scope), CObjmgrUtilException);
2233
2234 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
2235 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
2236 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2237 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2238 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2239 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2240 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2241 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
2242
2243 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
2244 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2245 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
2246 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2247 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2248 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2249 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2250 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
2251
2252 // Overlap on some seqs
2253 loc1->SetMix().Set().clear();
2254 loc1->SetMix().Set().push_back(MakeInterval(12, 20, 39));
2255 loc1->SetMix().Set().push_back(MakeInterval(3, 20, 39));
2256 loc1->SetMix().Set().push_back(MakeInterval(14, 20, 39));
2257 loc1->SetMix().Set().push_back(MakeInterval(5, 20, 39));
2258 loc1->SetMix().Set().push_back(MakeInterval(6, 20, 39));
2259 loc2->SetMix().Set().clear();
2260 loc2->SetMix().Set().push_back(MakeInterval(22, 20, 39));
2261 loc2->SetMix().Set().push_back(MakeInterval(3, 10, 29));
2262 loc2->SetMix().Set().push_back(MakeInterval(24, 20, 39));
2263 loc2->SetMix().Set().push_back(MakeInterval(5, 30, 49));
2264 loc2->SetMix().Set().push_back(MakeInterval(6, 50, 59));
2265
2266 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 150);
2267 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
2268 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2269 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2270 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2271 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2272 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2273 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 150);
2274
2275 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 150);
2276 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2277 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
2278 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2279 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2280 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2281 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2282 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 150);
2283
2284 // Overlap, multistrand
2285 loc1->SetMix().Set().clear();
2286 loc1->SetMix().Set().push_back(MakeInterval(gi2, 10, 30, eNa_strand_plus));
2287 loc1->SetMix().Set().push_back(MakeInterval(gi3, 50, 70, eNa_strand_minus));
2288 loc2->SetMix().Set().clear();
2289 loc2->SetMix().Set().push_back(MakeInterval(lcl2, 20, 40, eNa_strand_plus));
2290 loc2->SetMix().Set().push_back(MakeInterval(lcl3, 60, 80, eNa_strand_minus));
2291
2292 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
2293 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
2294 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2295 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2296 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2297 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2298 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2299 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
2300
2301 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
2302 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2303 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
2304 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2305 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2306 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2307 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2308 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
2309
2310 // Contained (on each sequence)
2311 loc1->SetMix().Set().clear();
2312 loc1->SetMix().Set().push_back(MakeInterval(gi2, 10, 20));
2313 loc1->SetMix().Set().push_back(MakeInterval(gi2, 30, 40));
2314 loc1->SetMix().Set().push_back(MakeInterval(gi3, 50, 60));
2315 loc1->SetMix().Set().push_back(MakeInterval(gi3, 70, 80));
2316 loc2->SetMix().Set().clear();
2317 loc2->SetMix().Set().push_back(MakeInterval(lcl2, 15, 35));
2318 loc2->SetMix().Set().push_back(MakeInterval(lcl3, 55, 75));
2319
2320 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
2321 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 20);
2322 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2323 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2324 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2325 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2326 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2327 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
2328
2329 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
2330 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2331 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 20);
2332 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2333 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2334 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2335 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2336 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
2337
2338 // Contained, multistrand
2339 loc1->SetMix().Set().clear();
2340 loc1->SetMix().Set().push_back(MakeInterval(gi2, 10, 20, eNa_strand_plus));
2341 loc1->SetMix().Set().push_back(MakeInterval(gi2, 30, 40, eNa_strand_plus));
2342 loc1->SetMix().Set().push_back(MakeInterval(gi3, 70, 80, eNa_strand_minus));
2343 loc1->SetMix().Set().push_back(MakeInterval(gi3, 50, 60, eNa_strand_minus));
2344 loc2->SetMix().Set().clear();
2345 loc2->SetMix().Set().push_back(MakeInterval(lcl2, 15, 35, eNa_strand_plus));
2346 loc2->SetMix().Set().push_back(MakeInterval(lcl3, 55, 75, eNa_strand_minus));
2347
2348 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
2349 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 20);
2350 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2351 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2352 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2353 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2354 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2355 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
2356
2357 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
2358 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2359 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 20);
2360 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2361 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2362 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2363 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2364 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
2365
2366 // Subset
2367 loc1->SetMix().Set().clear();
2368 loc1->SetMix().Set().push_back(MakeInterval(gi2, 10, 40));
2369 loc1->SetMix().Set().push_back(MakeInterval(gi3, 50, 80));
2370 loc2->SetMix().Set().clear();
2371 loc2->SetMix().Set().push_back(MakeInterval(lcl2, 20, 30));
2372 loc2->SetMix().Set().push_back(MakeInterval(lcl3, 60, 70));
2373
2374 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
2375 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 40);
2376 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2377 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 40);
2378 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2379 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2380 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2381 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
2382
2383 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
2384 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2385 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 40);
2386 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2387 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 40);
2388 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2389 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2390 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
2391
2392 // Subset, multistrand
2393 loc1->SetMix().Set().clear();
2394 loc1->SetMix().Set().push_back(MakeInterval(gi2, 10, 40, eNa_strand_plus));
2395 loc1->SetMix().Set().push_back(MakeInterval(gi3, 50, 80, eNa_strand_minus));
2396 loc2->SetMix().Set().clear();
2397 loc2->SetMix().Set().push_back(MakeInterval(lcl2, 20, 30, eNa_strand_plus));
2398 loc2->SetMix().Set().push_back(MakeInterval(lcl3, 60, 70, eNa_strand_minus));
2399
2400 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
2401 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 40);
2402 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2403 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 40);
2404 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2405 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2406 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2407 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
2408
2409 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
2410 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2411 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 40);
2412 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2413 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 40);
2414 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2415 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2416 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
2417
2418 // Check-intervals
2419 loc1->SetMix().Set().clear();
2420 loc1->SetMix().Set().push_back(MakeInterval(gi2, 10, 20));
2421 loc1->SetMix().Set().push_back(MakeInterval(gi2, 30, 40));
2422 loc1->SetMix().Set().push_back(MakeInterval(gi3, 50, 60));
2423 loc1->SetMix().Set().push_back(MakeInterval(gi3, 70, 80));
2424 loc2->SetMix().Set().clear();
2425 loc2->SetMix().Set().push_back(MakeInterval(lcl2, 15, 20));
2426 loc2->SetMix().Set().push_back(MakeInterval(lcl2, 30, 40));
2427 loc2->SetMix().Set().push_back(MakeInterval(lcl3, 50, 60));
2428 loc2->SetMix().Set().push_back(MakeInterval(lcl3, 70, 75));
2429
2430 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 10);
2431 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 10);
2432 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2433 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 10);
2434 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2435 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 10);
2436 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2437 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 10);
2438
2439 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 10);
2440 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2441 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 10);
2442 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2443 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 10);
2444 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2445 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 10);
2446 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 10);
2447
2448 // Check-intervals, minus strand
2449 loc1->SetMix().Set().clear();
2450 loc1->SetMix().Set().push_back(MakeInterval(gi3, 70, 80, eNa_strand_minus));
2451 loc1->SetMix().Set().push_back(MakeInterval(gi3, 50, 60, eNa_strand_minus));
2452 loc1->SetMix().Set().push_back(MakeInterval(gi2, 30, 40, eNa_strand_minus));
2453 loc1->SetMix().Set().push_back(MakeInterval(gi2, 10, 20, eNa_strand_minus));
2454 loc2->SetMix().Set().clear();
2455 loc2->SetMix().Set().push_back(MakeInterval(lcl3, 70, 75, eNa_strand_minus));
2456 loc2->SetMix().Set().push_back(MakeInterval(lcl3, 50, 60, eNa_strand_minus));
2457 loc2->SetMix().Set().push_back(MakeInterval(lcl2, 30, 40, eNa_strand_minus));
2458 loc2->SetMix().Set().push_back(MakeInterval(lcl2, 15, 20, eNa_strand_minus));
2459
2460 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 10);
2461 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 10);
2462 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2463 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 10);
2464 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2465 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 10);
2466 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2467 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 10);
2468
2469 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 10);
2470 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2471 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 10);
2472 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2473 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 10);
2474 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2475 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 10);
2476 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 10);
2477 }
2478
2479
BOOST_AUTO_TEST_CASE(Test_TestForOverlap_Multistrand)2480 BOOST_AUTO_TEST_CASE(Test_TestForOverlap_Multistrand)
2481 {
2482 CScope* scope = &GetScope();
2483 CRef<CSeq_loc> loc1, loc2;
2484
2485 // Different strands
2486 loc1.Reset(new CSeq_loc);
2487 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 20, eNa_strand_plus));
2488 loc1->SetMix().Set().push_back(MakeInterval(2, 30, 40, eNa_strand_plus));
2489 loc2.Reset(new CSeq_loc);
2490 loc2->SetMix().Set().push_back(MakeInterval(2, 30, 40, eNa_strand_minus));
2491 loc2->SetMix().Set().push_back(MakeInterval(2, 10, 20, eNa_strand_minus));
2492
2493 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), -1);
2494 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
2495 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2496 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2497 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2498 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2499 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2500 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), -1);
2501
2502 // Mixed strand in the same location
2503 loc1->SetMix().Set().clear();
2504 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 20, eNa_strand_plus));
2505 loc1->SetMix().Set().push_back(MakeInterval(2, 30, 40, eNa_strand_minus));
2506 loc2->SetMix().Set().clear();
2507 loc2->SetMix().Set().push_back(MakeInterval(2, 10, 20));
2508 loc2->SetMix().Set().push_back(MakeInterval(2, 30, 40));
2509 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 31);
2510 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
2511 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2512 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2513 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2514 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2515 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2516 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 31);
2517
2518 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 31);
2519 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2520 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
2521 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2522 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2523 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2524 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2525 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 31);
2526
2527 // Mixed strand in the first location, minus in the second one.
2528 loc1->SetMix().Set().clear();
2529 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 20, eNa_strand_plus));
2530 loc1->SetMix().Set().push_back(MakeInterval(2, 30, 40, eNa_strand_minus));
2531 loc2->SetMix().Set().clear();
2532 loc2->SetMix().Set().push_back(MakeInterval(2, 30, 40, eNa_strand_minus));
2533 loc2->SetMix().Set().push_back(MakeInterval(2, 10, 20, eNa_strand_minus));
2534 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 31);
2535 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
2536 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2537 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2538 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2539 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2540 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2541 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 31);
2542
2543 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 31);
2544 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2545 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
2546 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2547 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2548 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2549 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2550 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 31);
2551
2552 // Multistrand, overlap
2553 loc1->SetMix().Set().clear();
2554 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 30, eNa_strand_plus));
2555 loc1->SetMix().Set().push_back(MakeInterval(2, 50, 70, eNa_strand_plus));
2556 loc1->SetMix().Set().push_back(MakeInterval(2, 150, 170, eNa_strand_minus));
2557 loc1->SetMix().Set().push_back(MakeInterval(2, 110, 130, eNa_strand_minus));
2558 loc2->SetMix().Set().clear();
2559 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 40));
2560 loc2->SetMix().Set().push_back(MakeInterval(2, 60, 80));
2561 loc2->SetMix().Set().push_back(MakeInterval(2, 160, 180, eNa_strand_minus));
2562 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 140, eNa_strand_minus));
2563 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
2564 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
2565 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2566 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2567 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2568 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2569 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2570 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
2571
2572 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
2573 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2574 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
2575 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2576 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2577 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2578 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2579 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
2580
2581 // Multistrand, overlap
2582 loc1->SetMix().Set().clear();
2583 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 30, eNa_strand_plus));
2584 loc1->SetMix().Set().push_back(MakeInterval(2, 50, 70, eNa_strand_plus));
2585 loc1->SetMix().Set().push_back(MakeInterval(2, 150, 170, eNa_strand_minus));
2586 loc1->SetMix().Set().push_back(MakeInterval(2, 110, 130, eNa_strand_minus));
2587 loc2->SetMix().Set().clear();
2588 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 40));
2589 loc2->SetMix().Set().push_back(MakeInterval(2, 60, 80));
2590 loc2->SetMix().Set().push_back(MakeInterval(2, 160, 180, eNa_strand_minus));
2591 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 140, eNa_strand_minus));
2592
2593 // Invalid combination of arguments.
2594 BOOST_CHECK_THROW(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple,
2595 scope, fOverlap_NoMultiStrand), CObjmgrUtilException);
2596
2597 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
2598 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
2599 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2600 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2601 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2602 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2603 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2604 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
2605
2606 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
2607 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2608 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
2609 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2610 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2611 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2612 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2613 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
2614
2615 // Multistrand, overlap 2
2616 loc1->SetMix().Set().clear();
2617 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 30, eNa_strand_plus));
2618 loc1->SetMix().Set().push_back(MakeInterval(2, 50, 70, eNa_strand_plus));
2619 loc1->SetMix().Set().push_back(MakeInterval(2, 110, 130, eNa_strand_plus));
2620 loc1->SetMix().Set().push_back(MakeInterval(2, 150, 170, eNa_strand_plus));
2621 loc2->SetMix().Set().clear();
2622 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 40));
2623 loc2->SetMix().Set().push_back(MakeInterval(2, 60, 80));
2624 loc2->SetMix().Set().push_back(MakeInterval(2, 160, 180, eNa_strand_minus));
2625 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 140, eNa_strand_minus));
2626 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 161);
2627 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
2628 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2629 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2630 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2631 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2632 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2633 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 161);
2634
2635 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 161);
2636 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2637 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
2638 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2639 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2640 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2641 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2642 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 161);
2643
2644 // Multistrand, overlap 3
2645 loc1->SetMix().Set().clear();
2646 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 30, eNa_strand_plus));
2647 loc1->SetMix().Set().push_back(MakeInterval(2, 50, 70, eNa_strand_plus));
2648 loc1->SetMix().Set().push_back(MakeInterval(2, 110, 130));
2649 loc1->SetMix().Set().push_back(MakeInterval(2, 150, 170));
2650 loc2->SetMix().Set().clear();
2651 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 40));
2652 loc2->SetMix().Set().push_back(MakeInterval(2, 60, 80));
2653 loc2->SetMix().Set().push_back(MakeInterval(2, 160, 180, eNa_strand_minus));
2654 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 140, eNa_strand_minus));
2655 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 161);
2656 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
2657 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2658 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2659 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2660 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2661 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2662 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 161);
2663
2664 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 161);
2665 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2666 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
2667 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2668 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2669 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2670 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2671 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 161);
2672
2673 // Multistrand, contained
2674 loc1->SetMix().Set().clear();
2675 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 30, eNa_strand_plus));
2676 loc1->SetMix().Set().push_back(MakeInterval(2, 50, 80, eNa_strand_plus));
2677 loc1->SetMix().Set().push_back(MakeInterval(2, 150, 180, eNa_strand_minus));
2678 loc1->SetMix().Set().push_back(MakeInterval(2, 110, 130, eNa_strand_minus));
2679 loc2->SetMix().Set().clear();
2680 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 40));
2681 loc2->SetMix().Set().push_back(MakeInterval(2, 60, 70));
2682 loc2->SetMix().Set().push_back(MakeInterval(2, 160, 170, eNa_strand_minus));
2683 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 140, eNa_strand_minus));
2684 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
2685 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 40);
2686 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2687 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2688 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2689 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2690 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2691 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
2692
2693 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
2694 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2695 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 40);
2696 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2697 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2698 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2699 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2700 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
2701
2702 // Multistrand, subset
2703 loc1->SetMix().Set().clear();
2704 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 40));
2705 loc1->SetMix().Set().push_back(MakeInterval(2, 50, 80));
2706 loc1->SetMix().Set().push_back(MakeInterval(2, 150, 180, eNa_strand_minus));
2707 loc1->SetMix().Set().push_back(MakeInterval(2, 110, 140, eNa_strand_minus));
2708 loc2->SetMix().Set().clear();
2709 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 30));
2710 loc2->SetMix().Set().push_back(MakeInterval(2, 60, 70));
2711 loc2->SetMix().Set().push_back(MakeInterval(2, 160, 170, eNa_strand_minus));
2712 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 130, eNa_strand_minus));
2713 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
2714 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 40);
2715 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2716 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 80);
2717 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2718 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2719 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2720 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
2721
2722 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
2723 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2724 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 40);
2725 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2726 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 80);
2727 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2728 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2729 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
2730
2731 // CheckIntervals - extra intervals before/after.
2732 // Note, that ranges on minus strand have wrong order, so the
2733 // extremes will be calculated for each minus-strand range.
2734 loc1->SetMix().Set().clear();
2735 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 30));
2736 loc1->SetMix().Set().push_back(MakeInterval(2, 40, 50));
2737 loc1->SetMix().Set().push_back(MakeInterval(2, 140, 150, eNa_strand_minus));
2738 loc1->SetMix().Set().push_back(MakeInterval(2, 160, 180, eNa_strand_minus));
2739 loc2->SetMix().Set().clear();
2740 loc2->SetMix().Set().push_back(MakeInterval(2, 40, 50));
2741 loc2->SetMix().Set().push_back(MakeInterval(2, 140, 150, eNa_strand_minus));
2742 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 51);
2743 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 51);
2744 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2745 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 42);
2746 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2747 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 42);
2748 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2749 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 51);
2750
2751 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 51);
2752 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2753 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 51);
2754 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2755 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 42);
2756 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2757 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 42);
2758 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 51);
2759
2760 // Check intervals, extra-ranges in the first/last intervals
2761 // NOTE: Only the first interval's strand is used to detect the direction.
2762 loc2->SetMix().Set().clear();
2763 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 30));
2764 loc2->SetMix().Set().push_back(MakeInterval(2, 40, 50));
2765 loc2->SetMix().Set().push_back(MakeInterval(2, 140, 150, eNa_strand_minus));
2766 loc2->SetMix().Set().push_back(MakeInterval(2, 160, 170, eNa_strand_minus));
2767 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 20);
2768 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 20);
2769 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2770 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 20);
2771 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2772 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 20);
2773 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2774 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 20);
2775
2776 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 20);
2777 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2778 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 20);
2779 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2780 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 20);
2781 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2782 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 20);
2783 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 20);
2784
2785 // Subset - several intervals whithin a single interval
2786 loc1->SetMix().Set().clear();
2787 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 60));
2788 loc1->SetMix().Set().push_back(MakeInterval(2, 110, 160, eNa_strand_minus));
2789 loc2->SetMix().Set().clear();
2790 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 30));
2791 loc2->SetMix().Set().push_back(MakeInterval(2, 40, 50));
2792 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 130, eNa_strand_minus));
2793 loc2->SetMix().Set().push_back(MakeInterval(2, 140, 150, eNa_strand_minus));
2794 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 49);
2795 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 49);
2796 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2797 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 58);
2798 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2799 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2800 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2801 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 49);
2802
2803 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 49);
2804 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2805 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 49);
2806 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2807 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 58);
2808 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2809 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2810 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 49);
2811
2812 // Subset - several intervals whithin a single interval. Same as
2813 // above, but minus strand ranges are ordered correctly.
2814 loc1->SetMix().Set().clear();
2815 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 60));
2816 loc1->SetMix().Set().push_back(MakeInterval(2, 110, 160, eNa_strand_minus));
2817 loc2->SetMix().Set().clear();
2818 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 30));
2819 loc2->SetMix().Set().push_back(MakeInterval(2, 40, 50));
2820 loc2->SetMix().Set().push_back(MakeInterval(2, 140, 150, eNa_strand_minus));
2821 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 130, eNa_strand_minus));
2822 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
2823 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 40);
2824 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2825 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 58);
2826 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2827 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2828 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2829 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
2830
2831 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
2832 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2833 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 40);
2834 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2835 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 58);
2836 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2837 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2838 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
2839
2840 // Not a subset - strands do not match
2841 loc1->SetMix().Set().clear();
2842 loc1->SetMix().Set().push_back(MakeInterval(2, 10, 60));
2843 loc1->SetMix().Set().push_back(MakeInterval(2, 110, 160, eNa_strand_minus));
2844 loc2->SetMix().Set().clear();
2845 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 30));
2846 loc2->SetMix().Set().push_back(MakeInterval(2, 40, 50, eNa_strand_minus));
2847 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 130, eNa_strand_minus));
2848 loc2->SetMix().Set().push_back(MakeInterval(2, 140, 150));
2849 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 102);
2850 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
2851 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
2852 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
2853 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
2854 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
2855 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
2856 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 102);
2857
2858 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 102);
2859 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
2860 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
2861 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
2862 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
2863 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
2864 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
2865 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 102);
2866 }
2867
2868
BOOST_AUTO_TEST_CASE(Test_TestForOverlap64_Circular)2869 BOOST_AUTO_TEST_CASE(Test_TestForOverlap64_Circular)
2870 {
2871 CScope* scope = &GetScope();
2872
2873 CRef<CSeq_loc> loc1(new CSeq_loc);
2874 CRef<CSeq_loc> loc2(new CSeq_loc);
2875
2876 // No overlap
2877 loc1->SetMix().Set().push_back(MakeInterval(2, 1100, 1200));
2878 loc1->SetMix().Set().push_back(MakeInterval(2, 100, 200));
2879 loc2->SetMix().Set().push_back(MakeInterval(2, 300, 400));
2880 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
2881 1442, scope), -1);
2882 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
2883 1442, scope), -1);
2884 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
2885 1442, scope), -1);
2886 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
2887 1442, scope), -1);
2888 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
2889 1442, scope), -1);
2890 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
2891 1442, scope), -1);
2892 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
2893 1442, scope), -1);
2894 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
2895 1442, scope), -1);
2896
2897 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
2898 1442, scope), -1);
2899 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
2900 1442, scope), -1);
2901 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
2902 1442, scope), -1);
2903 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
2904 1442, scope), -1);
2905 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
2906 1442, scope), -1);
2907 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
2908 1442, scope), -1);
2909 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
2910 1442, scope), -1);
2911 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
2912 1442, scope), -1);
2913
2914 // Overlap on the left end, second is not circular
2915 loc2->SetMix().Set().clear();
2916 loc2->SetMix().Set().push_back(MakeInterval(2, 190, 220));
2917 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
2918 1442, scope), 552);
2919 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
2920 1442, scope), -1);
2921 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
2922 1442, scope), -1);
2923 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
2924 1442, scope), -1);
2925 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
2926 1442, scope), -1);
2927 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
2928 1442, scope), -1);
2929 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
2930 1442, scope), -1);
2931 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
2932 1442, scope), 552);
2933
2934 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
2935 1442, scope), 552);
2936 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
2937 1442, scope), -1);
2938 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
2939 1442, scope), -1);
2940 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
2941 1442, scope), -1);
2942 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
2943 1442, scope), -1);
2944 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
2945 1442, scope), -1);
2946 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
2947 1442, scope), -1);
2948 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
2949 1442, scope), 552);
2950
2951 // Overlap on the right end, second is not circular
2952 loc2->SetMix().Set().clear();
2953 loc2->SetMix().Set().push_back(MakeInterval(2, 1080, 1110));
2954 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
2955 1442, scope), 552);
2956 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
2957 1442, scope), -1);
2958 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
2959 1442, scope), -1);
2960 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
2961 1442, scope), -1);
2962 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
2963 1442, scope), -1);
2964 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
2965 1442, scope), -1);
2966 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
2967 1442, scope), -1);
2968 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
2969 1442, scope), 552);
2970
2971 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
2972 1442, scope), 552);
2973 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
2974 1442, scope), -1);
2975 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
2976 1442, scope), -1);
2977 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
2978 1442, scope), -1);
2979 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
2980 1442, scope), -1);
2981 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
2982 1442, scope), -1);
2983 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
2984 1442, scope), -1);
2985 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
2986 1442, scope), 552);
2987
2988 // Overlap on both ends, second is not circular
2989 loc2->SetMix().Set().clear();
2990 loc2->SetMix().Set().push_back(MakeInterval(2, 190, 1110));
2991 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
2992 1442, scope), 1420);
2993 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
2994 1442, scope), -1);
2995 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
2996 1442, scope), -1);
2997 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
2998 1442, scope), -1);
2999 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3000 1442, scope), -1);
3001 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3002 1442, scope), -1);
3003 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3004 1442, scope), -1);
3005 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3006 1442, scope), 1420);
3007
3008 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3009 1442, scope), 1420);
3010 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3011 1442, scope), -1);
3012 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3013 1442, scope), -1);
3014 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3015 1442, scope), -1);
3016 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3017 1442, scope), -1);
3018 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3019 1442, scope), -1);
3020 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3021 1442, scope), -1);
3022 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3023 1442, scope), 1420);
3024
3025 // The second contained in the first
3026 loc2->SetMix().Set().clear();
3027 loc2->SetMix().Set().push_back(MakeInterval(2, 110, 190));
3028 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3029 1442, scope), 462);
3030 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3031 1442, scope), 462);
3032 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3033 1442, scope), -1);
3034 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3035 1442, scope), 121);
3036 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3037 1442, scope), -1);
3038 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3039 1442, scope), 121);
3040 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3041 1442, scope), -1);
3042 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3043 1442, scope), 462);
3044
3045 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3046 1442, scope), 462);
3047 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3048 1442, scope), -1);
3049 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3050 1442, scope), 462);
3051 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3052 1442, scope), -1);
3053 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3054 1442, scope), 121);
3055 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3056 1442, scope), -1);
3057 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3058 1442, scope), 121);
3059 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3060 1442, scope), 462);
3061
3062 // The second's ranges (but not extremes) are contained in the first
3063 loc2->SetMix().Set().push_back(MakeInterval(2, 1110, 1190));
3064 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3065 1442, scope), 1260);
3066 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3067 1442, scope), -1);
3068 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3069 1442, scope), -1);
3070 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3071 1442, scope), 40);
3072 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3073 1442, scope), -1);
3074 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3075 1442, scope), -1);
3076 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3077 1442, scope), -1);
3078 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3079 1442, scope), 1260);
3080
3081 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3082 1442, scope), 1260);
3083 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3084 1442, scope), -1);
3085 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3086 1442, scope), -1);
3087 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3088 1442, scope), -1);
3089 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3090 1442, scope), 40);
3091 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3092 1442, scope), -1);
3093 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3094 1442, scope), -1);
3095 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3096 1442, scope), 1260);
3097
3098 // Matching intervals, but loc2 is not circular
3099 loc2->SetMix().Set().clear();
3100 loc2->SetMix().Set().push_back(MakeInterval(2, 100, 190));
3101 loc2->SetMix().Set().push_back(MakeInterval(2, 1110, 1200));
3102 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3103 1442, scope), 1240);
3104 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3105 1442, scope), -1);
3106 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3107 1442, scope), -1);
3108 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3109 1442, scope), 20);
3110 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3111 1442, scope), -1);
3112 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3113 1442, scope), -1);
3114 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3115 1442, scope), -1);
3116 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3117 1442, scope), 1240);
3118
3119 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3120 1442, scope), 1240);
3121 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3122 1442, scope), -1);
3123 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3124 1442, scope), -1);
3125 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3126 1442, scope), -1);
3127 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3128 1442, scope), 20);
3129 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3130 1442, scope), -1);
3131 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3132 1442, scope), -1);
3133 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3134 1442, scope), 1240);
3135
3136 // Two circular locations - overlap
3137 loc2->SetMix().Set().clear();
3138 loc2->SetMix().Set().push_back(MakeInterval(2, 1020, 1120));
3139 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 120));
3140 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3141 1442, scope), 160);
3142 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3143 1442, scope), -1);
3144 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3145 1442, scope), -1);
3146 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3147 1442, scope), -1);
3148 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3149 1442, scope), -1);
3150 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3151 1442, scope), -1);
3152 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3153 1442, scope), -1);
3154 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3155 1442, scope), 160);
3156
3157 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3158 1442, scope), 160);
3159 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3160 1442, scope), -1);
3161 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3162 1442, scope), -1);
3163 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3164 1442, scope), -1);
3165 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3166 1442, scope), -1);
3167 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3168 1442, scope), -1);
3169 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3170 1442, scope), -1);
3171 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3172 1442, scope), 160);
3173
3174 // Two circular locations - contained
3175 loc2->SetMix().Set().clear();
3176 loc2->SetMix().Set().push_back(MakeInterval(2, 1020, 1120));
3177 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 220));
3178 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3179 1442, scope), 100);
3180 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3181 1442, scope), -1);
3182 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3183 1442, scope), 100);
3184 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3185 1442, scope), -1);
3186 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3187 1442, scope), -1);
3188 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3189 1442, scope), -1);
3190 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3191 1442, scope), -1);
3192 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3193 1442, scope), 100);
3194
3195 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3196 1442, scope), 100);
3197 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3198 1442, scope), 100);
3199 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3200 1442, scope), -1);
3201 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3202 1442, scope), -1);
3203 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3204 1442, scope), -1);
3205 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3206 1442, scope), -1);
3207 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3208 1442, scope), -1);
3209 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3210 1442, scope), 100);
3211
3212 // Two circular locations - subset
3213 loc2->SetMix().Set().clear();
3214 loc2->SetMix().Set().push_back(MakeInterval(2, 1120, 1180));
3215 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 180));
3216 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3217 1442, scope), 40);
3218 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3219 1442, scope), 40);
3220 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3221 1442, scope), -1);
3222 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3223 1442, scope), 80);
3224 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3225 1442, scope), -1);
3226 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3227 1442, scope), -1);
3228 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3229 1442, scope), -1);
3230 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3231 1442, scope), 40);
3232
3233 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3234 1442, scope), 40);
3235 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3236 1442, scope), -1);
3237 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3238 1442, scope), 40);
3239 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3240 1442, scope), -1);
3241 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3242 1442, scope), 80);
3243 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3244 1442, scope), -1);
3245 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3246 1442, scope), -1);
3247 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3248 1442, scope), 40);
3249
3250 // Two circular locations - not a subset anymore
3251 loc2->SetMix().Set().clear();
3252 loc2->SetMix().Set().push_back(MakeInterval(2, 1120, 1180));
3253 loc2->SetMix().Set().push_back(MakeInterval(2, 1320, 1380));
3254 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 180));
3255 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3256 1442, scope), 40);
3257 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3258 1442, scope), 40);
3259 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3260 1442, scope), -1);
3261 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3262 1442, scope), -1);
3263 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3264 1442, scope), -1);
3265 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3266 1442, scope), -1);
3267 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3268 1442, scope), -1);
3269 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3270 1442, scope), 40);
3271
3272 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3273 1442, scope), 40);
3274 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3275 1442, scope), -1);
3276 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3277 1442, scope), 40);
3278 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3279 1442, scope), -1);
3280 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3281 1442, scope), -1);
3282 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3283 1442, scope), -1);
3284 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3285 1442, scope), -1);
3286 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3287 1442, scope), 40);
3288
3289 // Two circular locations - matching intervals
3290 loc2->SetMix().Set().clear();
3291 loc2->SetMix().Set().push_back(MakeInterval(2, 1120, 1200));
3292 loc2->SetMix().Set().push_back(MakeInterval(2, 100, 180));
3293 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3294 1442, scope), 40);
3295 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3296 1442, scope), 40);
3297 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3298 1442, scope), -1);
3299 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3300 1442, scope), 40);
3301 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3302 1442, scope), -1);
3303 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3304 1442, scope), 40);
3305 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3306 1442, scope), -1);
3307 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3308 1442, scope), 40);
3309
3310 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3311 1442, scope), 40);
3312 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3313 1442, scope), -1);
3314 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3315 1442, scope), 40);
3316 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3317 1442, scope), -1);
3318 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3319 1442, scope), 40);
3320 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3321 1442, scope), -1);
3322 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3323 1442, scope), 40);
3324 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3325 1442, scope), 40);
3326
3327 // Two circular locations - more matching intervals
3328 loc1->SetMix().Set().clear();
3329 loc1->SetMix().Set().push_back(MakeInterval(2, 1100, 1200));
3330 loc1->SetMix().Set().push_back(MakeInterval(2, 1300, 1400));
3331 loc1->SetMix().Set().push_back(MakeInterval(2, 100, 200));
3332 loc2->SetMix().Set().clear();
3333 loc2->SetMix().Set().push_back(MakeInterval(2, 1120, 1200));
3334 loc2->SetMix().Set().push_back(MakeInterval(2, 1300, 1400));
3335 loc2->SetMix().Set().push_back(MakeInterval(2, 100, 180));
3336 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3337 1442, scope), 40);
3338 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3339 1442, scope), 40);
3340 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3341 1442, scope), -1);
3342 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3343 1442, scope), 40);
3344 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3345 1442, scope), -1);
3346 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3347 1442, scope), 40);
3348 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3349 1442, scope), -1);
3350 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3351 1442, scope), 40);
3352
3353 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3354 1442, scope), 40);
3355 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3356 1442, scope), -1);
3357 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3358 1442, scope), 40);
3359 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3360 1442, scope), -1);
3361 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3362 1442, scope), 40);
3363 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3364 1442, scope), -1);
3365 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3366 1442, scope), 40);
3367 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3368 1442, scope), 40);
3369
3370 // Two circular locations, minus strand - overlap
3371 loc1->SetMix().Set().clear();
3372 loc1->SetMix().Set().push_back(MakeInterval(2, 100, 200, eNa_strand_minus));
3373 loc1->SetMix().Set().push_back(MakeInterval(2, 1100, 1200, eNa_strand_minus));
3374 loc2->SetMix().Set().clear();
3375 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 120, eNa_strand_minus));
3376 loc2->SetMix().Set().push_back(MakeInterval(2, 1020, 1120, eNa_strand_minus));
3377 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3378 1442, scope), 160);
3379 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3380 1442, scope), -1);
3381 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3382 1442, scope), -1);
3383 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3384 1442, scope), -1);
3385 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3386 1442, scope), -1);
3387 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3388 1442, scope), -1);
3389 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3390 1442, scope), -1);
3391 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3392 1442, scope), 160);
3393
3394 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3395 1442, scope), 160);
3396 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3397 1442, scope), -1);
3398 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3399 1442, scope), -1);
3400 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3401 1442, scope), -1);
3402 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3403 1442, scope), -1);
3404 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3405 1442, scope), -1);
3406 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3407 1442, scope), -1);
3408 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3409 1442, scope), 160);
3410
3411 // Circular location vs interval, minus strand - contained
3412 loc2->SetMix().Set().clear();
3413 loc2->SetMix().Set().push_back(MakeInterval(2, 20, 120, eNa_strand_minus));
3414 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3415 1442, scope), 442);
3416 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3417 1442, scope), 442);
3418 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3419 1442, scope), -1);
3420 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3421 1442, scope), -1);
3422 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3423 1442, scope), -1);
3424 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3425 1442, scope), -1);
3426 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3427 1442, scope), -1);
3428 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3429 1442, scope), 442);
3430
3431 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3432 1442, scope), 442);
3433 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3434 1442, scope), -1);
3435 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3436 1442, scope), 442);
3437 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3438 1442, scope), -1);
3439 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3440 1442, scope), -1);
3441 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3442 1442, scope), -1);
3443 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3444 1442, scope), -1);
3445 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3446 1442, scope), 442);
3447
3448 // Two circular locations, minus strand - contained
3449 loc2->SetMix().Set().push_back(MakeInterval(2, 1120, 1220, eNa_strand_minus));
3450 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3451 1442, scope), 100);
3452 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3453 1442, scope), 100);
3454 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3455 1442, scope), -1);
3456 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3457 1442, scope), -1);
3458 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3459 1442, scope), -1);
3460 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3461 1442, scope), -1);
3462 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3463 1442, scope), -1);
3464 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3465 1442, scope), 100);
3466
3467 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3468 1442, scope), 100);
3469 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3470 1442, scope), -1);
3471 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3472 1442, scope), 100);
3473 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3474 1442, scope), -1);
3475 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3476 1442, scope), -1);
3477 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3478 1442, scope), -1);
3479 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3480 1442, scope), -1);
3481 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3482 1442, scope), 100);
3483
3484 // Two circular locations, minus strand - subset
3485 loc2->SetMix().Set().clear();
3486 loc2->SetMix().Set().push_back(MakeInterval(2, 120, 180, eNa_strand_minus));
3487 loc2->SetMix().Set().push_back(MakeInterval(2, 1120, 1180, eNa_strand_minus));
3488 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3489 1442, scope), 40);
3490 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3491 1442, scope), 40);
3492 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3493 1442, scope), -1);
3494 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3495 1442, scope), 80);
3496 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3497 1442, scope), -1);
3498 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3499 1442, scope), -1);
3500 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3501 1442, scope), -1);
3502 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3503 1442, scope), 40);
3504
3505 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3506 1442, scope), 40);
3507 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3508 1442, scope), -1);
3509 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3510 1442, scope), 40);
3511 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3512 1442, scope), -1);
3513 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3514 1442, scope), 80);
3515 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3516 1442, scope), -1);
3517 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3518 1442, scope), -1);
3519 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3520 1442, scope), 40);
3521
3522 // Two circular locations, minus strand - matching intervals
3523 loc2->SetMix().Set().clear();
3524 loc2->SetMix().Set().push_back(MakeInterval(2, 100, 180, eNa_strand_minus));
3525 loc2->SetMix().Set().push_back(MakeInterval(2, 1120, 1200, eNa_strand_minus));
3526 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Simple,
3527 1442, scope), 40);
3528 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contained,
3529 1442, scope), 40);
3530 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Contains,
3531 1442, scope), -1);
3532 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Subset,
3533 1442, scope), 40);
3534 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_SubsetRev,
3535 1442, scope), -1);
3536 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntervals,
3537 1442, scope), 40);
3538 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_CheckIntRev,
3539 1442, scope), -1);
3540 BOOST_CHECK_EQUAL(TestForOverlap64(*loc1, *loc2, eOverlap_Interval,
3541 1442, scope), 40);
3542
3543 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Simple,
3544 1442, scope), 40);
3545 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contained,
3546 1442, scope), -1);
3547 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Contains,
3548 1442, scope), 40);
3549 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Subset,
3550 1442, scope), -1);
3551 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_SubsetRev,
3552 1442, scope), 40);
3553 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntervals,
3554 1442, scope), -1);
3555 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_CheckIntRev,
3556 1442, scope), 40);
3557 BOOST_CHECK_EQUAL(TestForOverlap64(*loc2, *loc1, eOverlap_Interval,
3558 1442, scope), 40);
3559 }
3560
3561
BOOST_AUTO_TEST_CASE(Test_TestForOverlapEx_Circular)3562 BOOST_AUTO_TEST_CASE(Test_TestForOverlapEx_Circular)
3563 {
3564 CScope* scope = &GetScope();
3565
3566 CRef<CSeq_loc> loc1(new CSeq_loc);
3567 CRef<CSeq_loc> loc2(new CSeq_loc);
3568
3569 // No overlap
3570 loc1->SetMix().Set().push_back(MakeInterval(102, 1100, 1200));
3571 loc1->SetMix().Set().push_back(MakeInterval(102, 100, 200));
3572 loc2->SetMix().Set().push_back(MakeInterval(102, 300, 400));
3573 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), -1);
3574 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
3575 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3576 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
3577 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3578 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3579 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3580 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), -1);
3581
3582 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), -1);
3583 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3584 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
3585 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3586 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
3587 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3588 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3589 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), -1);
3590
3591 // Overlap on the left end, second is not circular
3592 loc2->SetMix().Set().clear();
3593 loc2->SetMix().Set().push_back(MakeInterval(102, 190, 220));
3594 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 552);
3595 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
3596 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3597 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
3598 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3599 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3600 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3601 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 552);
3602
3603 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 552);
3604 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3605 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
3606 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3607 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
3608 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3609 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3610 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 552);
3611
3612 // Overlap on the right end, second is not circular
3613 loc2->SetMix().Set().clear();
3614 loc2->SetMix().Set().push_back(MakeInterval(102, 1080, 1110));
3615 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 552);
3616 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
3617 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3618 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
3619 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3620 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3621 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3622 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 552);
3623
3624 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 552);
3625 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3626 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
3627 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3628 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
3629 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3630 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3631 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 552);
3632
3633 // Overlap on both ends, second is not circular
3634 loc2->SetMix().Set().clear();
3635 loc2->SetMix().Set().push_back(MakeInterval(102, 190, 1110));
3636 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 1420);
3637 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
3638 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3639 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
3640 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3641 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3642 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3643 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 1420);
3644
3645 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 1420);
3646 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3647 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
3648 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3649 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
3650 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3651 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3652 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 1420);
3653
3654 // The second contained in the first
3655 loc2->SetMix().Set().clear();
3656 loc2->SetMix().Set().push_back(MakeInterval(102, 110, 190));
3657 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 462);
3658 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 462);
3659 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3660 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 121);
3661 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3662 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 121);
3663 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3664 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 462);
3665
3666 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 462);
3667 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3668 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 462);
3669 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3670 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 121);
3671 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3672 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 121);
3673 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 462);
3674
3675 // The second's ranges (but not extremes) are contained in the first
3676 loc2->SetMix().Set().push_back(MakeInterval(102, 1110, 1190));
3677 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 1260);
3678 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
3679 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3680 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 40);
3681 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3682 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3683 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3684 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 1260);
3685
3686 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 1260);
3687 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3688 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
3689 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3690 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 40);
3691 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3692 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3693 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 1260);
3694
3695 // Matching intervals, but loc2 is not circular
3696 loc2->SetMix().Set().clear();
3697 loc2->SetMix().Set().push_back(MakeInterval(102, 100, 190));
3698 loc2->SetMix().Set().push_back(MakeInterval(102, 1110, 1200));
3699 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 1240);
3700 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
3701 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3702 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 20);
3703 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3704 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3705 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3706 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 1240);
3707
3708 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 1240);
3709 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3710 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
3711 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3712 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 20);
3713 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3714 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3715 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 1240);
3716
3717 // Two circular locations - overlap
3718 loc2->SetMix().Set().clear();
3719 loc2->SetMix().Set().push_back(MakeInterval(102, 1020, 1120));
3720 loc2->SetMix().Set().push_back(MakeInterval(102, 20, 120));
3721 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 160);
3722 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
3723 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3724 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
3725 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3726 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3727 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3728 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 160);
3729
3730 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 160);
3731 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3732 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
3733 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3734 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
3735 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3736 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3737 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 160);
3738
3739 // Without topology some results must be different
3740 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple,
3741 scope, fOverlap_IgnoreTopology), 320);
3742 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval,
3743 scope, fOverlap_IgnoreTopology), 320);
3744
3745 // Two circular locations - contained
3746 loc2->SetMix().Set().clear();
3747 loc2->SetMix().Set().push_back(MakeInterval(102, 1020, 1120));
3748 loc2->SetMix().Set().push_back(MakeInterval(102, 120, 220));
3749 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 100);
3750 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
3751 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), 100);
3752 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
3753 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3754 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3755 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3756 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 100);
3757
3758 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 100);
3759 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), 100);
3760 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
3761 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3762 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
3763 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3764 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3765 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 100);
3766
3767 // Two circular locations - subset
3768 loc2->SetMix().Set().clear();
3769 loc2->SetMix().Set().push_back(MakeInterval(102, 1120, 1180));
3770 loc2->SetMix().Set().push_back(MakeInterval(102, 120, 180));
3771 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
3772 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 40);
3773 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3774 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 80);
3775 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3776 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3777 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3778 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
3779
3780 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
3781 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3782 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 40);
3783 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3784 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 80);
3785 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3786 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3787 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
3788
3789 // Two circular locations - not a subset anymore
3790 loc2->SetMix().Set().clear();
3791 loc2->SetMix().Set().push_back(MakeInterval(102, 1120, 1180));
3792 loc2->SetMix().Set().push_back(MakeInterval(102, 1320, 1380));
3793 loc2->SetMix().Set().push_back(MakeInterval(102, 120, 180));
3794 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
3795 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 40);
3796 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3797 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
3798 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3799 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3800 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3801 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
3802
3803 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
3804 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3805 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 40);
3806 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3807 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
3808 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3809 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3810 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
3811
3812 // Two circular locations - matching intervals
3813 loc2->SetMix().Set().clear();
3814 loc2->SetMix().Set().push_back(MakeInterval(102, 1120, 1200));
3815 loc2->SetMix().Set().push_back(MakeInterval(102, 100, 180));
3816 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
3817 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 40);
3818 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3819 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 40);
3820 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3821 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 40);
3822 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3823 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
3824
3825 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
3826 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3827 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 40);
3828 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3829 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 40);
3830 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3831 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 40);
3832 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
3833
3834 // Two circular locations - more matching intervals
3835 loc1->SetMix().Set().clear();
3836 loc1->SetMix().Set().push_back(MakeInterval(102, 1100, 1200));
3837 loc1->SetMix().Set().push_back(MakeInterval(102, 1300, 1400));
3838 loc1->SetMix().Set().push_back(MakeInterval(102, 100, 200));
3839 loc2->SetMix().Set().clear();
3840 loc2->SetMix().Set().push_back(MakeInterval(102, 1120, 1200));
3841 loc2->SetMix().Set().push_back(MakeInterval(102, 1300, 1400));
3842 loc2->SetMix().Set().push_back(MakeInterval(102, 100, 180));
3843 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
3844 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 40);
3845 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3846 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 40);
3847 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3848 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 40);
3849 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3850 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
3851
3852 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
3853 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3854 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 40);
3855 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3856 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 40);
3857 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3858 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 40);
3859 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
3860
3861 // Two circular locations, minus strand - overlap
3862 loc1->SetMix().Set().clear();
3863 loc1->SetMix().Set().push_back(MakeInterval(102, 100, 200, eNa_strand_minus));
3864 loc1->SetMix().Set().push_back(MakeInterval(102, 1100, 1200, eNa_strand_minus));
3865 loc2->SetMix().Set().clear();
3866 loc2->SetMix().Set().push_back(MakeInterval(102, 20, 120, eNa_strand_minus));
3867 loc2->SetMix().Set().push_back(MakeInterval(102, 1020, 1120, eNa_strand_minus));
3868 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 160);
3869 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
3870 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3871 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
3872 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3873 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3874 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3875 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 160);
3876
3877 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 160);
3878 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3879 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
3880 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3881 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
3882 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3883 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3884 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 160);
3885
3886 // Circular location vs interval, minus strand - contained
3887 loc2->SetMix().Set().clear();
3888 loc2->SetMix().Set().push_back(MakeInterval(102, 20, 120, eNa_strand_minus));
3889 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 442);
3890 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 442);
3891 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3892 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
3893 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3894 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3895 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3896 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 442);
3897
3898 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 442);
3899 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3900 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 442);
3901 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3902 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
3903 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3904 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3905 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 442);
3906
3907 // Two circular locations, minus strand - contained
3908 loc2->SetMix().Set().push_back(MakeInterval(102, 1120, 1220, eNa_strand_minus));
3909 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 100);
3910 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 100);
3911 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3912 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
3913 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3914 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3915 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3916 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 100);
3917
3918 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 100);
3919 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3920 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 100);
3921 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3922 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
3923 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3924 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3925 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 100);
3926
3927 // Two circular locations, minus strand - subset
3928 loc2->SetMix().Set().clear();
3929 loc2->SetMix().Set().push_back(MakeInterval(102, 120, 180, eNa_strand_minus));
3930 loc2->SetMix().Set().push_back(MakeInterval(102, 1120, 1180, eNa_strand_minus));
3931 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
3932 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 40);
3933 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3934 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 80);
3935 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3936 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3937 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3938 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
3939
3940 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
3941 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3942 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 40);
3943 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3944 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 80);
3945 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3946 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3947 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
3948
3949 // Two circular locations, minus strand - matching intervals
3950 loc2->SetMix().Set().clear();
3951 loc2->SetMix().Set().push_back(MakeInterval(102, 100, 180, eNa_strand_minus));
3952 loc2->SetMix().Set().push_back(MakeInterval(102, 1120, 1200, eNa_strand_minus));
3953 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 40);
3954 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 40);
3955 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3956 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), 40);
3957 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3958 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), 40);
3959 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3960 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 40);
3961
3962 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 40);
3963 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3964 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 40);
3965 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3966 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), 40);
3967 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3968 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), 40);
3969 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 40);
3970
3971 // Test with multiple circular bioseqs.
3972 // No overlap
3973 loc1->SetMix().Set().clear();
3974 loc1->SetMix().Set().push_back(MakeInterval(102, 1100, 1200));
3975 loc1->SetMix().Set().push_back(MakeInterval(102, 100, 200));
3976 loc1->SetMix().Set().push_back(MakeInterval(202, 400, 450));
3977 loc1->SetMix().Set().push_back(MakeInterval(202, 100, 150));
3978 loc2->SetMix().Set().clear();
3979 loc2->SetMix().Set().push_back(MakeInterval(102, 400, 500));
3980 loc2->SetMix().Set().push_back(MakeInterval(202, 200, 300));
3981 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), -1);
3982 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
3983 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
3984 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
3985 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
3986 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
3987 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
3988 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), -1);
3989
3990 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), -1);
3991 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
3992 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
3993 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
3994 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
3995 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
3996 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
3997 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), -1);
3998
3999 // Overlap
4000 loc2->SetMix().Set().clear();
4001 loc2->SetMix().Set().push_back(MakeInterval(102, 180, 280));
4002 loc2->SetMix().Set().push_back(MakeInterval(202, 420, 520));
4003 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 894);
4004 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), -1);
4005 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
4006 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
4007 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
4008 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
4009 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
4010 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 894);
4011
4012 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 894);
4013 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
4014 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), -1);
4015 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
4016 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
4017 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
4018 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
4019 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 894);
4020
4021 // Contained
4022 loc2->SetMix().Set().clear();
4023 loc2->SetMix().Set().push_back(MakeInterval(102, 80, 120));
4024 loc2->SetMix().Set().push_back(MakeInterval(202, 520, 580));
4025 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 834);
4026 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 834);
4027 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
4028 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
4029 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
4030 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
4031 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
4032 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), 834);
4033
4034 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 834);
4035 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
4036 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 834);
4037 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
4038 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
4039 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
4040 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
4041 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), 834);
4042
4043 // Overlap, mixed strands
4044 loc1->SetMix().Set().clear();
4045 loc1->SetMix().Set().push_back(MakeInterval(102, 1100, 1200));
4046 loc1->SetMix().Set().push_back(MakeInterval(102, 100, 200));
4047 loc1->SetMix().Set().push_back(MakeInterval(202, 100, 150, eNa_strand_minus));
4048 loc1->SetMix().Set().push_back(MakeInterval(202, 400, 450, eNa_strand_minus));
4049 loc2->SetMix().Set().clear();
4050 loc2->SetMix().Set().push_back(MakeInterval(102, 1300, 1400));
4051 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 835);
4052 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 835);
4053 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
4054 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
4055 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
4056 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
4057 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
4058 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), -1);
4059
4060 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 835);
4061 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
4062 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 835);
4063 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
4064 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
4065 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
4066 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
4067 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), -1);
4068
4069 loc2->SetMix().Set().push_back(MakeInterval(202, 20, 80, eNa_strand_minus));
4070 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Simple, scope), 774);
4071 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contained, scope), 774);
4072 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Contains, scope), -1);
4073 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Subset, scope), -1);
4074 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_SubsetRev, scope), -1);
4075 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntervals, scope), -1);
4076 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_CheckIntRev, scope), -1);
4077 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc1, *loc2, eOverlap_Interval, scope), -1);
4078
4079 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Simple, scope), 774);
4080 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contained, scope), -1);
4081 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Contains, scope), 774);
4082 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Subset, scope), -1);
4083 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_SubsetRev, scope), -1);
4084 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntervals, scope), -1);
4085 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_CheckIntRev, scope), -1);
4086 BOOST_CHECK_EQUAL(TestForOverlapEx(*loc2, *loc1, eOverlap_Interval, scope), -1);
4087 }
4088
4089
4090 const char* sc_TestEntry = "\
4091 Seq-entry ::= set {\
4092 class nuc-prot,\
4093 seq-set {\
4094 seq {\
4095 id {\
4096 local str \"local2\",\
4097 gi 2\
4098 },\
4099 inst {\
4100 repr raw,\
4101 mol rna,\
4102 length 1442,\
4103 seq-data iupacna \"TTTTTTTTTTTGAGATGGAGTTTTCGCTCTTGTTGCCCAGGCTGGAGTGCAA\
4104 TGGCGCAATCTCAGCTCACCGCAACCTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCCAGTAGCTGG\
4105 GATTACAGGCATGTGCACCCACGCTCGGCTAATTTTGTATTTTTTTTTAGTAGAGATGGAGTTTCTCCATGTTGGTCA\
4106 GGCTGGTCTCGAACTCCCGACCTCAGATGATCCCTCCGTCTCGGCCTCCCAAAGTGCTAGATACAGGACTGGCCACCA\
4107 TGCCCGGCTCTGCCTGGCTAATTTTTGTGGTAGAAACAGGGTTTCACTGATGTGCCCAAGCTGGTCTCCTGAGCTCAA\
4108 GCAGTCCACCTGCCTCAGCCTCCCAAAGTGCTGGGATTACAGGCGTGCAGCCGTGCCTGGCCTTTTTATTTTATTTTT\
4109 TTTAAGACACAGGTGTCCCACTCTTACCCAGGATGAAGTGCAGTGGTGTGATCACAGCTCACTGCAGCCTTCAACTCC\
4110 TGAGATCAAGCATCCTCCTGCCTCAGCCTCCCAAGTAGCTGGGACCAAAGACATGCACCACTACACCTGGCTAATTTT\
4111 TATTTTTATTTTTAATTTTTTGAGACAGAGTCTCAACTCTGTCACCCAGGCTGGAGTGCAGTGGCGCAATCTTGGCTC\
4112 ACTGCAACCTCTGCCTCCCGGGTTCAAGTTATTCTCCTGCCCCAGCCTCCTGAGTAGCTGGGACTACAGGCGCCCACC\
4113 ACGCCTAGCTAATTTTTTTGTATTTTTAGTAGAGATGGGGTTCACCATGTTCGCCAGGTTGATCTTGATCTCTGGACC\
4114 TTGTGATCTGCCTGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCACGCCCGGCTTATTTTTAATTT\
4115 TTGTTTGTTTGAAATGGAATCTCACTCTGTTACCCAGGCTGGAGTGCAATGGCCAAATCTCGGCTCACTGCAACCTCT\
4116 GCCTCCCGGGCTCAAGCGATTCTCCTGTCTCAGCCTCCCAAGCAGCTGGGATTACGGGCACCTGCCACCACACCCCGC\
4117 TAATTTTTGTATTTTCATTAGAGGCGGGGTTTCACCATATTTGTCAGGCTGGTCTCAAACTCCTGACCTCAGGTGACC\
4118 CACCTGCCTCAGCCTTCCAAAGTGCTGGGATTACAGGCGTGAGCCACCTCACCCAGCCGGCTAATTTAGATAAAAAAA\
4119 TATGTAGCAATGGGGGGTCTTGCTATGTTGCCCAGGCTGGTCTCAAACTTCTGGCTTCATGCAATCCTTCCAAATGAG\
4120 CCACAACACCCAGCCAGTCACATTTTTTAAACAGTTACATCTTTATTTTAGTATACTAGAAAGTAATACAATAAACAT\
4121 GTCAAACCTGCAAATTCAGTAGTAACAGAGTTCTTTTATAACTTTTAAACAAAGCTTTAGAGCA\"\
4122 }\
4123 },\
4124 seq {\
4125 id {\
4126 local str \"local3\",\
4127 gi 3\
4128 },\
4129 inst {\
4130 repr raw,\
4131 mol aa,\
4132 length 375,\
4133 topology not-set,\
4134 seq-data ncbieaa \"MEFSLLLPRLECNGAISAHRNLRLPGSSDSPASASPVAGITGMCTHARLILY\
4135 FFLVEMEFLHVGQAGLELPTSDDPSVSASQSARYRTGHHARLCLANFCGRNRVSLMCPSWSPELKQSTCLSLPKCWDY\
4136 RRAAVPGLFILFFLRHRCPTLTQDEVQWCDHSSLQPSTPEIKHPPASASQVAGTKDMHHYTWLIFIFIFNFLRQSLNS\
4137 VTQAGVQWRNLGSLQPLPPGFKLFSCPSLLSSWDYRRPPRLANFFVFLVEMGFTMFARLILISGPCDLPASASQSAGI\
4138 TGVSHHARLIFNFCLFEMESHSVTQAGVQWPNLGSLQPLPPGLKRFSCLSLPSSWDYGHLPPHPANFCIFIRGGVSPY\
4139 LSGWSQTPDLR\"\
4140 }\
4141 },\
4142 seq {\
4143 id {\
4144 local str \"local102\",\
4145 gi 102\
4146 },\
4147 inst {\
4148 repr raw,\
4149 mol rna,\
4150 length 1442,\
4151 topology circular,\
4152 seq-data iupacna \"TTTTTTTTTTTGAGATGGAGTTTTCGCTCTTGTTGCCCAGGCTGGAGTGCAA\
4153 TGGCGCAATCTCAGCTCACCGCAACCTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCCAGTAGCTGG\
4154 GATTACAGGCATGTGCACCCACGCTCGGCTAATTTTGTATTTTTTTTTAGTAGAGATGGAGTTTCTCCATGTTGGTCA\
4155 GGCTGGTCTCGAACTCCCGACCTCAGATGATCCCTCCGTCTCGGCCTCCCAAAGTGCTAGATACAGGACTGGCCACCA\
4156 TGCCCGGCTCTGCCTGGCTAATTTTTGTGGTAGAAACAGGGTTTCACTGATGTGCCCAAGCTGGTCTCCTGAGCTCAA\
4157 GCAGTCCACCTGCCTCAGCCTCCCAAAGTGCTGGGATTACAGGCGTGCAGCCGTGCCTGGCCTTTTTATTTTATTTTT\
4158 TTTAAGACACAGGTGTCCCACTCTTACCCAGGATGAAGTGCAGTGGTGTGATCACAGCTCACTGCAGCCTTCAACTCC\
4159 TGAGATCAAGCATCCTCCTGCCTCAGCCTCCCAAGTAGCTGGGACCAAAGACATGCACCACTACACCTGGCTAATTTT\
4160 TATTTTTATTTTTAATTTTTTGAGACAGAGTCTCAACTCTGTCACCCAGGCTGGAGTGCAGTGGCGCAATCTTGGCTC\
4161 ACTGCAACCTCTGCCTCCCGGGTTCAAGTTATTCTCCTGCCCCAGCCTCCTGAGTAGCTGGGACTACAGGCGCCCACC\
4162 ACGCCTAGCTAATTTTTTTGTATTTTTAGTAGAGATGGGGTTCACCATGTTCGCCAGGTTGATCTTGATCTCTGGACC\
4163 TTGTGATCTGCCTGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCACGCCCGGCTTATTTTTAATTT\
4164 TTGTTTGTTTGAAATGGAATCTCACTCTGTTACCCAGGCTGGAGTGCAATGGCCAAATCTCGGCTCACTGCAACCTCT\
4165 GCCTCCCGGGCTCAAGCGATTCTCCTGTCTCAGCCTCCCAAGCAGCTGGGATTACGGGCACCTGCCACCACACCCCGC\
4166 TAATTTTTGTATTTTCATTAGAGGCGGGGTTTCACCATATTTGTCAGGCTGGTCTCAAACTCCTGACCTCAGGTGACC\
4167 CACCTGCCTCAGCCTTCCAAAGTGCTGGGATTACAGGCGTGAGCCACCTCACCCAGCCGGCTAATTTAGATAAAAAAA\
4168 TATGTAGCAATGGGGGGTCTTGCTATGTTGCCCAGGCTGGTCTCAAACTTCTGGCTTCATGCAATCCTTCCAAATGAG\
4169 CCACAACACCCAGCCAGTCACATTTTTTAAACAGTTACATCTTTATTTTAGTATACTAGAAAGTAATACAATAAACAT\
4170 GTCAAACCTGCAAATTCAGTAGTAACAGAGTTCTTTTATAACTTTTAAACAAAGCTTTAGAGCA\"\
4171 }\
4172 },\
4173 seq {\
4174 id {\
4175 local str \"local202\",\
4176 gi 202\
4177 },\
4178 inst {\
4179 repr raw,\
4180 mol rna,\
4181 length 642,\
4182 topology circular,\
4183 seq-data iupacna \"TTTTTTTTTTTGAGATGGAGTTTTCGCTCTTGTTGCCCAGGCTGGAGTGCAA\
4184 TTGTGATCTGCCTGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCACGCCCGGCTTATTTTTAATTT\
4185 TTGTTTGTTTGAAATGGAATCTCACTCTGTTACCCAGGCTGGAGTGCAATGGCCAAATCTCGGCTCACTGCAACCTCT\
4186 GCCTCCCGGGCTCAAGCGATTCTCCTGTCTCAGCCTCCCAAGCAGCTGGGATTACGGGCACCTGCCACCACACCCCGC\
4187 TAATTTTTGTATTTTCATTAGAGGCGGGGTTTCACCATATTTGTCAGGCTGGTCTCAAACTCCTGACCTCAGGTGACC\
4188 CACCTGCCTCAGCCTTCCAAAGTGCTGGGATTACAGGCGTGAGCCACCTCACCCAGCCGGCTAATTTAGATAAAAAAA\
4189 TATGTAGCAATGGGGGGTCTTGCTATGTTGCCCAGGCTGGTCTCAAACTTCTGGCTTCATGCAATCCTTCCAAATGAG\
4190 CCACAACACCCAGCCAGTCACATTTTTTAAACAGTTACATCTTTATTTTAGTATACTAGAAAGTAATACAATAAACAT\
4191 GTCAAACCTGCAAATTCAGTAGTAACAGAGTTCTTTTATAACTTTTAAACAAAGCTTTAGAGCA\"\
4192 }\
4193 }\
4194 }\
4195 }";
4196
4197
4198 static const char * sc_TestFramePlus = "\
4199 Seq-entry ::= set {\
4200 class nuc-prot ,\
4201 descr {\
4202 source {\
4203 genome genomic ,\
4204 org {\
4205 taxname \"Homo sapiens\" ,\
4206 common \"human\" ,\
4207 db {\
4208 {\
4209 db \"taxon\" ,\
4210 tag\
4211 id 9606 } } ,\
4212 syn {\
4213 \"woman\" ,\
4214 \"man\" } ,\
4215 orgname {\
4216 name\
4217 binomial {\
4218 genus \"Homo\" ,\
4219 species \"sapiens\" } ,\
4220 lineage \"Eukaryota; Metazoa; Chordata; Craniata; Vertebrata;\
4221 Euteleostomi; Mammalia; Eutheria; Euarchontoglires; Primates; Haplorrhini;\
4222 Catarrhini; Hominidae; Homo\" ,\
4223 gcode 1 ,\
4224 mgcode 2 ,\
4225 div \"PRI\" } } ,\
4226 subtype {\
4227 {\
4228 subtype chromosome ,\
4229 name \"22\" } ,\
4230 {\
4231 subtype map ,\
4232 name \"22q13.31-q13.33\" } } } } ,\
4233 seq-set {\
4234 seq {\
4235 id {\
4236 other {\
4237 accession \"NG_032160\" } } ,\
4238 descr {\
4239 title \"Homo sapiens tubulin, gamma complex associated protein 6\
4240 (TUBGCP6), RefSeqGene on chromosome 22\" ,\
4241 molinfo {\
4242 biomol genomic } ,\
4243 create-date\
4244 std {\
4245 year 2012 ,\
4246 month 3 ,\
4247 day 15 ,\
4248 hour 15 ,\
4249 minute 39 ,\
4250 second 2 } } ,\
4251 inst {\
4252 repr raw ,\
4253 mol dna ,\
4254 length 1683 ,\
4255 seq-data\
4256 ncbi2na '527578925EEF52B961F44045F71F9E275F54BA2722D94A5E9A0F5E94A78\
4257 E892EE5D5E8A278A7A5F5A5523A355AEAC74BD71F7FA3FBF5200A0930D201229EAA209C88489E9\
4258 EA952BA79D6754A848F4B4A9F4A937798E7AA5AFAD122C88BA629E112BBAA9212EB779EEAEA7D2\
4259 2025DEAFDCA883A9D522B427F544537D40A82A795EDE08B56546E4A3886E8033EF9FC1F0004214\
4260 BAAFA7A8916949295E78930155D47A20A6E9579517A15F7A038A82E70492E54D51093C076A2BA2\
4261 1DD492027A9248BAD7957695102A5FA5893A9397AEEE547AAD4D5E52EABD4A85DAA16A79FA95FA\
4262 1DCAE25B889A9EA929A249E5E4A92A11AD2A9C5D52115E9775129273538E78E7A64B405649EF66\
4263 7CEA456A4A4D94A89E89BBA2492DDA7A249E2E692279224A052A51EA787A7129B12B895E6D4EB4\
4264 5AA869AB66E7A002D495A7B87522568ED3D4895A7A10A17A0A67AA19E597A4A7891B99B8E46504\
4265 1582C6E78A07136648394D8A796266A87DD229091197B57BAD5EA2AAB6954855DD15D78D752B9A\
4266 6AE78071E8855F14798A6AA59448658A51A0961AA6869292675C492C255677A92481EE6E138DF6\
4267 C18'H } ,\
4268 annot {\
4269 {\
4270 data\
4271 ftable {\
4272 {\
4273 data\
4274 cdregion {\
4275 frame three ,\
4276 code {\
4277 id 1 } ,\
4278 code-break {\
4279 {\
4280 loc\
4281 int {\
4282 from 30 ,\
4283 to 32 ,\
4284 strand plus ,\
4285 id\
4286 other {\
4287 accession \"NG_032160\" } } ,\
4288 aa\
4289 ncbieaa 85 } } } ,\
4290 partial TRUE ,\
4291 product\
4292 whole\
4293 local\
4294 id 32880229 ,\
4295 location\
4296 int {\
4297 from 28 ,\
4298 to 178 ,\
4299 strand plus ,\
4300 id\
4301 other {\
4302 accession \"NG_032160\" } ,\
4303 fuzz-from\
4304 lim lt } ,\
4305 dbxref {\
4306 {\
4307 db \"CCDS\" ,\
4308 tag\
4309 str \"CCDS43034.1\" } ,\
4310 {\
4311 db \"GeneID\" ,\
4312 tag\
4313 id 83642 } } } ,\
4314 {\
4315 data\
4316 gene {\
4317 locus \"SELO\" } ,\
4318 partial TRUE ,\
4319 location\
4320 int {\
4321 from 28 ,\
4322 to 1680 ,\
4323 strand plus ,\
4324 id\
4325 other {\
4326 accession \"NG_032160\" } ,\
4327 fuzz-from\
4328 lim lt } } } } } } ,\
4329 seq {\
4330 id {\
4331 local\
4332 id 32880229 } ,\
4333 descr {\
4334 molinfo {\
4335 biomol peptide ,\
4336 tech concept-trans ,\
4337 completeness no-left } } ,\
4338 inst {\
4339 repr raw ,\
4340 mol aa ,\
4341 length 218 ,\
4342 seq-data\
4343 ncbieaa \"ADFTNTFYLLSSFPVELESPGLAEFLARLMEQCASLEELRLAFRPQMDPRQLSMMLMLA\
4344 QSNPQLFALMGTRAGIARELERVEQQSRLEQLSAAELQSRNQGHWADWLQAYRARLDKDLEGAGDAAAWQAEHVRVMH\
4345 ANNPKYVLRNYIAQNAIEAAERGDFSEVRRVLKLLETPYHCEAGAATDAEATEADGADGRQRSYSSKPPLWAAELCVT\
4346 USS\" } ,\
4347 annot {\
4348 {\
4349 data\
4350 ftable {\
4351 {\
4352 data\
4353 prot {\
4354 name {\
4355 \"selenoprotein O\" } } ,\
4356 partial TRUE ,\
4357 location\
4358 int {\
4359 from 0 ,\
4360 to 217 ,\
4361 id\
4362 local\
4363 id 32880229 ,\
4364 fuzz-from\
4365 lim lt } } } } } } } }\
4366 ";
4367
4368
TestOneCDS(CRef<CSeq_feat> feat,CScope * scope,int expected_frame)4369 static void TestOneCDS (CRef<CSeq_feat> feat, CScope * scope, int expected_frame)
4370 {
4371 CCdregion& cds = feat->SetData().SetCdregion();
4372 CRef<CCode_break> cbr = cds.GetCode_break().front();
4373 CSeq_loc& cbr_loc = cbr->SetLoc();
4374 int frame = 0;
4375 if (cbr_loc.GetStrand() == eNa_strand_minus) {
4376 cbr_loc.SetInt().SetTo(feat->GetLocation().GetStart(eExtreme_Biological) - 3);
4377 cbr_loc.SetInt().SetFrom(cbr_loc.SetInt().SetTo() - 2);
4378 } else {
4379 cbr_loc.SetInt().SetFrom(feat->GetLocation().GetStart(eExtreme_Biological) + 3);
4380 cbr_loc.SetInt().SetTo(cbr_loc.SetInt().SetFrom() + 2);
4381 }
4382
4383 CRef<CSeq_loc> p_loc = SourceToProduct(*feat, cbr_loc, fS2P_AllowTer, scope, &frame);
4384 BOOST_CHECK_EQUAL(expected_frame, frame);
4385 if (cbr_loc.GetStrand() == eNa_strand_minus) {
4386 cbr_loc.SetInt().SetTo(cbr_loc.GetInt().GetTo() - 1);
4387 cbr_loc.SetInt().SetFrom(cbr_loc.SetInt().SetTo() - 2);
4388 } else {
4389 cbr_loc.SetInt().SetFrom(cbr_loc.GetInt().GetFrom() + 1);
4390 cbr_loc.SetInt().SetTo(cbr_loc.SetInt().SetFrom() + 2);
4391 }
4392 p_loc = SourceToProduct(*feat, cbr_loc, fS2P_AllowTer, scope, &frame);
4393 expected_frame ++;
4394 if (expected_frame > 3) {
4395 expected_frame = 1;
4396 }
4397 BOOST_CHECK_EQUAL(expected_frame, frame);
4398 if (cbr_loc.GetStrand() == eNa_strand_minus) {
4399 cbr_loc.SetInt().SetTo(cbr_loc.GetInt().GetTo() - 1);
4400 cbr_loc.SetInt().SetFrom(cbr_loc.SetInt().SetTo() - 2);
4401 } else {
4402 cbr_loc.SetInt().SetFrom(cbr_loc.GetInt().GetFrom() + 1);
4403 cbr_loc.SetInt().SetTo(cbr_loc.SetInt().SetFrom() + 2);
4404 }
4405 p_loc = SourceToProduct(*feat, cbr_loc, fS2P_AllowTer, scope, &frame);
4406 expected_frame ++;
4407 if (expected_frame > 3) {
4408 expected_frame = 1;
4409 }
4410 BOOST_CHECK_EQUAL(expected_frame, frame);
4411 }
4412
4413
BOOST_AUTO_TEST_CASE(Test_SourceToProductFrame)4414 BOOST_AUTO_TEST_CASE(Test_SourceToProductFrame)
4415 {
4416 CScope scope(*CObjectManager::GetInstance());
4417 CRef<CSeq_entry> s_Entry = s_Parse<CSeq_entry>(sc_TestFramePlus);
4418 scope.AddTopLevelSeqEntry(*s_Entry);
4419
4420 CRef<CSeq_annot> annot = s_Entry->SetSet().SetSeq_set().front()->SetSeq().SetAnnot().front();
4421 CRef<CSeq_feat> feat = annot->SetData().SetFtable().front();
4422 CCdregion& cds = feat->SetData().SetCdregion();
4423 cds.SetFrame (CCdregion::eFrame_one);
4424 TestOneCDS (feat, &scope, 1);
4425 cds.SetFrame (CCdregion::eFrame_two);
4426 TestOneCDS (feat, &scope, 3);
4427 cds.SetFrame (CCdregion::eFrame_three);
4428 TestOneCDS (feat, &scope, 2);
4429
4430 feat->SetLocation().SetStrand(eNa_strand_minus);
4431 cds.SetCode_break().front()->SetLoc().SetStrand(eNa_strand_minus);
4432 cds.SetFrame (CCdregion::eFrame_one);
4433 TestOneCDS (feat, &scope, 1);
4434 cds.SetFrame (CCdregion::eFrame_two);
4435 TestOneCDS (feat, &scope, 3);
4436 cds.SetFrame (CCdregion::eFrame_three);
4437 TestOneCDS (feat, &scope, 2);
4438
4439
4440 }
4441
4442
4443 const char* sc_TestRevCmpEntryRaw = "\
4444 Seq-entry ::= seq {\
4445 id {\
4446 local str \"seq_1\" } , \
4447 inst {\
4448 repr raw,\
4449 mol dna,\
4450 length 20,\
4451 seq-data iupacna \"ATGCATGCAAATTTGGGCCC\"\
4452 }\
4453 }\
4454 ";
4455
4456
4457 const char* sc_TestRevCmpEntryDelta = "\
4458 Seq-entry ::= seq { \
4459 id {\
4460 local str \"seq_2\" } , \
4461 inst { \
4462 repr delta,\
4463 mol dna,\
4464 length 40,\
4465 ext delta {\
4466 literal {\
4467 length 8,\
4468 seq-data iupacna \"ATGCATGC\"},\
4469 literal {\
4470 length 5},\
4471 literal {\
4472 length 12,\
4473 seq-data iupacna \"AAATTTGGGCCC\"},\
4474 literal {\
4475 length 7,\
4476 seq-data gap { type unknown } },\
4477 literal {\
4478 length 8,\
4479 seq-data iupacna \"AATTGGCC\"}\
4480 }\
4481 }\
4482 }\
4483 ";
4484
4485
4486 const char* sc_TestRevCmpEntryDeltaFar = "\
4487 Seq-entry ::= seq { \
4488 id {\
4489 local str \"seq_3\" } , \
4490 inst { \
4491 repr delta,\
4492 mol dna,\
4493 length 16,\
4494 ext delta {\
4495 loc int {\
4496 from 0,\
4497 to 3,\
4498 id local str \"seq_1\" },\
4499 literal {\
4500 length 5},\
4501 loc int {\
4502 from 13,\
4503 to 19,\
4504 id local str \"seq_1\" }\
4505 }\
4506 }\
4507 }\
4508 ";
4509
4510
4511 const char* sc_TestRevCmpError = "\
4512 Seq-entry ::= seq { \
4513 id { \
4514 local str \"Euplotes\", \
4515 general { \
4516 db \"NCBIFILE\", \
4517 tag str \"Euplotes vannus GPx mRNA sequence-2013-05-16.sqn/Euplotes\" \
4518 }, \
4519 general { \
4520 db \"TMSMART\", \
4521 tag id 37854013 \
4522 }, \
4523 genbank { \
4524 accession \"KF049698\" \
4525 } \
4526 }, \
4527 inst { \
4528 repr raw, \
4529 mol rna, \
4530 length 549, \
4531 strand ss, \
4532 seq-data ncbi2na '3AA0FF0FDF0E8F4D775209D503777F89CDE40E33E3A41DD2\
4533 DDF9E37E70A1C4090D78FB81BE7DC0EEA74702947389078788D4E30BD2E102BFD037F9FD5F9052\
4534 F6B9D0894A8706288D227FE44A3031A2603D4BEFE300C86D0EA8631D3DADFC4F7909B0F5D5D4E3\
4535 D741221C7A21354E81FE50BDF8D04982882DBE2CFF854880496820ECF5003E08177E8C80'H \
4536 }, \
4537 annot { \
4538 { \
4539 data ftable { \
4540 { \
4541 data rna { \
4542 type mRNA \
4543 }, \
4544 location int { \
4545 from 0, \
4546 to 548, \
4547 strand plus, \
4548 id local str \"Euplotes\" \
4549 } \
4550 } \
4551 } \
4552 } \
4553 } \
4554 } \
4555 ";
4556
BOOST_AUTO_TEST_CASE(Test_RevCompBioseq)4557 BOOST_AUTO_TEST_CASE(Test_RevCompBioseq)
4558 {
4559 CScope scope(*CObjectManager::GetInstance());
4560 {{
4561 CRef<CSeq_entry> s_Entry = s_Parse<CSeq_entry>(sc_TestRevCmpEntryRaw);
4562 ReverseComplement(s_Entry->SetSeq().SetInst(), &scope);
4563 scope.AddTopLevelSeqEntry(*s_Entry);
4564 CBioseq_Handle bsh = scope.GetBioseqHandle(s_Entry->GetSeq());
4565 CSeqVector vec(bsh, CBioseq_Handle::eCoding_Iupac);
4566 string rev = "";
4567 vec.GetSeqData(0, bsh.GetInst_Length(), rev);
4568 BOOST_CHECK_EQUAL(rev, "GGGCCCAAATTTGCATGCAT");
4569 }}
4570 {{
4571 CRef<CSeq_entry> s_Entry = s_Parse<CSeq_entry>(sc_TestRevCmpEntryDelta);
4572 ReverseComplement(s_Entry->SetSeq().SetInst(), &scope);
4573 scope.AddTopLevelSeqEntry(*s_Entry);
4574 CBioseq_Handle bsh = scope.GetBioseqHandle(s_Entry->GetSeq());
4575 CSeqVector vec(bsh, CBioseq_Handle::eCoding_Iupac);
4576 string rev = "";
4577 vec.GetSeqData(0, bsh.GetInst_Length(), rev);
4578 BOOST_CHECK_EQUAL(rev, "GGCCAATTNNNNNNNGGGCCCAAATTTNNNNNGCATGCAT");
4579 }}
4580 {{
4581 CRef<CSeq_entry> s_Entry = s_Parse<CSeq_entry>(sc_TestRevCmpEntryDeltaFar);
4582 ReverseComplement(s_Entry->SetSeq().SetInst(), &scope);
4583 scope.AddTopLevelSeqEntry(*s_Entry);
4584
4585 CBioseq_Handle bsh = scope.GetBioseqHandle(s_Entry->GetSeq());
4586 CSeqVector vec(bsh, CBioseq_Handle::eCoding_Iupac);
4587
4588 string rev = "";
4589 vec.GetSeqData(0, bsh.GetInst_Length(), rev);
4590 BOOST_CHECK_EQUAL(rev, "ATGCATGNNNNNGCCC");
4591 }}
4592
4593 {{
4594 CRef<CSeq_entry> s_Entry = s_Parse<CSeq_entry>(sc_TestRevCmpError);
4595 CSeq_entry_Handle seh = scope.AddTopLevelSeqEntry(*s_Entry);
4596 CSeqVector orig_vec(scope.GetBioseqHandle(s_Entry->GetSeq()), CBioseq_Handle::eCoding_Iupac);
4597 string orig = "";
4598 orig_vec.GetSeqData(0, s_Entry->GetSeq().GetLength(), orig);
4599 scope.RemoveTopLevelSeqEntry(seh);
4600
4601 ReverseComplement(s_Entry->SetSeq().SetInst(), &scope);
4602 scope.AddTopLevelSeqEntry(*s_Entry);
4603
4604 CBioseq_Handle bsh = scope.GetBioseqHandle(s_Entry->GetSeq());
4605 CSeqVector vec(bsh, CBioseq_Handle::eCoding_Iupac);
4606
4607 string rev = "";
4608 vec.GetSeqData(0, bsh.GetInst_Length(), rev);
4609 string expected = "CTATCCAAGAGGTTCTTCAATTTTTGGAATACATTCTTCCGGCTGTTTCTCTGGGTCAAAATACTCAACG\
4610 ACTTCTCCTTCGCTGTTGATCAAGAACTTGGCAAAGTTCCATGGGATGTCTCCAGTAGTCTCTGTTGAGG\
4611 AATCATGGAGGGAGGAATTACGCTTGCAGAATGTAAAGACCGAATGAGTATCGTCCCCATTGACGTCTAT\
4612 TTTATCAAACAACTGGAATTTCGCTCCGTATTTATCCTGTGCAAAAGCTCTGATCTCCTCGTTAGTCCCT\
4613 GGCTCTTGAGCACCGAACTGGTTGCAAGGGAAAGCAAAGATTTGAAAACCTTTGTCACTGAACTTATCAT\
4614 GGATCTCAGTCAGTTGCTCATAGTGGCCTTTAGTGAGCCCACATTTAGAAGCAACGTTCACAATCAGGAT\
4615 TGCTTTGTAGTCCTTAGCAAGATCAGCAAGAGACTGAGAGTTGCCATCAATATCATTTGCAGATAGCTCA\
4616 AAGAGAGATTTGGGAGCTTCTGGAGAGGATGAATCCATTAAGAAATTAAAATTCCCCAT";
4617 BOOST_CHECK_EQUAL(rev, expected);
4618 }}
4619 }
4620
4621
BOOST_AUTO_TEST_CASE(Test_Add1)4622 BOOST_AUTO_TEST_CASE(Test_Add1)
4623 {
4624 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4625 ("Seq-loc::=int {from 1,to 10,id gi 2}");
4626 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4627 ("Seq-loc::=int {from 1,to 10,strand minus,id gi 2}");
4628 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4629 ("Seq-loc::=mix{"
4630 " int {from 1,to 10,id gi 2},"
4631 " int {from 1,to 10,strand minus,id gi 2}"
4632 "}");
4633 CRef<CSeq_loc> loc = Seq_loc_Add(*loc1, *loc2, 0, 0);
4634 BOOST_CHECK(s_Equals(*loc, *loc3));
4635 }
4636
4637
BOOST_AUTO_TEST_CASE(Test_Add2)4638 BOOST_AUTO_TEST_CASE(Test_Add2)
4639 {
4640 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4641 ("Seq-loc::=int {from 1,to 10,id gi 2}");
4642 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4643 ("Seq-loc::=int {from 100,to 110,strand minus,id gi 2}");
4644 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4645 ("Seq-loc::=mix{"
4646 " int {from 1,to 10,id gi 2},"
4647 " int {from 100,to 110,strand minus,id gi 2}"
4648 "}");
4649 CRef<CSeq_loc> loc = Seq_loc_Add(*loc1, *loc2, 0, 0);
4650 BOOST_CHECK(s_Equals(*loc, *loc3));
4651 }
4652
4653
BOOST_AUTO_TEST_CASE(Test_Subtract1)4654 BOOST_AUTO_TEST_CASE(Test_Subtract1)
4655 {
4656 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4657 ("Seq-loc::=mix{"
4658 " int {from 1,to 10,id gi 2},"
4659 " int {from 1,to 10,strand minus,id gi 2}"
4660 "}");
4661 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4662 ("Seq-loc::=int {from 1,to 10,strand minus,id gi 2}");
4663 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4664 ("Seq-loc::=int {from 1,to 10,id gi 2}");
4665 CRef<CSeq_loc> loc = Seq_loc_Subtract(*loc1, *loc2, 0, 0);
4666 BOOST_CHECK(s_Equals(*loc, *loc3));
4667 }
4668
4669
BOOST_AUTO_TEST_CASE(Test_Subtract2)4670 BOOST_AUTO_TEST_CASE(Test_Subtract2)
4671 {
4672 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4673 ("Seq-loc::=mix{"
4674 " int {from 1,to 10,id gi 2},"
4675 " int {from 101,to 110,strand minus,id gi 2}"
4676 "}");
4677 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4678 ("Seq-loc::=int {from 101,to 110,strand minus,id gi 2}");
4679 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4680 ("Seq-loc::=int {from 1,to 10,id gi 2}");
4681 CRef<CSeq_loc> loc = Seq_loc_Subtract(*loc1, *loc2, 0, 0);
4682 BOOST_CHECK(s_Equals(*loc, *loc3));
4683 }
4684
4685
BOOST_AUTO_TEST_CASE(Test_Subtract3)4686 BOOST_AUTO_TEST_CASE(Test_Subtract3)
4687 {
4688 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4689 ("Seq-loc::=mix{"
4690 " int {from 1,to 10,id gi 2},"
4691 " int {from 1,to 10,strand minus,id gi 2}"
4692 "}");
4693 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4694 ("Seq-loc::=int {from 1,to 10,strand minus,id gi 2}");
4695 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4696 ("Seq-loc::=null NULL");
4697 CRef<CSeq_loc> loc = Seq_loc_Subtract(*loc1, *loc2, CSeq_loc::fStrand_Ignore, 0);
4698 BOOST_CHECK(s_Equals(*loc, *loc3));
4699 }
4700
4701
BOOST_AUTO_TEST_CASE(Test_Subtract4)4702 BOOST_AUTO_TEST_CASE(Test_Subtract4)
4703 {
4704 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4705 ("Seq-loc::=mix{"
4706 " int {from 1,to 10,id gi 2},"
4707 " int {from 101,to 110,strand minus,id gi 2}"
4708 "}");
4709 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4710 ("Seq-loc::=int {from 101,to 110,strand minus,id gi 2}");
4711 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4712 ("Seq-loc::=int {from 1,to 10,id gi 2}");
4713 CRef<CSeq_loc> loc = Seq_loc_Subtract(*loc1, *loc2, CSeq_loc::fStrand_Ignore, 0);
4714 BOOST_CHECK(s_Equals(*loc, *loc3));
4715 }
4716
4717
BOOST_AUTO_TEST_CASE(Test_Subtract5)4718 BOOST_AUTO_TEST_CASE(Test_Subtract5)
4719 {
4720 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4721 ("Seq-loc::=mix{"
4722 " int {from 1,to 10,id gi 2},"
4723 " int {from 1,to 10,id gi 2}"
4724 "}");
4725 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4726 ("Seq-loc::=int {from 1,to 10,id gi 2}");
4727 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4728 ("Seq-loc::=null NULL");
4729 CRef<CSeq_loc> loc = Seq_loc_Subtract(*loc1, *loc2, 0, 0);
4730 BOOST_CHECK(s_Equals(*loc, *loc3));
4731 }
4732
4733
BOOST_AUTO_TEST_CASE(Test_Subtract6)4734 BOOST_AUTO_TEST_CASE(Test_Subtract6)
4735 {
4736 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4737 ("Seq-loc::=mix{"
4738 " int {from 1,to 10,id gi 2},"
4739 " int {from 100,to 110,id gi 2}"
4740 "}");
4741 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4742 ("Seq-loc::=int {from 101,to 110,id gi 2}");
4743 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4744 ("Seq-loc::=mix{"
4745 " int {from 1,to 10,id gi 2},"
4746 " pnt {point 100,id gi 2}"
4747 "}");
4748 CRef<CSeq_loc> loc = Seq_loc_Subtract(*loc1, *loc2, 0, 0);
4749 BOOST_CHECK(s_Equals(*loc, *loc3));
4750 }
4751
4752
BOOST_AUTO_TEST_CASE(Test_Subtract7)4753 BOOST_AUTO_TEST_CASE(Test_Subtract7)
4754 {
4755 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4756 ("Seq-loc::=mix{"
4757 " int {from 1,to 10,id gi 2},"
4758 " int {from 1,to 10,id gi 2}"
4759 "}");
4760 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4761 ("Seq-loc::=int {from 1,to 10,id gi 2}");
4762 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4763 ("Seq-loc::=null NULL");
4764 CRef<CSeq_loc> loc = Seq_loc_Subtract(*loc1, *loc2, CSeq_loc::fStrand_Ignore, 0);
4765 BOOST_CHECK(s_Equals(*loc, *loc3));
4766 }
4767
4768
BOOST_AUTO_TEST_CASE(Test_Subtract8)4769 BOOST_AUTO_TEST_CASE(Test_Subtract8)
4770 {
4771 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4772 ("Seq-loc::=mix{"
4773 " int {from 1,to 10,id gi 2},"
4774 " int {from 100,to 110,id gi 2}"
4775 "}");
4776 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4777 ("Seq-loc::=int {from 101,to 110,id gi 2}");
4778 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4779 ("Seq-loc::=mix{"
4780 " int {from 1,to 10,id gi 2},"
4781 " pnt {point 100,id gi 2}"
4782 "}");
4783 CRef<CSeq_loc> loc = Seq_loc_Subtract(*loc1, *loc2, CSeq_loc::fStrand_Ignore, 0);
4784 BOOST_CHECK(s_Equals(*loc, *loc3));
4785 }
4786
4787
BOOST_AUTO_TEST_CASE(Test_Subtract9)4788 BOOST_AUTO_TEST_CASE(Test_Subtract9)
4789 {
4790 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4791 ("Seq-loc::=int {from 100,to 110,id gi 2}");
4792 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4793 ("Seq-loc::=int {from 101,to 105,id gi 2}");
4794 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4795 ("Seq-loc::=mix{"
4796 " pnt {point 100,id gi 2},"
4797 " int {from 106,to 110,id gi 2}"
4798 "}");
4799 CRef<CSeq_loc> loc = Seq_loc_Subtract(*loc1, *loc2, 0, 0);
4800 BOOST_CHECK(s_Equals(*loc, *loc3));
4801 }
4802
4803
BOOST_AUTO_TEST_CASE(Test_Subtract10)4804 BOOST_AUTO_TEST_CASE(Test_Subtract10)
4805 {
4806 return;
4807 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4808 ("Seq-loc::=int {from 100,to 110,id gi 2}");
4809 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4810 ("Seq-loc::=int {from 101,to 105,id gi 2}");
4811 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4812 ("Seq-loc::=mix{"
4813 " pnt {point 100,id gi 2},"
4814 " int {from 106,to 110,id gi 2}"
4815 "}");
4816 CRef<CSeq_loc> loc = Seq_loc_Subtract(*loc1, *loc2, CSeq_loc::fSort, 0);
4817 BOOST_CHECK(s_Equals(*loc, *loc3));
4818 }
4819
4820
BOOST_AUTO_TEST_CASE(Test_Subtract11)4821 BOOST_AUTO_TEST_CASE(Test_Subtract11)
4822 {
4823 return;
4824 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4825 ("Seq-loc::=int {from 100,to 110,id gi 2}");
4826 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4827 ("Seq-loc::=int {from 102,to 105,id gi 2}");
4828 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4829 ("Seq-loc::=mix{"
4830 " int {from 100,to 101,id gi 2},"
4831 " int {from 106,to 110,id gi 2}"
4832 "}");
4833 CRef<CSeq_loc> loc = Seq_loc_Subtract(*loc1, *loc2, CSeq_loc::fSort, 0);
4834 BOOST_CHECK(s_Equals(*loc, *loc3));
4835 }
4836
4837
BOOST_AUTO_TEST_CASE(Test_Subtract12)4838 BOOST_AUTO_TEST_CASE(Test_Subtract12)
4839 {
4840 return;
4841 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4842 ("Seq-loc::=int {from 100,to 110,id gi 2}");
4843 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4844 ("Seq-loc::=int {from 102,to 105,id gi 2}");
4845 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4846 ("Seq-loc::=mix{"
4847 " int {from 100,to 101,id gi 2},"
4848 " int {from 106,to 110,id gi 2}"
4849 "}");
4850 CRef<CSeq_loc> loc = loc1->Subtract(*loc2, CSeq_loc::fSort, 0, 0);
4851 BOOST_CHECK(s_Equals(*loc, *loc3));
4852 }
4853
4854
BOOST_AUTO_TEST_CASE(Test_Merge1)4855 BOOST_AUTO_TEST_CASE(Test_Merge1)
4856 {
4857 return;
4858 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4859 ("Seq-loc::=int {from 1,to 10,id gi 2}");
4860 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4861 ("Seq-loc::=int {from 1,to 10,strand minus,id gi 2}");
4862 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4863 ("Seq-loc::=mix{"
4864 " int {from 1,to 10,id gi 2},"
4865 " int {from 1,to 10,strand minus,id gi 2}"
4866 "}");
4867 CRef<CSeq_loc> loc = Seq_loc_Add(*loc1, *loc2, 0, 0);
4868 BOOST_CHECK(s_Equals(*loc, *loc3));
4869 }
4870
4871
BOOST_AUTO_TEST_CASE(Test_Merge2)4872 BOOST_AUTO_TEST_CASE(Test_Merge2)
4873 {
4874 return;
4875 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4876 ("Seq-loc::=int {from 1,to 10,id gi 2}");
4877 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4878 ("Seq-loc::=int {from 100,to 110,strand minus,id gi 2}");
4879 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4880 ("Seq-loc::=mix{"
4881 " int {from 1,to 10,id gi 2},"
4882 " int {from 100,to 110,strand minus,id gi 2}"
4883 "}");
4884 CRef<CSeq_loc> loc = Seq_loc_Add(*loc1, *loc2, 0, 0);
4885 BOOST_CHECK(s_Equals(*loc, *loc3));
4886 }
4887
4888
BOOST_AUTO_TEST_CASE(Test_Merge3)4889 BOOST_AUTO_TEST_CASE(Test_Merge3)
4890 {
4891 return;
4892 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4893 ("Seq-loc::=int {from 1,to 10,id gi 2}");
4894 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4895 ("Seq-loc::=int {from 1,to 10,strand minus,id gi 2}");
4896 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4897 ("Seq-loc::=mix{"
4898 " int {from 1,to 10,id gi 2},"
4899 " int {from 1,to 10,strand minus,id gi 2}"
4900 "}");
4901 CRef<CSeq_loc> loc = Seq_loc_Add(*loc1, *loc2, CSeq_loc::fSort, 0);
4902 BOOST_CHECK(s_Equals(*loc, *loc3));
4903 }
4904
4905
BOOST_AUTO_TEST_CASE(Test_Merge4)4906 BOOST_AUTO_TEST_CASE(Test_Merge4)
4907 {
4908 return;
4909 CRef<CSeq_loc> loc1 = s_Parse<CSeq_loc>
4910 ("Seq-loc::=int {from 1,to 10,id gi 2}");
4911 CRef<CSeq_loc> loc2 = s_Parse<CSeq_loc>
4912 ("Seq-loc::=int {from 100,to 110,strand minus,id gi 2}");
4913 CRef<CSeq_loc> loc3 = s_Parse<CSeq_loc>
4914 ("Seq-loc::=mix{"
4915 " int {from 1,to 10,id gi 2},"
4916 " int {from 100,to 110,strand minus,id gi 2}"
4917 "}");
4918 CRef<CSeq_loc> loc = Seq_loc_Add(*loc1, *loc2, CSeq_loc::fSort, 0);
4919 BOOST_CHECK(s_Equals(*loc, *loc3));
4920 }
4921
4922
4923