test_helper.cpp

ncbi源码

            "TestEntry1a --------------------" << NcbiEndl;
        auto_ptr<CObjectOStream>
            out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
        *out << *entry;
    }
    return *entry.Release();
}


/************************************************************************
    1.2.1.3. Bio sequences for testing
    Test entry = 1 top-level entry + 3 sub-entries
    TSE
        one annotation (Seq_feat), which refers to ids 12+1000i and 21+1000i
    1 sub-entry
        two Seq_ids: local and GI, (local id = 21+1000i)
        one description
        segmented sequence: references to
            an interval, ( id= 11+1000i)
            whole seq,   ( id= 12+1000i)
            self         ( id= 21+1000i)
        two annotations (Seq_feat)
            both - for an interval,  local Seq_id = 11+1000i
    2 sub-entry
        two Seq_ids: local and GI, (local id = 22+1000i)
        continuous sequence
    3 sub-entry
        two Seq_ids: local and GI, (local id = 23+1000i)
        continuous sequence
        conversion from one seq.data format to another
************************************************************************/
CSeq_entry& CDataGenerator::CreateTestEntry2(int index)
{
    // create top level seq entry
    CRef<CSeq_entry> entry(new CSeq_entry);
    CBioseq_set& set = entry->SetSet();
    // class = nucleic acid and coded proteins
    set.SetClass(CBioseq_set::eClass_nuc_prot);
    list< CRef<CSeq_entry> >& seq_set = set.SetSeq_set();

    // Sub-entry Seq 21
    {{
        CRef<CSeq_entry> sub_entry(new CSeq_entry);
        CBioseq& seq = sub_entry->SetSeq();
        CBioseq::TId& id_list = seq.SetId();

        // list of Ids (local + gi)
        CRef<CSeq_id> id(new CSeq_id);
        id->SetLocal().SetStr("seq"+NStr::IntToString(21+index*1000));
        id_list.push_back(id);
        id.Reset(new CSeq_id);
        id->SetGi(21+index*1000);
        id_list.push_back(id);

        // Description (name)
        list< CRef<CSeqdesc> >& descr1 = seq.SetDescr().Set();
        CRef<CSeqdesc> desc1(new CSeqdesc);
        desc1->SetName("D3 from bioseq 21-"+NStr::IntToString(index));
        descr1.push_back(desc1);

        // Instance (sequence data)
        CSeq_inst& inst = seq.SetInst();
        // representation class = segmented sequence
        inst.SetRepr(CSeq_inst::eRepr_seg);
        // molecule class in living organism = dna
        inst.SetMol(CSeq_inst::eMol_dna);
        // segments = list of Seq_locs
        CSeg_ext::Tdata& seg_list = inst.SetExt().SetSeg();

        // Seq_interval (gi)
        CRef<CSeq_loc> loc(new CSeq_loc);
        CSeq_interval& ref_loc = loc->SetInt();
        ref_loc.SetId().SetGi(11+index*1000);
        ref_loc.SetFrom(0);
        ref_loc.SetTo(4);
        seg_list.push_back(loc);

        // whole sequence (gi)
        loc = new CSeq_loc;
        loc->SetWhole().SetGi(12+index*1000);
        seg_list.push_back(loc);

        // Seq_interval (gi)
        loc = new CSeq_loc;
        CSeq_interval& ref_loc2 = loc->SetInt();
        // "simple" self-reference
        ref_loc2.SetId().SetGi(21+index*1000);
        ref_loc2.SetFrom(0);
        ref_loc2.SetTo(9);
        seg_list.push_back(loc);

        // More complicated self-reference
        loc = new CSeq_loc;
        CSeq_interval& ref_loc3 = loc->SetInt();
        ref_loc3.SetId().SetGi(21+index*1000);
        ref_loc3.SetFrom(54);
        ref_loc3.SetTo(60);
        seg_list.push_back(loc);

        inst.SetStrand(CSeq_inst::eStrand_ds);

        // Annotations
        list< CRef<CSeq_annot> >& annot_list = seq.SetAnnot();
        CRef<CSeq_annot> annot(new CSeq_annot);
        // list of features
        list< CRef<CSeq_feat> >& ftable = annot->SetData().SetFtable();
        {{
            CRef<CSeq_feat> feat(new CSeq_feat);
            // feature Id
            feat->SetId().SetLocal().SetStr("F5: lcl|11");
            // the specific data
            CSeqFeatData& fdata = feat->SetData();
            CCdregion& cdreg = fdata.SetCdregion();
            cdreg.SetFrame(CCdregion::eFrame_one);
            // genetic code used
            list< CRef< CGenetic_code::C_E > >& gcode = cdreg.SetCode().Set();
            CRef< CGenetic_code::C_E > ce(new CGenetic_code::C_E);
            ce->SetId(215); // TSE=2; seq=1; feat=5
            gcode.push_back(ce);
            // feature location on the sequence: Seq_interval (local seq_Id)
            CSeq_interval& floc = feat->SetLocation().SetInt();
            floc.SetId().SetLocal().SetStr
                ("seq"+NStr::IntToString(11+index*1000));
            floc.SetFrom(20);
            floc.SetTo(30);
            // plus strand
            floc.SetStrand(eNa_strand_plus);
            ftable.push_back(feat);
        }}
        {{
            CRef<CSeq_feat> feat(new CSeq_feat);
            // feature Id
            feat->SetId().SetLocal().SetStr("F6: gi|11");
            // the specific data
            CSeqFeatData& fdata = feat->SetData();
            CCdregion& cdreg = fdata.SetCdregion();
            cdreg.SetFrame(CCdregion::eFrame_one);
            // genetic code used
            list< CRef< CGenetic_code::C_E > >& gcode = cdreg.SetCode().Set();
            CRef< CGenetic_code::C_E > ce(new CGenetic_code::C_E);
            ce->SetId(216); // TSE=2; seq=1; feat=6
            gcode.push_back(ce);
            // feature location on the sequence: Seq_interval (gi seq_Id)
            CSeq_interval& floc = feat->SetLocation().SetInt();
            floc.SetId().SetGi(11+index*1000);
            floc.SetFrom(5);
            floc.SetTo(15);
            ftable.push_back(feat);
        }}
        annot_list.push_back(annot);

        // Add sub-entry
        seq_set.push_back(sub_entry);
    }}

    // Sub-entry Seq 22
    {{
        CRef<CSeq_entry> sub_entry(new CSeq_entry);
        CBioseq& seq = sub_entry->SetSeq();
        CBioseq::TId& id_list = seq.SetId();

        // list of Ids (local + gi)
        CRef<CSeq_id> id(new CSeq_id);
        id->SetLocal().SetStr
            ("seq"+NStr::IntToString(22+index*1000));
        id_list.push_back(id);
        id.Reset(new CSeq_id);
        id->SetGi(22+index*1000);
        id_list.push_back(id);

        // Instance (sequence data)
        CSeq_inst& inst = seq.SetInst();
        // representation class = continuous sequence
        inst.SetRepr(CSeq_inst::eRepr_raw);
        // molecule class in living organism = aa (amino acid)
        inst.SetMol(CSeq_inst::eMol_aa);
        // length of sequence in residues
        inst.SetLength(20);
        // seq data in Ncbieaa
        inst.SetSeq_data().SetNcbieaa().Set("QGCGEQTMTLLAPTLAASRY");
        // single strand
        inst.SetStrand(CSeq_inst::eStrand_ss);

        // Add sub-entry
        seq_set.push_back(sub_entry);
    }}

    // Sub-entry Seq 23
    {{
        CRef<CSeq_entry> sub_entry(new CSeq_entry);
        CBioseq& seq = sub_entry->SetSeq();
        CBioseq::TId& id_list = seq.SetId();

        // list of Ids (local + gi)
        CRef<CSeq_id> id(new CSeq_id);
        id->SetLocal().SetStr
            ("seq"+NStr::IntToString(23+index*1000));
        id_list.push_back(id);
        id.Reset(new CSeq_id);
        id->SetGi(23+index*1000);
        id_list.push_back(id);

        // Instance (sequence data)
        CSeq_inst& inst = seq.SetInst();
        // representation class = continuous sequence
        inst.SetRepr(CSeq_inst::eRepr_raw);
        // molecule class in living organism = dna
        inst.SetMol(CSeq_inst::eMol_dna);
        // length of sequence in residues
        inst.SetLength(13);
        // seq data in Iupacna
        inst.SetSeq_data().SetIupacna().Set("ATGCAGCTGTACG");
        // double strand
        inst.SetStrand(CSeq_inst::eStrand_ds);

        CRef<CSeq_data> packed_data(new CSeq_data);
        // convert seq data to another format
        // (NCBI2na = 2 bit nucleic acid code)
        CSeqportUtil::Convert(inst.GetSeq_data(),
                              packed_data,
                              CSeq_data::e_Ncbi2na);
        inst.SetSeq_data(*packed_data);

        // Add sub-entry
        seq_set.push_back(sub_entry);
    }}

    // Annotations
    list< CRef<CSeq_annot> >& set_annot_list = set.SetAnnot();
    CRef<CSeq_annot> annot(new CSeq_annot);
    // list of features
    list< CRef<CSeq_feat> >& ftable = annot->SetData().SetFtable();
    {{
        CRef<CSeq_feat> feat(new CSeq_feat);
        // feature Id
        feat->SetId().SetLocal().SetStr("F7: lcl|21 + gi|12");
        // the specific data
        CSeqFeatData& fdata = feat->SetData();
        CCdregion& cdreg = fdata.SetCdregion();
        cdreg.SetFrame(CCdregion::eFrame_one);
        // genetic code used
        list< CRef< CGenetic_code::C_E > >& gcode = cdreg.SetCode().Set();
        CRef< CGenetic_code::C_E > ce(new CGenetic_code::C_E);
        ce->SetId(207); // TSE=2; no seq; feat=7
        gcode.push_back(ce);
        // feature location on the sequence: Seq_interval (local seq_Id)
        CSeq_interval& floc = feat->SetLocation().SetInt();
        floc.SetId().SetLocal().SetStr
            ("seq"+NStr::IntToString(21+index*1000));
        floc.SetFrom(1);
        floc.SetTo(20);
        // product of process (seq_loc = whole, gi)
        feat->SetProduct().SetWhole().SetGi(12+index*1000);
        ftable.push_back(feat);
    }}
    set_annot_list.push_back(annot);

    if ( sm_DumpEntries ) {
        NcbiCout << "-------------------- "
            "TestEntry2 --------------------" << NcbiEndl;
        auto_ptr<CObjectOStream>
            out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
        *out << *entry;
    }
    return *entry.Release();
}

/************************************************************************
    1.2.1.4. Bio sequences for testing
    Test entry = 1 top-level entry
    TSE
        only contains references to other sequences
************************************************************************/
CSeq_entry& CDataGenerator::CreateConstructedEntry(int idx, int index)
{
    CSeq_loc constr_loc;
    list< CRef<CSeq_interval> >& int_list = constr_loc.SetPacked_int();

    CRef<CSeq_interval> int_ref(new CSeq_interval);
    int_ref->SetId().SetGi(11+idx*1000);
    int_ref->SetFrom(5);
    int_ref->SetTo(10);
    if (index == 2) {
        int_ref->SetStrand(eNa_strand_minus);
    }
    int_list.push_back(int_ref);

    int_ref.Reset(new CSeq_interval);
    int_ref->SetId().SetGi(12+idx*1000);
    int_ref->SetFrom(0);
    int_ref->SetTo(20);
    int_list.push_back(int_ref);

    CRef<CBioseq> constr_seq(new CBioseq(constr_loc,
        "constructed"+NStr::IntToString(index)));
    CRef<CSeq_entry> constr_entry(new CSeq_entry);
    constr_entry->SetSeq(*constr_seq);
    if ( sm_DumpEntries ) {
        NcbiCout << "-------------------- "
            "ConstructedEntry --------------------" << NcbiEndl;
        auto_ptr<CObjectOStream>
            out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
        *out << *constr_entry;
    }
    return *constr_entry.Release();
}


/************************************************************************
    1.2.1.4. Bio sequences for testing
    Test entry = 1 top-level entry
    TSE
        Construct bioseq by excluding the seq-loc
************************************************************************/
/*
CSeq_entry& CDataGenerator::CreateConstructedExclusionEntry(int idx, int index)
{
    CSeq_loc loc;
    CSeq_loc_mix::Tdata& mix = loc.SetMix().Set();
    CRef<CSeq_loc> sl;

    sl.Reset(new CSeq_loc);
    sl->SetPnt().SetId().SetGi(11+idx*1000);
    sl->SetPnt().SetPoint(0);
    mix.push_back(sl);

    sl.Reset(new CSeq_loc);
    sl->SetInt().SetId().SetGi(11+idx*1000);
    sl->SetInt().SetFrom(0);
    sl->SetInt().SetTo(4);
    mix.push_back(sl);

    sl.Reset(new CSeq_loc);
    sl->SetInt().SetId().SetGi(11+idx*1000);
    sl->SetInt().SetFrom(10);
    sl->SetInt().SetTo(15);
    mix.push_back(sl);

    sl.Reset(new CSeq_loc);
    sl->SetInt().SetId().SetGi(11+idx*1000);
    sl->SetInt().SetFrom(10);
    sl->SetInt().SetTo(12);
    mix.push_back(sl);

    sl.Reset(new CSeq_loc);
    sl->SetInt().SetId().SetGi(11+idx*1000);
    sl->SetInt().SetFrom(13);
    sl->SetInt().SetTo(15);
    mix.push_back(sl);

    sl.Reset(new CSeq_loc);
    sl->SetInt().SetId().SetGi(11+idx*1000);
    sl->SetInt().SetFrom(8);
    sl->SetInt().SetTo(18);
    mix.push_back(sl);

    sl.Reset(new CSeq_loc);
    sl->SetPnt().SetId().SetGi(11+idx*1000);
    sl->SetPnt().SetPoint(20);
    mix.push_back(sl);

    sl.Reset(new CSeq_loc);
    sl->SetPnt().SetId().SetGi(11+idx*1000);
    sl->SetPnt().SetPoint(39);
    mix.push_back(sl);

    CRef<CBioseq> constr_ex_seq(&CBioseq::ConstructExcludedSequence(loc, 40,
        "construct_exclusion"+NStr::IntToString(index)));
    CRef<CSeq_entry> constr_ex_entry(new CSeq_entry);
    constr_ex_entry->SetSeq(*constr_ex_seq);
    return *constr_ex_entry.Release();
}
*/


CSeq_annot& CDataGenerator::CreateAnnotation1(int index)
{
    CRef<CSeq_annot> annot(new CSeq_annot);
    list< CRef<CSeq_feat> >& ftable = annot->SetData().SetFtable();
    {{
        CRef<CSeq_feat> feat(new CSeq_feat);
        feat->SetId().SetLocal().SetStr("attached feature");
        CSeqFeatData& fdata = feat->SetData();
        CCdregion& cdreg = fdata.SetCdregion();
        cdreg.SetFrame(CCdregion::eFrame_one);
        list< CRef< CGenetic_code::C_E > >& gcode = cdreg.SetCode().Set();
        CRef< CGenetic_code::C_E > ce(new CGenetic_code::C_E);
        ce->SetId(999);
        gcode.push_back(ce);
        feat->SetComment() = "Feature attached after indexing the entry";
        //feat->SetLocation().SetWhole().SetGi(11+index*1000);

        CSeq_interval& interval = feat->SetLocation().SetInt();
        interval.SetId().SetGi(11+index*1000);
        interval.SetFrom(1);
        interval.SetTo(9);
        interval.SetStrand(eNa_strand_unknown);

        ftable.push_back(feat);
    }}
    if ( sm_DumpEntries ) {
        NcbiCout << "-------------------- "
            "Annotation1 --------------------" << NcbiEndl;
        auto_ptr<CObjectOStream>
            out(CObjectOStream::Open(eSerial_AsnText, NcbiCout));
        *out << *annot;
    }
    return *annot.Release();
}