unit_test_validator.cpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/*  $Id: unit_test_validator.cpp 101299 2023-11-28 18:18:38Z stakhovv $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Author:  Colleen Bollin, NCBI
 *
 * File Description:
 *   Unit tests for the validator.
 *
 * ===========================================================================
 */
 
#include <ncbi_pch.hpp>
 
#include "unit_test_validator.hpp"
 
#include <corelib/ncbi_system.hpp>
 
// This macro should be defined before inclusion of test_boost.hpp in all
// "*.cpp" files inside executable except one. It is like function main() for
// non-Boost.Test executables is defined only in one *.cpp file - other files
// should not include it. If NCBI_BOOST_NO_AUTO_TEST_MAIN will not be defined
// then test_boost.hpp will define such "main()" function for tests.
//
// Usually if your unit tests contain only one *.cpp file you should not
// care about this macro at all.
//
//#define NCBI_BOOST_NO_AUTO_TEST_MAIN
 
#define BAD_VALIDATOR
 
// This header must be included before all Boost.Test headers if there are any
#include <corelib/test_boost.hpp>
 
// for ignoring external config files
#include <util/util_misc.hpp>
 
#include <objects/biblio/Id_pat.hpp>
#include <objects/biblio/Title.hpp>
#include <objects/general/Object_id.hpp>
#include <objects/general/Dbtag.hpp>
#include <objects/general/User_object.hpp>
#include <objects/medline/Medline_entry.hpp>
#include <objects/pub/Pub_equiv.hpp>
#include <objects/pub/Pub.hpp>
#include <objects/seqset/Seq_entry.hpp>
#include <objects/seq/GIBB_mol.hpp>
#include <objects/seq/Seq_ext.hpp>
#include <objects/seq/Delta_ext.hpp>
#include <objects/seq/Delta_seq.hpp>
#include <objects/seq/Seq_literal.hpp>
#include <objects/seq/Ref_ext.hpp>
#include <objects/seq/Map_ext.hpp>
#include <objects/seq/Seg_ext.hpp>
#include <objects/seq/Seq_gap.hpp>
#include <objects/seq/Seq_data.hpp>
#include <objects/seq/Seq_descr.hpp>
#include <objects/seq/Seqdesc.hpp>
#include <objects/seq/MolInfo.hpp>
#include <objects/seq/Pubdesc.hpp>
#include <objects/seq/Seq_hist.hpp>
#include <objects/seq/Seq_hist_rec.hpp>
#include <objects/seqalign/Dense_seg.hpp>
#include <objects/seqblock/GB_block.hpp>
#include <objects/seqblock/EMBL_block.hpp>
#include <objects/seqfeat/BioSource.hpp>
#include <objects/seqfeat/Org_ref.hpp>
#include <objects/seqfeat/OrgName.hpp>
#include <objects/seqfeat/SubSource.hpp>
#include <objects/seqfeat/Imp_feat.hpp>
#include <objects/seqfeat/Cdregion.hpp>
#include <objects/seqloc/Seq_id.hpp>
#include <objects/seqloc/PDB_seq_id.hpp>
#include <objects/seqloc/Giimport_id.hpp>
#include <objects/seqloc/Patent_seq_id.hpp>
#include <objects/seqloc/Seq_loc.hpp>
#include <objects/seqloc/Seq_interval.hpp>
#include <objects/taxon3/taxon3.hpp>
#include <objmgr/object_manager.hpp>
#include <objmgr/scope.hpp>
#include <objmgr/bioseq_ci.hpp>
#include <objmgr/feat_ci.hpp>
#include <objmgr/seq_vector.hpp>
#include <objmgr/util/sequence.hpp>
#include <objmgr/seqdesc_ci.hpp>
#include <objmgr/util/sequence.hpp>
#include <objects/seq/seqport_util.hpp>
#include <objtools/validator/validator.hpp>
#include <objtools/validator/validatorp.hpp>
#include <objtools/validator/utilities.hpp>
#include <objtools/validator/validerror_format.hpp>
#include <objtools/validator/translation_problems.hpp>
#include <objtools/validator/go_term_validation_and_cleanup.hpp>
#include <corelib/ncbiapp.hpp>
#include <common/ncbi_export.h>
#include <objtools/unit_test_util/unit_test_util.hpp>
#include <objtools/edit/struc_comm_field.hpp>
#include <objtools/edit/dblink_field.hpp>
#include <objtools/edit/cds_fix.hpp>
#include <objtools/validator/dup_feats.hpp>
 
// for writing out tmp files
#include <serial/objostrasn.hpp>
#include <serial/objostrasnb.hpp>
 
extern const std::string sc_TestEntryCollidingLocusTags;
 
BEGIN_NCBI_SCOPE
BEGIN_SCOPE(objects)
 
using namespace validator;
using namespace unit_test_util;
 
 
CExpectedError::CExpectedError(string accession, EDiagSev severity, string err_code, string err_msg)
: m_Accession (accession), m_Severity (severity), m_ErrCode(err_code), m_ErrMsg(err_msg)
{
}
 
CExpectedError::~CExpectedError()
{
}
 
 
bool CExpectedError::Match(const CValidErrItem& err_item, bool ignore_severity)
{
    if (!NStr::IsBlank(m_Accession) && !NStr::IsBlank(err_item.GetAccnver()) &&
        !NStr::Equal(err_item.GetAccnver(), m_Accession)) {
        return false;
    }
    if (!NStr::Equal(err_item.GetErrCode(), m_ErrCode)) {
        return false;
    }
    string msg = err_item.GetMsg();
    size_t pos = NStr::Find(msg, " EXCEPTION: NCBI C++ Exception:");
    if (pos != string::npos) {
        msg = msg.substr(0, pos);
    }
 
    if (!NStr::Equal(msg, m_ErrMsg)) {
        return false;
    }
    if (!ignore_severity && m_Severity != err_item.GetSeverity()) {
        return false;
    }
    return true;
}
 
 
void CExpectedError::Test(const CValidErrItem& err_item)
{
    if (!NStr::IsBlank (m_Accession) && !NStr::IsBlank (err_item.GetAccnver())) {
        BOOST_CHECK_EQUAL(err_item.GetAccnver(), m_Accession);
    }
    BOOST_CHECK_EQUAL(err_item.GetSeverity(), m_Severity);
    BOOST_CHECK_EQUAL(err_item.GetErrCode(), m_ErrCode);
    string msg = err_item.GetMsg();
    size_t pos = NStr::Find(msg, " EXCEPTION: NCBI C++ Exception:");
    if (pos != string::npos) {
        msg = msg.substr(0, pos);
    }
    BOOST_CHECK_EQUAL(msg, m_ErrMsg);
}
 
 
void CExpectedError::PrintSeenError(const CValidErrItem& err_item)
{
    string description = err_item.GetAccnver() + ":"
        + CValidErrItem::ConvertSeverity(err_item.GetSeverity()) + ":"
        + err_item.GetErrCode() + ":"
        + err_item.GetMsg();
    printf("%s\n", description.c_str());
 
}
 
 
void CExpectedError::Print() const
{
    string description = m_Accession + ":"
        + CValidErrItem::ConvertSeverity(m_Severity) + ":"
        + m_ErrCode + ":"
        + m_ErrMsg;
    printf("%s\n", description.c_str());
 
}
 
 
static bool s_debugMode = false;
 
void WriteErrors(const CValidError& eval, bool debug_mode)
{
    if (debug_mode) {
        printf ("\n-\n");
    }
    for ( CValidError_CI vit(eval); vit; ++vit) {
        CExpectedError::PrintSeenError(*vit);
    }
    if (debug_mode) {
        printf ("\n\n");
    }
        printf ("\n\n");
}
 
 
void CheckErrors(const CValidError& eval,
                 vector< CExpectedError* >& expected_errors)
{
    //static int count(1);
    //if (count == 1367) {
    //    cerr << "";
    //}
    //cerr << count++ << "\n";
 
    bool   problem_found = false;
 
    if (s_debugMode) {
        WriteErrors (eval, true);
        return;
    }
 
    vector<bool> expected_found;
    for (size_t i = 0; i < expected_errors.size(); i++) {
        if (expected_errors[i]) {
            expected_found.push_back(false);
        } else {
            expected_found.push_back(true);
        }
    }
 
    for (CValidError_CI vit(eval); vit; ++vit) {
        bool found = false;
        for (size_t i = 0; i < expected_errors.size(); i++) {
            if (!expected_found[i] && expected_errors[i]->Match(*vit)) {
                expected_found[i] = true;
                found = true;
                break;
            }
        }
        if (!found) {
            for (size_t i = 0; i < expected_errors.size(); i++) {
                if (!expected_found[i] && expected_errors[i]->Match(*vit, true)) {
                    printf("Problem with ");
                    CExpectedError::PrintSeenError(*vit);
                    expected_errors[i]->Test(*vit);
                    expected_found[i] = true;
                    found = true;
                    problem_found = true;
                    break;
                }
            }
        }
        if (!found) {
            BOOST_CHECK_EQUAL("Unexpected error", "Error not found");
            CExpectedError::PrintSeenError(*vit);
            problem_found = true;
        }
    }
 
    for (size_t i = 0; i < expected_errors.size(); i++) {
        if (!expected_found[i]) {
            BOOST_CHECK_EQUAL(expected_errors[i]->GetErrMsg(), "Expected error not found");
            problem_found = true;
        }
    }
 
    if (problem_found) {
        WriteErrors (eval, false);
 
        printf("Expected:\n");
        for (auto it : expected_errors) {
            if (it) {
                it->Print();
            }
        }
    }
}
 
 
void CheckStrings(const vector<string>& seen, const vector<string>& expected)
{
    auto it1 = seen.begin();
    auto it2 = expected.begin();
    bool any = false;
    while (it1 != seen.end() && it2 != expected.end()) {
        BOOST_CHECK_EQUAL(*it1, *it2);
        if (!NStr::Equal(*it1, *it2)) {
            any = true;
        }
        it1++;
        it2++;
    }
    while (it1 != seen.end()) {
        BOOST_CHECK_EQUAL(*it1, "Unexpected string");
        it1++;
        any = true;
    }
    while (it2 != expected.end()) {
        BOOST_CHECK_EQUAL("Missing string", *it2);
        it2++;
        any = true;
    }
 
    if (any) {
        printf("Seen:\n");
        auto it1 = seen.begin();
        while (it1 != seen.end()) {
            printf("%s\n", (*it1).c_str());
            it1++;
        }
        printf("Expected:\n");
        auto it2 = expected.begin();
        while (it2 != expected.end()) {
            printf("%s\n", (*it2).c_str());
            it2++;
        }
    }
}
 
 
// Not currently used, but I'll leave it here in case
// it's useful in the future.
 
#if 0
static void SetCountryOnSrc(CBioSource& src, string country)
{
    if (NStr::IsBlank(country)) {
        if (src.IsSetSubtype()) {
            auto& cont = src.SetSubtype();
            cont.remove_if(
                [](CSubSource* it) { return (it->IsSetSubtype() && it->GetSubtype() == CSubSource::eSubtype_country); });
        }
    } else {
        CRef<CSubSource> sub(new CSubSource(CSubSource::eSubtype_country, country));
        src.SetSubtype().push_back(sub);
    }
}
#endif
 
NCBI_UNUSED
static string ToAsn1(const CRef<CSeq_entry>& entry)
{
    CNcbiOstrstream os;
    os << MSerial_AsnText << entry;
    return os.str();
}
 
END_SCOPE(objects)
END_NCBI_SCOPE
 
USING_NCBI_SCOPE;
USING_SCOPE(objects);
 
NCBITEST_INIT_TREE()
{
    if ( !CNcbiApplication::Instance()->GetConfig().HasEntry("NCBI", "Data") ) {
        NCBITEST_DISABLE(Test_Descr_BadStructuredCommentFormat);
        NCBITEST_DISABLE(Test_Descr_MissingKeyword);
    }
}
 
 
static void SetErrorsAccessions (vector< CExpectedError *> & expected_errors, string accession)
{
    size_t i, len = expected_errors.size();
    for (i = 0; i < len; i++) {
        expected_errors[i]->SetAccession(accession);
    }
}
 
NCBITEST_INIT_CMDLINE(arg_desc)
{
    // Here we make descriptions of command line parameters that we are
    // going to use.
 
    arg_desc->AddFlag( "debug_mode",
        "Debugging mode writes errors seen for each test" );
}
 
NCBITEST_AUTO_INIT()
{
    // initialization function body
 
    const CArgs& args = CNcbiApplication::Instance()->GetArgs();
    if (args["debug_mode"]) {
        s_debugMode = true;
    }
    g_IgnoreDataFile("institution_codes.txt");
}
 
void AddChromosomeNoLocation(vector< CExpectedError *>& expected_errors, const string& id)
{
    expected_errors.push_back(new CExpectedError(id, eDiag_Error, "ChromosomeWithoutLocation",
        "INDEXER_ONLY - source contains chromosome value '1' but the BioSource location is not set to chromosome"));
}
 
void AddChromosomeNoLocation(vector< CExpectedError *>& expected_errors, CRef<CSeq_entry> entry)
{
    if (entry->IsSeq()) {
        CConstRef<CSeq_id> seqid = sequence::GetId(entry->GetSeq(), sequence::eGetId_Best).GetSeqId();
        AddChromosomeNoLocation(expected_errors, seqid->AsFastaString());
    } else if (entry->IsSet()) {
        if (entry->GetSet().GetClass() == CBioseq_set::eClass_nuc_prot) {
            CRef<CSeq_entry> nuc_entry = unit_test_util::GetNucleotideSequenceFromGoodNucProtSet(entry);
            AddChromosomeNoLocation(expected_errors, nuc_entry);
        } else {
            for (auto it : entry->SetSet().SetSeq_set()) {
                AddChromosomeNoLocation(expected_errors, it);
            }
        }
    }
}
 
 
// new case test ground
 
BOOST_AUTO_TEST_CASE(Test_Descr_MissingKeyword)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    CRef<CSeqdesc> sdesc(new CSeqdesc());
    sdesc->SetUser().SetType().SetStr("StructuredComment");
    entry->SetSeq().SetDescr().Set().push_back(sdesc);
 
    sdesc->SetUser().AddField("StructuredCommentPrefix", "##MIGS-Data-START##", CUser_object::eParse_String);
    sdesc->SetUser().AddField("alt_elev", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("assembly", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("collection_date", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("country", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("depth", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("environment", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("investigation_type", "eukaryote", CUser_object::eParse_String);
    sdesc->SetUser().AddField("isol_growth_condt", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("sequencing_meth", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("project_name", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("ploidy", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("num_replicons", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("estimated_size", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("trophic_level", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("propagation", "foo", CUser_object::eParse_String);
    sdesc->SetUser().AddField("lat_lon", "foo", CUser_object::eParse_String);
 
    CRef<CSeqdesc> gdesc(new CSeqdesc());
    gdesc->SetGenbank().SetKeywords().push_back("GSC:MIGS:2.1");
    entry->SetSeq().SetDescr().Set().push_back(gdesc);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "BadKeywordForStrucComm",
        "Structured Comment is non-compliant, keyword should be removed"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "BadStrucCommMissingField",
        "Required field finishing_strategy is missing when investigation_type has value 'eukaryote'"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "BadStrucCommInvalidFieldValue",
        "Structured Comment invalid; the field value and/or name are incorrect"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // if no keyword, no badkeyword error
    entry->SetSeq().SetDescr().Set().pop_back();
    delete expected_errors[0];
    expected_errors[0] = nullptr;
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // make the comment valid, should complain about missing keyword
    sdesc->SetUser().AddField("finishing_strategy", "foo", CUser_object::eParse_String);
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
    // put keyword back, should have no errors
    entry->SetSeq().SetDescr().Set().push_back(gdesc);
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_Descr_LatLonValue)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_country, "USA");
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_lat_lon, "35 S 80 W");
 
    STANDARD_SETUP
 
    /*
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "LatLonValue",
                              "Latitude should be set to N (northern hemisphere)"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    */
 
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_lat_lon, "");
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_lat_lon, "35 N 80 E");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "LatLonValue",
                              "Longitude should be set to W (western hemisphere)"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_country, "");
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_country, "Madagascar");
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_lat_lon, "");
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_lat_lon, "25 N 47 E");
    expected_errors[0]->SetErrMsg("Latitude should be set to S (southern hemisphere)");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    /*
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_lat_lon, "");
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_lat_lon, "25 S 47 W");
    expected_errors[0]->SetErrMsg("Longitude should be set to E (eastern hemisphere)");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    */
 
    CLEAR_ERRORS
 
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_lat_lon, "");
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_lat_lon, "15 N 47 E");
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_country, "");
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_country, "Austria");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "LatLonValue",
                              "Latitude and longitude values appear to be exchanged"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
void TestOneLatLonCountry(const string& country, const string& lat_lon, const string& error, bool use_state = false, const string& err_code = "LatLonCountry")
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_country, country);
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_lat_lon, lat_lon);
 
    STANDARD_SETUP
 
    if (use_state) {
        options |= CValidator::eVal_latlon_check_state;
    }
 
    if (!error.empty()) {
        expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, err_code, error));
    }
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    if (!error.empty()) {
        CValidErrorFormat format(*objmgr);
        vector<string> expected;
        expected.push_back("LatLonCountry Errors");
        expected.push_back("lcl|good:" + error);
        expected.push_back("");
 
        vector<string> seen;
        vector<string> cat_list = format.FormatCompleteSubmitterReport(*eval, scope);
        for (const string& it : cat_list) {
            vector<string> sublist;
            NStr::Split(it, "\n", sublist);
            for (const string& sit : sublist) {
                seen.push_back(sit);
            }
        }
 
        CheckStrings(seen, expected);
    }
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_VR_840)
{
    TestOneLatLonCountry("Portugal", "37.7715 N 25.3097 W", "", true);
}
 
 
 
