Пример #1
0
void test()
{
    unit_assert_operator_equal(Site::Any, unimod::site('x'));
    unit_assert_operator_equal(Site::Any, unimod::site('X'));
    unit_assert_operator_equal(Site::NTerminus, unimod::site('n'));
    unit_assert_operator_equal(Site::CTerminus, unimod::site('c'));
    unit_assert_operator_equal(Site::Alanine, unimod::site('A'));
    unit_assert_operator_equal(Site::Tyrosine, unimod::site('Y'));
    unit_assert_operator_equal((Site::Asparagine | Site::AsparticAcid), unimod::site('B'));
    unit_assert_operator_equal((Site::Glutamine | Site::GlutamicAcid), unimod::site('Z'));
    unit_assert_throws_what(unimod::site('1'), ArgumentException, "[unimod::site] invalid symbol");
    unit_assert_throws_what(unimod::site('z'), ArgumentException, "[unimod::site] invalid symbol");


    //unit_assert_operator_equal(Position::Anywhere, unimod::position());
    unit_assert_operator_equal(Position::AnyNTerminus, unimod::position(CVID::MS_modification_specificity_N_term));
    unit_assert_operator_equal(Position::AnyCTerminus, unimod::position(CVID::MS_modification_specificity_C_term));
    unit_assert_throws_what(unimod::position(CVID::MS_ion_trap), ArgumentException, "[unimod::position] invalid cvid");


    //if (os_) *os_ << "Unimod entries: " << modifications()->Count << endl;
    unit_assert(unimod::modifications()->Count > 500);


    Modification^ acetyl = unimod::modification("Acetyl");
    unit_assert_operator_equal(CVID::UNIMOD_Acetyl, acetyl->cvid);
    //unit_assert_operator_equal(&acetyl, &unimod::modification(CVID::UNIMOD_Acetyl));
    unit_assert_string_operator_equal(gcnew String("Acetyl"), acetyl->name);
    unit_assert(acetyl->approved);
    unit_assert_string_operator_equal(gcnew String("C2H2O1"), acetyl->deltaComposition->formula());
    unit_assert_operator_equal(8, acetyl->specificities->Count);

    unit_assert_operator_equal(Site::Lysine, acetyl->specificities->default[0]->site);
    unit_assert_operator_equal(Position::Anywhere, acetyl->specificities->default[0]->position);
    unit_assert_operator_equal(false, acetyl->specificities->default[0]->hidden);
    unit_assert_operator_equal(Classification::Multiple, acetyl->specificities->default[0]->classification);

    unit_assert_operator_equal(Site::NTerminus, acetyl->specificities->default[1]->site);
    unit_assert_operator_equal(Position::AnyNTerminus, acetyl->specificities->default[1]->position);
    unit_assert_operator_equal(false, acetyl->specificities->default[1]->hidden);
    unit_assert_operator_equal(Classification::Multiple, acetyl->specificities->default[1]->classification);

    unit_assert_operator_equal(Site::Cysteine, acetyl->specificities->default[2]->site);
    unit_assert_operator_equal(Position::Anywhere, acetyl->specificities->default[2]->position);
    unit_assert_operator_equal(true, acetyl->specificities->default[2]->hidden);
    unit_assert_operator_equal(Classification::PostTranslational, acetyl->specificities->default[2]->classification);

    unit_assert_operator_equal(Site::NTerminus, acetyl->specificities->default[4]->site);
    unit_assert_operator_equal(Position::ProteinNTerminus, acetyl->specificities->default[4]->position);
    unit_assert_operator_equal(false, acetyl->specificities->default[4]->hidden);
    unit_assert_operator_equal(Classification::PostTranslational, acetyl->specificities->default[4]->classification);

    unit_assert_operator_equal(CVID::UNIMOD_Acetyl, unimod::modifications(filter(acetyl->deltaMonoisotopicMass, 0))->default[0]->cvid);
    unit_assert_operator_equal(CVID::UNIMOD_Acetyl, unimod::modifications(filter(acetyl->deltaAverageMass, 0, false, indeterminate))->default[0]->cvid);

    // test a position-only filter
    unit_assert_operator_equal(1, unimod::modifications(filter(acetyl->deltaMonoisotopicMass, 0.5,
                                                               indeterminate, indeterminate,
                                                               Site::Any, Position::AnyNTerminus))->Count);
    unit_assert_operator_equal(CVID::UNIMOD_Acetyl, unimod::modifications(filter(acetyl->deltaMonoisotopicMass, 0.5,
                                                                                 indeterminate, indeterminate,
                                                                                 Site::Any, Position::AnyNTerminus))->default[0]->cvid);


    Modification^ hse = unimod::modification("Met->Hse");
    unit_assert_operator_equal(CVID::UNIMOD_Met__Hse, hse->cvid);
    unit_assert_string_operator_equal(gcnew String("Met->Hse"), hse->name);
    unit_assert(hse->approved);
    unit_assert_string_operator_equal(gcnew String("C-1H-2O1S-1"), hse->deltaComposition->formula());
    unit_assert_operator_equal(Site::Methionine, hse->specificities->default[0]->site);
    unit_assert_operator_equal(Position::AnyCTerminus, hse->specificities->default[0]->position);
    unit_assert_operator_equal(false, hse->specificities->default[0]->hidden);
    unit_assert_operator_equal(Classification::ChemicalDerivative, hse->specificities->default[0]->classification);


    Modification^ oxidation = unimod::modification(CVID::UNIMOD_Oxidation);

    // 3 mods have the same mass as oxidation
    unit_assert_operator_equal(3, unimod::modifications(filter(oxidation->deltaMonoisotopicMass, 0,
                                                               true, indeterminate))->Count);
    unit_assert_operator_equal(3, unimod::modifications(filter(oxidation->deltaAverageMass, 0,
                                                               false, indeterminate))->Count);

    // only one of those mods happen on Methionine
    unit_assert_operator_equal(1, unimod::modifications(filter(oxidation->deltaMonoisotopicMass, 0, true, indeterminate, Site::Methionine, Position::Anywhere))->Count);
    unit_assert_operator_equal(1, unimod::modifications(filter(oxidation->deltaAverageMass, 0, false, indeterminate, Site::Methionine, Position::Anywhere))->Count);

    // oxidation also happens on Proline (test multi-bit Site mask)
    unit_assert_operator_equal(1, unimod::modifications(filter(oxidation->deltaAverageMass, 0, false, indeterminate, Site::Methionine | Site::Proline, Position::Anywhere))->Count);

    // add Alanine as a site and it could be a substitution
    unit_assert_operator_equal(2, unimod::modifications(filter(oxidation->deltaAverageMass, 0, false, indeterminate, Site::Methionine | Site::Alanine, Position::Anywhere))->Count);


    // 18 mods are 28 +/- 1 (but 1 of them is an isotope label not yet supported)
    unit_assert_operator_equal(17, unimod::modifications(filter(28, 1, true, indeterminate))->Count);

    // only two of those mods happen post-translationally on protein N-termini
    unit_assert_operator_equal(2, unimod::modifications(filter(28, 1, true, indeterminate, Site::Any,
                                                               Position::ProteinNTerminus,
                                                               Classification::PostTranslational,
                                                               indeterminate))->Count);


    Modification^ phospho = unimod::modification(CVID::UNIMOD_Phospho);

    // phospho on S and T are grouped (property names are duplicated)
    unit_assert_operator_equal(CVID::UNIMOD_Phospho, unimod::modifications(filter(phospho->deltaMonoisotopicMass, 0, true, true, Site::Serine, Position::Anywhere))->default[0]->cvid);
    unit_assert_operator_equal(CVID::UNIMOD_Phospho, unimod::modifications(filter(phospho->deltaMonoisotopicMass, 0, true, true, Site::Threonine, Position::Anywhere))->default[0]->cvid);
    unit_assert_operator_equal(CVID::UNIMOD_Phospho, unimod::modifications(filter(phospho->deltaMonoisotopicMass, 0, true, true, Site::Tyrosine, Position::Anywhere))->default[0]->cvid);

    // test multi-bit Site mask
    unit_assert_operator_equal(CVID::UNIMOD_Phospho, unimod::modifications(filter(phospho->deltaMonoisotopicMass, 0, true, true, Site::Serine | Site::Tyrosine, Position::Anywhere))->default[0]->cvid);

    // there are no unapproved mods at phospho's mass
    unit_assert_operator_equal(0, unimod::modifications(filter(phospho->deltaMonoisotopicMass, 0, true, false))->Count);

    // phospho and sulfo are only distinguishable with PPM mass accuracy
    double mass_2000Da_1ppm = 2000 - (2000 - MZTolerance(1, MZTolerance::PPM));
    unit_assert_operator_equal(2, unimod::modifications(filter(phospho->deltaMonoisotopicMass, 0.5, true, true, Site::Serine, Position::Anywhere))->Count);
    unit_assert_operator_equal(1, unimod::modifications(filter(phospho->deltaMonoisotopicMass, mass_2000Da_1ppm, true, true, Site::Serine, Position::Anywhere))->Count);

    // test indeterminate and average mass
    unit_assert_operator_equal(2, unimod::modifications(filter(phospho->deltaMonoisotopicMass, 0.1, indeterminate, true, Site::Serine, Position::Anywhere))->Count);
    unit_assert_operator_equal(2, unimod::modifications(filter(phospho->deltaAverageMass, 0.1, indeterminate, true, Site::Serine, Position::Anywhere))->Count);
    unit_assert_operator_equal(2, unimod::modifications(filter(phospho->deltaAverageMass, 0.1, false, true, Site::Serine, Position::Anywhere))->Count);

    // test negative mass
    unit_assert_operator_equal(CVID::UNIMOD_Gln__pyro_Glu, unimod::modifications(filter(-17.0265,
                                                                                        mass_2000Da_1ppm,
                                                                                        true, true,
                                                                                        Site::Glutamine,
                                                                                        Position::AnyNTerminus))->default[0]->cvid);


    // at 14.5 +/- 0.5 there are 3 approved mods and 9 unapproved
    unit_assert_operator_equal(3, unimod::modifications(filter(14.5, 0.5, true, true))->Count);
    unit_assert_operator_equal(9, unimod::modifications(filter(14.5, 0.5, true, false))->Count);

    // all 9 unapproved mods are hidden
    unit_assert_operator_equal(0, unimod::modifications(filter(14.5, 0.5, true, false, Site::Any, Position::Anywhere, Classification::Any, false))->Count);

    // test ambiguous residue; this mod could be a Q->P substitution
    unit_assert_operator_equal(1, unimod::modifications(filter(-31, 0.01, true, indeterminate, unimod::site('Z'), Position::Anywhere))->Count);
}