开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
test_helper.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：57k
源码类别：

生物技术

开发平台：

C/C++

test_helper.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: test_helper.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:25:11  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.58
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: test_helper.cpp,v 1000.4 2004/06/01 19:25:11 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE
  14. *               National Center for Biotechnology Information
  15. *
  16. *  This software/database is a "United States Government Work" under the
  17. *  terms of the United States Copyright Act.  It was written as part of
  18. *  the author's official duties as a United States Government employee and
  19. *  thus cannot be copyrighted.  This software/database is freely available
  20. *  to the public for use. The National Library of Medicine and the U.S.
  21. *  Government have not placed any restriction on its use or reproduction.
  22. *
  23. *  Although all reasonable efforts have been taken to ensure the accuracy
  24. *  and reliability of the software and data, the NLM and the U.S.
  25. *  Government do not and cannot warrant the performance or results that
  26. *  may be obtained by using this software or data. The NLM and the U.S.
  27. *  Government disclaim all warranties, express or implied, including
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.
  30. *
  31. *  Please cite the author in any work or product based on this material.
  32. *
  33. * ===========================================================================
  34. *
  35. * Authors:  Eugene Vasilchenko, Aleksey Grichenko, Denis Vakatov
  36. *
  37. * File Description:
  38. *   Bio sequence data generator to test Object Manager
  39. */
  41. #include <ncbi_pch.hpp>
  42. #include "test_helper.hpp"
  43. #include <corelib/ncbithr.hpp>
  44. #include <objects/seqloc/Seq_point.hpp>
  45. #include <serial/object.hpp>
  46. #include <serial/objistr.hpp>
  47. #include <serial/objostr.hpp>
  48. #include <serial/objcopy.hpp>
  49. #include <serial/objectinfo.hpp>
  50. #include <serial/iterator.hpp>
  51. #include <serial/objectiter.hpp>
  52. #include <serial/serial.hpp>
  54. #include <objects/seq/Bioseq.hpp>
  55. #include <objects/seq/Seq_descr.hpp>
  56. #include <objects/seq/Seqdesc.hpp>
  57. #include <objects/seq/Seq_annot.hpp>
  58. #include <objects/seq/IUPACna.hpp>
  59. #include <objects/seq/NCBIeaa.hpp>
  60. #include <objects/seq/NCBI2na.hpp>
  61. #include <objects/seq/Seq_ext.hpp>
  62. #include <objects/seq/Seg_ext.hpp>
  63. #include <objects/seqset/Bioseq_set.hpp>
  64. #include <objects/seqloc/Seq_loc.hpp>
  65. #include <objects/seqloc/Seq_interval.hpp>
  66. #include <objects/seqfeat/Seq_feat.hpp>
  67. #include <objects/seqfeat/SeqFeatData.hpp>
  68. #include <objects/seqfeat/Feat_id.hpp>
  69. #include <objects/seqfeat/Cdregion.hpp>
  70. #include <objects/seqfeat/Genetic_code.hpp>
  71. #include <objects/seqalign/Dense_diag.hpp>
  72. #include <objects/seq/Seq_inst.hpp>
  73. #include <objects/seqalign/Seq_align.hpp>
  74. #include <objmgr/bioseq_handle.hpp>
  75. #include <objmgr/seq_vector.hpp>
  76. #include <objmgr/seq_vector_ci.hpp>
  77. #include <objmgr/seq_descr_ci.hpp>
  78. #include <objmgr/feat_ci.hpp>
  79. #include <objmgr/align_ci.hpp>
  80. #include <objects/seq/seqport_util.hpp>
  81. #include <objects/general/Date.hpp>
  82. // #include <objects/util/sequence.hpp>
  84. #include <test/test_assert.h>  /* This header must go last */
  87. BEGIN_NCBI_SCOPE
  88. BEGIN_SCOPE(objects)
  90. bool CDataGenerator::sm_DumpEntries = false;
  92. /************************************************************************
  93.     1.2.1.1. Bio sequences for testing
  94.     Test entry = 1 top-level entry + 2 sub-entries (continuous sequence)
  95.     TSE contains 1 description
  96.     each sub-entry has
  97.         two Seq_ids: local and GI, (local ids = 11+1000i, 12+1000i)
  98.         one description,
  99.         two annotations (Seq_feat)
  100.             first - for an interval, local Seq_id:
  101.                 "plus" strand for one sub-entry,
  102.                 "minus" strand for another one
  103.             second - for the whole seq, GI Seq_id
  104.     one sub-entry has also an alignment annotation
  105. ************************************************************************/
  106. CSeq_entry& CDataGenerator::CreateTestEntry1(int index)
  107. {
  108.     // create top level seq entry
  109.     CRef<CSeq_entry> entry(new CSeq_entry);
  110.     CBioseq_set& set = entry->SetSet();
  111.     // class = nucleic acid and coded proteins
  112.     set.SetClass(CBioseq_set::eClass_nuc_prot);
  113.     // add description (name)
  114.     list< CRef<CSeqdesc> >& descr = set.SetDescr().Set();
  115.     CRef<CSeqdesc> desc(new CSeqdesc);
  116.     desc->SetName("D1 from TSE1-"+NStr::IntToString(index));
  117.     descr.push_back(desc);
  118.     // list of sub-entries
  119.     list< CRef<CSeq_entry> >& seq_set = set.SetSeq_set();
  121.     // Sub-entry Seq 11
  122.     {{
  123.         CRef<CSeq_entry> sub_entry(new CSeq_entry);
  124.         CBioseq& seq = sub_entry->SetSeq();
  125.         CBioseq::TId& id_list = seq.SetId();
  127.         // list of Ids (local + gi)
  128.         CRef<CSeq_id> id(new CSeq_id);
  129.         id->SetLocal().SetStr("seq"+NStr::IntToString(11+index*1000));
  130.         id_list.push_back(id);
  131.         id.Reset(new CSeq_id);
  132.         id->SetGi(11+index*1000);
  133.         id_list.push_back(id);
  135.         // Description (name)
  136.         list< CRef<CSeqdesc> >& descr1 = seq.SetDescr().Set();
  137.         CRef<CSeqdesc> desc1(new CSeqdesc);
  138.         desc1->SetName("D1 from BS11-"+NStr::IntToString(index));
  139.         descr1.push_back(desc1);
  141.         // Instance (sequence data)
  142.         CSeq_inst& inst = seq.SetInst();
  143.         // representation class = continuous sequence
  144.         inst.SetRepr(CSeq_inst::eRepr_raw);
  145.         // molecule class in living organism = dna
  146.         inst.SetMol(CSeq_inst::eMol_dna);
  147.         // length of sequence in residues
  148.         inst.SetLength(40);
  149.         // seq data in Iupacna
  150.         inst.SetSeq_data().SetIupacna().Set(
  151.             "CAGCAGCGGTACAGGAGGGTGAGACATCCCAGAGCGGTGC");
  152.         // strandedness in living organism = double strand
  153.         inst.SetStrand(CSeq_inst::eStrand_ds);
  155.         // Annotations
  156.         list< CRef<CSeq_annot> >& annot_list = seq.SetAnnot();
  157.         CRef<CSeq_annot> annot(new CSeq_annot);
  158.         // list of features
  159.         list< CRef<CSeq_feat> >& ftable = annot->SetData().SetFtable();
  160.         {{
  161.             CRef<CSeq_feat> feat(new CSeq_feat);
  162.             // feature Id
  163.             feat->SetId().SetLocal().SetStr("F1: lcl|11");
  164.             // the specific data
  165.             CSeqFeatData& fdata = feat->SetData();
  166.             CCdregion& cdreg = fdata.SetCdregion();
  167.             cdreg.SetFrame(CCdregion::eFrame_one);
  168.             // genetic code used
  169.             list< CRef< CGenetic_code::C_E > >& gcode = cdreg.SetCode().Set();
  170.             CRef< CGenetic_code::C_E > ce(new CGenetic_code::C_E);
  171.             ce->SetId(111); // TSE=1; seq=1; feat=1
  172.             gcode.push_back(ce);
  173.             // feature location on the sequence: Seq_interval (local seq_Id)
  174.             CSeq_interval& floc = feat->SetLocation().SetInt();
  175.             floc.SetId().SetLocal().SetStr
  176.                 ("seq"+NStr::IntToString(11+index*1000));
  177.             floc.SetFrom(20);
  178.             floc.SetTo(30);
  179.             ftable.push_back(feat);
  180.         }}
  181.         {{
  182.             CRef<CSeq_feat> feat(new CSeq_feat);
  183.             // feature Id
  184.             feat->SetId().SetLocal().SetStr("F2: gi|11");
  185.             // the specific data
  186.             CSeqFeatData& fdata = feat->SetData();
  187.             CCdregion& cdreg = fdata.SetCdregion();
  188.             cdreg.SetFrame(CCdregion::eFrame_one);
  189.             // genetic code used
  190.             list< CRef< CGenetic_code::C_E > >& gcode = cdreg.SetCode().Set();
  191.             CRef< CGenetic_code::C_E > ce(new CGenetic_code::C_E);
  192.             ce->SetId(112); // TSE=1; seq=1; feat=2
  193.             gcode.push_back(ce);
  194.             // feature location on the sequence (seq_Id + "whole" sequence)
  195.             feat->SetLocation().SetWhole().SetGi(11+index*1000);
  196.             ftable.push_back(feat);
  197.         }}
  198.         annot_list.push_back(annot);
  200.         // Add sub-entry
  201.         seq_set.push_back(sub_entry);
  202.     }}
  204.     // Sub-entry Seq 12
  205.     {{
  206.         CRef<CSeq_entry> sub_entry(new CSeq_entry);
  207.         CBioseq& seq = sub_entry->SetSeq();
  208.         CBioseq::TId& id_list = seq.SetId();
  210.         // list of Ids (local + gi)
  211.         CRef<CSeq_id> id(new CSeq_id);
  212.         id->SetLocal().SetStr("seq"+NStr::IntToString(12+index*1000));
  213.         id_list.push_back(id);
  214.         id.Reset(new CSeq_id);
  215.         id->SetGi(12+index*1000);
  216.         id_list.push_back(id);
  218.         // Instance (sequence data)
  219.         CSeq_inst& inst = seq.SetInst();
  220.         // representation class = continuous sequence
  221.         inst.SetRepr(CSeq_inst::eRepr_raw);
  222.         // molecule class in living organism = dna
  223.         inst.SetMol(CSeq_inst::eMol_dna);
  224.         // length of sequence in residues
  225.         inst.SetLength(40);
  226.         // seq data in Iupacna
  227.         inst.SetSeq_data().SetIupacna().Set(
  228.             "CAATAACCTCAGCAGCAACAAGTGGCTTCCAGCGCCCTCC");
  229.         // strandedness in living organism = double strand
  230.         inst.SetStrand(CSeq_inst::eStrand_ds);
  232.         // Annotations
  233.         list< CRef<CSeq_annot> >& annot_list = seq.SetAnnot();
  234.         {{
  235.             CRef<CSeq_annot> annot(new CSeq_annot);
  236.             // list of features
  237.             list< CRef<CSeq_feat> >& ftable = annot->SetData().SetFtable();
  238.             {{
  239.                 CRef<CSeq_feat> feat(new CSeq_feat);
  240.                 // feature Id
  241.                 feat->SetId().SetLocal().SetStr("F3: gi|12");
  242.                 // the specific data
  243.                 CSeqFeatData& fdata = feat->SetData();
  244.                 CCdregion& cdreg = fdata.SetCdregion();
  245.                 cdreg.SetFrame(CCdregion::eFrame_one);
  246.                 // genetic code used
  247.                 list< CRef< CGenetic_code::C_E > >& gcode =
  248.                     cdreg.SetCode().Set();
  249.                 CRef< CGenetic_code::C_E > ce(new CGenetic_code::C_E);
  250.                 ce->SetId(123); // TSE=1; seq=2; feat=3
  251.                 gcode.push_back(ce);
  252.                 // feature location on the sequence: Seq_interval (gi seq_Id)
  253.                 CSeq_interval& floc = feat->SetLocation().SetInt();
  254.                 floc.SetId().SetGi(12+index*1000);
  255.                 floc.SetFrom(20);
  256.                 floc.SetTo(30);
  257.                 // minus strand
  258.                 floc.SetStrand(eNa_strand_minus);
  259.                 ftable.push_back(feat);
  260.             }}
  261.             {{
  262.                 CRef<CSeq_feat> feat(new CSeq_feat);
  263.                 // feature Id
  264.                 feat->SetId().SetLocal().SetStr("F4: lcl|12");
  265.                 // the specific data
  266.                 CSeqFeatData& fdata = feat->SetData();
  267.                 CCdregion& cdreg = fdata.SetCdregion();
  268.                 cdreg.SetFrame(CCdregion::eFrame_one);
  269.                 // genetic code used
  270.                 list< CRef< CGenetic_code::C_E > >& gcode =
  271.                     cdreg.SetCode().Set();
  272.                 CRef< CGenetic_code::C_E > ce(new CGenetic_code::C_E);
  273.                 ce->SetId(124); // TSE=1; seq=2; feat=4
  274.                 gcode.push_back(ce);
  275.                 // feature location on the sequence (seq_Id + "whole" sequence)
  276.                 feat->SetLocation().SetWhole().SetLocal().SetStr
  277.                     ("seq"+NStr::IntToString(12+index*1000));
  278.                 ftable.push_back(feat);
  279.             }}
  280.             annot_list.push_back(annot);
  281.         }}
  282.         {{
  283.             CRef<CSeq_annot> annot(new CSeq_annot);
  284.             // list of seq alignments
  285.             list< CRef<CSeq_align> >& atable = annot->SetData().SetAlign();
  286.             {{
  287.                 // CAGCAGC:
  288.                 // 11[0], 12[9]
  289.                 CRef<CSeq_align> align(new CSeq_align);
  290.                 align->SetType(CSeq_align::eType_not_set);
  291.                 // alignment data
  292.                 CSeq_align::C_Segs& segs = align->SetSegs();
  293.                 // for (multiway) diagonals
  294.                 CSeq_align::C_Segs::TDendiag& diag_list = segs.SetDendiag();
  295.                 CRef<CDense_diag> diag(new CDense_diag);
  296.                 // dimensionality = 2
  297.                 diag->SetDim(2);
  298.                 // list of Seq_ids (gi) (sequences in order)
  299.                 CDense_diag::TIds& id_list = diag->SetIds();
  300.                 CRef<CSeq_id> id(new CSeq_id);
  301.                 id->SetGi(11+index*1000);
  302.                 id_list.push_back(id);
  303.                 id.Reset(new CSeq_id);
  304.                 id->SetGi(12+index*1000);
  305.                 id_list.push_back(id);
  306.                 // start OFFSETS in ids order
  307.                 CDense_diag::TStarts& start_list = diag->SetStarts();
  308.                 start_list.push_back(0);
  309.                 start_list.push_back(9);
  310.                 diag->SetLen(7);
  311.                 diag_list.push_back(diag);
  312.                 atable.push_back(align);
  313.             }}
  314.             annot_list.push_back(annot);
  315.         }}
  316.         // Add sub-entry
  317.         seq_set.push_back(sub_entry);
  318.     }}
  320.     if ( sm_DumpEntries ) {
  321.         NcbiCout << "-------------------- "
  322.             "TestEntry1 --------------------" << NcbiEndl;
  323.         auto_ptr<CObjectOStream>
  324.             out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
  325.         *out << *entry;
  326.     }
  327.     return *entry.Release();
  328. }
  331. /************************************************************************
  332.     1.2.1.2. Bio sequences for testing
  333.     Test entry = 1 top-level entry + 2 sub-entries (continuous sequence)
  334.     each sub-entry has
  335.         two Seq_ids: local and GI, (local ids = 11+1000i, 12+1000i)
  336.     No descriptions, No annotations
  337. ************************************************************************/
  338. CSeq_entry& CDataGenerator::CreateTestEntry1a(int index)
  339. {
  340.     // create top level seq entry
  341.     CRef<CSeq_entry> entry(new CSeq_entry);
  342.     CBioseq_set& set = entry->SetSet();
  343.     // class = nucleic acid and coded proteins
  344.     set.SetClass(CBioseq_set::eClass_nuc_prot);
  345.     list< CRef<CSeq_entry> >& seq_set = set.SetSeq_set();
  347.     // Sub-entry Seq 11
  348.     {{
  349.         CRef<CSeq_entry> sub_entry(new CSeq_entry);
  350.         CBioseq& seq = sub_entry->SetSeq();
  351.         CBioseq::TId& id_list = seq.SetId();
  353.         // list of Ids (local + gi)
  354.         CRef<CSeq_id> id(new CSeq_id);
  355.         id->SetLocal().SetStr("seq"+NStr::IntToString(11+index*1000));
  356.         id_list.push_back(id);
  357.         id.Reset(new CSeq_id);
  358.         id->SetGi(11+index*1000);
  359.         id_list.push_back(id);
  361.         // Instance (sequence data)
  362.         CSeq_inst& inst = seq.SetInst();
  363.         // representation class = continuous sequence
  364.         inst.SetRepr(CSeq_inst::eRepr_raw);
  365.         // molecule class in living organism = dna
  366.         inst.SetMol(CSeq_inst::eMol_dna);
  367.         // length of sequence in residues
  368.         inst.SetLength(40);
  369.         // seq data in Iupacna
  370.         inst.SetSeq_data().SetIupacna().Set(
  371.             "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
  372.         // strandedness in living organism = double strand
  373.         inst.SetStrand(CSeq_inst::eStrand_ds);
  375.         // Add sub-entry
  376.         seq_set.push_back(sub_entry);
  377.     }}
  379.     // Sub-entry Seq 12
  380.     {{
  381.         CRef<CSeq_entry> sub_entry(new CSeq_entry);
  382.         CBioseq& seq = sub_entry->SetSeq();
  383.         CBioseq::TId& id_list = seq.SetId();
  385.         // list of Ids (local + gi)
  386.         CRef<CSeq_id> id(new CSeq_id);
  387.         id->SetLocal().SetStr("seq"+NStr::IntToString(12+index*1000));
  388.         id_list.push_back(id);
  389.         id.Reset(new CSeq_id);
  390.         id->SetGi(12+index*1000);
  391.         id_list.push_back(id);
  393.         // Instance (sequence data)
  394.         CSeq_inst& inst = seq.SetInst();
  395.         inst.SetRepr(CSeq_inst::eRepr_raw);
  396.         inst.SetMol(CSeq_inst::eMol_dna);
  397.         // length of sequence in residues
  398.         inst.SetLength(40);
  399.         // seq data in Iupacna
  400.         inst.SetSeq_data().SetIupacna().Set(
  401.             "TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT");
  402.         inst.SetStrand(CSeq_inst::eStrand_ds);
  404.         // Add sub-entry
  405.         seq_set.push_back(sub_entry);
  406.     }}
  408.     if ( sm_DumpEntries ) {
  409.         NcbiCout << "-------------------- "
  410.             "TestEntry1a --------------------" << NcbiEndl;
  411.         auto_ptr<CObjectOStream>
  412.             out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
  413.         *out << *entry;
  414.     }
  415.     return *entry.Release();
  416. }
  419. /************************************************************************
  420.     1.2.1.3. Bio sequences for testing
  421.     Test entry = 1 top-level entry + 3 sub-entries
  422.     TSE
  423.         one annotation (Seq_feat), which refers to ids 12+1000i and 21+1000i
  424.     1 sub-entry
  425.         two Seq_ids: local and GI, (local id = 21+1000i)
  426.         one description
  427.         segmented sequence: references to
  428.             an interval, ( id= 11+1000i)
  429.             whole seq,   ( id= 12+1000i)
  430.             self         ( id= 21+1000i)
  431.         two annotations (Seq_feat)
  432.             both - for an interval,  local Seq_id = 11+1000i
  433.     2 sub-entry
  434.         two Seq_ids: local and GI, (local id = 22+1000i)
  435.         continuous sequence
  436.     3 sub-entry
  437.         two Seq_ids: local and GI, (local id = 23+1000i)
  438.         continuous sequence
  439.         conversion from one seq.data format to another
  440. ************************************************************************/
  441. CSeq_entry& CDataGenerator::CreateTestEntry2(int index)
  442. {
  443.     // create top level seq entry
  444.     CRef<CSeq_entry> entry(new CSeq_entry);
  445.     CBioseq_set& set = entry->SetSet();
  446.     // class = nucleic acid and coded proteins
  447.     set.SetClass(CBioseq_set::eClass_nuc_prot);
  448.     list< CRef<CSeq_entry> >& seq_set = set.SetSeq_set();
  450.     // Sub-entry Seq 21
  451.     {{
  452.         CRef<CSeq_entry> sub_entry(new CSeq_entry);
  453.         CBioseq& seq = sub_entry->SetSeq();
  454.         CBioseq::TId& id_list = seq.SetId();
  456.         // list of Ids (local + gi)
  457.         CRef<CSeq_id> id(new CSeq_id);
  458.         id->SetLocal().SetStr("seq"+NStr::IntToString(21+index*1000));
  459.         id_list.push_back(id);
  460.         id.Reset(new CSeq_id);
  461.         id->SetGi(21+index*1000);
  462.         id_list.push_back(id);
  464.         // Description (name)
  465.         list< CRef<CSeqdesc> >& descr1 = seq.SetDescr().Set();
  466.         CRef<CSeqdesc> desc1(new CSeqdesc);
  467.         desc1->SetName("D3 from bioseq 21-"+NStr::IntToString(index));
  468.         descr1.push_back(desc1);
  470.         // Instance (sequence data)
  471.         CSeq_inst& inst = seq.SetInst();
  472.         // representation class = segmented sequence
  473.         inst.SetRepr(CSeq_inst::eRepr_seg);
  474.         // molecule class in living organism = dna
  475.         inst.SetMol(CSeq_inst::eMol_dna);
  476.         // segments = list of Seq_locs
  477.         CSeg_ext::Tdata& seg_list = inst.SetExt().SetSeg();
  479.         // Seq_interval (gi)
  480.         CRef<CSeq_loc> loc(new CSeq_loc);
  481.         CSeq_interval& ref_loc = loc->SetInt();
  482.         ref_loc.SetId().SetGi(11+index*1000);
  483.         ref_loc.SetFrom(0);
  484.         ref_loc.SetTo(4);
  485.         seg_list.push_back(loc);
  487.         // whole sequence (gi)
  488.         loc = new CSeq_loc;
  489.         loc->SetWhole().SetGi(12+index*1000);
  490.         seg_list.push_back(loc);
  492.         // Seq_interval (gi)
  493.         loc = new CSeq_loc;
  494.         CSeq_interval& ref_loc2 = loc->SetInt();
  495.         // "simple" self-reference
  496.         ref_loc2.SetId().SetGi(21+index*1000);
  497.         ref_loc2.SetFrom(0);
  498.         ref_loc2.SetTo(9);
  499.         seg_list.push_back(loc);
  501.         // More complicated self-reference
  502.         loc = new CSeq_loc;
  503.         CSeq_interval& ref_loc3 = loc->SetInt();
  504.         ref_loc3.SetId().SetGi(21+index*1000);
  505.         ref_loc3.SetFrom(54);
  506.         ref_loc3.SetTo(60);
  507.         seg_list.push_back(loc);
  509.         inst.SetStrand(CSeq_inst::eStrand_ds);
  511.         // Annotations
  512.         list< CRef<CSeq_annot> >& annot_list = seq.SetAnnot();
  513.         CRef<CSeq_annot> annot(new CSeq_annot);
  514.         // list of features
  515.         list< CRef<CSeq_feat> >& ftable = annot->SetData().SetFtable();
  516.         {{
  517.             CRef<CSeq_feat> feat(new CSeq_feat);
  518.             // feature Id
  519.             feat->SetId().SetLocal().SetStr("F5: lcl|11");
  520.             // the specific data
  521.             CSeqFeatData& fdata = feat->SetData();
  522.             CCdregion& cdreg = fdata.SetCdregion();
  523.             cdreg.SetFrame(CCdregion::eFrame_one);
  524.             // genetic code used
  525.             list< CRef< CGenetic_code::C_E > >& gcode = cdreg.SetCode().Set();
  526.             CRef< CGenetic_code::C_E > ce(new CGenetic_code::C_E);
  527.             ce->SetId(215); // TSE=2; seq=1; feat=5
  528.             gcode.push_back(ce);
  529.             // feature location on the sequence: Seq_interval (local seq_Id)
  530.             CSeq_interval& floc = feat->SetLocation().SetInt();
  531.             floc.SetId().SetLocal().SetStr
  532.                 ("seq"+NStr::IntToString(11+index*1000));
  533.             floc.SetFrom(20);
  534.             floc.SetTo(30);
  535.             // plus strand
  536.             floc.SetStrand(eNa_strand_plus);
  537.             ftable.push_back(feat);
  538.         }}
  539.         {{
  540.             CRef<CSeq_feat> feat(new CSeq_feat);
  541.             // feature Id
  542.             feat->SetId().SetLocal().SetStr("F6: gi|11");
  543.             // the specific data
  544.             CSeqFeatData& fdata = feat->SetData();
  545.             CCdregion& cdreg = fdata.SetCdregion();
  546.             cdreg.SetFrame(CCdregion::eFrame_one);
  547.             // genetic code used
  548.             list< CRef< CGenetic_code::C_E > >& gcode = cdreg.SetCode().Set();
  549.             CRef< CGenetic_code::C_E > ce(new CGenetic_code::C_E);
  550.             ce->SetId(216); // TSE=2; seq=1; feat=6
  551.             gcode.push_back(ce);
  552.             // feature location on the sequence: Seq_interval (gi seq_Id)
  553.             CSeq_interval& floc = feat->SetLocation().SetInt();
  554.             floc.SetId().SetGi(11+index*1000);
  555.             floc.SetFrom(5);
  556.             floc.SetTo(15);
  557.             ftable.push_back(feat);
  558.         }}
  559.         annot_list.push_back(annot);
  561.         // Add sub-entry
  562.         seq_set.push_back(sub_entry);
  563.     }}
  565.     // Sub-entry Seq 22
  566.     {{
  567.         CRef<CSeq_entry> sub_entry(new CSeq_entry);
  568.         CBioseq& seq = sub_entry->SetSeq();
  569.         CBioseq::TId& id_list = seq.SetId();
  571.         // list of Ids (local + gi)
  572.         CRef<CSeq_id> id(new CSeq_id);
  573.         id->SetLocal().SetStr
  574.             ("seq"+NStr::IntToString(22+index*1000));
  575.         id_list.push_back(id);
  576.         id.Reset(new CSeq_id);
  577.         id->SetGi(22+index*1000);
  578.         id_list.push_back(id);
  580.         // Instance (sequence data)
  581.         CSeq_inst& inst = seq.SetInst();
  582.         // representation class = continuous sequence
  583.         inst.SetRepr(CSeq_inst::eRepr_raw);
  584.         // molecule class in living organism = aa (amino acid)
  585.         inst.SetMol(CSeq_inst::eMol_aa);
  586.         // length of sequence in residues
  587.         inst.SetLength(20);
  588.         // seq data in Ncbieaa
  589.         inst.SetSeq_data().SetNcbieaa().Set("QGCGEQTMTLLAPTLAASRY");
  590.         // single strand
  591.         inst.SetStrand(CSeq_inst::eStrand_ss);
  593.         // Add sub-entry
  594.         seq_set.push_back(sub_entry);
  595.     }}
  597.     // Sub-entry Seq 23
  598.     {{
  599.         CRef<CSeq_entry> sub_entry(new CSeq_entry);
  600.         CBioseq& seq = sub_entry->SetSeq();
  601.         CBioseq::TId& id_list = seq.SetId();
  603.         // list of Ids (local + gi)
  604.         CRef<CSeq_id> id(new CSeq_id);
  605.         id->SetLocal().SetStr
  606.             ("seq"+NStr::IntToString(23+index*1000));
  607.         id_list.push_back(id);
  608.         id.Reset(new CSeq_id);
  609.         id->SetGi(23+index*1000);
  610.         id_list.push_back(id);
  612.         // Instance (sequence data)
  613.         CSeq_inst& inst = seq.SetInst();
  614.         // representation class = continuous sequence
  615.         inst.SetRepr(CSeq_inst::eRepr_raw);
  616.         // molecule class in living organism = dna
  617.         inst.SetMol(CSeq_inst::eMol_dna);
  618.         // length of sequence in residues
  619.         inst.SetLength(13);
  620.         // seq data in Iupacna
  621.         inst.SetSeq_data().SetIupacna().Set("ATGCAGCTGTACG");
  622.         // double strand
  623.         inst.SetStrand(CSeq_inst::eStrand_ds);
  625.         CRef<CSeq_data> packed_data(new CSeq_data);
  626.         // convert seq data to another format
  627.         // (NCBI2na = 2 bit nucleic acid code)
  628.         CSeqportUtil::Convert(inst.GetSeq_data(),
  629.                               packed_data,
  630.                               CSeq_data::e_Ncbi2na);
  631.         inst.SetSeq_data(*packed_data);
  633.         // Add sub-entry
  634.         seq_set.push_back(sub_entry);
  635.     }}
  637.     // Annotations
  638.     list< CRef<CSeq_annot> >& set_annot_list = set.SetAnnot();
  639.     CRef<CSeq_annot> annot(new CSeq_annot);
  640.     // list of features
  641.     list< CRef<CSeq_feat> >& ftable = annot->SetData().SetFtable();
  642.     {{
  643.         CRef<CSeq_feat> feat(new CSeq_feat);
  644.         // feature Id
  645.         feat->SetId().SetLocal().SetStr("F7: lcl|21 + gi|12");
  646.         // the specific data
  647.         CSeqFeatData& fdata = feat->SetData();
  648.         CCdregion& cdreg = fdata.SetCdregion();
  649.         cdreg.SetFrame(CCdregion::eFrame_one);
  650.         // genetic code used
  651.         list< CRef< CGenetic_code::C_E > >& gcode = cdreg.SetCode().Set();
  652.         CRef< CGenetic_code::C_E > ce(new CGenetic_code::C_E);
  653.         ce->SetId(207); // TSE=2; no seq; feat=7
  654.         gcode.push_back(ce);
  655.         // feature location on the sequence: Seq_interval (local seq_Id)
  656.         CSeq_interval& floc = feat->SetLocation().SetInt();
  657.         floc.SetId().SetLocal().SetStr
  658.             ("seq"+NStr::IntToString(21+index*1000));
  659.         floc.SetFrom(1);
  660.         floc.SetTo(20);
  661.         // product of process (seq_loc = whole, gi)
  662.         feat->SetProduct().SetWhole().SetGi(12+index*1000);
  663.         ftable.push_back(feat);
  664.     }}
  665.     set_annot_list.push_back(annot);
  667.     if ( sm_DumpEntries ) {
  668.         NcbiCout << "-------------------- "
  669.             "TestEntry2 --------------------" << NcbiEndl;
  670.         auto_ptr<CObjectOStream>
  671.             out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
  672.         *out << *entry;
  673.     }
  674.     return *entry.Release();
  675. }
  677. /************************************************************************
  678.     1.2.1.4. Bio sequences for testing
  679.     Test entry = 1 top-level entry
  680.     TSE
  681.         only contains references to other sequences
  682. ************************************************************************/
  683. CSeq_entry& CDataGenerator::CreateConstructedEntry(int idx, int index)
  684. {
  685.     CSeq_loc constr_loc;
  686.     list< CRef<CSeq_interval> >& int_list = constr_loc.SetPacked_int();
  688.     CRef<CSeq_interval> int_ref(new CSeq_interval);
  689.     int_ref->SetId().SetGi(11+idx*1000);
  690.     int_ref->SetFrom(5);
  691.     int_ref->SetTo(10);
  692.     if (index == 2) {
  693.         int_ref->SetStrand(eNa_strand_minus);
  694.     }
  695.     int_list.push_back(int_ref);
  697.     int_ref.Reset(new CSeq_interval);
  698.     int_ref->SetId().SetGi(12+idx*1000);
  699.     int_ref->SetFrom(0);
  700.     int_ref->SetTo(20);
  701.     int_list.push_back(int_ref);
  703.     CRef<CBioseq> constr_seq(new CBioseq(constr_loc,
  704.         "constructed"+NStr::IntToString(index)));
  705.     CRef<CSeq_entry> constr_entry(new CSeq_entry);
  706.     constr_entry->SetSeq(*constr_seq);
  707.     if ( sm_DumpEntries ) {
  708.         NcbiCout << "-------------------- "
  709.             "ConstructedEntry --------------------" << NcbiEndl;
  710.         auto_ptr<CObjectOStream>
  711.             out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
  712.         *out << *constr_entry;
  713.     }
  714.     return *constr_entry.Release();
  715. }
  718. /************************************************************************
  719.     1.2.1.4. Bio sequences for testing
  720.     Test entry = 1 top-level entry
  721.     TSE
  722.         Construct bioseq by excluding the seq-loc
  723. ************************************************************************/
  724. /*
  725. CSeq_entry& CDataGenerator::CreateConstructedExclusionEntry(int idx, int index)
  726. {
  727.     CSeq_loc loc;
  728.     CSeq_loc_mix::Tdata& mix = loc.SetMix().Set();
  729.     CRef<CSeq_loc> sl;
  731.     sl.Reset(new CSeq_loc);
  732.     sl->SetPnt().SetId().SetGi(11+idx*1000);
  733.     sl->SetPnt().SetPoint(0);
  734.     mix.push_back(sl);
  736.     sl.Reset(new CSeq_loc);
  737.     sl->SetInt().SetId().SetGi(11+idx*1000);
  738.     sl->SetInt().SetFrom(0);
  739.     sl->SetInt().SetTo(4);
  740.     mix.push_back(sl);
  742.     sl.Reset(new CSeq_loc);
  743.     sl->SetInt().SetId().SetGi(11+idx*1000);
  744.     sl->SetInt().SetFrom(10);
  745.     sl->SetInt().SetTo(15);
  746.     mix.push_back(sl);
  748.     sl.Reset(new CSeq_loc);
  749.     sl->SetInt().SetId().SetGi(11+idx*1000);
  750.     sl->SetInt().SetFrom(10);
  751.     sl->SetInt().SetTo(12);
  752.     mix.push_back(sl);
  754.     sl.Reset(new CSeq_loc);
  755.     sl->SetInt().SetId().SetGi(11+idx*1000);
  756.     sl->SetInt().SetFrom(13);
  757.     sl->SetInt().SetTo(15);
  758.     mix.push_back(sl);
  760.     sl.Reset(new CSeq_loc);
  761.     sl->SetInt().SetId().SetGi(11+idx*1000);
  762.     sl->SetInt().SetFrom(8);
  763.     sl->SetInt().SetTo(18);
  764.     mix.push_back(sl);
  766.     sl.Reset(new CSeq_loc);
  767.     sl->SetPnt().SetId().SetGi(11+idx*1000);
  768.     sl->SetPnt().SetPoint(20);
  769.     mix.push_back(sl);
  771.     sl.Reset(new CSeq_loc);
  772.     sl->SetPnt().SetId().SetGi(11+idx*1000);
  773.     sl->SetPnt().SetPoint(39);
  774.     mix.push_back(sl);
  776.     CRef<CBioseq> constr_ex_seq(&CBioseq::ConstructExcludedSequence(loc, 40,
  777.         "construct_exclusion"+NStr::IntToString(index)));
  778.     CRef<CSeq_entry> constr_ex_entry(new CSeq_entry);
  779.     constr_ex_entry->SetSeq(*constr_ex_seq);
  780.     return *constr_ex_entry.Release();
  781. }
  782. */
  785. CSeq_annot& CDataGenerator::CreateAnnotation1(int index)
  786. {
  787.     CRef<CSeq_annot> annot(new CSeq_annot);
  788.     list< CRef<CSeq_feat> >& ftable = annot->SetData().SetFtable();
  789.     {{
  790.         CRef<CSeq_feat> feat(new CSeq_feat);
  791.         feat->SetId().SetLocal().SetStr("attached feature");
  792.         CSeqFeatData& fdata = feat->SetData();
  793.         CCdregion& cdreg = fdata.SetCdregion();
  794.         cdreg.SetFrame(CCdregion::eFrame_one);
  795.         list< CRef< CGenetic_code::C_E > >& gcode = cdreg.SetCode().Set();
  796.         CRef< CGenetic_code::C_E > ce(new CGenetic_code::C_E);
  797.         ce->SetId(999);
  798.         gcode.push_back(ce);
  799.         feat->SetComment() = "Feature attached after indexing the entry";
  800.         //feat->SetLocation().SetWhole().SetGi(11+index*1000);
  802.         CSeq_interval& interval = feat->SetLocation().SetInt();
  803.         interval.SetId().SetGi(11+index*1000);
  804.         interval.SetFrom(1);
  805.         interval.SetTo(9);
  806.         interval.SetStrand(eNa_strand_unknown);
  808.         ftable.push_back(feat);
  809.     }}
  810.     if ( sm_DumpEntries ) {
  811.         NcbiCout << "-------------------- "
  812.             "Annotation1 --------------------" << NcbiEndl;
  813.         auto_ptr<CObjectOStream>
  814.             out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
  815.         *out << *annot;
  816.     }
  817.     return *annot.Release();
  818. }
  821. /////////////////////////////////////////////////////////////////////////////
  822. /************************************************************************
  823.     1.2.2. Test function
  824.     Input: scope + seq_id
  825.         other parameters - only to verify results.
  826.     Operations:
  827.         investigate SeqMap, verify lengths
  828.         investigate SeqVector, verify seq.data (as strings)
  829.         investigate SeqMap again - some references may be resolved now
  830.         enumerate descriptions
  831.         enumerate features for the whole sequence
  832.         enumerate features for an interval
  833.         enumerate alignments for the whole sequence
  834.         enumerate alignments for an interval
  835. ************************************************************************/
  836. #define CHECK_WRAP() 
  837.     {{ 
  838.         bool got_exception = false; 
  839.         try {
  840. #define CHECK_END2(MSG, have_errors) 
  841.         } catch (exception) { 
  842.             got_exception = true; 
  843.             if ( !have_errors ) { 
  844.                 LOG_POST("Can not " MSG); throw; 
  845.             } 
  846.         } 
  847.         if ( have_errors && !got_exception ) { 
  848.             THROW1_TRACE(runtime_error, 
  849.                          "Managed to " MSG " of erroneous sequence"); 
  850.         } 
  851.     }}
  852. #define CHECK_END(MSG)         CHECK_END2(MSG, have_errors)
  853. #define CHECK_END_ALWAYS(MSG)  CHECK_END2(MSG, false)
  856. bool CTestHelper::sm_DumpFeatures = false;
  857. #if defined _MT
  858. bool CTestHelper::sm_TestRemoveEntry = false;
  859. #else 
  860. bool CTestHelper::sm_TestRemoveEntry = true;
  861. #endif
  863. void CTestHelper::ProcessBioseq(CScope& scope, CSeq_id& id,
  864.                                 TSeqPos seq_len,
  865.                                 string seq_str, string seq_str_compl,
  866.                                 int seq_desc_cnt,
  867.                                 int seq_feat_ra_cnt, // resolve-all method
  868.                                 int seq_feat_cnt, int seq_featrg_cnt,
  869.                                 int seq_align_cnt, int seq_alignrg_cnt,
  870.                                 size_t feat_annots_cnt,
  871.                                 size_t featrg_annots_cnt,
  872.                                 size_t align_annots_cnt,
  873.                                 size_t alignrg_annots_cnt,
  874.                                 bool tse_feat_test,
  875.                                 bool have_errors)
  876. {
  877.     CBioseq_Handle handle = scope.GetBioseqHandle(id);
  878.     if ( !handle ) {
  879.         LOG_POST("No seq-id found");
  880.         return;
  881.     }
  882.     handle.GetTopLevelSeqEntry();
  883. #if 0 // build order issues
  884.     CHECK_WRAP();
  885.     sequence::GetTitle(handle);
  886.     CHECK_END("get sequence title");
  887. #endif
  889.     CBioseq_Handle::TBioseqCore seq_core = handle.GetBioseqCore();
  890.     CHECK_WRAP();
  891.     CConstRef<CSeqMap> seq_map(&handle.GetSeqMap());
  892.     TSeqPos len = 0;
  893.     _TRACE("ProcessBioseq("<<id.AsFastaString()<<") seq_len="<<seq_len<<"):");
  894.     // Iterate seq-map except the last element
  895.     len = 0;
  896.     CSeqMap::const_iterator seg = seq_map->begin(&scope);
  897.     vector<CSeqMap::const_iterator> itrs;
  898.     for ( ; seg != seq_map->end(&scope); ++seg ) {
  899.         _ASSERT(seg);
  900.         itrs.push_back(seg);
  901.         switch (seg.GetType()) {
  902.         case CSeqMap::eSeqData:
  903.             _TRACE('@'<<len<<": seqData("<<seg.GetLength()<<")");
  904.             len += seg.GetLength();
  905.             break;
  906.         case CSeqMap::eSeqRef:
  907.             _TRACE('@'<<len<<": seqRef("<<seg.GetLength()<<
  908.                    ", id="<<seg.GetRefSeqid().AsString()<<
  909.                    ", pos="<<seg.GetRefPosition()<<
  910.                    ", minus="<<seg.GetRefMinusStrand()<<")");
  911.             len += seg.GetLength();
  912.             break;
  913.         case CSeqMap::eSeqGap:
  914.             _TRACE('@'<<len<<": seqGap("<<seg.GetLength()<<")");
  915.             len += seg.GetLength();
  916.             break;
  917.         case CSeqMap::eSeqEnd:
  918.             _ASSERT("Unexpected END segment" && 0);
  919.             break;
  920.         default:
  921.             _ASSERT("Unexpected segment type" && 0);
  922.             break;
  923.         }
  924.     }
  925.     _ASSERT(!seg);
  926.     for ( int i = itrs.size()-1; i >= 0; --i ) {
  927.         --seg;
  928.         _ASSERT(seg);
  929.         _ASSERT(seg == itrs[i]);
  930.     }
  931.     --seg;
  932.     _ASSERT(!seg);
  934.     _TRACE("ProcessBioseq("<<id.AsFastaString()<<") len="<<len<<")");
  935.     _ASSERT(len == seq_len);
  936.     CHECK_END("get sequence map");
  938.     CHECK_WRAP();
  939.     CConstRef<CSeqMap> seq_map(&handle.GetSeqMap());
  940.     TSeqPos len = 0;
  941.     _TRACE("ProcessBioseq("<<id.AsFastaString()<<") - depth-restricted");
  942.     // Iterate seq-map except the last element
  943.     len = 0;
  944.     CSeqMap::const_iterator seg(seq_map, &scope, SSeqMapSelector()
  945.                                 .SetResolveCount(2));
  946.     vector<CSeqMap::const_iterator> itrs;
  947.     for ( ; seg != seq_map->end(&scope); ++seg ) {
  948.         _ASSERT(seg);
  949.         itrs.push_back(seg);
  950.         switch (seg.GetType()) {
  951.         case CSeqMap::eSeqData:
  952.             _TRACE('@'<<len<<": seqData("<<seg.GetLength()<<")");
  953.             len += seg.GetLength();
  954.             break;
  955.         case CSeqMap::eSeqRef:
  956.             _TRACE('@'<<len<<": seqRef("<<seg.GetLength()<<
  957.                    ", id="<<seg.GetRefSeqid().AsString()<<
  958.                    ", pos="<<seg.GetRefPosition()<<
  959.                    ", minus="<<seg.GetRefMinusStrand()<<")");
  960.             len += seg.GetLength();
  961.             break;
  962.         case CSeqMap::eSeqGap:
  963.             _TRACE('@'<<len<<": seqGap("<<seg.GetLength()<<")");
  964.             len += seg.GetLength();
  965.             break;
  966.         case CSeqMap::eSeqEnd:
  967.             _ASSERT("Unexpected END segment" && 0);
  968.             break;
  969.         default:
  970.             _ASSERT("Unexpected segment type" && 0);
  971.             break;
  972.         }
  973.     }
  974.     _ASSERT(!seg);
  975.     for ( int i = itrs.size()-1; i >= 0; --i ) {
  976.         --seg;
  977.         _ASSERT(seg);
  978.         _ASSERT(seg == itrs[i]);
  979.     }
  980.     --seg;
  981.     _ASSERT(!seg);
  982.     CHECK_END("get restricted sequence map");
  984.     CHECK_WRAP();
  985.     CConstRef<CSeqMap> seq_map(&handle.GetSeqMap());
  986.     TSeqPos len = 0;
  987.     _TRACE("ProcessBioseq("<<id.AsFastaString()<<") - TSE-restricted");
  988.     // Iterate seq-map except the last element
  989.     len = 0;
  990.     CSeqMap::const_iterator seg(seq_map, &scope, SSeqMapSelector()
  991.                                 .SetLimitTSE(&handle.GetTopLevelSeqEntry())
  992.                                 .SetResolveCount(kInvalidSeqPos)
  993.                                 .SetFlags(CSeqMap::fFindAny));
  994.     vector<CSeqMap::const_iterator> itrs;
  995.     for ( ; seg != seq_map->end(&scope); ++seg ) {
  996.         _ASSERT(seg);
  997.         itrs.push_back(seg);
  998.         switch (seg.GetType()) {
  999.         case CSeqMap::eSeqData:
  1000.             _TRACE('@'<<len<<": seqData("<<seg.GetLength()<<")");
  1001.             len += seg.GetLength();
  1002.             break;
  1003.         case CSeqMap::eSeqRef:
  1004.             _TRACE('@'<<len<<": seqRef("<<seg.GetLength()<<
  1005.                    ", id="<<seg.GetRefSeqid().AsString()<<
  1006.                    ", pos="<<seg.GetRefPosition()<<
  1007.                    ", minus="<<seg.GetRefMinusStrand()<<")");
  1008.             len += seg.GetLength();
  1009.             break;
  1010.         case CSeqMap::eSeqGap:
  1011.             _TRACE('@'<<len<<": seqGap("<<seg.GetLength()<<")");
  1012.             len += seg.GetLength();
  1013.             break;
  1014.         case CSeqMap::eSeqEnd:
  1015.             _ASSERT("Unexpected END segment" && 0);
  1016.             break;
  1017.         default:
  1018.             _ASSERT("Unexpected segment type" && 0);
  1019.             break;
  1020.         }
  1021.     }
  1022.     _ASSERT(!seg);
  1023.     for ( int i = itrs.size()-1; i >= 0; --i ) {
  1024.         --seg;
  1025.         _ASSERT(seg);
  1026.         _ASSERT(seg == itrs[i]);
  1027.     }
  1028.     --seg;
  1029.     _ASSERT(!seg);
  1030.     CHECK_END("get restricted sequence map");
  1032.     CHECK_WRAP();
  1033.     CConstRef<CSeqMap> seq_map(&handle.GetSeqMap());
  1034.     TSeqPos len = 0;
  1035.     _TRACE("ProcessBioseq("<<id.AsFastaString()<<
  1036.            ") seq_len="<<seq_len<<") resolved:");
  1037.     // Iterate seq-map except the last element
  1038.     len = 0;
  1039.     CSeqMap::const_iterator seg = seq_map->begin_resolved(&scope);
  1040.     vector<CSeqMap::const_iterator> itrs;
  1041.     for ( ; seg != seq_map->end_resolved(&scope); ++seg ) {
  1042.         _ASSERT(seg);
  1043.         itrs.push_back(seg);
  1044.         switch (seg.GetType()) {
  1045.         case CSeqMap::eSeqData:
  1046.             _TRACE('@'<<len<<": seqData("<<seg.GetLength()<<")");
  1047.             len += seg.GetLength();
  1048.             break;
  1049.         case CSeqMap::eSeqRef:
  1050.             _TRACE('@'<<len<<": seqRef("<<seg.GetLength()<<
  1051.                    ", id="<<seg.GetRefSeqid().AsString()<<
  1052.                    ", pos="<<seg.GetRefPosition()<<
  1053.                    ", minus="<<seg.GetRefMinusStrand()<<")");
  1054.             _ASSERT("Unexpected REF segment" && 0);
  1055.             //len += seg.GetLength();
  1056.             break;
  1057.         case CSeqMap::eSeqGap:
  1058.             _TRACE('@'<<len<<": seqGap("<<seg.GetLength()<<")");
  1059.             len += seg.GetLength();
  1060.             break;
  1061.         case CSeqMap::eSeqEnd:
  1062.             _ASSERT("Unexpected END segment" && 0);
  1063.             break;
  1064.         default:
  1065.             _ASSERT("Unexpected segment type" && 0);
  1066.             break;
  1067.         }
  1068.     }
  1069.     _ASSERT(!seg);
  1070.     for ( int i = itrs.size()-1; i >= 0; --i ) {
  1071.         --seg;
  1072.         _ASSERT(seg);
  1073.         _ASSERT(seg == itrs[i]);
  1074.     }
  1075.     --seg;
  1076.     _ASSERT(!seg);
  1078.     _TRACE("ProcessBioseq("<<id.AsFastaString()<<") len="<<len<<")");
  1079.     _ASSERT(len == seq_len);
  1080.     CHECK_END("get resolved sequence map");
  1082.     CSeqVector seq_vect;
  1084.     CHECK_WRAP();
  1085.     seq_vect = handle.GetSeqVector(CBioseq_Handle::eCoding_NotSet);
  1086.     string sout = "";
  1087.     {{
  1088.         CSeqVector_CI vit(seq_vect, 0);
  1089.         for ( ; vit.GetPos() < seq_vect.size(); ++vit) {
  1090.             sout += *vit;
  1091.         }
  1092.         _ASSERT(NStr::PrintableString(sout) == seq_str);
  1093.         seq_vect.SetCoding(CBioseq_Handle::eCoding_Ncbi);
  1094.         int pos = seq_vect.size() - 1;
  1095.         vit.SetPos(pos);
  1096.         for ( ; pos > 0; --vit, --pos) {
  1097.             _ASSERT(sout[vit.GetPos()] == *vit);
  1098.         }
  1099.         _ASSERT(sout[vit.GetPos()] == *vit);
  1100.         vit.GetSeqData(0, seq_vect.size(), sout);
  1101.         _ASSERT(NStr::PrintableString(sout) == seq_str);
  1102.         sout = "";
  1103.         seq_vect.SetCoding(CBioseq_Handle::eCoding_NotSet);
  1104.     }}
  1105.     for (TSeqPos i = 0; i < seq_vect.size(); i++) {
  1106.         sout += seq_vect[i];
  1107.     }
  1108.     _ASSERT(NStr::PrintableString(sout) == seq_str);
  1109.     CHECK_END("get seq vector");
  1111.     CHECK_WRAP();
  1112.     CSeq_interval interval;
  1113.     interval.SetId(id);
  1114.     interval.SetFrom(seq_str.size());
  1115.     interval.SetTo(seq_str.size()-1);
  1116.     CSeq_loc loc;
  1117.     loc.SetInt(interval);
  1118.     seq_vect = handle.GetSequenceView(loc, CBioseq_Handle::eViewConstructed);
  1119.     string sout = "";
  1120.     for (TSeqPos i = 0; i < seq_vect.size(); i++) {
  1121.         sout += seq_vect[i];
  1122.     }
  1123.     _ASSERT(sout.empty());
  1124.     CHECK_END_ALWAYS("get seq view");
  1126.     if (seq_core->GetInst().IsSetStrand() &&
  1127.         seq_core->GetInst().GetStrand() == CSeq_inst::eStrand_ds) {
  1128.         CHECK_WRAP();
  1129.         seq_vect = handle.GetSeqVector(CBioseq_Handle::eCoding_NotSet,
  1130.                                        eNa_strand_minus);
  1131.         string sout_rev = "";
  1132.         for (TSeqPos i = seq_vect.size(); i> 0; i--) {
  1133.             sout_rev += seq_vect[i-1];
  1134.         }
  1135.         _ASSERT(NStr::PrintableString(sout_rev) == seq_str_compl);
  1136.         CHECK_END("get reverse seq vector");
  1137.     }
  1138.     else {
  1139.         _ASSERT(seq_str_compl.empty());
  1140.     }
  1142.     CConstRef<CBioseq> bioseq(&(handle.GetBioseq()));
  1144.     int count = 0;
  1145.     CHECK_WRAP();
  1146.     // Test CSeq_descr iterator
  1147.     for (CSeq_descr_CI desc_it(handle); desc_it;  ++desc_it) {
  1148.         count++;
  1149.         //### _ASSERT(desc_it->
  1150.     }
  1151.     _ASSERT(count == seq_desc_cnt);
  1152.     CHECK_END_ALWAYS("count CSeq_descr");
  1154.     CHECK_WRAP();
  1155.     // Test CSeq_feat iterator, resolve-all method
  1156.     CSeq_loc loc;
  1157.     loc.SetWhole(id);
  1158.     count = 0;
  1159.     if ( !tse_feat_test ) {
  1160.         if ( sm_DumpFeatures ) {
  1161.             NcbiCout << "-------------------- CFeat_CI resolve-all over "<<
  1162.                 id.AsFastaString()<<" --------------------" << NcbiEndl;
  1163.         }
  1164.         for ( CFeat_CI feat_it(scope, loc, SAnnotSelector().SetResolveAll());
  1165.               feat_it;  ++feat_it) {
  1166.             count++;
  1167.             if ( sm_DumpFeatures ) {
  1168.                 auto_ptr<CObjectOStream>
  1169.                     out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
  1170.                 *out << feat_it->GetMappedFeature();
  1171.             }
  1172.             //### _ASSERT(feat_it->
  1173.         }
  1174.         _ASSERT(count == seq_feat_ra_cnt);
  1175.     }
  1176.     CHECK_END("get annot set");
  1178.     CHECK_WRAP();
  1179.     // Test CSeq_feat iterator
  1180.     CSeq_loc loc;
  1181.     loc.SetWhole(id);
  1182.     count = 0;
  1183.     set<const CSeq_annot*> annot_set;
  1184.     if ( sm_DumpFeatures ) {
  1185.         NcbiCout << "-------------------- CFeat_CI over "<<
  1186.             id.AsFastaString()<<" --------------------" << NcbiEndl;
  1187.     }
  1188.     if ( !tse_feat_test ) {
  1189.         for ( CFeat_CI feat_it(scope, loc); feat_it;  ++feat_it) {
  1190.             count++;
  1191.             annot_set.insert(&feat_it.GetSeq_annot());
  1192.             if ( sm_DumpFeatures ) {
  1193.                 auto_ptr<CObjectOStream>
  1194.                     out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
  1195.                 *out << feat_it->GetMappedFeature();
  1196.             }
  1197.             //### _ASSERT(feat_it->
  1198.         }
  1199.         if ( sm_DumpFeatures ) {
  1200.             NcbiCout << "-------------------- "
  1201.                 "product CFeat_CI --------------------" << NcbiEndl;
  1202.         }
  1203.         // Get products
  1204.         for ( CFeat_CI feat_it(scope, loc, SAnnotSelector().SetByProduct());
  1205.               feat_it;  ++feat_it) {
  1206.             count++;
  1207.             annot_set.insert(&feat_it.GetSeq_annot());
  1208.             if ( sm_DumpFeatures ) {
  1209.                 auto_ptr<CObjectOStream>
  1210.                     out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
  1211.                 *out << feat_it->GetMappedFeature();
  1212.             }
  1213.             //### _ASSERT(feat_it->
  1214.         }
  1215.     }
  1216.     else {
  1217.         if ( sm_DumpFeatures ) {
  1218.             NcbiCout << "-------------------- "
  1219.                 "LimitTSE --------------------" << NcbiEndl;
  1220.         }
  1221.         for ( CFeat_CI feat_it(handle, 0, 0,
  1222.                                SAnnotSelector()
  1223.                                .SetLimitTSE(&handle.GetTopLevelSeqEntry()));
  1224.               feat_it;  ++feat_it) {
  1225.             count++;
  1226.             annot_set.insert(&feat_it.GetSeq_annot());
  1227.             if ( sm_DumpFeatures ) {
  1228.                 auto_ptr<CObjectOStream>
  1229.                     out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
  1230.                 *out << feat_it->GetMappedFeature();
  1231.             }
  1232.             //### _ASSERT(feat_it->
  1233.         }
  1234.         if ( sm_DumpFeatures ) {
  1235.             NcbiCout << "-------------------- "
  1236.                 "product CFeat_CI --------------------" << NcbiEndl;
  1237.         }
  1238.         // Get products
  1239.         for ( CFeat_CI feat_it(handle, 0, 0,
  1240.                                SAnnotSelector()
  1241.                                .SetLimitTSE(&handle.GetTopLevelSeqEntry())
  1242.                                .SetByProduct());
  1243.               feat_it;  ++feat_it) {
  1244.             count++;
  1245.             annot_set.insert(&feat_it.GetSeq_annot());
  1246.             if ( sm_DumpFeatures ) {
  1247.                 auto_ptr<CObjectOStream>
  1248.                     out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
  1249.                 *out << feat_it->GetMappedFeature();
  1250.             }
  1251.             //### _ASSERT(feat_it->
  1252.         }
  1253.     }
  1254.     if ( sm_DumpFeatures ) {
  1255.         NcbiCout << "-------------------- "
  1256.             "end CFeat_CI --------------------" << NcbiEndl;
  1257.     }
  1258.     _ASSERT(count == seq_feat_cnt);
  1259.     _ASSERT(annot_set.size() == feat_annots_cnt);
  1260.     CHECK_END("get annot set");
  1262.     CHECK_WRAP();
  1263.     // Test CSeq_feat iterator for the specified range
  1264.     // Copy location seq-id
  1265.     count = 0;
  1266.     set<const CSeq_annot*> annot_set;
  1267.     CSeq_loc loc;
  1268.     loc.SetInt().SetId().Assign(id);
  1269.     loc.SetInt().SetFrom(0);
  1270.     loc.SetInt().SetTo(10);
  1271.     if ( !tse_feat_test ) {
  1272.         for ( CFeat_CI feat_it(scope, loc);
  1273.               feat_it;  ++feat_it) {
  1274.             count++;
  1275.             annot_set.insert(&feat_it.GetSeq_annot());
  1276.             //### _ASSERT(feat_it->
  1277.         }
  1278.     }
  1279.     else {
  1280.         for ( CFeat_CI feat_it(handle, 0, 10,
  1281.                                SAnnotSelector()
  1282.                                .SetLimitTSE(&handle.GetTopLevelSeqEntry()));
  1283.               feat_it;  ++feat_it) {
  1284.             count++;
  1285.             annot_set.insert(&feat_it.GetSeq_annot());
  1286.             //### _ASSERT(feat_it->
  1287.         }
  1288.     }
  1289.     _ASSERT(count == seq_featrg_cnt);
  1290.     _ASSERT(annot_set.size() == featrg_annots_cnt);
  1291.     CHECK_END("get annot set");
  1293.     CHECK_WRAP();
  1294.     // Test CSeq_align iterator
  1295.     count = 0;
  1296.     set<const CSeq_annot*> annot_set;
  1297.     CSeq_loc loc;
  1298.     loc.SetWhole(id);
  1299.     if ( !tse_feat_test ) {
  1300.         for (CAlign_CI align_it(scope, loc);
  1301.              align_it;  ++align_it) {
  1302.             count++;
  1303.             annot_set.insert(&align_it.GetSeq_annot());
  1304.             //### _ASSERT(align_it->
  1305.         }
  1306.     }
  1307.     else {
  1308.         for (CAlign_CI align_it(handle, 0, 0,
  1309.                                 SAnnotSelector()
  1310.                                 .SetLimitTSE(&handle.GetTopLevelSeqEntry()));
  1311.              align_it;  ++align_it) {
  1312.             count++;
  1313.             annot_set.insert(&align_it.GetSeq_annot());
  1314.             //### _ASSERT(align_it->
  1315.         }
  1316.     }
  1317.     _ASSERT(count == seq_align_cnt);
  1318.     _ASSERT(annot_set.size() == align_annots_cnt);
  1319.     CHECK_END("get align set");
  1321.     CHECK_WRAP();
  1322.     // Test CSeq_align iterator for the specified range
  1323.     // Copy location seq-id
  1324.     count = 0;
  1325.     set<const CSeq_annot*> annot_set;
  1326.     CSeq_loc loc;
  1327.     loc.SetInt().SetId().Assign(id);
  1328.     loc.SetInt().SetFrom(10);
  1329.     loc.SetInt().SetTo(20);
  1330.     if ( !tse_feat_test ) {
  1331.         for (CAlign_CI align_it(scope, loc);
  1332.              align_it;  ++align_it) {
  1333.             count++;
  1334.             annot_set.insert(&align_it.GetSeq_annot());
  1335.             //### _ASSERT(align_it->
  1336.         }
  1337.     }
  1338.     else {
  1339.         for (CAlign_CI align_it(handle, 10, 20,
  1340.                                 SAnnotSelector()
  1341.                                 .SetLimitTSE(&handle.GetTopLevelSeqEntry()));
  1342.              align_it;  ++align_it) {
  1343.             count++;
  1344.             annot_set.insert(&align_it.GetSeq_annot());
  1345.             //### _ASSERT(align_it->
  1346.         }
  1347.     }
  1348.     _ASSERT(count == seq_alignrg_cnt);
  1349.     _ASSERT(annot_set.size() == alignrg_annots_cnt);
  1350.     CHECK_END("get align set");
  1351.     if ( sm_TestRemoveEntry ) {
  1352.         CHECK_WRAP();
  1353.         CRef<CSeq_entry> tse
  1354.             (const_cast<CSeq_entry*>(&handle.GetTopLevelSeqEntry()));
  1355.         
  1356.         CRef<CSeq_entry> entry(const_cast<CSeq_entry*>(
  1357.                                    handle.GetBioseq().GetParentEntry()));
  1358.         CSeq_entry* parent = entry->GetParentEntry();
  1359.         scope.RemoveEntry(*entry);
  1360.         handle = scope.GetBioseqHandle(id);
  1361.         _ASSERT(!handle  ||  handle.GetBioseq().GetParentEntry() != entry);
  1362.         if ( parent ) {
  1363.             // Non-TSE
  1364.             scope.AttachEntry(*parent, *entry);
  1365.         }
  1366.         else {
  1367.             // TSE
  1368.             scope.AddTopLevelSeqEntry(*entry);
  1369.         }
  1370.         handle = scope.GetBioseqHandle(id);
  1371.         _ASSERT(handle);
  1372.         CHECK_END_ALWAYS("remove/attach seq-entry");
  1373.     }
  1374. }
  1377. void CTestHelper::TestDataRetrieval(CScope& scope, int idx,
  1378.                                     int delta)
  1379. {
  1380.     CSeq_id id;
  1381.     // find seq. by local id
  1382.     id.SetLocal().SetStr("seq" + NStr::IntToString(11+idx*1000));
  1383.     // iterate through the whole Scope
  1384.     ProcessBioseq(scope, id, 40,
  1385.         "CAGCAGCGGTACAGGAGGGTGAGACATCCCAGAGCGGTGC",
  1386.         "GTCGTCGCCATGTCCTCCCACTCTGTAGGGTCTCGCCACG",
  1387.         2, 4+delta, 4+delta, 2+delta, 1, 0, 2+delta, 2+delta, 1, 0);
  1388.     // iterate through the specific sequence only
  1389.     ProcessBioseq(scope, id, 40,
  1390.         "CAGCAGCGGTACAGGAGGGTGAGACATCCCAGAGCGGTGC",
  1391.         "GTCGTCGCCATGTCCTCCCACTCTGTAGGGTCTCGCCACG",
  1392.         2, -1, 2+delta, 1+delta, 1, 0, 1+delta, 1+delta, 1, 0, true);
  1393.     // find seq. by GI
  1394.     id.SetGi(12+idx*1000);
  1395.     ProcessBioseq(scope, id, 40,
  1396.         "CAATAACCTCAGCAGCAACAAGTGGCTTCCAGCGCCCTCC",
  1397.         "GTTATTGGAGTCGTCGTTGTTCACCGAAGGTCGCGGGAGG",
  1398.         1, 2, 3, 1, 1, 1, 2, 1, 1, 1); //1, 3, 2, 1, 1, 2, 2, 1, 1);
  1399.     // segmented sequence
  1400.     id.SetGi(21+idx*1000);
  1401.     ProcessBioseq(scope, id, 62,
  1402.         "CAGCACAATAACCTCAGCAGCAACAAGTGGCTTCCAGCGCCCTCCCAGCACAATAAAAAAAA",
  1403.         "GTCGTGTTATTGGAGTCGTCGTTGTTCACCGAAGGTCGCGGGAGGGTCGTGTTATTTTTTTT",
  1404.         1, 6+delta, 2, 1, 0, 0, 1, 1, 0, 0);
  1405.     id.SetGi(22+idx*1000);
  1406.     ProcessBioseq(scope, id, 20, "QGCGEQTMTLLAPTLAASRY", "",
  1407.         0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  1408.     // another seq.data format
  1409.     id.SetGi(23+idx*1000);
  1410.     ProcessBioseq(scope, id, 13,
  1411.         "\x00\x03\x02\x01\x00\x02\x01\x03\x02\x03\x00\x01\x02",
  1412.         "\x03\x00\x01\x02\x03\x01\x02\x00\x01\x00\x03\x02\x01",
  1413.         0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  1414. }
  1416. END_SCOPE(objects)
  1417. END_NCBI_SCOPE
  1419. /*
  1420. * ===========================================================================
  1421. *
  1422. * $Log: test_helper.cpp,v $
  1423. * Revision 1000.4  2004/06/01 19:25:11  gouriano
  1424. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.58
  1425. *
  1426. * Revision 1.58  2004/05/21 21:42:14  gorelenk
  1427. * Added PCH ncbi_pch.hpp
  1428. *
  1429. * Revision 1.57  2004/04/01 20:18:12  grichenk
  1430. * Added initialization of m_MultiId member.
  1431. *
  1432. * Revision 1.56  2004/03/31 22:35:17  grichenk
  1433. * Fixed number of features found
  1434. *
  1435. * Revision 1.55  2004/03/24 18:30:30  vasilche
  1436. * Fixed edit API.
  1437. * Every *_Info object has its own shallow copy of original object.
  1438. *
  1439. * Revision 1.54  2004/03/23 15:14:01  vasilche
  1440. * Restored automatic call to Parentize() for Seq-entries in object manager.
  1441. *
  1442. * Revision 1.53  2004/03/18 16:30:24  grichenk
  1443. * Changed type of seq-align containers from list to vector.
  1444. *
  1445. * Revision 1.52  2004/03/16 15:47:28  vasilche
  1446. * Added CBioseq_set_Handle and set of EditHandles
  1447. *
  1448. * Revision 1.51  2004/02/09 19:18:55  grichenk
  1449. * Renamed CDesc_CI to CSeq_descr_CI. Redesigned CSeq_descr_CI
  1450. * and CSeqdesc_CI to avoid using data directly.
  1451. *
  1452. * Revision 1.50  2004/02/03 17:58:50  vasilche
  1453. * Always test CScope::RemoveEntry() in single thread.
  1454. *
  1455. * Revision 1.49  2003/12/22 22:32:10  grichenk
  1456. * Enabled RemoveEntry/AttachEntry test in non-MT builds.
  1457. *
  1458. * Revision 1.48  2003/12/18 18:14:47  grichenk
  1459. * Removed test for CScope::RemoveEntry() since it breaks MT test.
  1460. *
  1461. * Revision 1.47  2003/12/18 16:38:07  grichenk
  1462. * Added CScope::RemoveEntry()
  1463. *
  1464. * Revision 1.46  2003/11/10 18:12:09  grichenk
  1465. * Removed extra EFlags declaration from seq_map_ci.hpp
  1466. *
  1467. * Revision 1.45  2003/11/04 16:21:37  grichenk
  1468. * Updated CAnnotTypes_CI to map whole features instead of splitting
  1469. * them by sequence segments.
  1470. *
  1471. * Revision 1.44  2003/09/30 16:22:05  vasilche
  1472. * Updated internal object manager classes to be able to load ID2 data.
  1473. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  1474. * Scope caches results of requests for data to data loaders.
  1475. * Optimized CSeq_id_Handle for gis.
  1476. * Optimized bioseq lookup in scope.
  1477. * Reduced object allocations in annotation iterators.
  1478. * CScope is allowed to be destroyed before other objects using this scope are
  1479. * deleted (feature iterators, bioseq handles etc).
  1480. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  1481. * Added 'adaptive' option to objmgr_demo application.
  1482. *
  1483. * Revision 1.43  2003/09/05 18:45:10  grichenk
  1484. * Fixed exceptions
  1485. *
  1486. * Revision 1.42  2003/07/14 21:13:27  grichenk
  1487. * Added possibility to resolve seq-map iterator withing a single TSE
  1488. * and to skip intermediate references during this resolving.
  1489. *
  1490. * Revision 1.41  2003/06/12 18:39:46  vasilche
  1491. * Chech CSeqVector assignment.
  1492. *
  1493. * Revision 1.40  2003/06/02 21:04:25  vasilche
  1494. * Fixed CSeqVector_CI test to not to go beyond begin().
  1495. *
  1496. * Revision 1.39  2003/06/02 16:06:39  dicuccio
  1497. * Rearranged src/objects/ subtree.  This includes the following shifts:
  1498. *     - src/objects/asn2asn --> arc/app/asn2asn
  1499. *     - src/objects/testmedline --> src/objects/ncbimime/test
  1500. *     - src/objects/objmgr --> src/objmgr
  1501. *     - src/objects/util --> src/objmgr/util
  1502. *     - src/objects/alnmgr --> src/objtools/alnmgr
  1503. *     - src/objects/flat --> src/objtools/flat
  1504. *     - src/objects/validator --> src/objtools/validator
  1505. *     - src/objects/cddalignview --> src/objtools/cddalignview
  1506. * In addition, libseq now includes six of the objects/seq... libs, and libmmdb
  1507. * replaces the three libmmdb? libs.
  1508. *
  1509. * Revision 1.37  2003/05/28 16:20:16  vasilche
  1510. * Added check for REF segments.
  1511. *
  1512. * Revision 1.36  2003/05/27 19:44:07  grichenk
  1513. * Added CSeqVector_CI class
  1514. *
  1515. * Revision 1.35  2003/05/23 16:32:54  vasilche
  1516. * Added tests for backward traversal of CSeqMap_CI.
  1517. *
  1518. * Revision 1.34  2003/05/12 19:17:42  vasilche
  1519. * Added initialization of mandatory field.
  1520. *
  1521. * Revision 1.33  2003/05/09 20:34:23  grichenk
  1522. * Reverted to 1.31
  1523. *
  1524. * Revision 1.32  2003/05/09 20:28:03  grichenk
  1525. * Changed warnings to info
  1526. *
  1527. * Revision 1.31  2003/04/24 16:12:39  vasilche
  1528. * Object manager internal structures are splitted more straightforward.
  1529. * Removed excessive header dependencies.
  1530. *
  1531. * Revision 1.30  2003/03/26 14:30:23  lavr
  1532. * Conform to modified representation of NUL char in NStr::PrintableString()
  1533. *
  1534. * Revision 1.29  2003/03/21 14:52:28  vasilche
  1535. * Modified testobjmgr1 to reflect changes in CFeat_CI and CAlign_CI
  1536. * constructors' behaviour.
  1537. *
  1538. * Revision 1.28  2003/03/05 20:56:44  vasilche
  1539. * SAnnotSelector now holds all parameters of annotation iterators.
  1540. *
  1541. * Revision 1.27  2003/03/04 16:43:53  grichenk
  1542. * +Test CFeat_CI with eResolve_All flag
  1543. *
  1544. * Revision 1.26  2003/02/28 16:37:47  vasilche
  1545. * Fixed expected feature count.
  1546. * Added optional flags to testobjmgr to dump generated data and found features.
  1547. *
  1548. * Revision 1.25  2003/01/24 20:13:38  vasilche
  1549. * Added check for empty CSeqVector from CBioseq_Handle::GetSequenceView().
  1550. *
  1551. * Revision 1.24  2003/01/22 20:11:55  vasilche
  1552. * Merged functionality of CSeqMapResolved_CI to CSeqMap_CI.
  1553. * CSeqMap_CI now supports resolution and iteration over sequence range.
  1554. * Added several caches to CScope.
  1555. * Optimized CSeqVector().
  1556. * Added serveral variants of CBioseqHandle::GetSeqVector().
  1557. * Tried to optimize annotations iterator (not much success).
  1558. * Rewritten CHandleRange and CHandleRangeMap classes to avoid sorting of list.
  1559. *
  1560. * Revision 1.23  2003/01/22 19:25:11  ucko
  1561. * Avoid use of xobjutil.
  1562. *
  1563. * Revision 1.22  2002/12/26 20:34:53  ucko
  1564. * Drop unused header <sstream>, which older compilers (such as GCC 2.9x) lack;
  1565. * move CVS log to end.
  1566. *
  1567. * Revision 1.21  2002/12/26 16:39:24  vasilche
  1568. * Object manager class CSeqMap rewritten.
  1569. *
  1570. * Revision 1.20  2002/12/20 20:54:25  grichenk
  1571. * Added optional location/product switch to CFeat_CI
  1572. *
  1573. * Revision 1.19  2002/12/19 20:18:57  grichenk
  1574. * Fixed test case for minus strand location
  1575. *
  1576. * Revision 1.18  2002/11/08 19:43:37  grichenk
  1577. * CConstRef<> constructor made explicit
  1578. *
  1579. * Revision 1.17  2002/09/10 19:55:54  grichenk
  1580. * Catch exceptions when resolving seq-maps; new arguments for GetSeqVector()
  1581. *
  1582. * Revision 1.16  2002/07/25 15:01:53  grichenk
  1583. * Replaced non-const GetXXX() with SetXXX()
  1584. *
  1585. * Revision 1.15  2002/07/03 14:40:46  ucko
  1586. * Use typedef rather than hard-coded type for Dense_diag.ids.
  1587. *
  1588. * Revision 1.14  2002/06/07 16:13:24  ucko
  1589. * GetTitle() is now in sequence::.
  1590. *
  1591. * Revision 1.13  2002/06/06 19:49:54  clausen
  1592. * Changed CBioseq_Handle::GetTitle() call to GetTitle()
  1593. *
  1594. * Revision 1.12  2002/05/24 14:57:14  grichenk
  1595. * SerialAssign<>() -> CSerialObject::Assign()
  1596. *
  1597. * Revision 1.11  2002/05/21 18:39:31  grichenk
  1598. * CBioseq_Handle::GetResolvedSeqMap() -> CreateResolvedSeqMap()
  1599. *
  1600. * Revision 1.10  2002/05/09 14:21:50  grichenk
  1601. * Turned GetTitle() test on, removed unresolved seq-map test
  1602. *
  1603. * Revision 1.9  2002/05/06 03:28:53  vakatov
  1604. * OM/OM1 renaming
  1605. *
  1606. * Revision 1.8  2002/05/03 21:28:12  ucko
  1607. * Introduce T(Signed)SeqPos.
  1608. *
  1609. * Revision 1.7  2002/04/25 18:15:25  grichenk
  1610. * Adjusted tests to work with the updated CSeqVector
  1611. *
  1612. * Revision 1.6  2002/04/23 15:26:07  gouriano
  1613. * added test_assert.h
  1614. *
  1615. * Revision 1.5  2002/04/22 20:07:45  grichenk
  1616. * Commented calls to CBioseq::ConstructExcludedSequence()
  1617. *
  1618. * Revision 1.4  2002/04/22 18:33:48  gouriano
  1619. * corrected feature counts
  1620. *
  1621. * Revision 1.3  2002/03/28 21:22:38  grichenk
  1622. * More tests for location-exclusive bioseq
  1623. *
  1624. * Revision 1.2  2002/03/18 21:47:15  grichenk
  1625. * Moved most includes to test_helper.cpp
  1626. * Added test for CBioseq::ConstructExcludedSequence()
  1627. *
  1628. * Revision 1.1  2002/03/13 18:06:31  gouriano
  1629. * restructured MT test. Put common functions into a separate file
  1630. *
  1631. * ===========================================================================
  1632. */