BOOST_AUTO_TEST_CASE(Test_Descr_LatLonCountry)
{
    TestOneLatLonCountry("Romania", "46.5 N 20 E",
        "Lat_lon '46.5 N 20 E' maps to 'Hungary' instead of 'Romania' - claimed region 'Romania' is at distance 45 km");
    TestOneLatLonCountry("Romania", "34 N 65 E", "Lat_lon '34 N 65 E' maps to 'Afghanistan' instead of 'Romania'");
    TestOneLatLonCountry("Romania", "48 N 15 E", "Lat_lon '48 N 15 E' maps to 'Austria' instead of 'Romania'");
    TestOneLatLonCountry("Romania", "48 N 15 W", "Lat_lon '48 N 15 W' is in water 'Atlantic Ocean'", false, "LatLonWater");
    // RW-1137 this had inconsistent behavior in production vs. development tests, possibly due to version skew in
    // Puerto Rico cleanup code, so commenting out to avoid spurious error reports
    /*
    TestOneLatLonCountry("Puerto Rico: Rio Mameyes in Luquillo", "18.47 N 64.23000000000002 W",
        "Lat_lon '18.47 N 64.23000000000002 W' is in water 'Caribbean Sea', 'Puerto Rico: Rio Mameyes in Luquillo' is 108 km away",
        false, "LatLonWater");
    */
 
}
 
 
BOOST_AUTO_TEST_CASE(Test_ValidError_Format)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodNucProtSet();
 
    // Create consensus splice problems
    CRef<CSeq_feat> cds = unit_test_util::GetCDSFromGoodNucProtSet(entry);
    CRef<CSeq_entry> nuc = unit_test_util::GetNucleotideSequenceFromGoodNucProtSet(entry);
    cds->SetLocation().Assign(*unit_test_util::MakeMixLoc(nuc->SetSeq().SetId().front()));
    nuc->SetSeq().SetInst().SetSeq_data().SetIupacna().Set()[44] = 'A';
    nuc->SetSeq().SetInst().SetSeq_data().SetIupacna().Set()[45] = 'G';
    CRef<CSeq_feat> intron = unit_test_util::MakeIntronForMixLoc(nuc->SetSeq().SetId().front());
    unit_test_util::AddFeat(intron, nuc);
 
    CRef<CSeq_feat> other_intron = unit_test_util::AddMiscFeature(nuc);
    other_intron->SetData().SetImp().SetKey("intron");
    CRef<CSeq_feat> gene = MakeGeneForFeature(cds);
    gene->SetData().SetGene().SetLocus_tag("fake_locustag");
    AddFeat(gene, nuc);
 
    // create EC number problems
    CRef<CSeq_feat> prot = entry->GetSet().GetSeq_set().back()->GetAnnot().front()->GetData().GetFtable().front();
    prot->SetData().SetProt().SetEc().push_back("1.2.3.10");
    prot->SetData().SetProt().SetEc().push_back("1.1.3.22");
    prot->SetData().SetProt().SetEc().push_back("1.1.99.n");
    prot->SetData().SetProt().SetEc().push_back("1.1.1.17");
    prot->SetData().SetProt().SetEc().push_back("11.22.33.44");
    prot->SetData().SetProt().SetEc().push_back("11.22.n33.44");
    prot->SetData().SetProt().SetEc().push_back("11.22.33.n44");
 
 
    // create bad institution code errors
    unit_test_util::SetOrgMod(entry, COrgMod::eSubtype_specimen_voucher, "XXX:foo");
    unit_test_util::SetOrgMod(entry, COrgMod::eSubtype_culture_collection, "YYY:foo");
    unit_test_util::SetOrgMod(entry, COrgMod::eSubtype_bio_material, "ZZZ:foo");
 
    // create lat-lon country error
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_lat_lon, "30 N 30 E");
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_country, "Panama");
 
    STANDARD_SETUP
 
    eval = validator.Validate(seh, options);
 
    CValidErrorFormat format(*objmgr);
 
    vector<string> expected;
    expected.push_back("intron\tlcl|nuc\tGT at 17");
    expected.push_back("intron\tlcl|nuc\tGT at 1");
    expected.push_back("intron\tlcl|nuc\tAG at 11");
    expected.push_back("lcl|prot\t1.2.3.10;1.1.3.22;1.1.99.n;1.1.1.17;11.22.33.44;11.22.n33.44;11.22.33.n44\t\tfake protein name");
    expected.push_back("lcl|prot\t1.2.3.10;1.1.3.22;1.1.99.n;1.1.1.17;11.22.33.44;11.22.n33.44;11.22.33.n44\t\tfake protein name");
    expected.push_back("lcl|prot\t1.2.3.10;1.1.3.22;1.1.99.n;1.1.1.17;11.22.33.44;11.22.n33.44;11.22.33.n44\t\tfake protein name");
    expected.push_back("lcl|prot\t1.2.3.10;1.1.3.22;1.1.99.n;1.1.1.17;11.22.33.44;11.22.n33.44;11.22.33.n44\t\tfake protein name");
    expected.push_back("lcl|prot\t1.2.3.10;1.1.3.22;1.1.99.n;1.1.1.17;11.22.33.44;11.22.n33.44;11.22.33.n44\t\tfake protein name");
    expected.push_back("CDS\tlcl|nuc\tGT at 16");
    expected.push_back("lcl|nuc:Lat_lon '30 N 30 E' maps to 'Egypt' instead of 'Panama'");
    expected.push_back("lcl|nuc\tXXX;YYY;ZZZ");
    expected.push_back("lcl|nuc\tXXX;YYY;ZZZ");
    expected.push_back("lcl|nuc\tXXX;YYY;ZZZ");
 
    vector<string> seen;
    for (CValidError_CI vit(*eval); vit; ++vit) {
        string val = format.FormatForSubmitterReport(*vit, scope);
        seen.push_back(val);
    }
    CheckStrings(seen, expected);
 
    expected.clear();
    seen.clear();
    for (CValidError_CI vit(*eval); vit; ++vit) {
        seen.push_back(vit->GetErrCode());
    }
    expected.push_back("NotSpliceConsensusDonor");
    expected.push_back("NotSpliceConsensusDonorTerminalIntron");
    expected.push_back("NotSpliceConsensusAcceptor");
    expected.push_back("DeletedEcNumber");
    expected.push_back("ReplacedEcNumber");
    expected.push_back("BadEcNumberValue");
    expected.push_back("BadEcNumberFormat");
    expected.push_back("BadEcNumberValue");
    expected.push_back("NotSpliceConsensusDonor");
    expected.push_back("LatLonCountry");
    expected.push_back("BadInstitutionCode");
    expected.push_back("BadInstitutionCode");
    expected.push_back("BadInstitutionCode");
    CheckStrings(seen, expected);
 
    seen.clear();
    expected.clear();
    vector<unsigned int> codes = format.GetListOfErrorCodes(*eval);
    for (unsigned int it : codes) {
        string val = CValidErrItem::ConvertErrCode(it);
        seen.push_back(val);
    }
    expected.push_back("LatLonCountry");
    expected.push_back("BadInstitutionCode");
    expected.push_back("BadEcNumberFormat");
    expected.push_back("BadEcNumberValue");
    expected.push_back("NotSpliceConsensusDonor");
    expected.push_back("NotSpliceConsensusAcceptor");
    expected.push_back("DeletedEcNumber");
    expected.push_back("ReplacedEcNumber");
    expected.push_back("NotSpliceConsensusDonorTerminalIntron");
    CheckStrings(seen, expected);
 
    string rval = format.FormatForSubmitterReport(*eval, scope, eErr_SEQ_FEAT_NotSpliceConsensusDonor);
    expected.clear();
    seen.clear();
    NStr::Split(rval, "\n", seen);
    expected.push_back("Not Splice Consensus");
    expected.push_back("intron\tlcl|nuc\tGT at 17");
    expected.push_back("CDS\tlcl|nuc\tGT at 16");
    expected.push_back("");
    CheckStrings(seen, expected);
 
    rval = format.FormatCategoryForSubmitterReport(*eval, scope, eSubmitterFormatErrorGroup_ConsensusSplice);
    expected.clear();
    seen.clear();
    NStr::Split(rval, "\n", seen);
    expected.push_back("Not Splice Consensus");
    expected.push_back("intron\tlcl|nuc\tGT at 17");
    expected.push_back("intron\tlcl|nuc\tGT at 1");
    expected.push_back("intron\tlcl|nuc\tAG at 11");
    expected.push_back("CDS\tlcl|nuc\tGT at 16");
    expected.push_back("");
    CheckStrings(seen, expected);
 
    expected.clear();
    seen.clear();
    vector<string> cat_list = format.FormatCompleteSubmitterReport(*eval, scope);
    for (const string& it : cat_list) {
        vector<string> sublist;
        NStr::Split(it, "\n", sublist);
        for (const string& sit : sublist) {
            seen.push_back(sit);
        }
    }
    expected.push_back("Not Splice Consensus");
    expected.push_back("intron\tlcl|nuc\tGT at 17");
    expected.push_back("intron\tlcl|nuc\tGT at 1");
    expected.push_back("intron\tlcl|nuc\tAG at 11");
    expected.push_back("CDS\tlcl|nuc\tGT at 16");
    expected.push_back("");
    expected.push_back("EC Number Format");
    expected.push_back("lcl|prot\t1.2.3.10;1.1.3.22;1.1.99.n;1.1.1.17;11.22.33.44;11.22.n33.44;11.22.33.n44\t\tfake protein name");
    expected.push_back("");
    expected.push_back("EC Number Value");
    expected.push_back("lcl|prot\t1.2.3.10;1.1.3.22;1.1.99.n;1.1.1.17;11.22.33.44;11.22.n33.44;11.22.33.n44\t\tfake protein name");
    expected.push_back("lcl|prot\t1.2.3.10;1.1.3.22;1.1.99.n;1.1.1.17;11.22.33.44;11.22.n33.44;11.22.33.n44\t\tfake protein name");
    expected.push_back("lcl|prot\t1.2.3.10;1.1.3.22;1.1.99.n;1.1.1.17;11.22.33.44;11.22.n33.44;11.22.33.n44\t\tfake protein name");
    expected.push_back("lcl|prot\t1.2.3.10;1.1.3.22;1.1.99.n;1.1.1.17;11.22.33.44;11.22.n33.44;11.22.33.n44\t\tfake protein name");
    expected.push_back("");
    expected.push_back("Bad Institution Codes");
    expected.push_back("lcl|nuc\tXXX;YYY;ZZZ");
    expected.push_back("lcl|nuc\tXXX;YYY;ZZZ");
    expected.push_back("lcl|nuc\tXXX;YYY;ZZZ");
    expected.push_back("");
    expected.push_back("LatLonCountry Errors");
    expected.push_back("lcl|nuc:Lat_lon '30 N 30 E' maps to 'Egypt' instead of 'Panama'");
    expected.push_back("");
    CheckStrings(seen, expected);
 
}
 
 
BOOST_AUTO_TEST_CASE(Test_GB_6395)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    unit_test_util::SetTaxon(entry, 0);
 
    STANDARD_SETUP
 
    eval = validator.Validate(seh, options);
 
    CValidErrorFormat format(*objmgr);
    vector<string> expected;
    vector<string> seen;
 
    vector<string> cat_list = format.FormatCompleteSubmitterReport(*eval, scope);
    for (const string& it : cat_list) {
        vector<string> sublist;
        NStr::Split(it, "\n", sublist);
        for (const string& sit : sublist) {
            seen.push_back(sit);
        }
    }
    expected.push_back("NoTaxonID");
    expected.push_back("lcl|good:Sebaea microphylla");
    expected.push_back("");
 
    CheckStrings(seen, expected);
}
 
 
BOOST_AUTO_TEST_CASE(Test_Descr_LatLonState)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_country, "USA: South Carolina");
    unit_test_util::SetSubSource(entry, CSubSource::eSubtype_lat_lon, "36 N 80 W");
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "LatLonState",
    "Lat_lon '36 N 80 W' maps to 'USA: North Carolina' instead of 'USA: South Carolina' - claimed region 'USA: South Carolina' is at distance 130 km"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    options |= CValidator::eVal_latlon_check_state;
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
CRef<CSeq_entry> s_BuildBadEcNumberEntry()
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodNucProtSet ();
    CRef<CSeq_feat> prot = entry->GetSet().GetSeq_set().back()->GetAnnot().front()->GetData().GetFtable().front();
    prot->SetData().SetProt().SetEc().push_back("1.2.3.10");
    prot->SetData().SetProt().SetEc().push_back("1.1.3.22");
    prot->SetData().SetProt().SetEc().push_back("1.1.99.n");
    prot->SetData().SetProt().SetEc().push_back("1.1.1.17");
    prot->SetData().SetProt().SetEc().push_back("11.22.33.44");
    prot->SetData().SetProt().SetEc().push_back("11.22.n33.44");
    prot->SetData().SetProt().SetEc().push_back("11.22.33.n44");
    return entry;
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_FEAT_BadEcNumberValue)
{
    CRef<CSeq_entry> entry = s_BuildBadEcNumberEntry ();
    CRef<CSeq_feat> prot = entry->GetSet().GetSeq_set().back()->GetAnnot().front()->GetData().GetFtable().front();
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|prot", eDiag_Warning, "DeletedEcNumber",
                      "EC_number 1.2.3.10 was deleted"));
    expected_errors.push_back(new CExpectedError("lcl|prot", eDiag_Warning, "ReplacedEcNumber",
                      "EC_number 1.1.3.22 was transferred and is no longer valid"));
    expected_errors.push_back(new CExpectedError("lcl|prot", eDiag_Warning, "BadEcNumberValue",
                      "11.22.33.44 is not a legal value for qualifier EC_number"));
    expected_errors.push_back(new CExpectedError("lcl|prot", eDiag_Warning, "BadEcNumberFormat",
                      "11.22.n33.44 is not in proper EC_number format"));
    expected_errors.push_back(new CExpectedError("lcl|prot", eDiag_Info, "BadEcNumberValue",
                      "11.22.33.n44 is not a legal preliminary value for qualifier EC_number"));
    // AddChromosomeNoLocation(expected_errors, "lcl|nuc");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    scope.RemoveTopLevelSeqEntry(seh);
    prot->SetData().SetProt().ResetEc();
    CRef<CSeq_feat> misc = unit_test_util::AddMiscFeature (entry->GetSet().GetSeq_set().front());
    misc->SetData().SetImp().SetKey("exon");
    misc->AddQualifier("EC_number", "1.2.3.10");
    misc->AddQualifier("EC_number", "1.1.3.22");
    misc->AddQualifier("EC_number", "1.1.99.n");
    misc->AddQualifier("EC_number", "1.1.1.17");
    misc->AddQualifier("EC_number", "11.22.33.44");
    misc->AddQualifier("EC_number", "11.22.n33.44");
    misc->AddQualifier("EC_number", "11.22.33.n44");
    SetErrorsAccessions(expected_errors, "lcl|nuc");
    expected_errors[1]->SetErrMsg("EC_number 1.1.3.22 was replaced");
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_FEAT_InvalidQualifierValue)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    CRef<CSeq_feat> misc = unit_test_util::AddMiscFeature (entry);
    misc->SetData().SetImp().SetKey("repeat_region");
    misc->AddQualifier("rpt_unit_seq", "ATA");
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "RepeatSeqDoNotMatch",
                      "repeat_region /rpt_unit and underlying sequence do not match"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry = unit_test_util::BuildGoodSeq();
    misc = unit_test_util::AddMiscFeature(entry);
    misc->SetData().SetImp().SetKey("repeat_region");
    misc->AddQualifier("rpt_unit_seq", "ATAGTGATAGTG");
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors[0]->SetErrCode("InvalidRepeatUnitLength");
    expected_errors[0]->SetErrMsg("Length of rpt_unit_seq is greater than feature length");
    expected_errors[0]->SetSeverity(eDiag_Info);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_ExtNotAllowed)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "ExtNotAllowed", "Bioseq-ext not allowed on virtual Bioseq"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
 
    // repr = virtual
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_virtual);
    entry->SetSeq().SetInst().ResetSeq_data();
    entry->SetSeq().SetInst().SetExt().SetDelta();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // repr = raw
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_raw);
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("AATTGG");
    expected_errors[0]->SetErrMsg("Bioseq-ext not allowed on raw Bioseq");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().ResetExt();
    entry->SetSeq().SetInst().ResetSeq_data();
    expected_errors[0]->SetErrCode("SeqDataNotFound");
    expected_errors[0]->SetErrMsg("Missing Seq-data on raw Bioseq");
    expected_errors[0]->SetSeverity(eDiag_Critical);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetSeq_data().SetGap();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // repr = const
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_const);
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("AATTGG");
    entry->SetSeq().SetInst().SetExt().SetDelta();
    expected_errors[0]->SetErrCode("ExtNotAllowed");
    expected_errors[0]->SetErrMsg("Bioseq-ext not allowed on constructed Bioseq");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().ResetExt();
    entry->SetSeq().SetInst().ResetSeq_data();
    expected_errors[0]->SetErrCode("SeqDataNotFound");
    expected_errors[0]->SetErrMsg("Missing Seq-data on constructed Bioseq");
    expected_errors[0]->SetSeverity(eDiag_Critical);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetSeq_data().SetGap();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // repr = map
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_map);
    entry->SetSeq().SetInst().ResetSeq_data();
    expected_errors[0]->SetErrCode("ExtBadOrMissing");
    expected_errors[0]->SetErrMsg("Missing or incorrect Bioseq-ext on map Bioseq");
    expected_errors[0]->SetSeverity(eDiag_Error);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetExt().SetDelta();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetExt().SetRef();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetExt().SetMap();
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("AATTGG");
    expected_errors[0]->SetErrCode("SeqDataNotAllowed");
    expected_errors[0]->SetErrMsg("Seq-data not allowed on map Bioseq");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
 
    // repr = ref
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_ref);
    entry->SetSeq().SetInst().ResetExt();
    entry->SetSeq().SetInst().ResetSeq_data();
    expected_errors[0]->SetErrCode("ExtBadOrMissing");
    expected_errors[0]->SetErrMsg("Missing or incorrect Bioseq-ext on reference Bioseq");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    /*
    // repr = seg
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_seg);
    expected_errors[0]->SetErrMsg("Missing or incorrect Bioseq-ext on seg Bioseq");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    */
 
    // repr = consen
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_consen);
    expected_errors[0]->SetSeverity(eDiag_Critical);
    expected_errors[0]->SetErrCode("ReprInvalid");
    expected_errors[0]->SetErrMsg("Invalid Bioseq->repr = 6");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // repr = notset
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_not_set);
    expected_errors[0]->SetErrMsg("Invalid Bioseq->repr = 0");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // repr = other
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_other);
    expected_errors[0]->SetErrMsg("Invalid Bioseq->repr = 255");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // repr = delta
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_delta);
    entry->SetSeq().SetInst().SetExt().SetDelta();
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("AATTGG");
    expected_errors[0]->SetSeverity(eDiag_Error);
    expected_errors[0]->SetErrCode("SeqDataNotAllowed");
    expected_errors[0]->SetErrMsg("Seq-data not allowed on delta Bioseq");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().ResetExt();
    entry->SetSeq().SetInst().ResetSeq_data();
    expected_errors[0]->SetSeverity(eDiag_Error);
    expected_errors[0]->SetErrCode("ExtBadOrMissing");
    expected_errors[0]->SetErrMsg("Missing or incorrect Bioseq-ext on delta Bioseq");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_ReprInvalid)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
 
    STANDARD_SETUP
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "ReprInvalid", "Invalid Bioseq->repr = 0"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
 
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_not_set);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    expected_errors[0]->SetErrMsg("Invalid Bioseq->repr = 255");
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_other);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    expected_errors[0]->SetErrMsg("Invalid Bioseq->repr = 6");
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_consen);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_CollidingLocusTags)
{
    CRef<CSeq_entry> entry(new CSeq_entry());
    {
        CNcbiIstrstream istr(sc_TestEntryCollidingLocusTags);
        istr >> MSerial_AsnText >> *entry;
    }
 
    CRef<CObjectManager> objmgr = CObjectManager::GetInstance();
    CScope scope(*objmgr);
    CSeq_entry_Handle seh = scope.AddTopLevelSeqEntry(*entry);
 
    CValidator validator(*objmgr);
 
    // Set validator options
    unsigned int options = CValidator::eVal_need_isojta
                          | CValidator::eVal_far_fetch_mrna_products
                          | CValidator::eVal_validate_id_set | CValidator::eVal_indexer_version
                          | CValidator::eVal_use_entrez;
 
    // list of expected errors
    vector< CExpectedError *> expected_errors;
    expected_errors.push_back(new CExpectedError("lcl|LocusCollidesWithLocusTag", eDiag_Warning, "TerminalNs", "N at end of sequence"));
    expected_errors.push_back(new CExpectedError("lcl|LocusCollidesWithLocusTag", eDiag_Warning, "GeneLocusCollidesWithLocusTag", "locus collides with locus_tag in another gene"));
    expected_errors.push_back(new CExpectedError("lcl|LocusCollidesWithLocusTag", eDiag_Error, "CollidingLocusTags", "Colliding locus_tags in gene features"));
    expected_errors.push_back(new CExpectedError("lcl|LocusCollidesWithLocusTag", eDiag_Error, "CollidingLocusTags", "Colliding locus_tags in gene features"));
    expected_errors.push_back(new CExpectedError("lcl|LocusCollidesWithLocusTag", eDiag_Error, "NoMolInfoFound", "No Mol-info applies to this Bioseq"));
    expected_errors.push_back(new CExpectedError("lcl|LocusCollidesWithLocusTag", eDiag_Error, "LocusTagGeneLocusMatch", "Gene locus and locus_tag 'foo' match"));
    expected_errors.push_back(new CExpectedError("lcl|LocusCollidesWithLocusTag", eDiag_Error, "NoPubFound", "No publications anywhere on this entire record."));
    expected_errors.push_back(new CExpectedError("lcl|LocusCollidesWithLocusTag", eDiag_Info, "MissingPubRequirement", "No submission citation anywhere on this entire record."));
    expected_errors.push_back(new CExpectedError("lcl|LocusCollidesWithLocusTag", eDiag_Error, "NoSourceDescriptor", "No source information included on this record."));
 
    CConstRef<CValidError> eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
const string sc_TestEntryCollidingLocusTags ="Seq-entry ::= seq {\
    id {\
      local str \"LocusCollidesWithLocusTag\" } ,\
    inst {\
      repr raw ,\
      mol dna ,\
      length 24 ,\
      seq-data\
        iupacna \"AATTGGCCAANNAATTGGCCAANN\" } ,\
    annot {\
      {\
        data\
          ftable {\
            {\
              data\
                gene {\
                  locus \"foo\" ,\
                  locus-tag \"foo\" } ,\
              location\
                int {\
                  from 0 ,\
                  to 4 ,\
                  strand plus ,\
                  id\
                    local str \"LocusCollidesWithLocusTag\" } } ,\
            {\
              data\
                gene {\
                  locus \"bar\" ,\
                  locus-tag \"foo\" } ,\
              location\
                int {\
                  from 5 ,\
                  to 9 ,\
                  strand plus ,\
                  id\
                    local str \"LocusCollidesWithLocusTag\" } } ,\
            {\
              data\
                gene {\
                  locus \"bar\" ,\
                  locus-tag \"baz\" } ,\
              location\
                int {\
                  from 10 ,\
                  to 14 ,\
                  strand plus ,\
                  id\
                    local str \"LocusCollidesWithLocusTag\" } } ,\
            {\
              data\
                gene {\
                  locus \"quux\" ,\
                  locus-tag \"baz\" } ,\
              location\
                int {\
                  from 15 ,\
                  to 19 ,\
                  strand plus ,\
                  id\
                    local str \"LocusCollidesWithLocusTag\" } } } } } }\
";
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_CircularProtein)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodProtSeq();
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "CircularProtein", "Non-linear topology set on protein"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
 
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_complete);
 
    entry->SetSeq().SetInst().SetTopology(CSeq_inst::eTopology_circular);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetTopology(CSeq_inst::eTopology_tandem);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetTopology(CSeq_inst::eTopology_other);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // should be no error for not set or linear
    CLEAR_ERRORS
 
    entry->SetSeq().SetInst().SetTopology(CSeq_inst::eTopology_not_set);
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetTopology(CSeq_inst::eTopology_linear);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_BadProteinMoltype)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodProtSeq();
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "BadProteinMoltype", "Protein not single stranded"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
 
    entry->SetSeq().SetInst().SetStrand(CSeq_inst::eStrand_ds);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetStrand(CSeq_inst::eStrand_mixed);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetStrand(CSeq_inst::eStrand_other);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // no errors expected for not set or single strand
    CLEAR_ERRORS
 
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
 
    entry->SetSeq().SetInst().SetStrand(CSeq_inst::eStrand_not_set);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetStrand(CSeq_inst::eStrand_ss);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_MolNotSet)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "MolNotSet", "Bioseq.mol is 0"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
 
    entry->SetSeq().SetInst().SetMol(CSeq_inst::eMol_not_set);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    expected_errors[0]->SetErrCode("MolOther");
    expected_errors[0]->SetErrMsg("Bioseq.mol is type other");
    entry->SetSeq().SetInst().SetMol(CSeq_inst::eMol_other);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    expected_errors[0]->SetErrCode("MolNuclAcid");
    expected_errors[0]->SetErrMsg("Bioseq.mol is type nucleic acid");
    entry->SetSeq().SetInst().SetMol(CSeq_inst::eMol_na);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_FuzzyLen)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "FuzzyLen", "Fuzzy length on raw Bioseq"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
 
    entry->SetSeq().SetInst().SetFuzz();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    expected_errors[0]->SetErrMsg("Fuzzy length on const Bioseq");
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_const);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // shouldn't get fuzzy length if gap
    expected_errors[0]->SetErrCode("SeqDataNotFound");
    expected_errors[0]->SetErrMsg("Missing Seq-data on constructed Bioseq");
    expected_errors[0]->SetSeverity(eDiag_Critical);
    entry->SetSeq().SetInst().SetSeq_data().SetGap();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_InvalidAlphabet)
{
    CRef<CSeq_entry> prot_entry = unit_test_util::BuildGoodProtSeq();
 
    CRef<CObjectManager> objmgr = CObjectManager::GetInstance();
    CScope scope(*objmgr);
    scope.AddDefaults();
    CSeq_entry_Handle prot_seh = scope.AddTopLevelSeqEntry(*prot_entry);
 
    CValidator validator(*objmgr);
 
    // Set validator options
    unsigned int options = CValidator::eVal_need_isojta
                          | CValidator::eVal_far_fetch_mrna_products
                          | CValidator::eVal_validate_id_set | CValidator::eVal_indexer_version
                          | CValidator::eVal_use_entrez;
 
    // list of expected errors
    vector< CExpectedError *> expected_errors;
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidAlphabet", "Using a nucleic acid alphabet on a protein sequence"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    prot_entry->SetSeq().SetInst().SetSeq_data().SetIupacna();
    CConstRef<CValidError> eval = validator.Validate(prot_seh, options);
    CheckErrors(*eval, expected_errors);
 
    prot_entry->SetSeq().SetInst().SetSeq_data().SetNcbi2na();
    eval = validator.Validate(prot_seh, options);
    CheckErrors(*eval, expected_errors);
 
    prot_entry->SetSeq().SetInst().SetSeq_data().SetNcbi4na();
    eval = validator.Validate(prot_seh, options);
    CheckErrors(*eval, expected_errors);
 
    prot_entry->SetSeq().SetInst().SetSeq_data().SetNcbi8na();
    eval = validator.Validate(prot_seh, options);
    CheckErrors(*eval, expected_errors);
 
    prot_entry->SetSeq().SetInst().SetSeq_data().SetNcbipna();
    eval = validator.Validate(prot_seh, options);
    CheckErrors(*eval, expected_errors);
 
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    CScope scope2(*objmgr);
    scope2.AddDefaults();
    CSeq_entry_Handle seh = scope2.AddTopLevelSeqEntry(*entry);
 
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa();
    expected_errors[0]->SetErrMsg("Using a protein alphabet on a nucleic acid");
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetSeq_data().SetNcbi8aa();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetSeq_data().SetNcbieaa();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetSeq_data().SetNcbipaa();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetSeq_data().SetNcbistdaa();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_InvalidResidue)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
 
    STANDARD_SETUP
 
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ");
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFB');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFB');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFB');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFC');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFC');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFC');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFD');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFD');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFD');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFE');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFE');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFF');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set().push_back('\xFF');
    entry->SetSeq().SetInst().SetLength(65);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'E' at position [5]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'F' at position [6]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'I' at position [9]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'J' at position [10]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'L' at position [12]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'O' at position [15]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'P' at position [16]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'Q' at position [17]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'U' at position [21]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'X' at position [24]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'Z' at position [26]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'E' at position [31]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'F' at position [32]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'I' at position [35]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'J' at position [36]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'L' at position [38]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'O' at position [41]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'P' at position [42]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'Q' at position [43]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'U' at position [47]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'X' at position [50]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid nucleotide residue 'Z' at position [52]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [251] at position [53]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [251] at position [54]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [251] at position [55]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [252] at position [56]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [252] at position [57]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [252] at position [58]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [253] at position [59]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [253] at position [60]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [253] at position [61]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [254] at position [62]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "More than 10 invalid residues. Checking stopped"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Fatal, "NonAsciiAsn", "Non-ASCII character '251' found in item"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // now repeat test, but with mRNA - this time Us should not be reported
    entry->SetSeq().SetInst().SetMol(CSeq_inst::eMol_rna);
    delete expected_errors[8];
    expected_errors[8] = nullptr;
    delete expected_errors[19];
    expected_errors[19] = nullptr;
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // now repeat test, but with protein
    entry->SetSeq().SetInst().SetMol(CSeq_inst::eMol_aa);
    for (auto& it : entry->SetSeq().SetDescr().Set()) {
        if (it->IsMolinfo()) {
            it->SetMolinfo().SetBiomol(CMolInfo::eBiomol_peptide);
        }
    }
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ");
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFB');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFB');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFB');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFC');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFC');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFC');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFD');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFD');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFD');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFE');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFE');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFF');
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set().push_back('\xFF');
    entry->SetSeq().SetInst().SetLength(65);
    CRef<CSeq_feat> feat (new CSeq_feat());
    feat->SetData().SetProt().SetName().push_back("fake protein name");
    feat->SetLocation().SetInt().SetId().SetLocal().SetStr("good");
    feat->SetLocation().SetInt().SetFrom(0);
    feat->SetLocation().SetInt().SetTo(64);
    unit_test_util::AddFeat(feat, entry);
    scope.RemoveEntry (*entry);
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    for (int j = 0; j < 22; j++) {
        if (expected_errors[j]) {
            delete expected_errors[j];
            expected_errors[j] = nullptr;
        }
    }
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // now look for lowercase characters
    scope.RemoveEntry (*entry);
    entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("abcdefghijklmnopqrstuvwxyz");
    entry->SetSeq().SetInst().SetLength(26);
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Sequence contains lower-case characters"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    scope.RemoveEntry (*entry);
    entry = unit_test_util::BuildGoodProtSeq();
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set("protein");
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
 
    CLEAR_ERRORS
 
    // now try delta sequence
    scope.RemoveEntry (*entry);
    entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_delta);
    entry->SetSeq().SetInst().ResetSeq_data();
    CRef<CDelta_seq> seg(new CDelta_seq());
    seg->SetLiteral().SetSeq_data().SetIupacna().Set("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ");
    seg->SetLiteral().SetLength(52);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().push_back(seg);
    entry->SetSeq().SetInst().SetLength(52);
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [E] at position [5]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [F] at position [6]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [I] at position [9]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [J] at position [10]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [L] at position [12]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [O] at position [15]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [P] at position [16]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [Q] at position [17]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [U] at position [21]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [X] at position [24]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [Z] at position [26]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [E] at position [31]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [F] at position [32]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [I] at position [35]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [J] at position [36]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [L] at position [38]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [O] at position [41]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [P] at position [42]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [Q] at position [43]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [U] at position [47]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [X] at position [50]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [Z] at position [52]"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // try protein delta sequence
    scope.RemoveEntry (*entry);
    entry = unit_test_util::BuildGoodProtSeq();
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_delta);
    entry->SetSeq().SetInst().ResetSeq_data();
    CRef<CDelta_seq> seg2(new CDelta_seq());
    seg2->SetLiteral().SetSeq_data().SetIupacaa().Set("1234567");
    seg2->SetLiteral().SetLength(7);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().push_back(seg2);
    entry->SetSeq().SetInst().SetLength(7);
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [1] at position [1]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [2] at position [2]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [3] at position [3]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [4] at position [4]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [5] at position [5]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [6] at position [6]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue [7] at position [7]"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
/*
static void WriteOutTemp (CRef<CSeq_entry> entry)
{
    // construct a temp file name
    CNcbiOstrstream oss;
    oss << "test.asn";
    string filename = CNcbiOstrstreamToString(oss);
    string fullPath = CDirEntry::MakePath(".", filename);
 
    // initialize a binary output stream
    unique_ptr<CNcbiOstream> outStream;
    outStream.reset(new CNcbiOfstream(
        fullPath.c_str(),
        IOS_BASE::out));
    if (!(*outStream)) {
        return;
    }
 
    unique_ptr<CObjectOStream> outObject;
    // Associate ASN.1 text serialization methods with the input
    outObject.reset(new CObjectOStreamAsn(*outStream));
 
    // write the asn data
    try {
        *outObject << *entry;
        outStream->flush();
    } catch (exception& ) {
    }
}
*/
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_StopInProtein)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodNucProtSet();
 
    STANDARD_SETUP
 
    entry->SetSet().SetSeq_set().back()->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set("MP*K*E*N");
    entry->SetSet().SetSeq_set().front()->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("GTGCCCTAAAAATAAGAGTAAAACTAAGGGATGCCCAGAAAAACAGAGATAAACTAAGGG");
    CRef<CSeq_feat> cds = unit_test_util::GetCDSFromGoodNucProtSet(entry);
    cds->SetExcept(true);
    cds->SetExcept_text("unclassified translation discrepancy");
 
    BOOST_CHECK_EQUAL(validator::HasStopInProtein(*cds, scope), true);
    BOOST_CHECK_EQUAL(validator::HasInternalStop(*cds, scope, false), true);
 
    // list of expected errors
    expected_errors.push_back(new CExpectedError("lcl|nuc", eDiag_Error, "StopInProtein", "[3] termination symbols in protein sequence (gene? - fake protein name)"));
    expected_errors.push_back(new CExpectedError("lcl|nuc", eDiag_Error, "ExceptionProblem", "unclassified translation discrepancy is not a legal exception explanation"));
    expected_errors.push_back(new CExpectedError("lcl|nuc", eDiag_Warning, "InternalStop", "3 internal stops (and illegal start codon). Genetic code [0]"));
    expected_errors.push_back (new CExpectedError("lcl|nuc", eDiag_Warning, "UnnecessaryException",
                              "CDS has unnecessary translated product replaced exception"));
    // AddChromosomeNoLocation(expected_errors, "lcl|nuc");
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    // WriteOutTemp(entry);
 
    CLEAR_ERRORS
    cds->ResetExcept();
    cds->ResetExcept_text();
    BOOST_CHECK_EQUAL(validator::HasStopInProtein(*cds, scope), true);
    BOOST_CHECK_EQUAL(validator::HasInternalStop(*cds, scope, false), true);
    BOOST_CHECK_EQUAL(validator::HasBadStartCodon(*cds, scope, false), true);
 
    expected_errors.push_back(new CExpectedError("lcl|nuc", eDiag_Error, "StopInProtein", "[3] termination symbols in protein sequence (gene? - fake protein name)"));
    expected_errors.push_back(new CExpectedError("lcl|nuc", eDiag_Error, "StartCodon", "Illegal start codon (and 3 internal stops). Probably wrong genetic code [0]"));
    expected_errors.push_back(new CExpectedError("lcl|nuc", eDiag_Error, "InternalStop", "3 internal stops (and illegal start codon). Genetic code [0]"));
    // AddChromosomeNoLocation(expected_errors, "lcl|nuc");
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    // WriteOutTemp(entry);
 
    CRef<CSeq_entry> nuc = unit_test_util::GetNucleotideSequenceFromGoodNucProtSet(entry);
    nuc->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("ATGCCCTAAAAATAAGAGTAAAACTAAGGGATGCCCAGAAAAACAGAGATAAACTAAGGG");
 
    // write out seq-entry
    // WriteOutTemp(entry);
 
    delete expected_errors[1];
    expected_errors[1] = nullptr;
    expected_errors[2]->SetErrMsg("3 internal stops. Genetic code [0]");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_PartialInconsistent)
{
#if 0
    //We don't care about segmented sets any more
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodProtSeq();
 
    STANDARD_SETUP
 
    entry->SetSeq().SetInst().ResetSeq_data();
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_seg);
    CRef<CSeq_id> id(new CSeq_id("gb|AY123456"));
    CRef<CSeq_loc> loc1(new CSeq_loc(*id, 0, 3));
    entry->SetSeq().SetInst().SetExt().SetSeg().Set().push_back(loc1);
    CRef<CSeq_id> id2(new CSeq_id("gb|AY123457"));
    CRef<CSeq_loc> loc2(new CSeq_loc(*id2, 0, 2));
    entry->SetSeq().SetInst().SetExt().SetSeg().Set().push_back(loc2);
 
    // list of expected errors
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "PartialInconsistent", "Partial segmented sequence without MolInfo partial"));
 
    // not-set
    loc1->SetPartialStart(true, eExtreme_Biological);
    loc2->SetPartialStop(true, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    loc1->SetPartialStart(true, eExtreme_Biological);
    loc2->SetPartialStop(false, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    loc1->SetPartialStart(false, eExtreme_Biological);
    loc2->SetPartialStop(true, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // unknown
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_unknown);
 
    loc1->SetPartialStart(true, eExtreme_Biological);
    loc2->SetPartialStop(true, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    loc1->SetPartialStart(true, eExtreme_Biological);
    loc2->SetPartialStop(false, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    loc1->SetPartialStart(false, eExtreme_Biological);
    loc2->SetPartialStop(true, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // complete
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_complete);
 
    loc1->SetPartialStart(true, eExtreme_Biological);
    loc2->SetPartialStop(true, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    loc1->SetPartialStart(true, eExtreme_Biological);
    loc2->SetPartialStop(false, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    loc1->SetPartialStart(false, eExtreme_Biological);
    loc2->SetPartialStop(true, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // partial
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_partial);
 
    loc1->SetPartialStart(false, eExtreme_Biological);
    loc2->SetPartialStop(false, eExtreme_Biological);
    expected_errors[0]->SetErrMsg("Complete segmented sequence with MolInfo partial");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // no-left
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_no_left);
 
    loc1->SetPartialStart(true, eExtreme_Biological);
    loc2->SetPartialStop(true, eExtreme_Biological);
    expected_errors[0]->SetErrMsg("No-left inconsistent with segmented SeqLoc");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    loc1->SetPartialStart(false, eExtreme_Biological);
    loc2->SetPartialStop(true, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    loc1->SetPartialStart(false, eExtreme_Biological);
    loc2->SetPartialStop(false, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // no-right
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_no_right);
 
    loc1->SetPartialStart(true, eExtreme_Biological);
    loc2->SetPartialStop(true, eExtreme_Biological);
    expected_errors[0]->SetErrMsg("No-right inconsistent with segmented SeqLoc");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    loc1->SetPartialStart(true, eExtreme_Biological);
    loc2->SetPartialStop(false, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    loc1->SetPartialStart(false, eExtreme_Biological);
    loc2->SetPartialStop(false, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // no-ends
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_no_ends);
 
    expected_errors[0]->SetErrMsg("No-ends inconsistent with segmented SeqLoc");
    loc1->SetPartialStart(true, eExtreme_Biological);
    loc2->SetPartialStop(false, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    loc1->SetPartialStart(false, eExtreme_Biological);
    loc2->SetPartialStop(true, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    loc1->SetPartialStart(false, eExtreme_Biological);
    loc2->SetPartialStop(false, eExtreme_Biological);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
#endif
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_ShortSeq)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodProtSeq();
 
    STANDARD_SETUP
 
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set("MPR");
    entry->SetSeq().SetInst().SetLength(3);
    entry->SetSeq().SetAnnot().front()->SetData().SetFtable().front()->SetLocation().SetInt().SetTo(2);
 
    // don't report if pdb
    CRef<CPDB_seq_id> pdb_id(new CPDB_seq_id());
    pdb_id->SetMol().Set("foo");
    entry->SetSeq().SetId().front()->SetPdb(*pdb_id);
    entry->SetSeq().SetAnnot().front()->SetData().SetFtable().front()->SetLocation().SetInt().SetId().SetPdb(*pdb_id);
    scope.RemoveTopLevelSeqEntry(seh);
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, "pdb|foo| ");
    CheckErrors(*eval, expected_errors);
 
    // new test if no coding region
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "PartialsInconsistent", "Molinfo completeness and protein feature partials conflict"));
    expected_errors[0]->SetAccession("lcl|good");
    entry->SetSeq().SetId().front()->SetLocal().SetStr("good");
    entry->SetSeq().SetAnnot().front()->SetData().SetFtable().front()->SetLocation().SetInt().SetId().SetLocal().SetStr("good");
    scope.RemoveTopLevelSeqEntry(seh);
    seh = scope.AddTopLevelSeqEntry(*entry);
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_partial);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_no_left);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_no_right);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_no_ends);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // for all other completeness, report
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "ShortSeq", "Sequence only 3 residues"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    for (auto& it : entry->SetSeq().SetDescr().Set()) {
        if (it->IsMolinfo()) {
            it->SetMolinfo().ResetCompleteness();
        }
    }
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_unknown);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_complete);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    unit_test_util::SetCompleteness (entry, CMolInfo::eCompleteness_other);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // nucleotide
    scope.RemoveTopLevelSeqEntry(seh);
    entry = unit_test_util::BuildGoodSeq();
    seh = scope.AddTopLevelSeqEntry(*entry);
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("ATGCCCTTT");
    entry->SetSeq().SetInst().SetLength(9);
    expected_errors[0]->SetErrMsg("Sequence only 9 residues");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // don't report if pdb
    entry->SetSeq().SetId().front()->SetPdb(*pdb_id);
    scope.RemoveTopLevelSeqEntry(seh);
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, "pdb|foo| ");
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
static bool IsProteinTech(CMolInfo::TTech tech)
{
    bool rval = false;
 
    switch (tech) {
    case CMolInfo::eTech_concept_trans:
    case CMolInfo::eTech_seq_pept:
    case CMolInfo::eTech_both:
    case CMolInfo::eTech_seq_pept_overlap:
    case CMolInfo::eTech_seq_pept_homol:
    case CMolInfo::eTech_concept_trans_a:
        rval = true;
        break;
    default:
        break;
    }
    return rval;
}
 
 
static void AddRefGeneTrackingUserObject(CRef<CSeq_entry> entry)
{
    CRef<CSeqdesc> desc(new CSeqdesc());
    desc->SetUser().SetObjectType(CUser_object::eObjectType_RefGeneTracking);
    desc->SetUser().SetRefGeneTrackingStatus(CUser_object::eRefGeneTrackingStatus_INFERRED);
    if (entry->IsSeq()) {
        entry->SetSeq().SetDescr().Set().push_back(desc);
    } else if (entry->IsSet()) {
        entry->SetSet().SetDescr().Set().push_back(desc);
    }
}
 
 
static void SetRefGeneTrackingStatus(CRef<CSeq_entry> entry, string status)
{
    if (entry->IsSeq()) {
        for (auto& it : entry->SetSeq().SetDescr().Set()) {
            if (it->IsUser() && it->GetUser().IsRefGeneTracking()) {
                it->SetUser().SetData().front()->SetData().SetStr(status);
            }
        }
    } else if (entry->IsSet()) {
        for (auto& it : entry->SetSet().SetDescr().Set()) {
            if (it->IsUser() && it->GetUser().IsRefGeneTracking()) {
                it->SetUser().SetData().front()->SetData().SetStr(status);
            }
        }
    }
}
 
 
static void SetTitle(CRef<CSeq_entry> entry, string title)
{
    bool found = false;
 
    if (entry->IsSetDescr()) {
        auto& cont = entry->SetDescr().Set();
        for (auto it = cont.begin(); it != cont.end();) {
            if ((*it)->IsTitle()) {
                found = true;
                if (NStr::IsBlank((*it)->GetTitle())) {
                    it = cont.erase(it);
                    continue;
                } else {
                    (*it)->SetTitle(title);
                }
            }
            ++it;
        }
    }
 
    if (!found && !NStr::IsBlank(title)) {
        CRef<CSeqdesc> desc(new CSeqdesc());
        desc->SetTitle(title);
        entry->SetSeq().SetDescr().Set().push_back(desc);
    }
}
 
 
static void AddGenbankKeyword (CRef<CSeq_entry> entry, string keyword)
{
    bool found = false;
 
    for (auto& it : entry->SetSeq().SetDescr().Set()) {
        if (it->IsGenbank()) {
            it->SetGenbank().SetKeywords().push_back(keyword);
            found = true;
        }
    }
    if (!found) {
        CRef<CSeqdesc> desc(new CSeqdesc());
        desc->SetGenbank().SetKeywords().push_back(keyword);
        entry->SetSeq().SetDescr().Set().push_back(desc);
    }
}
 
 
void TestDeltaTechAllowed(CMolInfo::TTech tech)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
    STANDARD_SETUP
 
    SetTech(entry, tech);
    eval = validator.Validate(seh, options);
    if (tech == CMolInfo::eTech_barcode) {
        expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "NoKeywordHasTechnique", "Molinfo.tech barcode without BARCODE keyword"));
    } else if (tech == CMolInfo::eTech_tsa) {
        expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "TSAseqGapProblem", "TSA Seq_gap NULL"));
        expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "TSAshouldBNotBeDNA", "TSA sequence should not be DNA"));
        expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "WrongBiomolForTSA", "Biomol \"genomic\" is not appropriate for sequences that use the TSA technique."));
        expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "TSAseqGapProblem", "TSA submission includes wrong gap type. Gaps for TSA should be Assembly Gaps with linkage evidence."));
    } else if (tech == CMolInfo::eTech_wgs) {
        expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "WGSseqGapProblem", "WGS submission includes wrong gap type. Gaps for WGS genomes should be Assembly Gaps with linkage evidence."));
    }
    if (tech == CMolInfo::eTech_wgs) {
        AddChromosomeNoLocation(expected_errors, "lcl|good");
    }
 
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
void TestDeltaTechNotAllowed(CMolInfo::TTech tech)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
    STANDARD_SETUP
 
    SetTech(entry, tech);
    eval = validator.Validate(seh, options);
    if (IsProteinTech(tech)) {
        expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "ProteinTechniqueOnNucleotide", "Nucleic acid with protein sequence method"));
    } else if (tech == CMolInfo::eTech_est) {
        expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "ESTshouldBemRNA", "EST sequence should be mRNA"));
    }
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "BadDeltaSeq", "Delta seq technique should not be [" + NStr::UIntToString(tech) + "]"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
}
 
 
void TestStartGapSeg(CMolInfo::TTech tech)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
 
    STANDARD_SETUP
 
    CRef<CDelta_seq> start_gap_seg(new CDelta_seq());
    start_gap_seg->SetLiteral().SetLength(10);
    start_gap_seg->SetLiteral().SetSeq_data().SetGap();
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().insert(entry->SetSeq().SetInst().SetExt().SetDelta().Set().begin(), start_gap_seg);
    entry->SetSeq().SetInst().SetExt().SetDelta().AddLiteral(10);
    entry->SetSeq().SetInst().SetExt().SetDelta().AddLiteral(10);
    entry->SetSeq().SetInst().SetExt().SetDelta().AddLiteral("AAATTTGGGC", CSeq_inst::eMol_dna);
    CRef<CDelta_seq> end_gap_seg(new CDelta_seq());
    end_gap_seg->SetLiteral().SetLength(10);
    end_gap_seg->SetLiteral().SetSeq_data().SetGap();
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().push_back(end_gap_seg);
    entry->SetSeq().SetInst().SetExt().SetDelta().AddLiteral(10);
    entry->SetSeq().SetInst().SetLength(94);
    SetTech(entry, tech);
    if (tech == CMolInfo::eTech_wgs) {
        AddChromosomeNoLocation(expected_errors, "lcl|good");
    }
    // expected_errors.push_back(new CExpectedError("lcl|good", tech == CMolInfo::eTech_wgs ? eDiag_Warning : eDiag_Error, "BadDeltaSeq", "First delta seq component is a gap"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "BadDeltaSeq", "There is 1 adjacent gap in delta seq"));
    // expected_errors.push_back(new CExpectedError("lcl|good", tech == CMolInfo::eTech_wgs ? eDiag_Warning : eDiag_Error, "BadDeltaSeq", "Last delta seq component is a gap"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "TerminalGap", "Gap at beginning of sequence"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "TerminalGap", "Gap at end of sequence"));
    /*
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent5Prime",
        "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent3Prime",
        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    */
    if (tech == CMolInfo::eTech_wgs) {
        expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "WGSseqGapProblem", "WGS submission includes wrong gap type. Gaps for WGS genomes should be Assembly Gaps with linkage evidence."));
    }
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_BadDeltaSeq)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
 
    STANDARD_SETUP
 
    for (auto& it : entry->SetSeq().SetDescr().Set()) {
        if (it->IsMolinfo()) {
            it->SetMolinfo().SetTech(CMolInfo::eTech_derived);
        }
    }
 
    // don't report if NT or NC
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetOther().SetAccession("NC_123456");
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, "ref|NC_123456|");
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
 
    entry->SetSeq().SetId().front()->SetOther().SetAccession("NT_123456");
    scope.RemoveTopLevelSeqEntry(seh);
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, "ref|NT_123456|");
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
 
    // don't report if gen-prod-set
 
    entry->SetSeq().SetId().front()->SetLocal().SetStr("good");
    scope.RemoveTopLevelSeqEntry(seh);
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    // allowed tech values
    vector<CMolInfo::TTech> allowed_list;
    allowed_list.push_back(CMolInfo::eTech_htgs_0);
    allowed_list.push_back(CMolInfo::eTech_htgs_1);
    allowed_list.push_back(CMolInfo::eTech_htgs_2);
    allowed_list.push_back(CMolInfo::eTech_htgs_3);
    allowed_list.push_back(CMolInfo::eTech_wgs);
    allowed_list.push_back(CMolInfo::eTech_composite_wgs_htgs);
    allowed_list.push_back(CMolInfo::eTech_unknown);
    allowed_list.push_back(CMolInfo::eTech_standard);
    allowed_list.push_back(CMolInfo::eTech_htc);
    allowed_list.push_back(CMolInfo::eTech_barcode);
    allowed_list.push_back(CMolInfo::eTech_tsa);
 
    for (CMolInfo::TTech i = CMolInfo::eTech_unknown; i <= CMolInfo::eTech_tsa; ++i) {
        bool allowed = false;
        for (CMolInfo::TTech it : allowed_list) {
            if (it == i) {
                allowed = true;
                break;
            }
        }
        if (allowed) {
            // don't report for htgs_0
            TestDeltaTechAllowed(i);
        } else {
            TestDeltaTechNotAllowed(i);
        }
    }
 
    CLEAR_ERRORS
 
    TestStartGapSeg(CMolInfo::eTech_wgs);
    TestStartGapSeg(CMolInfo::eTech_htgs_0);
 
    CLEAR_ERRORS
}
 
 
void AdjustGap(CSeq_gap& gap, CSeq_gap::EType gap_type, bool is_linked, vector<CLinkage_evidence::EType> linkage_evidence)
{
    gap.Reset();
    gap.SetType(gap_type);
    if (is_linked) {
        gap.SetLinkage(CSeq_gap::eLinkage_linked);
    } else {
        gap.ResetLinkage();
    }
    gap.ResetLinkage_evidence();
    for (auto it : linkage_evidence) {
        CRef<CLinkage_evidence> ev(new CLinkage_evidence());
        ev->SetType(it);
        gap.SetLinkage_evidence().push_back(ev);
    }
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_SeqGapBadLinkage)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
 
    vector<CLinkage_evidence::EType> evidence;
    evidence.push_back(CLinkage_evidence::eType_align_genus);
    for (auto it : entry->SetSeq().SetInst().SetExt().SetDelta().Set()) {
        if (it->IsLiteral() && it->GetLiteral().IsSetSeq_data() &&
            it->GetLiteral().GetSeq_data().IsGap()) {
            AdjustGap(it->SetLiteral().SetSeq_data().SetGap(),
                CSeq_gap::eType_short_arm, true, evidence);
        }
    }
 
    STANDARD_SETUP
 
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical,
            "SeqGapBadLinkage", "Seq-gap of type 3 should not have linkage evidence"));
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    for (auto it : entry->SetSeq().SetInst().SetExt().SetDelta().Set()) {
        if (it->IsLiteral() && it->GetLiteral().IsSetSeq_data() &&
            it->GetLiteral().GetSeq_data().IsGap()) {
            CSeq_gap& gap = it->SetLiteral().SetSeq_data().SetGap();
            gap.ResetLinkage();
            gap.ResetType();
        }
    }
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical,
            "SeqGapBadLinkage", "Seq-gap with linkage evidence must have linkage field set to linked"));
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    evidence.push_back(CLinkage_evidence::eType_align_genus);
    for (auto it : entry->SetSeq().SetInst().SetExt().SetDelta().Set()) {
        if (it->IsLiteral() && it->GetLiteral().IsSetSeq_data() &&
            it->GetLiteral().GetSeq_data().IsGap()) {
            AdjustGap(it->SetLiteral().SetSeq_data().SetGap(),
                CSeq_gap::eType_fragment, true, evidence);
        }
    }
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error,
            "SeqGapBadLinkage", "Linkage evidence 'align genus' appears 2 times"));
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    evidence.pop_back();
    evidence.push_back(CLinkage_evidence::eType_unspecified);
    scope.RemoveTopLevelSeqEntry(seh);
    for (auto it : entry->SetSeq().SetInst().SetExt().SetDelta().Set()) {
        if (it->IsLiteral() && it->GetLiteral().IsSetSeq_data() &&
            it->GetLiteral().GetSeq_data().IsGap()) {
            AdjustGap(it->SetLiteral().SetSeq_data().SetGap(),
                CSeq_gap::eType_fragment, true, evidence);
        }
    }
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error,
            "SeqGapBadLinkage", "Seq-gap type has unspecified and additional linkage evidence"));
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    evidence.clear();
    evidence.push_back(CLinkage_evidence::eType_unspecified);
    for (auto it : entry->SetSeq().SetInst().SetExt().SetDelta().Set()) {
        if (it->IsLiteral() && it->GetLiteral().IsSetSeq_data() &&
            it->GetLiteral().GetSeq_data().IsGap()) {
            AdjustGap(it->SetLiteral().SetSeq_data().SetGap(),
                CSeq_gap::eType_unknown, true, evidence);
        }
    }
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning,
            "SeqGapBadLinkage", "Single Seq-gap has unknown type and unspecified linkage"));
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    CRef<CDelta_seq> gap_seg(new CDelta_seq());
    gap_seg->SetLiteral().SetLength(10);
    AdjustGap(gap_seg->SetLiteral().SetSeq_data().SetGap(),
                CSeq_gap::eType_unknown, true, evidence);
 
    // adjust delta to avoid errors about large number of Ns in first and last 50 bp
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLiteral().SetSeq_data().SetIupacna().Set("CCCATGATGATGTACCGTACGTTTTCCCATGATGATGTACCGTACGTTTT");
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLiteral().SetLength(50);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().push_back(gap_seg);
    entry->SetSeq().SetInst().SetExt().SetDelta().AddLiteral("CCCATGATGATGTACCGTACGTTTTCCCATGATGATGTACCGTACGTTTT", CSeq_inst::eMol_dna);
    entry->SetSeq().SetInst().SetLength(132);
 
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning,
            "SeqGapBadLinkage", "All 2 Seq-gaps have unknown type and unspecified linkage"));
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
void ChangeErrorAcc(vector<CExpectedError *> expected_errors, const string& acc)
{
    for (auto it : expected_errors) {
        if (it) {
            it->SetAccession(acc);
        }
    }
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_ConflictingIdsOnBioseq)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "ConflictingIdsOnBioseq", "Conflicting ids on a Bioseq: (lcl|good - lcl|bad)"));
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
 
    // local IDs
    scope.RemoveTopLevelSeqEntry(seh);
    CRef<CSeq_id> id2(new CSeq_id());
    id2->SetLocal().SetStr("bad");
    entry->SetSeq().SetId().push_back(id2);
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // GIBBSQ
    scope.RemoveTopLevelSeqEntry(seh);
    CRef<CSeq_id> id1 = entry->SetSeq().SetId().front();
    id1->SetGibbsq(1);
    id2->SetGibbsq(2);
    seh = scope.AddTopLevelSeqEntry(*entry);
    ChangeErrorAcc(expected_errors, "bbs|1");
    expected_errors[0]->SetErrMsg("Conflicting ids on a Bioseq: (bbs|1 - bbs|2)");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // GIBBSQ
    scope.RemoveTopLevelSeqEntry(seh);
    id1->SetGibbmt(1);
    id2->SetGibbmt(2);
    seh = scope.AddTopLevelSeqEntry(*entry);
    ChangeErrorAcc(expected_errors, "bbm|1");
    expected_errors[0]->SetErrMsg("Conflicting ids on a Bioseq: (bbm|1 - bbm|2)");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // GI
    scope.RemoveTopLevelSeqEntry(seh);
    id1->SetGi(GI_CONST(1));
    id2->SetGi(GI_CONST(2));
    CRef<CSeq_id> id3(new CSeq_id("gb|AY123456.1"));
    entry->SetSeq().SetId().push_back (id3);
    seh = scope.AddTopLevelSeqEntry(*entry);
    ChangeErrorAcc(expected_errors, "gb|AY123456.1|");
    expected_errors[0]->SetErrMsg("Conflicting ids on a Bioseq: (gi|1 - gi|2)");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    entry->SetSeq().SetId().pop_back();
 
    // GIIM
    scope.RemoveTopLevelSeqEntry(seh);
    id1->SetGiim().SetId(1);
    id1->SetGiim().SetDb("foo");
    id2->SetGiim().SetId(2);
    id2->SetGiim().SetDb("foo");
    seh = scope.AddTopLevelSeqEntry(*entry);
    CLEAR_ERRORS
 
    expected_errors.push_back(new CExpectedError("gim|1", eDiag_Error, "IdOnMultipleBioseqs", "BioseqFind (gim|1) unable to find itself - possible internal error"));
    expected_errors.push_back(new CExpectedError("gim|1", eDiag_Error, "ConflictingIdsOnBioseq", "Conflicting ids on a Bioseq: (gim|1 - gim|2)"));
    expected_errors.push_back(new CExpectedError("gim|1", eDiag_Error, "IdOnMultipleBioseqs", "BioseqFind (gim|2) unable to find itself - possible internal error"));
    // AddChromosomeNoLocation(expected_errors, "gim|1");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
 
    // patent
    scope.RemoveTopLevelSeqEntry(seh);
    id1->SetPatent().SetSeqid(1);
    id1->SetPatent().SetCit().SetCountry("USA");
    id1->SetPatent().SetCit().SetId().SetNumber("1");
    id2->SetPatent().SetSeqid(2);
    id2->SetPatent().SetCit().SetCountry("USA");
    id2->SetPatent().SetCit().SetId().SetNumber("2");
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors.push_back(new CExpectedError("pat|USA|1|1", eDiag_Error, "ConflictingIdsOnBioseq", "Conflicting ids on a Bioseq: (pat|USA|1|1 - pat|USA|2|2)"));
    // AddChromosomeNoLocation(expected_errors, "pat|USA|1|1");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // pdb
    scope.RemoveTopLevelSeqEntry(seh);
    id1->SetPdb().SetMol().Set("good");
    id2->SetPdb().SetMol().Set("badd");
    seh = scope.AddTopLevelSeqEntry(*entry);
    ChangeErrorAcc(expected_errors, "pdb|good| ");
    expected_errors[0]->SetErrMsg("Conflicting ids on a Bioseq: (pdb|good|  - pdb|badd| )");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // general
    scope.RemoveTopLevelSeqEntry(seh);
    id1->SetGeneral().SetDb("a");
    id1->SetGeneral().SetTag().SetStr("good");
    id2->SetGeneral().SetDb("a");
    id2->SetGeneral().SetTag().SetStr("bad");
    seh = scope.AddTopLevelSeqEntry(*entry);
    ChangeErrorAcc(expected_errors, "gnl|a|good");
    expected_errors[0]->SetErrMsg("Conflicting ids on a Bioseq: (gnl|a|good - gnl|a|bad)");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
    // should get no error if db values are different
    scope.RemoveTopLevelSeqEntry(seh);
    id2->SetGeneral().SetDb("b");
    seh = scope.AddTopLevelSeqEntry(*entry);
    // AddChromosomeNoLocation(expected_errors, "gnl|a|good");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // genbank
    scope.RemoveTopLevelSeqEntry(seh);
    expected_errors.push_back(new CExpectedError("gb|AY123456|", eDiag_Error, "ConflictingIdsOnBioseq", "Conflicting ids on a Bioseq: (gb|AY123456| - gb|AY222222|)"));
    id1->SetGenbank().SetAccession("AY123456");
    id2->SetGenbank().SetAccession("AY222222");
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // try genbank with accession same, versions different
    scope.RemoveTopLevelSeqEntry(seh);
    id2->SetGenbank().SetAccession("AY123456");
    id2->SetGenbank().SetVersion(2);
    seh = scope.AddTopLevelSeqEntry(*entry);
    CLEAR_ERRORS
    // AddChromosomeNoLocation(expected_errors, "gb|AY123456.2|");
    expected_errors.push_back(new CExpectedError("gb|AY123456.2|", eDiag_Error, "ConflictingIdsOnBioseq", "Conflicting ids on a Bioseq: (gb|AY123456| - gb|AY123456.2|)"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // try similar id type
    scope.RemoveTopLevelSeqEntry(seh);
    id2->SetGpipe().SetAccession("AY123456");
    seh = scope.AddTopLevelSeqEntry(*entry);
    CLEAR_ERRORS
    expected_errors.push_back(new CExpectedError("gb|AY123456|", eDiag_Error, "ConflictingIdsOnBioseq", "Conflicting ids on a Bioseq: (gb|AY123456| - gpp|AY123456|)"));
    // AddChromosomeNoLocation(expected_errors, "gb|AY123456|");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // LRG
    scope.RemoveTopLevelSeqEntry(seh);
    id1->SetGeneral().SetDb("LRG");
    id1->SetGeneral().SetTag().SetStr("good");
    seh = scope.AddTopLevelSeqEntry(*entry);
    ChangeErrorAcc(expected_errors, "gpp|AY123456|");
    expected_errors[0]->SetErrMsg("LRG sequence needs NG_ accession");
    expected_errors[0]->SetSeverity(eDiag_Critical);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    // no error if has NG
    scope.RemoveTopLevelSeqEntry(seh);
    id2->SetOther().SetAccession("NG_123456");
    seh = scope.AddTopLevelSeqEntry(*entry);
    CLEAR_ERRORS
    // AddChromosomeNoLocation(expected_errors, "ref|NG_123456|");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_MolNuclAcid)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
 
    STANDARD_SETUP
 
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "MolNuclAcid", "Bioseq.mol is type nucleic acid"));
 
    entry->SetSeq().SetInst().SetMol(CSeq_inst::eMol_na);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_ConflictingBiomolTech)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
 
    STANDARD_SETUP
 
    // allowed tech values
    vector<CMolInfo::TTech> genomic_list;
    genomic_list.push_back(CMolInfo::eTech_sts);
    genomic_list.push_back(CMolInfo::eTech_survey);
    genomic_list.push_back(CMolInfo::eTech_wgs);
    genomic_list.push_back(CMolInfo::eTech_htgs_0);
    genomic_list.push_back(CMolInfo::eTech_htgs_1);
    genomic_list.push_back(CMolInfo::eTech_htgs_2);
    genomic_list.push_back(CMolInfo::eTech_htgs_3);
    genomic_list.push_back(CMolInfo::eTech_composite_wgs_htgs);
 
    for (CMolInfo::TTech i = CMolInfo::eTech_unknown; i <= CMolInfo::eTech_tsa; i++) {
        bool genomic = false;
        for (CMolInfo::TTech it : genomic_list) {
            if (it == i) {
                genomic = true;
                break;
            }
        }
        entry->SetSeq().SetInst().SetMol(CSeq_inst::eMol_dna);
        SetTech (entry, i);
        unit_test_util::SetBiomol (entry, CMolInfo::eBiomol_cRNA);
        expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InconsistentMolType", "Molecule type (DNA) does not match biomol (RNA)"));
        if (i == CMolInfo::eTech_wgs) {
            AddChromosomeNoLocation(expected_errors, "lcl|good");
        }
        if (i == CMolInfo::eTech_est) {
            expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "ESTshouldBemRNA", "EST sequence should be mRNA"));
        }
        if (i == CMolInfo::eTech_htgs_2) {
            expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "BadHTGSeq", "HTGS 2 raw seq has no gaps and no graphs"));
        }
        if (genomic) {
            expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "HTGS_STS_GSS_WGSshouldBeGenomic", "HTGS/STS/GSS/WGS sequence should be genomic"));
            eval = validator.Validate(seh, options);
            CheckErrors(*eval, expected_errors);
            unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_genomic);
            entry->SetSeq().SetInst().SetMol(CSeq_inst::eMol_rna);
            delete expected_errors[0];
            expected_errors[0] = nullptr;
            expected_errors.back()->SetErrCode("HTGS_STS_GSS_WGSshouldNotBeRNA");
            expected_errors.back()->SetErrMsg("HTGS/STS/GSS/WGS sequence should not be RNA");
            eval = validator.Validate(seh, options);
            CheckErrors(*eval, expected_errors);
        } else {
            if (IsProteinTech(i)) {
                expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "ProteinTechniqueOnNucleotide", "Nucleic acid with protein sequence method"));
            }
            if (i == CMolInfo::eTech_barcode) {
                expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "NoKeywordHasTechnique", "Molinfo.tech barcode without BARCODE keyword"));
            } else if (i == CMolInfo::eTech_tsa) {
                expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "TSAshouldBNotBeDNA", "TSA sequence should not be DNA"));
                expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "WrongBiomolForTSA", "Biomol \"cRNA\" is not appropriate for sequences that use the TSA technique."));
            }
            eval = validator.Validate(seh, options);
            CheckErrors(*eval, expected_errors);
        }
        CLEAR_ERRORS
    }
 
    entry->SetSeq().SetInst().SetMol(CSeq_inst::eMol_dna);
    SetTech (entry, CMolInfo::eTech_tsa);
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InconsistentMolType", "Molecule type (DNA) does not match biomol (RNA)"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "TSAshouldBNotBeDNA", "TSA sequence should not be DNA"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "WrongBiomolForTSA", "Biomol \"cRNA\" is not appropriate for sequences that use the TSA technique."));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "TSAshouldBNotBeDNA", "TSA sequence should not be DNA"));
    eval = validator.GetTSAConflictingBiomolTechErrors(seh);
    CheckErrors(*eval, expected_errors);
    eval = validator.GetTSAConflictingBiomolTechErrors(*(seh.GetSeq().GetCompleteBioseq()));
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_SeqIdNameHasSpace)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetId().front()->SetOther().SetAccession("NC_123456");
    entry->SetSeq().SetId().front()->SetOther().SetName("good one");
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("ref|NC_123456|good one", eDiag_Critical, "SeqIdNameHasSpace", "Seq-id.name 'good one' should be a single word without any spaces"));
    // AddChromosomeNoLocation(expected_errors, "ref|NC_123456|good one");
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_DuplicateSegmentReferences)
{
#if 0
    // removed per VR-779
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetInst().ResetSeq_data();
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_seg);
    CRef<CSeq_loc> seg1 (new CSeq_loc());
    seg1->SetWhole().SetGenbank().SetAccession("AY123456");
    entry->SetSeq().SetInst().SetExt().SetSeg().Set().push_back(seg1);
    CRef<CSeq_loc> seg2 (new CSeq_loc());
    seg2->SetWhole().SetGenbank().SetAccession("AY123456");
    entry->SetSeq().SetInst().SetExt().SetSeg().Set().push_back(seg2);
    entry->SetSeq().SetInst().SetLength(970);
 
    CRef<CObjectManager> objmgr = CObjectManager::GetInstance();
    // need to call this statement before calling AddDefaults
    // to make sure that we can fetch the sequence referenced by the
    // delta sequence so that we can detect that the loc in the
    // delta sequence is longer than the referenced sequence
    CGBDataLoader::RegisterInObjectManager(*objmgr);
    CScope scope(*objmgr);
    scope.AddDefaults();
    CSeq_entry_Handle seh = scope.AddTopLevelSeqEntry(*entry);
 
    CValidator validator(*objmgr);
 
    // Set validator options
    unsigned int options = CValidator::eVal_need_isojta
                          | CValidator::eVal_far_fetch_mrna_products
                          | CValidator::eVal_validate_id_set | CValidator::eVal_indexer_version
                          | CValidator::eVal_use_entrez;
 
    // list of expected errors
    vector< CExpectedError *> expected_errors;
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "SeqLocOrder", "Segmented BioseqIntervals out of order in SeqLoc [[gb|AY123456|, gb|AY123456|]]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "DuplicateSegmentReferences", "Segmented sequence has multiple references to gb|AY123456"));
    CConstRef<CValidError> eval;
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    seg2->SetInt().SetId().SetGenbank().SetAccession("AY123456");
    seg2->SetInt().SetFrom(0);
    seg2->SetInt().SetTo(484);
    expected_errors[0]->SetErrMsg("Segmented BioseqIntervals out of order in SeqLoc [[gb|AY123456|, 1-485]]");
    expected_errors[1]->SetSeverity(eDiag_Warning);
    expected_errors[1]->SetErrMsg("Segmented sequence has multiple references to gb|AY123456 that are not SEQLOC_WHOLE");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
