pub_soft/rdkit
3
0
Fork 0
mirror of https://github.com/rdkit/rdkit.git synced 2026-06-04 21:54:27 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
8eb02b8bedfaf6d011e917e42af4e38f0e52aad0
rdkit/Code/GraphMol/SubstructLibrary/substructLibraryTest.cpp
Hussein Faara f35e7e6414 remove no-op macros and dead code (pt 1) (#8012)
2024-11-19 04:31:56 +01:00

751 lines
25 KiB
C++
Raw Blame History

// Copyright (c) 2017-2019, Novartis Institutes for BioMedical Research Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Novartis Institutes for BioMedical Research Inc.
// nor the names of its contributors may be used to endorse or promote
// products derived from this software without specific prior written
// permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// std bits
#include <RDGeneral/test.h>
#include <iostream>
// RD bits
#include <GraphMol/RDKitBase.h>
#include <GraphMol/RDKitQueries.h>
#include <GraphMol/SubstructLibrary/SubstructLibrary.h>
#include <GraphMol/SubstructLibrary/PatternFactory.h>
#include <GraphMol/Substruct/SubstructMatch.h>
#include <GraphMol/SmilesParse/SmilesParse.h>
#include <GraphMol/SmilesParse/SmilesWrite.h>
#include <GraphMol/FileParsers/FileParsers.h>
#include <GraphMol/FileParsers/MolSupplier.h>
using namespace RDKit;
namespace {
boost::dynamic_bitset<> runTest(SubstructLibrary &ssslib, const ROMol &pattern,
int nThreads) {
std::vector<unsigned int> libMatches = ssslib.getMatches(pattern, nThreads);
boost::dynamic_bitset<> hasMatch(ssslib.size());
for (auto idx : libMatches) {
hasMatch[idx] = 1;
}
for (unsigned int i = 0; i < ssslib.size(); ++i) {
MatchVectType match;
bool matched = SubstructMatch(*ssslib.getMol(i), pattern, match);
// std::cerr << MolToSmiles(*ssslib.getMol(i), true) << " " << hasMatch[i]
// << " " << matched << std::endl;
TEST_ASSERT(hasMatch[i] == matched);
}
return hasMatch;
};
void runTest(SubstructLibrary &ssslib, const ROMol &pattern, int nThreads,
const boost::dynamic_bitset<> &hasMatch) {
std::vector<unsigned int> libMatches = ssslib.getMatches(pattern, nThreads);
boost::dynamic_bitset<> hasMatch2(ssslib.size());
for (auto idx : libMatches) {
hasMatch2[idx] = 1;
}
TEST_ASSERT(hasMatch == hasMatch2);
for (unsigned int i = 0; i < ssslib.size(); ++i) {
MatchVectType match;
bool matched = SubstructMatch(*ssslib.getMol(i), pattern, match);
// std::cerr << MolToSmiles(*ssslib.getMol(i), true) << " " << hasMatch[i]
// << " " << matched << std::endl;
TEST_ASSERT(hasMatch[i] == matched);
}
};
} // namespace
void test1() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " Test1" << std::endl;
std::string fName = getenv("RDBASE");
fName += "/Data/NCI/first_200.props.sdf";
SDMolSupplier suppl(fName);
SubstructLibrary ssslib;
while (!suppl.atEnd()) {
ROMol *mol = nullptr;
try {
mol = suppl.next();
} catch (...) {
continue;
}
if (!mol) {
continue;
}
ssslib.addMol(*mol);
delete mol;
}
std::vector<SubstructLibrary *> libs;
libs.push_back(&ssslib);
#ifdef RDK_USE_BOOST_SERIALIZATION
std::string pickle = ssslib.Serialize();
SubstructLibrary serialized;
serialized.initFromString(pickle);
TEST_ASSERT(serialized.size() == ssslib.size());
libs.push_back(&serialized);
#endif
boost::dynamic_bitset<> hasMatch;
int i = 0;
for (auto lib : libs) {
ROMol *query = SmartsToMol("[#6;$([#6]([#6])[!#6])]");
if (i == 0) {
hasMatch = runTest(*lib, *query, 1);
} else {
runTest(*lib, *query, 1, hasMatch);
}
#ifdef RDK_TEST_MULTITHREADED
runTest(*lib, *query, -1, hasMatch);
#endif
delete query;
++i;
}
i = 0;
for (auto lib : libs) {
ROMol *query = SmartsToMol("[$([O,S]-[!$(*=O)])]");
if (i == 0) {
hasMatch = runTest(*lib, *query, 1);
} else {
runTest(*lib, *query, 1, hasMatch);
}
#ifdef RDK_TEST_MULTITHREADED
runTest(*lib, *query, -1, hasMatch);
#endif
delete query;
++i;
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
void test2() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " Test2" << std::endl;
std::string fName = getenv("RDBASE");
fName += "/Data/NCI/first_200.props.sdf";
SDMolSupplier suppl(fName);
auto *mols = new MolHolder();
auto *fps = new PatternHolder();
boost::shared_ptr<MolHolder> mols_ptr(mols);
boost::shared_ptr<PatternHolder> fps_ptr(fps);
SubstructLibrary ssslib(mols_ptr, fps_ptr);
while (!suppl.atEnd()) {
ROMol *mol = nullptr;
try {
mol = suppl.next();
} catch (...) {
continue;
}
if (!mol) {
continue;
}
ssslib.addMol(*mol);
delete mol;
}
std::vector<SubstructLibrary *> libs;
libs.push_back(&ssslib);
#ifdef RDK_USE_BOOST_SERIALIZATION
std::string pickle = ssslib.Serialize();
SubstructLibrary serialized;
serialized.initFromString(pickle);
TEST_ASSERT(serialized.size() == ssslib.size());
// check to see if we are still the right base type
MolHolderBase *_holder = serialized.getMolHolder().get();
TEST_ASSERT(_holder != nullptr);
TEST_ASSERT(dynamic_cast<MolHolder *>(_holder) != nullptr);
try {
serialized.getFingerprints();
} catch (...) {
TEST_ASSERT(0);
}
libs.push_back(&serialized);
#endif
for (auto lib : libs) {
ROMol *query = SmartsToMol("[#6]([#6])[!#6]");
runTest(*lib, *query, 1);
#ifdef RDK_TEST_MULTITHREADED
runTest(*lib, *query, -1);
#endif
delete query;
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
void test3() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " Test3 (stereo options)" << std::endl;
SubstructLibrary ssslib(boost::make_shared<MolHolder>());
for (int i = 0; i < 10; ++i) {
ROMol *m1 = SmilesToMol("C1CCO[C@@](N)(O)1");
ROMol *m2 = SmilesToMol("C1CCO[C@](N)(O)1");
ROMol *m3 = SmilesToMol("C1CCO[C@@](O)(N)1");
ROMol *m4 = SmilesToMol("C1CCO[C@](O)(N)1");
ssslib.addMol(*m1);
ssslib.addMol(*m2);
ssslib.addMol(*m3);
ssslib.addMol(*m4);
delete m1;
delete m2;
delete m3;
delete m4;
}
std::vector<SubstructLibrary *> libs;
libs.push_back(&ssslib);
#ifdef RDK_USE_BOOST_SERIALIZATION
std::string pickle = ssslib.Serialize();
SubstructLibrary serialized;
serialized.initFromString(pickle);
TEST_ASSERT(serialized.size() == ssslib.size());
libs.push_back(&serialized);
// check to see if we are still the right base type
MolHolderBase *_holder = serialized.getMolHolder().get();
TEST_ASSERT(_holder != nullptr);
TEST_ASSERT(dynamic_cast<MolHolder *>(_holder) != nullptr);
#endif
for (auto lib : libs) {
ROMol *query = SmartsToMol("C-1-C-C-O-C(-[O])(-[N])1");
std::vector<unsigned int> res = lib->getMatches(*query, true, false);
TEST_ASSERT(res.size() == 40);
delete query;
query = SmartsToMol("C-1-C-C-O-[C@@](-[O])(-[N])1");
res = lib->getMatches(*query, true, true);
TEST_ASSERT(res.size() == 20);
res = lib->getMatches(*query, true, false);
TEST_ASSERT(res.size() == 40);
delete query;
}
BOOST_LOG(rdErrorLog) << " Done (stereo options)" << std::endl;
}
void test4() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " Test4 (trusted smiles)" << std::endl;
boost::shared_ptr<CachedSmilesMolHolder> holder =
boost::make_shared<CachedSmilesMolHolder>();
SubstructLibrary ssslib(holder);
for (int i = 0; i < 10; ++i) {
holder->addSmiles("C1CCO[C@@](N)(O)1");
holder->addSmiles("C1CCO[C@](N)(O)1");
holder->addSmiles("C1CCO[C@@](O)(N)1");
holder->addSmiles("C1CCO[C@](O)(N)1");
}
std::vector<SubstructLibrary *> libs;
libs.push_back(&ssslib);
#ifdef RDK_USE_BOOST_SERIALIZATION
std::string pickle = ssslib.Serialize();
SubstructLibrary serialized;
serialized.initFromString(pickle);
TEST_ASSERT(serialized.size() == ssslib.size());
libs.push_back(&serialized);
// check to see if we are still the right base type
MolHolderBase *_holder = serialized.getMolHolder().get();
TEST_ASSERT(_holder != nullptr);
TEST_ASSERT(dynamic_cast<CachedSmilesMolHolder *>(_holder) != nullptr);
#endif
for (auto lib : libs) {
ROMol *query = SmartsToMol("C-1-C-C-O-C(-[O])(-[N])1");
std::vector<unsigned int> res = lib->getMatches(*query, true, false);
TEST_ASSERT(res.size() == 40);
delete query;
query = SmartsToMol("C-1-C-C-O-[C@@](-[O])(-[N])1");
res = lib->getMatches(*query, true, true);
TEST_ASSERT(res.size() == 20);
res = lib->getMatches(*query, true, false);
TEST_ASSERT(res.size() == 40);
delete query;
}
BOOST_LOG(rdErrorLog) << " Done (trusted smiles)" << std::endl;
}
/// Tests the code in the docs
// to make sure it compiles.
void docTest() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " Testing C++ docs" << std::endl;
ROMol *q = SmartsToMol("C-1-C-C-O-C(-[O])(-[N])1");
ROMol *m = SmilesToMol("C1CCO[C@@](N)(O)1");
ROMol &query = *q;
ROMol &mol = *m;
{
SubstructLibrary lib;
lib.addMol(mol);
std::vector<unsigned int> results = lib.getMatches(query);
for (std::vector<unsigned int>::const_iterator matchIndex = results.begin();
matchIndex != results.end(); ++matchIndex) {
boost::shared_ptr<ROMol> match = lib.getMol(*matchIndex);
}
}
{
boost::shared_ptr<CachedTrustedSmilesMolHolder> molHolder =
boost::make_shared<CachedTrustedSmilesMolHolder>();
boost::shared_ptr<PatternHolder> patternHolder =
boost::make_shared<PatternHolder>();
SubstructLibrary lib(molHolder, patternHolder);
lib.addMol(mol);
}
{
boost::shared_ptr<CachedTrustedSmilesMolHolder> molHolder =
boost::make_shared<CachedTrustedSmilesMolHolder>();
boost::shared_ptr<PatternHolder> patternHolder =
boost::make_shared<PatternHolder>();
// the PatternHolder instance is able to make fingerprints.
// These, of course, can be read from a file. For demonstration
// purposes we construct them here.
const std::string trustedSmiles = "c1ccccc1";
ROMol *m = SmilesToMol(trustedSmiles);
const ExplicitBitVect *bitVector = patternHolder->makeFingerprint(*m);
// The trusted smiles and bitVector can be read from any source.
// This is the fastest way to load a substruct library.
molHolder->addSmiles(trustedSmiles);
patternHolder->addFingerprint(*bitVector);
SubstructLibrary lib(molHolder, patternHolder);
delete m;
delete bitVector;
}
delete q;
delete m;
BOOST_LOG(rdErrorLog) << " Done (C++ doc tests)" << std::endl;
}
template <class Holder>
void ringTest(const std::string &name) {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " Testing C++ ring query: " << name << std::endl;
std::unique_ptr<ROMol> q(SmartsToMol("[C&R1]"));
std::unique_ptr<ROMol> q2(SmartsToMol("C@C"));
std::unique_ptr<ROMol> m(SmilesToMol("C1CCO[C@@](N)(O)1"));
boost::shared_ptr<CachedTrustedSmilesMolHolder> molHolder =
boost::make_shared<CachedTrustedSmilesMolHolder>();
boost::shared_ptr<Holder> patternHolder = boost::make_shared<Holder>();
SubstructLibrary lib(molHolder, patternHolder);
lib.addMol(*m.get());
std::vector<unsigned int> results = lib.getMatches(*q.get());
TEST_ASSERT(results.size() == 1);
results = lib.getMatches(*q2.get());
TEST_ASSERT(results.size() == 1);
BOOST_LOG(rdErrorLog) << " Done (C++ ring query tests)" << std::endl;
}
void testAddPatterns() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " Add Patterns " << std::endl;
std::vector<std::string> pdb_ligands = {
"CCS(=O)(=O)c1ccc(OC)c(Nc2ncc(-c3cccc(-c4ccccn4)c3)o2)c1",
"COc1ccc(S(=O)(=O)NCC2CC2)cc1Nc1ncc(-c2cccc(-c3cccnc3)c2)o1",
"COc1ccc(-c2oc3ncnc(N)c3c2-c2ccc(NC(=O)Nc3cc(C(F)(F)F)ccc3F)cc2)cc1",
"COC(=O)Nc1nc2ccc(Oc3ccc(NC(=O)Nc4cc(C(F)(F)F)ccc4F)cc3)cc2[nH]1",
"COc1cc(Nc2ncnc(-c3cccnc3Nc3ccccc3)n2)cc(OC)c1OC",
"O=C(Nc1ccc(Oc2ccccc2)cc1)c1cccnc1NCc1ccncc1",
"O=C(Nc1ccc(Oc2ccccc2)cc1)c1cccnc1NCc1ccncc1",
"CNC(=O)c1cc(Oc2ccc3[nH]c(Nc4ccc(Cl)c(C(F)(F)F)c4)nc3c2)ccn1",
"CNC(=O)c1cc(Oc2ccc3oc(Nc4ccc(Cl)c(OCC5CCC[NH+]5C)c4)nc3c2)ccn1",
"CNC(=O)c1cc(Oc2ccc3oc(Nc4ccc(Cl)c(OCC5CCC[NH+]5C)c4)nc3c2)ccn1",
"COc1cc2nccc(Oc3ccc4c(c3)OCCN4C(=O)Nc3ccc(Cl)cc3)c2cc1OC",
"CNC(=O)c1c(C)oc2cc(Oc3cc[nH+]c4cc(OCCN5CCOCC5)ccc34)ccc12",
"COc1cc2[nH+]ccc(Oc3ccc4c(C(=O)Nc5ccc(Cl)cc5)cccc4c3)c2cc1OC",
"COc1cc2[nH+]ccc(Oc3ccc4c(C(=O)Nc5ccc(Cl)cc5)cccc4c3)c2cc1OC",
"COc1cc2[nH+]ccc(Oc3ccc4c(C(=O)NC5CC5)cccc4c3)c2cc1OC",
"COc1cc2[nH+]ccc(Oc3ccc4c(C(=O)NC5CC5)cccc4c3)c2cc1OC",
"Cc1ccc(C(=O)Nc2cc(CCC[NH+](C)C)cc(C(F)(F)F)c2)cc1Nc1ncccc1-c1ccncn1",
"COc1cc(Nc2nccc(Nc3ccc4c(C)n[nH]c4c3)n2)cc(OC)c1OC",
"COc1cc(Nc2nccc(N(C)c3ccc4c(C)n[nH]c4c3)n2)cc(OC)c1OC",
"Cc1ccn(-c2ccc3c(c2)NCC3(C)C)c(=O)c1-c1ccc2nc(N)ncc2c1",
"Cc1ccn(-c2ccc3c(c2)NCC3(C)C)c(=O)c1-c1ccc2nc(N)ncc2c1",
"Cc1ccc(C(=O)NCCC2CCCC2)cc1C(=O)Nc1ccc(N)nc1",
"Cc1ccc(C(=O)NCCC2CCCC2)cc1C(=O)Nc1ccc(N)nc1",
"Cc1ccn(-c2cccc(C(F)(F)F)c2)c(=O)c1-c1ccc2nc(N)ncc2c1",
"Cc1ccn(-c2cccc(C(F)(F)F)c2)c(=O)c1-c1ccc2nc(N)ncc2c1",
"O=C(Nc1cncnc1)c1c(Cl)ccc2c(Nc3cccc(C(F)(F)F)c3)noc12",
"O=C(Nc1cncnc1)c1c(Cl)ccc2c(Nc3cccc(C(F)(F)F)c3)noc12",
"CC1(C)CNc2cc(NC(=O)c3cccnc3NCc3ccncc3)ccc21",
"CC1(C)CNc2cc(NC(=O)c3cccnc3NCc3ccncc3)ccc21"};
boost::shared_ptr<CachedSmilesMolHolder> holder =
boost::make_shared<CachedSmilesMolHolder>();
for (auto s : pdb_ligands) {
holder->addSmiles(s);
}
SubstructLibrary ssslib(holder);
std::vector<int> num_threads = {1, 0};
for (auto nthreads : num_threads) {
SubstructLibrary ssslib_with_patterns(holder);
SubstructLibrary ssslib_with_taut_patterns(holder);
addPatterns(ssslib_with_patterns, nthreads);
boost::shared_ptr<TautomerPatternHolder> patterns(
new TautomerPatternHolder);
addPatterns(ssslib_with_taut_patterns, patterns, nthreads);
for (unsigned int i = 0; i < ssslib.size(); ++i) {
TEST_ASSERT(ssslib.countMatches(*ssslib.getMol(i).get()) ==
ssslib_with_patterns.countMatches(*ssslib.getMol(i).get()));
TEST_ASSERT(
ssslib.countMatches(*ssslib.getMol(i).get()) ==
ssslib_with_taut_patterns.countMatches(*ssslib.getMol(i).get()));
}
}
}
void testMaxResultsNumThreads() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " Results do not depend on numThreads "
<< std::endl;
std::string fName = getenv("RDBASE");
fName += "/Data/NCI/first_5K.smi";
SmilesMolSupplier suppl(fName, "\t", 0, 1, false);
auto *mols = new MolHolder();
auto *fps = new PatternHolder();
boost::shared_ptr<MolHolder> mols_ptr(mols);
boost::shared_ptr<PatternHolder> fps_ptr(fps);
SubstructLibrary ssslib(mols_ptr, fps_ptr);
boost::logging::disable_logs("rdApp.error");
while (!suppl.atEnd()) {
ROMol *mol = nullptr;
try {
mol = suppl.next();
} catch (...) {
continue;
}
if (!mol) {
continue;
}
ssslib.addMol(*mol);
delete mol;
}
boost::logging::enable_logs("rdApp.error");
std::vector<std::vector<unsigned int>> resVect;
ROMOL_SPTR query(SmartsToMol("N"));
TEST_ASSERT(query);
for (auto numThreads : {1, 2, 4, 8}) {
resVect.emplace_back(
ssslib.getMatches(*query, true, false, false, numThreads));
}
for (auto it = resVect.begin() + 1; it != resVect.end(); ++it) {
TEST_ASSERT(resVect.front().size() == it->size());
for (size_t i = 0; i < resVect.front().size(); ++i) {
TEST_ASSERT(resVect.front().at(i) == it->at(i));
}
}
size_t results60 = resVect.front().size() * 0.6;
size_t results99 = resVect.front().size() * 0.99;
for (auto maxRes : {results60, results99}) {
std::vector<std::vector<unsigned int>> resVectPartial;
for (auto numThreads : {1, 2, 4, 8}) {
resVectPartial.emplace_back(
ssslib.getMatches(*query, true, false, false, numThreads, maxRes));
}
for (auto it = resVectPartial.begin(); it != resVectPartial.end(); ++it) {
TEST_ASSERT(it->size() == maxRes);
for (size_t i = 0; i < maxRes; ++i) {
TEST_ASSERT(resVect.front().at(i) == it->at(i));
}
}
}
}
void testMaxResultsAllSameNumThreads() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " Results do not depend on numThreads (all same) "
<< std::endl;
auto *mols = new MolHolder();
auto *fps = new PatternHolder();
boost::shared_ptr<MolHolder> mols_ptr(mols);
boost::shared_ptr<PatternHolder> fps_ptr(fps);
SubstructLibrary ssslib(mols_ptr, fps_ptr);
boost::logging::disable_logs("rdApp.error");
auto mol = "N"_smiles;
for (int i = 0; i < 999; ++i) {
ssslib.addMol(*mol);
}
boost::logging::enable_logs("rdApp.error");
std::vector<std::vector<unsigned int>> resVect;
ROMOL_SPTR query(SmartsToMol("N"));
TEST_ASSERT(query);
for (auto numThreads : {1, 2, 4, 8}) {
resVect.emplace_back(
ssslib.getMatches(*query, true, false, false, numThreads));
TEST_ASSERT(resVect.back().size() == 999);
}
for (auto it = resVect.begin() + 1; it != resVect.end(); ++it) {
TEST_ASSERT(resVect.front().size() == it->size());
for (size_t i = 0; i < resVect.front().size(); ++i) {
TEST_ASSERT(resVect.front().at(i) == it->at(i));
}
}
size_t results60 = resVect.front().size() * 0.6;
size_t results99 = resVect.front().size() * 0.99;
for (auto maxRes : {results60, results99}) {
std::vector<std::vector<unsigned int>> resVectPartial;
for (auto numThreads : {1, 2, 4, 8}) {
resVectPartial.emplace_back(
ssslib.getMatches(*query, true, false, false, numThreads, maxRes));
}
for (auto it = resVectPartial.begin(); it != resVectPartial.end(); ++it) {
TEST_ASSERT(it->size() == maxRes);
for (size_t i = 0; i < maxRes; ++i) {
TEST_ASSERT(resVect.front().at(i) == it->at(i));
}
}
}
}
template <class Holder>
void testPatternHolder(const std::string &name) {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " testing " << name << std::endl;
std::string fName = getenv("RDBASE");
fName += "/Data/NCI/first_5K.smi";
SmilesMolSupplier suppl(fName, "\t", 0, 1, false);
boost::shared_ptr<CachedTrustedSmilesMolHolder> mols1(
new CachedTrustedSmilesMolHolder());
boost::shared_ptr<Holder> fps1(new Holder());
SubstructLibrary ssslib1(mols1, fps1);
boost::shared_ptr<CachedTrustedSmilesMolHolder> mols2(
new CachedTrustedSmilesMolHolder());
boost::shared_ptr<Holder> fps2(new Holder());
SubstructLibrary ssslib2(mols2, fps2);
boost::logging::disable_logs("rdApp.error");
for (unsigned int i = 0; i < 1000; i += 10) {
ROMol *mol = nullptr;
try {
mol = suppl[i];
} catch (...) {
continue;
}
if (!mol) {
continue;
}
mols1->addSmiles(MolToSmiles(*mol));
fps1->addFingerprint(fps1->makeFingerprint(*mol));
ssslib2.addMol(*mol);
delete mol;
}
boost::logging::enable_logs("rdApp.error");
ROMOL_SPTR query(SmartsToMol("N"));
TEST_ASSERT(query);
{
auto matches1 = ssslib1.getMatches(*query);
std::sort(matches1.begin(), matches1.end());
auto matches2 = ssslib2.getMatches(*query);
std::sort(matches2.begin(), matches2.end());
TEST_ASSERT(matches1.size() == matches2.size());
for (size_t i = 0; i < matches1.size(); ++i) {
TEST_ASSERT(matches1.at(i) == matches2.at(i));
}
}
#ifdef RDK_USE_BOOST_SERIALIZATION
std::string pickle = ssslib1.Serialize();
SubstructLibrary serialized;
serialized.initFromString(pickle);
TEST_ASSERT(serialized.size() == ssslib1.size());
SubstructLibrary serializedLegacy;
std::string pklName = getenv("RDBASE");
TEST_ASSERT(!pklName.empty());
pklName += "/Code/GraphMol/test_data/substructLibV1.pkl";
std::ifstream pickle_istream(pklName.c_str(), std::ios_base::binary);
serializedLegacy.initFromStream(pickle_istream);
pickle_istream.close();
TEST_ASSERT(serializedLegacy.size() == serialized.size());
{
auto matches1 = serializedLegacy.getMatches(*query);
std::sort(matches1.begin(), matches1.end());
auto matches2 = serialized.getMatches(*query);
std::sort(matches2.begin(), matches2.end());
TEST_ASSERT(matches1.size() == matches2.size());
for (size_t i = 0; i < matches1.size(); ++i) {
TEST_ASSERT(matches1.at(i) == matches2.at(i));
}
}
for (size_t i = 0; i < 2; ++i) {
auto serialized_pattern_holder =
dynamic_cast<Holder *>(serialized.getFpHolder().get());
TEST_ASSERT(serialized_pattern_holder);
auto orig_pattern_holder =
dynamic_cast<Holder *>(ssslib1.getFpHolder().get());
TEST_ASSERT(orig_pattern_holder);
TEST_ASSERT(serialized_pattern_holder->getNumBits() ==
orig_pattern_holder->getNumBits());
if (i) {
break;
}
orig_pattern_holder->getNumBits() = 1024;
pickle = ssslib1.Serialize();
serialized.initFromString(pickle);
}
#endif
}
void testSegFaultInHolder() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " testSegFaultInHolder" << std::endl;
boost::shared_ptr<CachedTrustedSmilesMolHolder> mols1(
new CachedTrustedSmilesMolHolder());
boost::shared_ptr<CachedSmilesMolHolder> mols2(new CachedSmilesMolHolder());
for (int i = 0; i < 100; ++i) {
if (i % 2 == 0) {
mols1->addSmiles("dsafsdf");
mols2->addSmiles("dsafsdf");
} else {
mols1->addSmiles("c1ccccc1");
mols2->addSmiles("c1ccccc1");
}
}
SubstructLibrary sss(mols1);
SubstructLibrary sss2(mols2);
ROMOL_SPTR query(SmartsToMol("c1ccccc1"));
auto matches1 = sss.getMatches(*query);
TEST_ASSERT(matches1.size() == 50);
matches1 = sss2.getMatches(*query);
TEST_ASSERT(matches1.size() == 50);
// Check that we don't segfault when adding patterns
addPatterns(sss, 2);
addPatterns(sss2, 2);
}
void testTautomerQueries() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " testTautomerQueries" << std::endl;
boost::shared_ptr<CachedTrustedSmilesMolHolder> mols1(
new CachedTrustedSmilesMolHolder());
mols1->addSmiles("CN1C2=C(C(=O)Nc3ccccc3)C(=O)CCN2c2ccccc21");
SubstructLibrary sss(mols1);
auto query = "Cc1nc2ccccc2[nH]1"_smiles;
// auto matches1 = sss.getMatches(*query);
// TEST_ASSERT(matches1.size() == 0);
std::unique_ptr<TautomerQuery> tq(TautomerQuery::fromMol(*query));
auto matches2 = sss.getMatches(*tq);
TEST_ASSERT(matches2.size() == 1);
SubstructLibrary sss2(sss);
addPatterns(sss, boost::make_shared<TautomerPatternHolder>());
matches2 = sss.getMatches(*tq);
TEST_ASSERT(matches2.size() == 1);
// should work but throw logging errors
addPatterns(sss2);
matches2 = sss2.getMatches(*tq);
TEST_ASSERT(matches2.size() == 1);
}
void github3881() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " github3881 recursive smarts with rings "
<< std::endl;
boost::shared_ptr<CachedTrustedSmilesMolHolder> mols(
new CachedTrustedSmilesMolHolder());
mols->addSmiles("c1ccccc1S(=O)(=O)Cl");
SubstructLibrary sss(mols);
auto pat = "[$(S-!@[#6]):2](=O)(=O)(Cl)"_smarts;
TEST_ASSERT(sss.getMatches(*pat).size() == 1);
}
int main() {
RDLog::InitLogs();
test1();
test2();
test3();
test4();
docTest();
ringTest<PatternHolder>("PatternHolder");
ringTest<TautomerPatternHolder>("TautomerPatternHolder");
testAddPatterns();
testPatternHolder<PatternHolder>("PatternHolder");
testPatternHolder<TautomerPatternHolder>("TautomerPatternHolder");
testSegFaultInHolder();
#ifdef RDK_TEST_MULTITHREADED
testMaxResultsNumThreads();
testMaxResultsAllSameNumThreads();
testTautomerQueries();
#endif
github3881();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink