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

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

生物技术

开发平台：

C/C++

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