#endif
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_TrailingX)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodNucProtSet();
    CRef<CSeq_entry> nuc = entry->SetSet().SetSeq_set().front();
    CRef<CSeq_entry> prot = entry->SetSet().SetSeq_set().back();
    CRef<CSeq_feat> prot_feat = prot->SetSeq().SetAnnot().front()->SetData().SetFtable().front();
    CRef<CSeq_feat> cds_feat = unit_test_util::GetCDSFromGoodNucProtSet(entry);
    nuc->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("ATGCCCAGAAAAACAGAGATANNNNNN");
    nuc->SetSeq().SetInst().SetLength(27);
    prot->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set("MPRKTEIXX");
    prot->SetSeq().SetInst().SetLength(9);
    unit_test_util::SetCompleteness (prot, CMolInfo::eCompleteness_no_right);
    prot_feat->SetLocation().SetInt().SetTo(8);
    prot_feat->SetLocation().SetPartialStop(true, eExtreme_Biological);
    prot_feat->SetPartial(true);
    cds_feat->SetLocation().SetPartialStop(true, eExtreme_Biological);
    cds_feat->SetPartial(true);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|nuc", eDiag_Warning, "TerminalNs", "N at end of sequence"));
    expected_errors.push_back(new CExpectedError("lcl|prot", eDiag_Warning, "TrailingX", "Sequence ends in 2 trailing Xs"));
    expected_errors.push_back(new CExpectedError("lcl|nuc", eDiag_Info, "HighNpercent3Prime",
        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    // AddChromosomeNoLocation(expected_errors, "lcl|nuc");
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
}
 
 
void TestBadProtId(const string& id_str)
{
    // bad for just prots
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodNucProtSet();
    CRef<CSeq_id> bad_id(new CSeq_id());
    bad_id->SetGenbank().SetAccession(id_str);
    CRef<CSeq_id> good_nuc_id(new CSeq_id());
    good_nuc_id->SetLocal().SetStr("nuc");
    CRef<CSeq_id> good_prot_id(new CSeq_id());
    good_prot_id->SetLocal().SetStr("prot");
 
    unit_test_util::ChangeNucId(entry, good_nuc_id);
    unit_test_util::ChangeProtId(entry, bad_id);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("gb|" + id_str + "|", eDiag_Error, "BadSeqIdFormat", "Bad accession " + id_str));
    // AddChromosomeNoLocation(expected_errors, "lcl|nuc");
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
}
 
 
void TestGoodProtId(const string& id_str)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodNucProtSet();
    CRef<CSeq_id> bad_id(new CSeq_id());
    bad_id->SetGenbank().SetAccession(id_str);
    CRef<CSeq_id> good_nuc_id(new CSeq_id());
    good_nuc_id->SetLocal().SetStr("nuc");
    CRef<CSeq_id> good_prot_id(new CSeq_id());
    good_prot_id->SetLocal().SetStr("prot");
 
    unit_test_util::ChangeNucId(entry, good_nuc_id);
    unit_test_util::ChangeProtId(entry, bad_id);
 
    STANDARD_SETUP
 
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, "lcl|nuc");
 
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
}
 
 
void TestGoodNucId(const string& id_str)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodNucProtSet();
    CRef<CSeq_id> bad_id(new CSeq_id());
    bad_id->SetGenbank().SetAccession(id_str);
    CRef<CSeq_id> good_prot_id(new CSeq_id());
    good_prot_id->SetLocal().SetStr("prot");
    unit_test_util::ChangeNucId(entry, bad_id);
    unit_test_util::ChangeProtId(entry, good_prot_id);
    bool is_wgs = false;
    if (id_str.length() == 12 || id_str.length() == 13 || id_str.length() == 14 || id_str.length() == 15) {
        SetTech(entry->SetSet().SetSeq_set().front(), CMolInfo::eTech_wgs);
        is_wgs = true;
    }
 
    STANDARD_SETUP
 
    if (is_wgs) {
        AddChromosomeNoLocation(expected_errors, "gb|" + id_str + "|");
    }
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
}
 
 
BOOST_FIXTURE_TEST_CASE(Test_SEQ_INST_BadSeqIdFormat, CGenBankFixture)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodNucProtSet();
    CRef<CSeq_entry> nuc_entry = entry->SetSet().SetSeq_set().front();
    CRef<CSeq_entry> prot_entry = entry->SetSet().SetSeq_set().back();
    CRef<CSeq_feat> prot_feat = prot_entry->SetSeq().SetAnnot().front()->SetData().SetFtable().front();
    CRef<CSeq_feat> cds = unit_test_util::GetCDSFromGoodNucProtSet(entry);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("",eDiag_Error, "BadSeqIdFormat", "Bad accession"));
 
    vector<string> bad_ids;
    bad_ids.push_back("AY123456ABC");  // can't have letters after digits
    bad_ids.push_back("A1234");        // for a single letter, only acceptable number of digits is 5
    bad_ids.push_back("A123456");
    bad_ids.push_back("AY12345");      // for two letters, only acceptable number of digits is 6
    bad_ids.push_back("AY1234567");
    bad_ids.push_back("ABC1234");      // three letters bad unless prot and 5 digits
    bad_ids.push_back("ABC123456");
    bad_ids.push_back("ABCD1234567");  // four letters
    bad_ids.push_back("ABCDE123456");  // five letters
    bad_ids.push_back("ABCDE12345678");
 
    vector<string> bad_nuc_ids;
    bad_nuc_ids.push_back("ABC12345");
 
    vector<string> bad_prot_ids;
    bad_prot_ids.push_back("AY123456");
    bad_prot_ids.push_back("A12345");
 
    vector<string> good_ids;
 
    vector<string> good_nuc_ids;
    good_nuc_ids.push_back("AY123456");
    good_nuc_ids.push_back("A12345");
    good_nuc_ids.push_back("ABCD123456789");
    good_nuc_ids.push_back("ABCD1234567890");
 
    vector<string> good_prot_ids;
    good_prot_ids.push_back("ABC12345");
 
 
    CRef<CSeq_id> good_nuc_id(new CSeq_id());
    good_nuc_id->SetLocal().SetStr("nuc");
    CRef<CSeq_id> good_prot_id(new CSeq_id());
    good_prot_id->SetLocal().SetStr("prot");
 
    CRef<CSeq_id> bad_id(new CSeq_id());
 
    // bad for both
    for (const string& id_str : bad_ids) {
        const string acc_str = "gb|" + id_str + "|";
        ChangeErrorAcc(expected_errors, acc_str);
        expected_errors[0]->SetErrMsg("Bad accession " + id_str);
 
        // GenBank
        scope.RemoveTopLevelSeqEntry(seh);
        scope.ResetDataAndHistory();
        bad_id->SetGenbank().SetAccession(id_str);
        unit_test_util::ChangeNucId(entry, bad_id);
        unit_test_util::ChangeProtId(entry, good_prot_id);
        seh = scope.AddTopLevelSeqEntry(*entry);
        eval = validator.Validate(seh, options);
        CheckErrors(*eval, expected_errors);
        scope.RemoveTopLevelSeqEntry(seh);
        scope.ResetDataAndHistory();
        unit_test_util::ChangeNucId(entry, good_nuc_id);
        unit_test_util::ChangeProtId(entry, bad_id);
        seh = scope.AddTopLevelSeqEntry(*entry);
        eval = validator.Validate(seh, options);
        CheckErrors(*eval, expected_errors);
    }
 
    for (const string& id_it : bad_ids) {
        const string id_str = "B" + id_it.substr(1);
        expected_errors[0]->SetAccession("embl|" + id_str + "|");
        expected_errors[0]->SetErrMsg("Bad accession " + id_str);
 
        // EMBL
        scope.RemoveTopLevelSeqEntry(seh);
        scope.ResetDataAndHistory();
        bad_id->SetEmbl().SetAccession(id_str);
        unit_test_util::ChangeNucId(entry, bad_id);
        unit_test_util::ChangeProtId(entry, good_prot_id);
        seh = scope.AddTopLevelSeqEntry(*entry);
        eval = validator.Validate(seh, options);
        expected_errors[0]->SetAccession("emb|" + id_str + "|");
        CheckErrors(*eval, expected_errors);
        scope.RemoveTopLevelSeqEntry(seh);
        scope.ResetDataAndHistory();
        unit_test_util::ChangeNucId(entry, good_nuc_id);
        unit_test_util::ChangeProtId(entry, bad_id);
        seh = scope.AddTopLevelSeqEntry(*entry);
        eval = validator.Validate(seh, options);
        CheckErrors(*eval, expected_errors);
    }
 
    for (const string& id_it : bad_ids) {
        const string id_str = "C" + id_it.substr(1);
        expected_errors[0]->SetAccession("dbj|" + id_str + "|");
        expected_errors[0]->SetErrMsg("Bad accession " + id_str);
 
        // DDBJ
        scope.RemoveTopLevelSeqEntry(seh);
        scope.ResetDataAndHistory();
        bad_id->SetDdbj().SetAccession(id_str);
        unit_test_util::ChangeNucId(entry, bad_id);
        unit_test_util::ChangeProtId(entry, good_prot_id);
        seh = scope.AddTopLevelSeqEntry(*entry);
        eval = validator.Validate(seh, options);
        expected_errors[0]->SetAccession("dbj|" + id_str + "|");
        CheckErrors(*eval, expected_errors);
        scope.RemoveTopLevelSeqEntry(seh);
        scope.ResetDataAndHistory();
        unit_test_util::ChangeNucId(entry, good_nuc_id);
        unit_test_util::ChangeProtId(entry, bad_id);
        seh = scope.AddTopLevelSeqEntry(*entry);
        eval = validator.Validate(seh, options);
        CheckErrors(*eval, expected_errors);
    }
 
    // bad for just nucs
    for (const string& id_str : bad_nuc_ids) {
        bad_id->SetGenbank().SetAccession(id_str);
        scope.RemoveTopLevelSeqEntry(seh);
        unit_test_util::ChangeNucId(entry, bad_id);
        unit_test_util::ChangeProtId(entry, good_prot_id);
        expected_errors[0]->SetAccession("gb|" + id_str + "|");
        expected_errors[0]->SetErrMsg("Bad accession " + id_str);
        seh = scope.AddTopLevelSeqEntry(*entry);
        eval = validator.Validate(seh, options);
        CheckErrors(*eval, expected_errors);
    }
 
    // bad for just prots
    for (auto id_it : bad_prot_ids) {
        TestBadProtId(id_it);
    }
 
    CLEAR_ERRORS
 
    // good for both
    for (const string& id_str : good_ids) {
        bad_id->SetGenbank().SetAccession(id_str);
        scope.RemoveTopLevelSeqEntry(seh);
        unit_test_util::ChangeNucId(entry, bad_id);
        unit_test_util::ChangeProtId(entry, good_prot_id);
        seh = scope.AddTopLevelSeqEntry(*entry);
        eval = validator.Validate(seh, options);
        // AddChromosomeNoLocation(expected_errors, "gb|" + *id_it + "|");
        CheckErrors(*eval, expected_errors);
        scope.RemoveTopLevelSeqEntry(seh);
        unit_test_util::ChangeNucId(entry, good_nuc_id);
        unit_test_util::ChangeProtId(entry, bad_id);
        seh = scope.AddTopLevelSeqEntry(*entry);
        eval = validator.Validate(seh, options);
        CheckErrors(*eval, expected_errors);
        CLEAR_ERRORS
    }
 
    // good for nucs
    for (const string& id_it : good_nuc_ids) {
        TestGoodNucId(id_it);
    }
 
    // good for just prots
    for (const string& id_it : good_prot_ids) {
        TestGoodProtId(id_it);
    }
 
    // if GI, needs version
    scope.RemoveTopLevelSeqEntry(seh);
    bad_id->SetGenbank().SetAccession("AY123456");
    bad_id->SetGenbank().SetVersion(0);
    unit_test_util::ChangeNucId(entry, bad_id);
    unit_test_util::ChangeProtId(entry, good_prot_id);
    CRef<CSeq_id> gi_id(new CSeq_id("gi|21914627"));
    nuc_entry->SetSeq().SetId().push_back(gi_id);
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    expected_errors.push_back (new CExpectedError ("gb|AY123456|", eDiag_Critical, "BadSeqIdFormat",
                                                   "Accession AY123456 has 0 version"));
    expected_errors.push_back (new CExpectedError ("gb|AY123456|", eDiag_Warning, "UnexpectedIdentifierChange", "New accession (gb|AY123456|) does not match one in NCBI sequence repository (gb|AY123456.1|) on gi (21914627)"));
    // AddChromosomeNoLocation(expected_errors, "gb|AY123456|");
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    nuc_entry->SetSeq().SetId().pop_back();
 
    // id that is too long
    scope.RemoveTopLevelSeqEntry(seh);
    bad_id->SetLocal().SetStr("ABCDEFGHIJKLMNOPQRSTUVWXYZ012345678901234");
    unit_test_util::ChangeNucId(entry, bad_id);
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, "lcl|ABCDEFGHIJKLMNOPQRSTUVWXYZ012345678901234");
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // shouldn't report if ncbifile ID
    scope.RemoveTopLevelSeqEntry(seh);
    CRef<CSeq_id> ncbifile(new CSeq_id("gnl|NCBIFILE|ABCDEFGHIJKLMNOPQRSTUVWXYZ012345678901234"));
    unit_test_util::ChangeNucId(entry, good_nuc_id);
    nuc_entry->SetSeq().SetId().push_back(ncbifile);
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, entry);
    CheckErrors(*eval, expected_errors);
    nuc_entry->SetSeq().SetId().pop_back();
    CLEAR_ERRORS
 
    // report if database name len too long
    scope.RemoveTopLevelSeqEntry(seh);
    entry = unit_test_util::BuildGoodSeq();
    CRef<CSeq_id> general(new CSeq_id());
    general->SetGeneral().SetDb("thisdatabasevalueislong");
    general->SetGeneral().SetTag().SetStr("b");
    entry->SetSeq().ResetId();
    entry->SetSeq().SetId().push_back(general);
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors.push_back (new CExpectedError ("gnl|thisdatabasevalueislong|b", eDiag_Critical, "BadSeqIdFormat",
                                                   "General database longer than 20 characters"));
 
    // AddChromosomeNoLocation(expected_errors, "gnl|thisdatabasevalueislong|b");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // do not report forward slash
    scope.RemoveTopLevelSeqEntry(seh);
    entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetId().front()->SetLocal().SetStr("a/b");
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, "lcl|a/b");
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
void TestOneGeneralSeqId(const string& db, const string& tag, const string& errmsg)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    CRef<CSeq_id> id(new CSeq_id());
    id->SetGeneral().SetDb(db);
    id->SetGeneral().SetTag().SetStr(tag);
    entry->SetSeq().SetId().push_back(id);
 
    STANDARD_SETUP
 
    string acc_str = "lcl|good";
    if (!errmsg.empty()) {
        expected_errors.push_back(new CExpectedError(acc_str, eDiag_Warning, "BadSeqIdCharacter",
            errmsg));
    }
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_VR_748)
{
    TestOneGeneralSeqId("PRJNA318798", " CpPA02_0001", "Bad character ' ' in sequence ID 'gnl|PRJNA318798| CpPA02_0001'");
    TestOneGeneralSeqId("PRJNA3 18798", "CpPA02_0001", "Bad character ' ' in sequence ID 'gnl|PRJNA3 18798|CpPA02_0001'");
}
 
 
void TestOneLongGeneral(bool emb, bool err)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    CRef<CSeq_id> id(new CSeq_id());
    id->SetGeneral().SetDb("lgsi");
    id->SetGeneral().SetTag().SetStr("thisidentifierismorethanfiftycharactersinlengthsoitshouldberejected");
    entry->SetSeq().SetId().push_back(id);
 
    if (emb) {
        CRef<CSeq_id> emb(new CSeq_id());
        emb->SetEmbl().SetAccession("AY123457");
        emb->SetEmbl().SetVersion(1);
        entry->SetSeq().SetId().push_back(emb);
    }
 
    STANDARD_SETUP
 
    if (err) {
        string acc_str = "lcl|good";
        expected_errors.push_back(new CExpectedError(acc_str, eDiag_Critical, "BadSeqIdLength",
                                  "General identifier longer than 50 characters"));
    }
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_LongGeneralSeqId)
{
    TestOneLongGeneral(false, true);
    TestOneLongGeneral(true, false);
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_BadSecondaryAccn)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetId().front()->SetGenbank().SetAccession("AY123456");
 
    STANDARD_SETUP
 
    CRef<CSeqdesc> gbdesc (new CSeqdesc());
    gbdesc->SetGenbank().SetExtra_accessions().push_back("AY123456");
    entry->SetSeq().SetDescr().Set().push_back(gbdesc);
 
    expected_errors.push_back(new CExpectedError("gb|AY123456|", eDiag_Error, "BadSecondaryAccn", "AY123456 used for both primary and secondary accession"));
    // AddChromosomeNoLocation(expected_errors, "gb|AY123456|");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    gbdesc->SetEmbl().SetExtra_acc().push_back("AY123456");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SEQ_INST_ZeroGiNumber)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetId().front()->SetGi(ZERO_GI);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("gi|0", eDiag_Critical, "ZeroGiNumber", "Invalid GI number"));
    expected_errors.push_back(new CExpectedError("gi|0", eDiag_Error, "GiWithoutAccession", "No accession on sequence with gi number"));
    // AddChromosomeNoLocation(expected_errors, "gi|0");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_HistoryGiCollision)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetId().front()->SetGenbank().SetAccession("AY123456");
    entry->SetSeq().SetId().front()->SetGenbank().SetVersion(1);
    CRef<CSeq_id> gi_id(new CSeq_id());
    gi_id->SetGi(GI_CONST(21914627));
    entry->SetSeq().SetId().push_back(gi_id);
 
    STANDARD_SETUP
 
    CRef<CSeq_id> hist_id(new CSeq_id());
    hist_id->SetGi(GI_CONST(21914627));
    entry->SetSeq().SetInst().SetHist().SetReplaced_by().SetIds().push_back(hist_id);
    entry->SetSeq().SetInst().SetHist().SetReplaced_by().SetDate().SetStd().SetYear(2008);
 
    expected_errors.push_back(new CExpectedError("gb|AY123456.1|", eDiag_Error, "HistoryGiCollision", "Replaced by gi (21914627) is same as current Bioseq"));
    // AddChromosomeNoLocation(expected_errors, "gb|AY123456.1|");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetHist().ResetReplaced_by();
    entry->SetSeq().SetInst().SetHist().SetReplaces().SetIds().push_back(hist_id);
    entry->SetSeq().SetInst().SetHist().SetReplaces().SetDate().SetStd().SetYear(2008);
    expected_errors[0]->SetErrMsg("Replaces gi (21914627) is same as current Bioseq");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // should not generate errors if date has not been set
    entry->SetSeq().SetInst().SetHist().ResetReplaces();
    entry->SetSeq().SetInst().SetHist().SetReplaced_by().SetIds().push_back(hist_id);
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, entry);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetHist().ResetReplaced_by();
    entry->SetSeq().SetInst().SetHist().SetReplaces().SetIds().push_back(hist_id);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_GiWithoutAccession)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetId().front()->SetGi(GI_CONST(123456));
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("gi|123456", eDiag_Error, "GiWithoutAccession", "No accession on sequence with gi number"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
void TestOneOtherAcc(CRef<CSeq_id> other_acc, bool id_change, bool conflict, bool need_hist = false)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetId().front()->SetGenbank().SetAccession("AY123456");
    entry->SetSeq().SetId().front()->SetGenbank().SetVersion(1);
    CRef<CSeq_id> gi_id(new CSeq_id());
    gi_id->SetGi(GI_CONST(21914627));
    entry->SetSeq().SetId().push_back(gi_id);
    entry->SetSeq().SetId().push_back(other_acc);
    string acc_str = "gb|AY123456.1|";
 
    STANDARD_SETUP
 
    if (conflict) {
        expected_errors.push_back(new CExpectedError("gb|AY123456.1|", eDiag_Error, "ConflictingIdsOnBioseq",
            "Conflicting ids on a Bioseq: (gb|AY123456.1| - " + other_acc->AsFastaString() + ")"));
    }
    expected_errors.push_back(new CExpectedError(acc_str, eDiag_Error, "MultipleAccessions", "Multiple accessions on sequence with gi number"));
    if (id_change) {
        expected_errors.push_back(new CExpectedError("gb|AY123456.1|", eDiag_Warning, "UnexpectedIdentifierChange", "New accession (gb|AY123457.1|) does not match one in NCBI sequence repository (gb|AY123456.1|) on gi (21914627)"));
    }
    if (need_hist) {
        expected_errors.push_back(new CExpectedError("gb|AY123456.1|", eDiag_Info, "HistAssemblyMissing",
            "TPA record gb|AY123456.1| should have Seq-hist.assembly for PRIMARY block"));
    }
    // AddChromosomeNoLocation(expected_errors, acc_str);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_FIXTURE_TEST_CASE(Test_MultipleAccessions, CGenBankFixture)
{
    CRef<CSeq_id> other_acc(new CSeq_id());
 
    // genbank, ddbj, embl, tpg, tpe, tpd, other, pir, swissprot, and prf all count as accessionts
    // genbank
    other_acc->SetGenbank().SetAccession("AY123457");
    other_acc->SetGenbank().SetVersion(1);
    TestOneOtherAcc(other_acc, true, true);
 
    // ddbj
    other_acc->SetDdbj().SetAccession("AY123457");
    other_acc->SetDdbj().SetVersion(1);
    TestOneOtherAcc(other_acc, false, true);
 
    // embl
    other_acc->SetEmbl().SetAccession("AY123457");
    other_acc->SetEmbl().SetVersion(1);
    TestOneOtherAcc(other_acc, false, true);
 
    // pir
    other_acc->SetPir().SetAccession("AY123457");
    other_acc->SetPir().SetVersion(1);
    TestOneOtherAcc(other_acc, false, false);
 
    // swissprot
    other_acc->SetSwissprot().SetAccession("AY123457");
    other_acc->SetSwissprot().SetVersion(1);
    TestOneOtherAcc(other_acc, false, false);
 
    // prf
    other_acc->SetPrf().SetAccession("AY123457");
    other_acc->SetPrf().SetVersion(1);
    TestOneOtherAcc(other_acc, false, false);
 
    // tpg
    other_acc->SetTpg().SetAccession("AY123457");
    other_acc->SetTpg().SetVersion(1);
    TestOneOtherAcc(other_acc, false, true, true);
 
    // tpe
    other_acc->SetTpe().SetAccession("AY123457");
    other_acc->SetTpe().SetVersion(1);
    TestOneOtherAcc(other_acc, false, true, true);
 
    // tpd
    other_acc->SetTpd().SetAccession("AY123457");
    other_acc->SetTpd().SetVersion(1);
    TestOneOtherAcc(other_acc, false, true, true);
 
    // other
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetId().front()->SetGenbank().SetAccession("AY123456");
    entry->SetSeq().SetId().front()->SetGenbank().SetVersion(1);
    CRef<CSeq_id> gi_id(new CSeq_id());
    gi_id->SetGi(GI_CONST(21914627));
    entry->SetSeq().SetId().push_back(gi_id);
    entry->SetSeq().SetId().push_back(other_acc);
    other_acc->SetOther().SetAccession("NC_123457");
    other_acc->SetOther().SetVersion(1);
 
    STANDARD_SETUP
 
    string acc_str = "gb|AY123456.1|";
    expected_errors.push_back(new CExpectedError(acc_str, eDiag_Error, "INSDRefSeqPackaging", "INSD and RefSeq records should not be present in the same set"));
    expected_errors.push_back(new CExpectedError(acc_str, eDiag_Error, "MultipleAccessions", "Multiple accessions on sequence with gi number"));
    // AddChromosomeNoLocation(expected_errors, acc_str);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_HistAssemblyMissing)
{
    CRef<CSeq_entry> tpg_entry = unit_test_util::BuildGoodSeq();
    tpg_entry->SetSeq().SetId().front()->SetTpg().SetAccession("AY123456");
    tpg_entry->SetSeq().SetId().front()->SetTpg().SetVersion(1);
 
    CRef<CSeq_entry> tpe_entry = unit_test_util::BuildGoodSeq();
    tpe_entry->SetSeq().SetId().front()->SetTpe().SetAccession("AY123456");
    tpe_entry->SetSeq().SetId().front()->SetTpe().SetVersion(1);
 
    CRef<CSeq_entry> tpd_entry = unit_test_util::BuildGoodSeq();
    tpd_entry->SetSeq().SetId().front()->SetTpd().SetAccession("AY123456");
    tpd_entry->SetSeq().SetId().front()->SetTpd().SetVersion(1);
 
    STANDARD_SETUP_NAME(tpg_entry)
 
    // tpg
    expected_errors.push_back(new CExpectedError("tpg|AY123456.1|", eDiag_Info, "HistAssemblyMissing", "TPA record tpg|AY123456.1| should have Seq-hist.assembly for PRIMARY block"));
    // AddChromosomeNoLocation(expected_errors, tpg_entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // tpe
    scope.RemoveTopLevelSeqEntry(seh);
    seh = scope.AddTopLevelSeqEntry(*tpe_entry);
    ChangeErrorAcc(expected_errors, "tpe|AY123456.1|");
    expected_errors[0]->SetErrMsg("TPA record tpe|AY123456.1| should have Seq-hist.assembly for PRIMARY block");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
 
    // tpd
    scope.RemoveTopLevelSeqEntry(seh);
    seh = scope.AddTopLevelSeqEntry(*tpd_entry);
    ChangeErrorAcc(expected_errors, "tpd|AY123456.1|");
    expected_errors[0]->SetErrMsg("TPA record tpd|AY123456.1| should have Seq-hist.assembly for PRIMARY block");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // error suppressed if keyword present
    CRef<CSeqdesc> block(new CSeqdesc());
    block->SetGenbank().SetKeywords().push_back("TPA:reassembly");
    tpg_entry->SetSeq().SetDescr().Set().push_back(block);
    scope.RemoveTopLevelSeqEntry(seh);
    seh = scope.AddTopLevelSeqEntry(*tpg_entry);
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, tpg_entry);
 
    CheckErrors(*eval, expected_errors);
    block->SetEmbl().SetKeywords().push_back("TPA:reassembly");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
}
 
BOOST_AUTO_TEST_CASE(Test_TerminalNs)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("NNNNNNNNNNAAATTGGCCAAAATTGGCCAAAATTGGCCAAAATTGGCCCAANNNNNNNNNN");
    entry->SetSeq().SetInst().SetLength(62);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "TerminalNs", "N at beginning of sequence"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "TerminalNs", "N at end of sequence"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "HighNpercent5Prime",
        "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "HighNpercent3Prime",
        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // warning level changes if not local only
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetGenbank().SetAccession("AY123456");
    seh = scope.AddTopLevelSeqEntry(*entry);
    ChangeErrorAcc(expected_errors, "gb|AY123456|");
    expected_errors[0]->SetSeverity(eDiag_Error);
    expected_errors[1]->SetSeverity(eDiag_Error);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // also try delta sequence
    scope.RemoveTopLevelSeqEntry(seh);
    entry = unit_test_util::BuildGoodDeltaSeq ();
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLiteral().SetSeq_data().SetIupacna().Set("NNNNNNNNNCCC");
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().back()->SetLiteral().SetSeq_data().SetIupacna().Set("CCCNNNNNNNNN");
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "ContigsTooShort", "Maximum contig length is 3 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "TerminalNs", "N at beginning of sequence"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "TerminalNs", "N at end of sequence"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNContentPercent", "Sequence contains 52 percent Ns"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // 10 Ns but just local stays at warning
    scope.RemoveTopLevelSeqEntry(seh);
    entry = unit_test_util::BuildGoodDeltaSeq ();
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLiteral().SetSeq_data().SetIupacna().Set("NNNNNNNNNNCC");
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().back()->SetLiteral().SetSeq_data().SetIupacna().Set("CCNNNNNNNNNN");
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors[0]->SetErrMsg("Maximum contig length is 2 bases");
    expected_errors.back()->SetErrMsg ("Sequence contains 58 percent Ns");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // 10 Ns but now has non-local ID, error
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetGenbank().SetAccession("AY123456");
    seh = scope.AddTopLevelSeqEntry(*entry);
    ChangeErrorAcc(expected_errors, "gb|AY123456|");
    expected_errors[1]->SetSeverity(eDiag_Error);
    expected_errors[2]->SetSeverity(eDiag_Error);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // NC and patent IDs back to warning
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetOther().SetAccession("NC_123456");
    seh = scope.AddTopLevelSeqEntry(*entry);
    ChangeErrorAcc(expected_errors, "ref|NC_123456|");
    expected_errors[1]->SetSeverity(eDiag_Warning);
    expected_errors[2]->SetSeverity(eDiag_Warning);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetPatent().SetSeqid(1);
    entry->SetSeq().SetId().front()->SetPatent().SetCit().SetCountry("USA");
    entry->SetSeq().SetId().front()->SetPatent().SetCit().SetId().SetNumber("1");
    seh = scope.AddTopLevelSeqEntry(*entry);
    ChangeErrorAcc(expected_errors, "pat|USA|1|1");
    delete expected_errors.back();
    expected_errors.pop_back();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
 
    // no more TerminalNs warnings if circular
    entry->SetSeq().SetInst().SetTopology(CSeq_inst::eTopology_circular);
    unit_test_util::SetCompleteness(entry, CMolInfo::eCompleteness_complete);
    expected_errors.push_back(new CExpectedError("pat|USA|1|1", eDiag_Error, "ContigsTooShort",
                "Maximum contig length is 2 bases"));
    expected_errors.push_back(new CExpectedError("pat|USA|1|1", eDiag_Warning, "UnwantedCompleteFlag",
                "Suspicious use of complete"));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_FIXTURE_TEST_CASE(Test_UnexpectedIdentifierChange, CGenBankFixture)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetId().front()->SetGenbank().SetAccession("AY123457");
    entry->SetSeq().SetId().front()->SetGenbank().SetVersion(1);
    CRef<CSeq_id> gi_id(new CSeq_id());
    gi_id->SetGi(GI_CONST(21914627));
    entry->SetSeq().SetId().push_back(gi_id);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("gb|AY123457.1|", eDiag_Warning, "UnexpectedIdentifierChange", "New accession (gb|AY123457.1|) does not match one in NCBI sequence repository (gb|AY123456.1|) on gi (21914627)"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetTpg().SetAccession("AY123456");
    entry->SetSeq().SetId().front()->SetTpg().SetVersion(1);
    seh = scope.AddTopLevelSeqEntry(*entry);
    // AddChromosomeNoLocation(expected_errors, entry);
    expected_errors.push_back(new CExpectedError("tpg|AY123456.1|", eDiag_Info, "HistAssemblyMissing", "TPA record tpg|AY123456.1| should have Seq-hist.assembly for PRIMARY block"));
    expected_errors.push_back(new CExpectedError("tpg|AY123456.1|", eDiag_Warning, "UnexpectedIdentifierChange", "Loss of accession (gb|AY123456.1|) on gi (21914627) compared to the NCBI sequence repository"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // TODO - try to instigate other errors
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_InternalNsInSeqLit)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
    unit_test_util::AddToDeltaSeq(entry, "AANNNNNNNNNNNNNNNNNNNNGG");
    SetTech(entry, CMolInfo::eTech_wgs);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "InternalNsInSeqLit", "Run of 20 Ns in delta component 5 that starts at base 45"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "WGSseqGapProblem", "WGS submission includes wrong gap type. Gaps for WGS genomes should be Assembly Gaps with linkage evidence."));
    /*
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent5Prime",
        "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent3Prime",
        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    */
    AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    unit_test_util::AddToDeltaSeq(entry, "AANNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNGG");
    SetTech(entry, CMolInfo::eTech_htgs_1);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "InternalNsInSeqLit",
        "Run of 81 Ns in delta component 7 that starts at base 79"));
    /*
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent5Prime",
        "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent3Prime",
        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    */
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    SetTech(entry, CMolInfo::eTech_htgs_2);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    SetTech(entry, CMolInfo::eTech_composite_wgs_htgs);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::AddToDeltaSeq(entry, "AANNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNGG");
    SetTech(entry, CMolInfo::eTech_unknown);
    expected_errors[0]->SetErrMsg("Run of 101 Ns in delta component 9 that starts at base 174");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SeqLitGapLength0)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
    CRef<CDelta_seq> delta_seq(new CDelta_seq());
    delta_seq->SetLiteral().SetLength(0);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().push_back(delta_seq);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "SeqLitGapLength0", "Gap of length 0 in delta chain"));
    // expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "BadDeltaSeq", "Last delta seq component is a gap"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // some kinds of fuzz don't trigger other kind of error
    delta_seq->SetLiteral().SetFuzz().SetLim(CInt_fuzz::eLim_gt);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    delta_seq->SetLiteral().SetFuzz().Reset();
    delta_seq->SetLiteral().SetFuzz().SetP_m(10);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // others will
    delta_seq->SetLiteral().SetFuzz().Reset();
    delta_seq->SetLiteral().SetFuzz().SetLim(CInt_fuzz::eLim_unk);
    expected_errors[0]->SetErrMsg("Gap of length 0 with unknown fuzz in delta chain");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // try again with swissprot, error goes to warning
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetSwissprot().SetAccession("AY123456");
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors[0]->SetSeverity(eDiag_Warning);
    ChangeErrorAcc(expected_errors, "sp|AY123456|");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    delta_seq->SetLiteral().SetFuzz().SetP_m(10);
    expected_errors[0]->SetErrMsg("Gap of length 0 in delta chain");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    delta_seq->SetLiteral().SetFuzz().Reset();
    delta_seq->SetLiteral().SetFuzz().SetLim(CInt_fuzz::eLim_gt);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    delta_seq->SetLiteral().ResetFuzz();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
static void AddTpaAssemblyUserObject(CRef<CSeq_entry> entry)
{
    CRef<CSeqdesc> desc(new CSeqdesc());
    desc->SetUser().SetType().SetStr("TpaAssembly");
    entry->SetSeq().SetDescr().Set().push_back(desc);
 
    CRef<CUser_field> field(new CUser_field());
    field->SetLabel().SetStr("Label");
    field->SetData().SetStr("Data");
    desc->SetUser().SetData().push_back(field);
}
 
 
BOOST_FIXTURE_TEST_CASE(Test_TpaAssemblyProblem, CGenBankFixture)
{
    CRef<CSeq_entry> entry(new CSeq_entry());
    entry->SetSet().SetClass(CBioseq_set::eClass_genbank);
    CRef<CSeq_entry> member1 = unit_test_util::BuildGoodSeq();
    member1->SetSeq().SetId().front()->SetLocal().SetStr("good");
    AddTpaAssemblyUserObject(member1);
    entry->SetSet().SetSeq_set().push_back(member1);
    CRef<CSeq_entry> member2 = unit_test_util::BuildGoodSeq();
    member2->SetSeq().SetId().front()->SetLocal().SetStr("good2");
    AddTpaAssemblyUserObject(member2);
    entry->SetSet().SetSeq_set().push_back(member2);
 
    STANDARD_SETUP
 
    // two Tpa sequences, but neither has assembly and neither has GI, so no errors expected
    // AddChromosomeNoLocation(expected_errors, "lcl|good");
    // AddChromosomeNoLocation(expected_errors, "lcl|good2");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // now one has hist, other does not
    member1->SetSeq().SetInst().SetHist().SetAssembly().push_back(unit_test_util::BuildGoodAlign());
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "TpaAssemblyProblem", "There are 1 TPAs with history and 1 without history in this record."));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // now one has gi
    scope.RemoveTopLevelSeqEntry(seh);
    member1->SetSeq().SetId().front()->SetTpg().SetAccession("AY123456");
    member1->SetSeq().SetId().front()->SetTpg().SetVersion(1);
    CRef<CSeq_id> gi_id(new CSeq_id());
    gi_id->SetGi(GI_CONST(21914627));
    member1->SetSeq().SetId().push_back(gi_id);
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    CLEAR_ERRORS
 
    expected_errors.push_back(new CExpectedError("tpg|AY123456.1|", eDiag_Warning, "UnexpectedIdentifierChange", "Loss of accession (gb|AY123456.1|) on gi (21914627) compared to the NCBI sequence repository"));
    expected_errors.push_back(new CExpectedError("tpg|AY123456.1|", eDiag_Error, "TpaAssemblyProblem", "There are 1 TPAs with history and 1 without history in this record."));
    expected_errors.push_back(new CExpectedError("tpg|AY123456.1|", eDiag_Warning, "TpaAssemblyProblem", "There are 1 TPAs without history in this record, but the record has a gi number assignment."));
    // AddChromosomeNoLocation(expected_errors, "tpg|AY123456.1|");
    // AddChromosomeNoLocation(expected_errors, "lcl|good2");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_FIXTURE_TEST_CASE(Test_SeqLocLength, CGenBankFixture)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetInt().SetId().SetGenbank().SetAccession("AY123456");
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetInt().SetFrom(0);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetInt().SetTo(9);
    entry->SetSeq().SetInst().SetLength(32);
 
    STANDARD_SETUP
 
    // expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "SeqLocLength", "Short length (10) on seq-loc (gb|AY123456|:1-10) of delta seq_ext"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    scope.RemoveTopLevelSeqEntry(seh);
    // if length 11, should not be a problem
    entry = unit_test_util::BuildGoodDeltaSeq();
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetInt().SetId().SetGenbank().SetAccession("AY123456");
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetInt().SetFrom(0);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetInt().SetTo(10);
    entry->SetSeq().SetInst().SetLength(33);
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_MissingGaps)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
    // remove gaps
    unit_test_util::RemoveDeltaSeqGaps (entry);
 
    STANDARD_SETUP
 
    // AddChromosomeNoLocation(expected_errors, entry);
    // only report errors for specific molinfo tech values
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    // htgs_3 should not report
    SetTech(entry, CMolInfo::eTech_htgs_3);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    SetTech(entry, CMolInfo::eTech_htgs_0);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "MissingGaps", "HTGS delta seq should have gaps between all sequence runs"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    SetTech(entry, CMolInfo::eTech_htgs_1);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    SetTech(entry, CMolInfo::eTech_htgs_2);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "BadHTGSeq", "HTGS 2 delta seq has no gaps and no graphs"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // RefGeneTracking changes severity
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetOther().SetAccession("NC_123456");
    AddRefGeneTrackingUserObject(entry);
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors[0]->SetSeverity(eDiag_Info);
    ChangeErrorAcc(expected_errors, "ref|NC_123456|");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    delete expected_errors[1];
    expected_errors.pop_back();
 
    SetTech(entry, CMolInfo::eTech_htgs_1);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    SetTech(entry, CMolInfo::eTech_htgs_0);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_CompleteTitleProblem)
{
    // prepare entry
    CRef<CSeq_entry> entry = BuildGoodSeq();
    entry->SetSeq().SetId().front()->SetGenbank().SetAccession("AY123456");
    SetLineage (entry, "Viruses; foo");
    SetTitle(entry, "Foo complete genome");
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("gb|AY123456|", eDiag_Warning, "CompleteTitleProblem", "Complete genome in title without complete flag set"));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // should be no error if complete
    SetCompleteness(entry, CMolInfo::eCompleteness_complete);
 
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, entry);
    CheckErrors(*eval, expected_errors);
 
    // different message and code if gaps
    scope.RemoveTopLevelSeqEntry(seh);
    entry = BuildGoodDeltaSeq();
    entry->SetSeq().SetId().front()->SetGenbank().SetAccession("AY123456");
    unit_test_util::SetLineage (entry, "Viruses; foo");
    SetTitle(entry, "Foo complete genome");
    SetCompleteness(entry, CMolInfo::eCompleteness_complete);
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    expected_errors.push_back(new CExpectedError("gb|AY123456|", eDiag_Warning,
        "CompleteGenomeHasGaps", "Title contains 'complete genome' but sequence has gaps"));
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
}
 
 
BOOST_AUTO_TEST_CASE(Test_CompleteCircleProblem)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetInst().SetTopology(CSeq_inst::eTopology_circular);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning,
                              "CompleteCircleProblem",
                              "Circular topology without complete flag set"));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetGenbank().SetAccession("AY123456");
    SetTitle(entry, "This is just a title");
    unit_test_util::SetCompleteness(entry, CMolInfo::eCompleteness_complete);
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors.push_back(new CExpectedError("gb|AY123456|", eDiag_Warning,
                              "CompleteCircleProblem",
      "Circular topology has complete flag set, but title should say complete sequence or complete genome"));
    expected_errors.push_back(new CExpectedError("gb|AY123456|", eDiag_Warning,
                              "UnwantedCompleteFlag",
                              "Suspicious use of complete"));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_BadHTGSeq)
{
    // prepare entry
    CRef<CSeq_entry> delta_entry = unit_test_util::BuildGoodDeltaSeq();
    // remove gaps
    unit_test_util::RemoveDeltaSeqGaps (delta_entry);
 
    STANDARD_SETUP_NAME(delta_entry)
 
    SetTech(delta_entry, CMolInfo::eTech_htgs_2);
    // AddChromosomeNoLocation(expected_errors, delta_entry);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "MissingGaps", "HTGS delta seq should have gaps between all sequence runs"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "BadHTGSeq", "HTGS 2 delta seq has no gaps and no graphs"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    delete expected_errors[1];
    expected_errors.pop_back();
 
    // HTGS_ACTIVEFIN keyword disables BadHTGSeq error
    AddGenbankKeyword(delta_entry, "HTGS_ACTIVEFIN");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    CRef<CSeq_entry> raw_entry = unit_test_util::BuildGoodSeq();
    SetTech(raw_entry, CMolInfo::eTech_htgs_2);
    seh = scope.AddTopLevelSeqEntry(*raw_entry);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "BadHTGSeq", "HTGS 2 raw seq has no gaps and no graphs"));
    // AddChromosomeNoLocation(expected_errors, raw_entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // HTGS_ACTIVEFIN keyword disables error
    AddGenbankKeyword(raw_entry, "HTGS_ACTIVEFIN");
    // AddChromosomeNoLocation(expected_errors, raw_entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
 
    // htg3 errors
    SetTech(raw_entry, CMolInfo::eTech_htgs_3);
    AddGenbankKeyword(raw_entry, "HTGS_DRAFT");
    AddGenbankKeyword(raw_entry, "HTGS_PREFIN");
    AddGenbankKeyword(raw_entry, "HTGS_FULLTOP");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "BadHTGSeq", "HTGS 3 sequence should not have HTGS_DRAFT keyword"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "BadHTGSeq", "HTGS 3 sequence should not have HTGS_PREFIN keyword"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "BadHTGSeq", "HTGS 3 sequence should not have HTGS_ACTIVEFIN keyword"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "BadHTGSeq", "HTGS 3 sequence should not have HTGS_FULLTOP keyword"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    scope.RemoveTopLevelSeqEntry(seh);
    seh = scope.AddTopLevelSeqEntry(*delta_entry);
    SetTech(delta_entry, CMolInfo::eTech_htgs_3);
    AddGenbankKeyword(delta_entry, "HTGS_DRAFT");
    AddGenbankKeyword(delta_entry, "HTGS_PREFIN");
    AddGenbankKeyword(delta_entry, "HTGS_FULLTOP");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_GapInProtein_and_BadProteinStart)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodProtSeq();
    entry->SetSeq().SetInst().SetSeq_data().SetNcbieaa().Set("PRK-EIN");
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "GapInProtein", "[1] internal gap symbols in protein sequence (gene? - fake protein name)"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    entry->SetSeq().SetInst().SetSeq_data().SetNcbieaa().Set("-RKTEIN");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "BadProteinStart", "gap symbol at start of protein sequence (gene? - fake protein name)"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().SetSeq_data().SetNcbieaa().Set("-RK-EIN");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "GapInProtein", "[1] internal gap symbols in protein sequence (gene? - fake protein name)"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_TerminalGap)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
    CRef<CDelta_seq> first_seg(new CDelta_seq());
    first_seg->SetLiteral().SetLength(9);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().push_front(first_seg);
    CRef<CDelta_seq> last_seg(new CDelta_seq());
    last_seg->SetLiteral().SetLength(9);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().push_back(last_seg);
    entry->SetSeq().SetInst().SetLength(entry->SetSeq().SetInst().GetLength() + 18);
 
    STANDARD_SETUP
 
    // expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "BadDeltaSeq", "First delta seq component is a gap"));
    // expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "BadDeltaSeq", "Last delta seq component is a gap"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "TerminalGap", "Gap at beginning of sequence"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "TerminalGap", "Gap at end of sequence"));
    /*
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent5Prime",
        "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent3Prime",
        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    */
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // if gap length is 10, severity is still warning because still all local IDS
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLiteral().SetLength(10);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().back()->SetLiteral().SetLength(10);
    entry->SetSeq().SetInst().SetLength(entry->SetSeq().SetInst().GetLength() + 2);
    seh = scope.AddTopLevelSeqEntry(*entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetOther().SetAccession("NC_123456");
    seh = scope.AddTopLevelSeqEntry(*entry);
    ChangeErrorAcc(expected_errors, "ref|NC_123456|");
    /*
    expected_errors[2]->SetSeverity(eDiag_Warning);
    expected_errors[3]->SetSeverity(eDiag_Warning);
    */
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetPatent().SetSeqid(1);
    entry->SetSeq().SetId().front()->SetPatent().SetCit().SetCountry("USA");
    entry->SetSeq().SetId().front()->SetPatent().SetCit().SetId().SetNumber("1");
    seh = scope.AddTopLevelSeqEntry(*entry);
    ChangeErrorAcc(expected_errors, "pat|USA|1|1");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // no more terminal gap warnings if circular - changed to still show first/last delta component
    entry->SetSeq().SetInst().SetTopology(CSeq_inst::eTopology_circular);
    unit_test_util::SetCompleteness(entry, CMolInfo::eCompleteness_complete);
    expected_errors.push_back(new CExpectedError("pat|USA|1|1", eDiag_Warning, "UnwantedCompleteFlag",
                              "Suspicious use of complete"));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
}
 
 
BOOST_FIXTURE_TEST_CASE(Test_OverlappingDeltaRange, CGenBankFixture)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
    entry->SetSeq().SetInst().ResetExt();
    CRef<CSeq_id> seqid(new CSeq_id());
    seqid->SetGenbank().SetAccession("AY123456");
    entry->SetSeq().SetInst().SetExt().SetDelta().AddSeqRange(*seqid, 0, 10);
    entry->SetSeq().SetInst().SetExt().SetDelta().AddSeqRange(*seqid, 5, 15);
    entry->SetSeq().SetInst().SetExt().SetDelta().AddSeqRange(*seqid, 20, 30);
    entry->SetSeq().SetInst().SetExt().SetDelta().AddSeqRange(*seqid, 25, 35);
    entry->SetSeq().SetInst().SetLength(44);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "OverlappingDeltaRange", "Overlapping delta range 6-16 and 1-11 on a Bioseq gb|AY123456|"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "OverlappingDeltaRange", "Overlapping delta range 26-36 and 21-31 on a Bioseq gb|AY123456|"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_LeadingX)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodProtSeq();
    entry->SetSeq().SetInst().SetSeq_data().SetIupacaa().Set("XROTEIN");
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "LeadingX", "Sequence starts with leading X"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
BOOST_AUTO_TEST_CASE(Test_InternalNsInSeqRaw)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("AAAAANNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNTTTTT");
    entry->SetSeq().SetInst().SetLength(110);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "InternalNsInSeqRaw", "Run of 100 Ns in raw sequence starting at base 6"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "ContigsTooShort", "Maximum contig length is 5 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNContentPercent", "Sequence contains 90 percent Ns"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "HighNpercent5Prime",
        "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "HighNpercent3Prime",
        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // expect no InternalNsInSeqRaw error
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("AAAAANNNNNNNNNNNNNNNNNNNNTTTTT");
    entry->SetSeq().SetInst().SetLength(30);
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "ContigsTooShort", "Maximum contig length is 5 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNContentPercent", "Sequence contains 66 percent Ns"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "HighNpercent5Prime",
        "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "HighNpercent3Prime",
        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // WGS has lower threshold
    SetTech (entry, CMolInfo::eTech_wgs);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "InternalNsInSeqRaw", "Run of 20 Ns in raw sequence starting at base 6"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "ContigsTooShort", "Maximum contig length is 5 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNContentPercent", "Sequence contains 66 percent Ns"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "HighNpercent5Prime",
        "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "HighNpercent3Prime",
        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_InternalNsAdjacentToGap)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLiteral().SetSeq_data().SetIupacna().Set("ATGATGATGNNN");
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().back()->SetLiteral().SetSeq_data().SetIupacna().Set("NNNATGATGATG");
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "ContigsTooShort", "Maximum contig length is 9 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InternalNsAdjacentToGap", "Ambiguous residue N is adjacent to a gap around position 13"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InternalNsAdjacentToGap", "Ambiguous residue N is adjacent to a gap around position 23"));
//    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent5Prime",
//        "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases"));
//    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent3Prime",
//        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
BOOST_AUTO_TEST_CASE(Test_DeltaComponentIsGi0)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetInt().SetFrom(0);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetInt().SetTo(11);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetInt().SetId().SetGi(ZERO_GI);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "DeltaComponentIsGi0", "Delta component is gi|0"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "DeltaSeqError", "Unable to find far delta sequence component"));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_InternalGapsInSeqRaw)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("AATTGGCCAAAATTGGCCAAAATTGG-CAAAATTGGCCAAAATTGGCCAAAATTGGCCAA");
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "InvalidResidue", "Invalid residue '-' at position [27]"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "InternalGapsInSeqRaw", "Raw nucleotide should not contain gap characters"));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SelfReferentialSequence)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetInt().SetFrom(0);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetInt().SetTo(11);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetInt().SetId().SetLocal().SetStr("good");
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Critical, "SelfReferentialSequence", "Self-referential delta sequence"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "InstantiatedGapMismatch", "Exception 4 in GapByGapInst"));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_FIXTURE_TEST_CASE(Test_WholeComponent, CGenBankFixture)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().front()->SetLoc().SetWhole().SetGenbank().SetAccession("AY123456");
    entry->SetSeq().SetInst().SetLength(507);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "WholeComponent", "Delta seq component should not be of type whole"));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
void s_AddGeneralAndLocal(CBioseq& seq)
{
    CRef<CSeq_id> gnl(new CSeq_id());
    gnl->SetGeneral().SetDb("a");
    gnl->SetGeneral().SetTag().SetStr("b");
    seq.SetId().front()->Assign(*gnl);
    CRef<CSeq_id> lcl(new CSeq_id());
    lcl->SetLocal().SetStr("x");
    seq.SetId().push_back(lcl);
    seq.SetAnnot().front()->SetData().SetFtable().front()->SetLocation().SetInt().SetId().Assign(*gnl);
}
 
 
BOOST_AUTO_TEST_CASE(Test_ProteinsHaveGeneralID)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodProtSeq();
    s_AddGeneralAndLocal(entry->SetSeq());
 
    STANDARD_SETUP
 
    // no error unless part of nuc-prot set
    // AddChromosomeNoLocation(expected_errors,entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry = unit_test_util::BuildGoodNucProtSet();
    CRef<CSeq_entry> prot = GetProteinSequenceFromGoodNucProtSet(entry);
    s_AddGeneralAndLocal(prot->SetSeq());
 
    CRef<CSeq_feat> cds = unit_test_util::GetCDSFromGoodNucProtSet(entry);
    cds->SetProduct().SetWhole().SetGeneral().SetDb("a");
    cds->SetProduct().SetWhole().SetGeneral().SetTag().SetStr("b");
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    expected_errors.push_back(new CExpectedError("lcl|nuc", eDiag_Info, "ProteinsHaveGeneralID", "INDEXER_ONLY - Protein bioseqs have general seq-id."));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_HighNContentPercent_and_HighNContentStretch)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("AAAAATTTTTGGGGGCCCCCAAAAATTTTTGGGGGCCCCCNNNNNNNNNNNAAAATTTTTGGGGGCCCCCAAAAATTTTTGGGGGCCCCCAAAAATTTTT");
    entry->SetSeq().SetInst().SetLength(100);
    SetTech (entry, CMolInfo::eTech_tsa);
    unit_test_util::SetBiomol (entry, CMolInfo::eBiomol_mRNA);
    entry->SetSeq().SetInst().SetMol(CSeq_inst::eMol_rna);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNContentPercent", "Sequence contains 11 percent Ns"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("AAAAATTTTTGGGGGCCCCCAAAAATTTTTGGGGGCCCCCNNNNNNNNNNNNNNNNTTTTGGGGGCCCCCAAAAATTTTTGGGGGCCCCCAAAAATTTTT");
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors[0]->SetErrMsg("Sequence contains 16 percent Ns");
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNContentStretch", "Sequence has a stretch of 16 Ns"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNContentStretch", "Sequence has a stretch of 16 Ns"));
    eval = validator.GetTSANStretchErrors(seh);
    CheckErrors(*eval, expected_errors);
    eval = validator.GetTSANStretchErrors(entry->GetSeq());
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetInst().SetSeq_data().SetIupacna().Set("AANNNNNNNNNNGGGCCCCCAAAAATTTTTGGGGGCCCCCAAAAATTTTTGGGGGTTTTTGGGGGCCCCCAAAAATTTTTGGGGGCCNNNNNNNNNNAAA");
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "HighNpercent5Prime",
        "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Info, "HighNpercent3Prime",
        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNContentPercent",
        "Sequence contains 20 percent Ns"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNcontent5Prime",
        "Sequence has a stretch of at least 10 Ns within the first 20 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNcontent3Prime",
        "Sequence has a stretch of at least 10 Ns within the last 20 bases"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNcontent5Prime", "Sequence has a stretch of at least 10 Ns within the first 20 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNcontent3Prime", "Sequence has a stretch of at least 10 Ns within the last 20 bases"));
    eval = validator.GetTSANStretchErrors(seh);
    CheckErrors(*eval, expected_errors);
    eval = validator.GetTSANStretchErrors(entry->GetSeq());
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry = unit_test_util::BuildGoodDeltaSeq();
    CRef<CDelta_seq> gap_seg(new CDelta_seq());
    gap_seg->SetLiteral().SetSeq_data().SetGap();
    gap_seg->SetLiteral().SetLength(10);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().push_back(gap_seg);
    entry->SetSeq().SetInst().SetExt().SetDelta().AddLiteral("CCCATGATGA", CSeq_inst::eMol_dna);
    entry->SetSeq().SetInst().SetLength(entry->GetSeq().GetInst().GetLength() + 20);
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    /*
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent5Prime",
        "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent3Prime",
        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    */
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_SeqLitDataLength0)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodDeltaSeq();
 
    CDelta_ext::Tdata::iterator seg_it = entry->SetSeq().SetInst().SetExt().SetDelta().Set().begin();
    ++seg_it;
    (*seg_it)->SetLiteral().SetSeq_data().SetIupacna().Set();
    (*seg_it)->SetLiteral().SetLength(0);
 
    entry->SetSeq().SetInst().SetLength(24);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "SeqLitDataLength0", "Seq-lit of length 0 in delta chain"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
static CRef<CSeq_entry> BuildGapFuzz100DeltaSeq(void)
{
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
 
    entry->SetSeq().SetInst().ResetSeq_data();
    entry->SetSeq().SetInst().SetRepr(CSeq_inst::eRepr_delta);
    entry->SetSeq().SetInst().SetExt().SetDelta().AddLiteral("ATGATGATGCCC", CSeq_inst::eMol_dna);
    CRef<CDelta_seq> gap_seg(new CDelta_seq());
    gap_seg->SetLiteral().SetLength(101);
    gap_seg->SetLiteral().SetFuzz().SetLim(CInt_fuzz::eLim_unk);
    entry->SetSeq().SetInst().SetExt().SetDelta().Set().push_back(gap_seg);
    entry->SetSeq().SetInst().SetExt().SetDelta().AddLiteral("CCCATGATGATG", CSeq_inst::eMol_dna);
    entry->SetSeq().SetInst().SetLength(125);
 
    return entry;
}
 
 
BOOST_AUTO_TEST_CASE(Test_UnknownLengthGapNot100)
{
    CRef<CSeq_entry> entry = BuildGapFuzz100DeltaSeq();
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "UnknownLengthGapNot100", "Gap of unknown length should have length 100"));
    /*
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent5Prime",
        "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning, "HighNpercent3Prime",
        "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases"));
    */
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_DSmRNA)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    entry->SetSeq().SetInst().SetMol(CSeq_inst::eMol_rna);
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_mRNA);
    entry->SetSeq().SetInst().SetStrand(CSeq_inst::eStrand_ds);
 
    STANDARD_SETUP
 
    // double strand
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "mRNAshouldBeSingleStranded", "mRNA should be single stranded not double stranded"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // mixed strand
    entry->SetSeq().SetInst().SetStrand(CSeq_inst::eStrand_mixed);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // mixed strand
    entry->SetSeq().SetInst().SetStrand(CSeq_inst::eStrand_other);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // these should not produce errors
 
    // strand not set
    entry->SetSeq().SetInst().SetStrand(CSeq_inst::eStrand_not_set);
    eval = validator.Validate(seh, options);
    // AddChromosomeNoLocation(expected_errors, entry);
 
    CheckErrors(*eval, expected_errors);
 
    entry->SetSeq().SetInst().ResetStrand();
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    // single strand
    entry->SetSeq().SetInst().SetStrand(CSeq_inst::eStrand_ss);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_BioSourceMissing)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodNucProtSet();
    unit_test_util::RemoveDescriptorType (entry, CSeqdesc::e_Source);
    unit_test_util::AddGoodSource (entry->SetSet().SetSeq_set().front());
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|nuc", eDiag_Warning, "BioSourceMissing", "Nuc-prot set does not contain expected BioSource descriptor"));
    expected_errors.push_back(new CExpectedError("lcl|prot", eDiag_Fatal, "NoOrgFound", "No organism name included in the source. Other qualifiers may exist."));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
}
 
 
BOOST_AUTO_TEST_CASE(Test_Descr_InvalidForType)
{
    // prepare entry
    CRef<CSeq_entry> entry = unit_test_util::BuildGoodSeq();
    CRef<CSeqdesc> desc;
    desc.Reset(new CSeqdesc());
    desc->SetMol_type(eGIBB_mol_genomic);
    entry->SetDescr().Set().push_back(desc);
    desc.Reset(new CSeqdesc());
    desc->SetModif().push_back(eGIBB_mod_dna);
    entry->SetDescr().Set().push_back(desc);
    desc.Reset(new CSeqdesc());
    desc->SetMethod(eGIBB_method_other);
    entry->SetDescr().Set().push_back(desc);
    desc.Reset(new CSeqdesc());
    desc->SetOrg().SetTaxname("Sebaea microphylla");
    entry->SetDescr().Set().push_back(desc);
    AddTpaAssemblyUserObject (entry);
 
    STANDARD_SETUP
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "ProteinTechniqueOnNucleotide",
                              "Nucleic acid with protein sequence method"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InvalidForType",
                              "MolType descriptor is obsolete"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InvalidForType",
                              "Modif descriptor is obsolete"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InvalidForType",
                              "Method descriptor is obsolete"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InvalidForType",
                              "OrgRef descriptor is obsolete"));
    // AddChromosomeNoLocation(expected_errors, entry);
 
    // won't complain about TPA assembly if only local ID
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetGenbank().SetAccession("AY123456");
    unit_test_util::RemoveDescriptorType (entry, CSeqdesc::e_Mol_type);
    unit_test_util::RemoveDescriptorType (entry, CSeqdesc::e_Modif);
    unit_test_util::RemoveDescriptorType (entry, CSeqdesc::e_Method);
    unit_test_util::RemoveDescriptorType (entry, CSeqdesc::e_Org);
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "TPAassemblyWithoutTPAKeyword",
                              "Non-TPA record gb|AY123456| should not have TpaAssembly object"));
    // AddChromosomeNoLocation(expected_errors, entry);
    SetErrorsAccessions(expected_errors, "gb|AY123456|");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry->SetSeq().SetId().front()->SetOther().SetAccession("NC_123456");
    seh = scope.AddTopLevelSeqEntry(*entry);
    SetErrorsAccessions(expected_errors, "ref|NC_123456|");
    expected_errors[0]->SetErrMsg("Non-TPA record ref|NC_123456| should not have TpaAssembly object");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    desc.Reset(new CSeqdesc());
    desc->SetMol_type(eGIBB_mol_peptide);
    entry->SetDescr().Set().push_back(desc);
    expected_errors.push_back(new CExpectedError("ref|NC_123456|", eDiag_Error, "InvalidForTypeGIBB",
                              "Nucleic acid with GIBB-mol = peptide"));
    expected_errors.push_back(new CExpectedError("ref|NC_123456|", eDiag_Error, "InvalidForType",
                              "MolType descriptor is obsolete"));
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    desc->SetMol_type(eGIBB_mol_other);
    expected_errors[1]->SetErrMsg("GIBB-mol unknown or other used");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    desc->SetMol_type(eGIBB_mol_unknown);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry = unit_test_util::BuildGoodProtSeq();
    desc.Reset(new CSeqdesc());
    desc->SetMol_type(eGIBB_mol_genomic);
    entry->SetDescr().Set().push_back(desc);
    seh = scope.AddTopLevelSeqEntry(*entry);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InvalidForTypeGIBB",
                              "GIBB-mol [1] used on protein"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InvalidForType",
                              "MolType descriptor is obsolete"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    desc->SetMol_type(eGIBB_mol_pre_mRNA);
    expected_errors[0]->SetErrMsg("GIBB-mol [2] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    desc->SetMol_type(eGIBB_mol_mRNA);
    expected_errors[0]->SetErrMsg("GIBB-mol [3] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    desc->SetMol_type(eGIBB_mol_rRNA);
    expected_errors[0]->SetErrMsg("GIBB-mol [4] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    desc->SetMol_type(eGIBB_mol_tRNA);
    expected_errors[0]->SetErrMsg("GIBB-mol [5] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    desc->SetMol_type(eGIBB_mol_snRNA);
    expected_errors[0]->SetErrMsg("GIBB-mol [6] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    desc->SetMol_type(eGIBB_mol_scRNA);
    expected_errors[0]->SetErrMsg("GIBB-mol [7] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    desc->SetMol_type(eGIBB_mol_other_genetic);
    expected_errors[0]->SetErrMsg("GIBB-mol [9] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    desc->SetMol_type(eGIBB_mol_genomic_mRNA);
    expected_errors[0]->SetErrMsg("GIBB-mol [10] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    // invalid modif
    desc->SetModif().push_back(eGIBB_mod_dna);
    desc->SetModif().push_back(eGIBB_mod_rna);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InvalidForTypeGIBB",
                              "Nucleic acid GIBB-mod [0] on protein"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InvalidForTypeGIBB",
                              "Nucleic acid GIBB-mod [1] on protein"));
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error, "InvalidForType",
                              "Modif descriptor is obsolete"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry = unit_test_util::BuildGoodSeq();
    for (auto& it : entry->SetSeq().SetDescr().Set()) {
        if (it->IsSource()) {
            it->SetSource().SetOrigin(CBioSource::eOrigin_synthetic);
        }
    }
    seh = scope.AddTopLevelSeqEntry(*entry);
    // if biomol not other, should generate error
    expected_errors.push_back(new CExpectedError ("lcl|good", eDiag_Warning, "InvalidForType",
                                                  "Molinfo-biomol other should be used if Biosource-location is synthetic"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    for (auto& it : entry->SetSeq().SetDescr().Set()) {
        if (it->IsSource()) {
            it->SetSource().ResetOrigin();
        }
    }
 
    unit_test_util::SetBiomol (entry, CMolInfo::eBiomol_peptide);
    expected_errors.push_back(new CExpectedError ("lcl|good", eDiag_Error, "InvalidMolInfo",
                                                  "Nucleic acid with Molinfo = peptide"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
 
    unit_test_util::SetBiomol (entry, CMolInfo::eBiomol_other_genetic);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning,
        "MoltypeOtherGenetic", "Molinfo-biomol = other genetic"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
 
    unit_test_util::SetBiomol (entry, CMolInfo::eBiomol_unknown);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error,
        "MoltypeUnknown", "Molinfo-biomol unknown used"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
 
    unit_test_util::SetBiomol (entry, CMolInfo::eBiomol_other);
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Warning,
        "MoltypeOther", "Molinfo-biomol other used"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry = unit_test_util::BuildGoodProtSeq();
    seh = scope.AddTopLevelSeqEntry(*entry);
 
    expected_errors.push_back(new CExpectedError("lcl|good", eDiag_Error,
        "InvalidForType", "Molinfo-biomol [1] used on protein"));
    // AddChromosomeNoLocation(expected_errors, entry);
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_genomic);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [1] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_pre_RNA);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [2] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_mRNA);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [3] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_rRNA);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [4] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_tRNA);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [5] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_snRNA);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [6] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_scRNA);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [7] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_genomic_mRNA);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [10] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_cRNA);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [11] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_snoRNA);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [12] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_transcribed_RNA);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [13] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_ncRNA);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [14] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    unit_test_util::SetBiomol(entry, CMolInfo::eBiomol_tmRNA);
    expected_errors[0]->SetErrMsg("Molinfo-biomol [15] used on protein");
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    scope.RemoveTopLevelSeqEntry(seh);
    entry = unit_test_util::BuildGoodSeq();
    seh = scope.AddTopLevelSeqEntry(*entry);
    unit_test_util::SetSynthetic_construct(entry);
    expected_errors.push_back(new CExpectedError ("lcl|good", eDiag_Warning, "SyntheticConstructWrongMolType",
                                                  "synthetic construct should have other-genetic"));
    expected_errors.push_back(new CExpectedError ("lcl|good", eDiag_Warning, "SyntheticConstructNeedsArtificial",
                                                  "synthetic construct should have artificial origin"));
    // AddChromosomeNoLocation(expected_errors, entry);
    eval = validator.Validate(seh, options);
    CheckErrors(*eval, expected_errors);
 
    CLEAR_ERRORS
 
    unit_test_util::SetSebaea_microphylla(entry);
 
    SetTech(entry,