Xapian: Internal Source Documentation: xapian-core: tests/api

00001 /* api_db.cc: tests which need a backend
00002  *
00003  * Copyright 1999,2000,2001 BrightStation PLC
00004  * Copyright 2002 Ananova Ltd
00005  * Copyright 2002,2003,2004,2005,2006,2007,2008,2009,2012 Olly Betts
00006  * Copyright 2006,2007,2008,2009 Lemur Consulting Ltd
00007  *
00008  * This program is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU General Public License as
00010  * published by the Free Software Foundation; either version 2 of the
00011  * License, or (at your option) any later version.
00012  *
00013  * This program is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016  * GNU General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU General Public License
00019  * along with this program; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
00021  * USA
00022  */
00023 
00024 #include <config.h>
00025 
00026 #include "api_db.h"
00027 
00028 #include <algorithm>
00029 #include <fstream>
00030 #include <map>
00031 #include <string>
00032 #include <vector>
00033 #include "safesysstat.h" // For mkdir().
00034 #include "safeunistd.h" // For sleep().
00035 
00036 #include <xapian.h>
00037 
00038 #include "backendmanager.h"
00039 #include "backendmanager_local.h"
00040 #include "testsuite.h"
00041 #include "testutils.h"
00042 #include "unixcmds.h"
00043 #include "utils.h"
00044 
00045 #include "apitest.h"
00046 
00047 using namespace std;
00048 
00049 static Xapian::Query
00050 query(const string &t)
00051 {
00052     return Xapian::Query(Xapian::Stem("english")(t));
00053 }
00054 
00055 // #######################################################################
00056 // # Tests start here
00057 
00058 // tests Xapian::Database::get_termfreq() and Xapian::Database::term_exists()
00059 DEFINE_TESTCASE(termstats, backend) {
00060     Xapian::Database db(get_database("apitest_simpledata"));
00061 
00062     TEST(!db.term_exists("corn"));
00063     TEST_EQUAL(db.get_termfreq("corn"), 0);
00064     TEST(db.term_exists("banana"));
00065     TEST_EQUAL(db.get_termfreq("banana"), 1);
00066     TEST(db.term_exists("paragraph"));
00067     TEST_EQUAL(db.get_termfreq("paragraph"), 5);
00068 
00069     return true;
00070 }
00071 
00072 // Check that stub databases work.
00073 DEFINE_TESTCASE(stubdb1, backend && !inmemory && !remote) {
00074     // Only works for backends which have a path.
00075     mkdir(".stub", 0755);
00076     const char * dbpath = ".stub/stubdb1";
00077     ofstream out(dbpath);
00078     TEST(out.is_open());
00079     out << "auto ../" << get_database_path("apitest_simpledata") << endl;
00080     out.close();
00081 
00082     {
00083         Xapian::Database db = Xapian::Auto::open_stub(dbpath);
00084         Xapian::Enquire enquire(db);
00085         enquire.set_query(Xapian::Query("word"));
00086         enquire.get_mset(0, 10);
00087     }
00088     {
00089         Xapian::Database db(dbpath);
00090         Xapian::Enquire enquire(db);
00091         enquire.set_query(Xapian::Query("word"));
00092         enquire.get_mset(0, 10);
00093     }
00094 
00095     return true;
00096 }
00097 
00098 // Check that stub databases work remotely.
00099 DEFINE_TESTCASE(stubdb2, backend && !inmemory && !remote) {
00100     // Only works for backends which have a path.
00101     mkdir(".stub", 0755);
00102     const char * dbpath = ".stub/stubdb2";
00103     ofstream out(dbpath);
00104     TEST(out.is_open());
00105     out << "remote :" << BackendManager::get_xapian_progsrv_command()
00106         << ' ' << get_database_path("apitest_simpledata") << endl;
00107     out.close();
00108 
00109     {
00110         Xapian::Database db = Xapian::Auto::open_stub(dbpath);
00111         Xapian::Enquire enquire(db);
00112         enquire.set_query(Xapian::Query("word"));
00113         enquire.get_mset(0, 10);
00114     }
00115     {
00116         Xapian::Database db(dbpath);
00117         Xapian::Enquire enquire(db);
00118         enquire.set_query(Xapian::Query("word"));
00119         enquire.get_mset(0, 10);
00120     }
00121 
00122     return true;
00123 }
00124 
00125 // Regression test - bad entries were ignored after a good entry prior to 1.0.8.
00126 DEFINE_TESTCASE(stubdb3, backend && !inmemory && !remote) {
00127     // Only works for backends which have a path.
00128     mkdir(".stub", 0755);
00129     const char * dbpath = ".stub/stubdb3";
00130     ofstream out(dbpath);
00131     TEST(out.is_open());
00132     out << "auto ../" << get_database_path("apitest_simpledata") << "\n"
00133            "bad line here\n";
00134     out.close();
00135 
00136     TEST_EXCEPTION(Xapian::DatabaseOpeningError,
00137         Xapian::Database db = Xapian::Auto::open_stub(dbpath));
00138 
00139     TEST_EXCEPTION(Xapian::DatabaseOpeningError,
00140         Xapian::Database db(dbpath));
00141 
00142     return true;
00143 }
00144 
00145 // Test a stub database with just a bad entry.
00146 DEFINE_TESTCASE(stubdb4, backend && !inmemory && !remote) {
00147     // Only works for backends which have a path.
00148     mkdir(".stub", 0755);
00149     const char * dbpath = ".stub/stubdb4";
00150     ofstream out(dbpath);
00151     TEST(out.is_open());
00152     out << "bad line here\n";
00153     out.close();
00154 
00155     TEST_EXCEPTION(Xapian::DatabaseOpeningError,
00156         Xapian::Database db = Xapian::Auto::open_stub(dbpath));
00157 
00158     TEST_EXCEPTION(Xapian::DatabaseOpeningError,
00159         Xapian::Database db(dbpath));
00160 
00161     return true;
00162 }
00163 
00164 // Test a stub database with a bad entry with no spaces (prior to 1.1.0 this
00165 // was deliberately allowed, though not documented.
00166 DEFINE_TESTCASE(stubdb5, backend && !inmemory && !remote) {
00167     // Only works for backends which have a path.
00168     mkdir(".stub", 0755);
00169     const char * dbpath = ".stub/stubdb5";
00170     ofstream out(dbpath);
00171     TEST(out.is_open());
00172     out << "bad\n"
00173            "auto ../" << get_database_path("apitest_simpledata") << endl;
00174     out.close();
00175 
00176     TEST_EXCEPTION(Xapian::DatabaseOpeningError,
00177         Xapian::Database db = Xapian::Auto::open_stub(dbpath));
00178 
00179     TEST_EXCEPTION(Xapian::DatabaseOpeningError,
00180         Xapian::Database db(dbpath));
00181 
00182     return true;
00183 }
00184 
00185 // Test a stub database with an inmemory database (new feature in 1.1.0).
00186 DEFINE_TESTCASE(stubdb6, inmemory) {
00187     mkdir(".stub", 0755);
00188     const char * dbpath = ".stub/stubdb6";
00189     ofstream out(dbpath);
00190     TEST(out.is_open());
00191     out << "inmemory\n";
00192     out.close();
00193 
00194     // Read-only tests:
00195     {
00196         Xapian::Database db = Xapian::Auto::open_stub(dbpath);
00197         TEST_EQUAL(db.get_doccount(), 0);
00198         Xapian::Enquire enquire(db);
00199         enquire.set_query(Xapian::Query("word"));
00200         Xapian::MSet mset = enquire.get_mset(0, 10);
00201         TEST(mset.empty());
00202     }
00203     {
00204         Xapian::Database db(dbpath);
00205         TEST_EQUAL(db.get_doccount(), 0);
00206         Xapian::Enquire enquire(db);
00207         enquire.set_query(Xapian::Query("word"));
00208         Xapian::MSet mset = enquire.get_mset(0, 10);
00209         TEST(mset.empty());
00210     }
00211 
00212     // Writable tests:
00213     {
00214         Xapian::WritableDatabase db;
00215         db = Xapian::Auto::open_stub(dbpath, Xapian::DB_OPEN);
00216         TEST_EQUAL(db.get_doccount(), 0);
00217         db.add_document(Xapian::Document());
00218         TEST_EQUAL(db.get_doccount(), 1);
00219     }
00220     {
00221         Xapian::WritableDatabase db(dbpath, Xapian::DB_OPEN);
00222         TEST_EQUAL(db.get_doccount(), 0);
00223         db.add_document(Xapian::Document());
00224         TEST_EQUAL(db.get_doccount(), 1);
00225     }
00226  
00227     return true;
00228 }
00229 
00230 #if 0 // the "force error" mechanism is no longer in place...
00231 class MyErrorHandler : public Xapian::ErrorHandler {
00232     public:
00233         int count;
00234 
00235         bool handle_error(Xapian::Error & error) {
00236             ++count;
00237             tout << "Error handling caught: " << error.get_description()
00238                  << ", count is now " << count << "\n";
00239             return true;
00240         }
00241 
00242         MyErrorHandler() : count (0) {}
00243 };
00244 
00245 // tests error handler in multimatch().
00246 //DEFINE_TESTCASE(multierrhandler1, backend) {
00247     MyErrorHandler myhandler;
00248 
00249     Xapian::Database mydb2(get_database("apitest_simpledata"));
00250     Xapian::Database mydb3(get_database("apitest_simpledata2"));
00251     int errcount = 1;
00252     for (int testcount = 0; testcount < 14; testcount ++) {
00253         tout << "testcount=" << testcount << "\n";
00254         Xapian::Database mydb4(get_database("-e", "apitest_termorder"));
00255         Xapian::Database mydb5(get_network_database("apitest_termorder", 1));
00256         Xapian::Database mydb6(get_database("-e2", "apitest_termorder"));
00257         Xapian::Database mydb7(get_database("-e3", "apitest_simpledata"));
00258 
00259         Xapian::Database dbs;
00260         switch (testcount) {
00261             case 0:
00262                 dbs.add_database(mydb2);
00263                 dbs.add_database(mydb3);
00264                 dbs.add_database(mydb4);
00265                 break;
00266             case 1:
00267                 dbs.add_database(mydb4);
00268                 dbs.add_database(mydb2);
00269                 dbs.add_database(mydb3);
00270                 break;
00271             case 2:
00272                 dbs.add_database(mydb3);
00273                 dbs.add_database(mydb4);
00274                 dbs.add_database(mydb2);
00275                 break;
00276             case 3:
00277                 dbs.add_database(mydb2);
00278                 dbs.add_database(mydb3);
00279                 dbs.add_database(mydb5);
00280                 sleep(1);
00281                 break;
00282             case 4:
00283                 dbs.add_database(mydb5);
00284                 dbs.add_database(mydb2);
00285                 dbs.add_database(mydb3);
00286                 sleep(1);
00287                 break;
00288             case 5:
00289                 dbs.add_database(mydb3);
00290                 dbs.add_database(mydb5);
00291                 dbs.add_database(mydb2);
00292                 sleep(1);
00293                 break;
00294             case 6:
00295                 dbs.add_database(mydb2);
00296                 dbs.add_database(mydb3);
00297                 dbs.add_database(mydb6);
00298                 break;
00299             case 7:
00300                 dbs.add_database(mydb6);
00301                 dbs.add_database(mydb2);
00302                 dbs.add_database(mydb3);
00303                 break;
00304             case 8:
00305                 dbs.add_database(mydb3);
00306                 dbs.add_database(mydb6);
00307                 dbs.add_database(mydb2);
00308                 break;
00309             case 9:
00310                 dbs.add_database(mydb2);
00311                 dbs.add_database(mydb3);
00312                 dbs.add_database(mydb7);
00313                 break;
00314             case 10:
00315                 dbs.add_database(mydb7);
00316                 dbs.add_database(mydb2);
00317                 dbs.add_database(mydb3);
00318                 break;
00319             case 11:
00320                 dbs.add_database(mydb3);
00321                 dbs.add_database(mydb7);
00322                 dbs.add_database(mydb2);
00323                 break;
00324             case 12:
00325                 dbs.add_database(mydb2);
00326                 dbs.add_database(mydb6);
00327                 dbs.add_database(mydb7);
00328                 break;
00329             case 13:
00330                 dbs.add_database(mydb2);
00331                 dbs.add_database(mydb7);
00332                 dbs.add_database(mydb6);
00333                 break;
00334         }
00335         tout << "db=" << dbs << "\n";
00336         Xapian::Enquire enquire(dbs, &myhandler);
00337 
00338         // make a query
00339         Xapian::Query myquery = query(Xapian::Query::OP_OR, "inmemory", "word");
00340         enquire.set_weighting_scheme(Xapian::BoolWeight());
00341         enquire.set_query(myquery);
00342 
00343         tout << "query=" << myquery << "\n";
00344         // retrieve the top ten results
00345         Xapian::MSet mymset = enquire.get_mset(0, 10);
00346 
00347         switch (testcount) {
00348             case 0: case 3: case 6: case 9:
00349                 mset_expect_order(mymset, 2, 4, 10);
00350                 break;
00351             case 1: case 4: case 7: case 10:
00352                 mset_expect_order(mymset, 3, 5, 11);
00353                 break;
00354             case 2: case 5: case 8: case 11:
00355                 mset_expect_order(mymset, 1, 6, 12);
00356                 break;
00357             case 12:
00358             case 13:
00359                 mset_expect_order(mymset, 4, 10);
00360                 errcount += 1;
00361                 break;
00362         }
00363         TEST_EQUAL(myhandler.count, errcount);
00364         errcount += 1;
00365     }
00366 
00367     return true;
00368 }
00369 #endif
00370 
00371 class myMatchDecider : public Xapian::MatchDecider {
00372     public:
00373         bool operator()(const Xapian::Document &doc) const {
00374             // Note that this is not recommended usage of get_data()
00375             return doc.get_data().find("This is") != string::npos;
00376         }
00377 };
00378 
00379 // Test Xapian::MatchDecider functor.
00380 DEFINE_TESTCASE(matchdecider1, backend && !remote) {
00381     Xapian::Database db(get_database("apitest_simpledata"));
00382     Xapian::Enquire enquire(db);
00383     enquire.set_query(Xapian::Query("this"));
00384 
00385     myMatchDecider myfunctor;
00386 
00387     Xapian::MSet mymset = enquire.get_mset(0, 100, 0, &myfunctor);
00388 
00389     vector<bool> docid_checked(db.get_lastdocid());
00390 
00391     // Check that we get the expected number of matches, and that they
00392     // satisfy the condition.
00393     Xapian::MSetIterator i = mymset.begin();
00394     TEST(i != mymset.end());
00395     TEST_EQUAL(mymset.size(), 3);
00396     TEST_EQUAL(mymset.get_matches_lower_bound(), 3);
00397     TEST_EQUAL(mymset.get_matches_upper_bound(), 3);
00398     TEST_EQUAL(mymset.get_matches_estimated(), 3);
00399     TEST_EQUAL(mymset.get_uncollapsed_matches_lower_bound(), 3);
00400     TEST_EQUAL(mymset.get_uncollapsed_matches_upper_bound(), 3);
00401     TEST_EQUAL(mymset.get_uncollapsed_matches_estimated(), 3);
00402     for ( ; i != mymset.end(); ++i) {
00403         const Xapian::Document doc(i.get_document());
00404         TEST(myfunctor(doc));
00405         docid_checked[*i] = true;
00406     }
00407 
00408     // Check that there are some documents which aren't accepted by the match
00409     // decider.
00410     mymset = enquire.get_mset(0, 100);
00411     TEST(mymset.size() > 3);
00412 
00413     // Check that the bounds are appropriate even if we don't ask for any
00414     // actual matches.
00415     mymset = enquire.get_mset(0, 0, 0, &myfunctor);
00416     TEST_EQUAL(mymset.size(), 0);
00417     TEST_EQUAL(mymset.get_matches_lower_bound(), 0);
00418     TEST_EQUAL(mymset.get_matches_upper_bound(), 6);
00419     TEST_REL(mymset.get_matches_estimated(),>,0);
00420     TEST_REL(mymset.get_matches_estimated(),<=,6);
00421     TEST_EQUAL(mymset.get_uncollapsed_matches_lower_bound(), 0);
00422     TEST_EQUAL(mymset.get_uncollapsed_matches_upper_bound(), 6);
00423     TEST_REL(mymset.get_uncollapsed_matches_estimated(),>,0);
00424     TEST_REL(mymset.get_uncollapsed_matches_estimated(),<=,6);
00425 
00426     // Check that the bounds are appropriate if we ask for only one hit.
00427     // (Regression test - until SVN 10256, we didn't reduce the lower_bound
00428     // appropriately, and returned 6 here.)
00429     mymset = enquire.get_mset(0, 1, 0, &myfunctor);
00430     TEST_EQUAL(mymset.size(), 1);
00431     TEST_REL(mymset.get_matches_lower_bound(),>=,1);
00432     TEST_REL(mymset.get_matches_lower_bound(),<=,3);
00433     TEST_REL(mymset.get_matches_upper_bound(),>=,3);
00434     TEST_REL(mymset.get_matches_upper_bound(),<=,6);
00435     TEST_REL(mymset.get_matches_estimated(),>,0);
00436     TEST_REL(mymset.get_matches_estimated(),<=,6);
00437     TEST_REL(mymset.get_uncollapsed_matches_lower_bound(),>=,1);
00438     TEST_REL(mymset.get_uncollapsed_matches_lower_bound(),<=,3);
00439     TEST_REL(mymset.get_uncollapsed_matches_upper_bound(),>=,3);
00440     TEST_REL(mymset.get_uncollapsed_matches_upper_bound(),<=,6);
00441     TEST_REL(mymset.get_uncollapsed_matches_estimated(),>,0);
00442     TEST_REL(mymset.get_uncollapsed_matches_estimated(),<=,6);
00443 
00444     // Check that the other documents don't satisfy the condition.
00445     for (Xapian::docid did = 1; did < docid_checked.size(); ++did) {
00446         if (!docid_checked[did]) {
00447             TEST(!myfunctor(db.get_document(did)));
00448         }
00449     }
00450 
00451     // Check that the bounds are appropriate if a collapse key is used.
00452     // Use a value which is never set so we don't actually discard anything.
00453     enquire.set_collapse_key(99);
00454     mymset = enquire.get_mset(0, 1, 0, &myfunctor);
00455     TEST_EQUAL(mymset.size(), 1);
00456     TEST_REL(mymset.get_matches_lower_bound(),>=,1);
00457     TEST_REL(mymset.get_matches_lower_bound(),<=,3);
00458     TEST_REL(mymset.get_matches_upper_bound(),>=,3);
00459     TEST_REL(mymset.get_matches_upper_bound(),<=,6);
00460     TEST_REL(mymset.get_matches_estimated(),>,0);
00461     TEST_REL(mymset.get_matches_estimated(),<=,6);
00462     TEST_REL(mymset.get_uncollapsed_matches_lower_bound(),>=,1);
00463     TEST_REL(mymset.get_uncollapsed_matches_lower_bound(),<=,3);
00464     TEST_REL(mymset.get_uncollapsed_matches_upper_bound(),>=,3);
00465     TEST_REL(mymset.get_uncollapsed_matches_upper_bound(),<=,6);
00466     TEST_REL(mymset.get_uncollapsed_matches_estimated(),>,0);
00467     TEST_REL(mymset.get_uncollapsed_matches_estimated(),<=,6);
00468 
00469     // Check that the bounds are appropriate if a percentage cutoff is in
00470     // use.  Set a 1% threshold so we don't actually discard anything.
00471     enquire.set_collapse_key(Xapian::BAD_VALUENO);
00472     enquire.set_cutoff(1);
00473     mymset = enquire.get_mset(0, 1, 0, &myfunctor);
00474     TEST_EQUAL(mymset.size(), 1);
00475     TEST_REL(mymset.get_matches_lower_bound(),>=,1);
00476     TEST_REL(mymset.get_matches_lower_bound(),<=,3);
00477     TEST_REL(mymset.get_matches_upper_bound(),>=,3);
00478     TEST_REL(mymset.get_matches_upper_bound(),<=,6);
00479     TEST_REL(mymset.get_matches_estimated(),>,0);
00480     TEST_REL(mymset.get_matches_estimated(),<=,6);
00481     TEST_REL(mymset.get_uncollapsed_matches_lower_bound(),>=,1);
00482     TEST_REL(mymset.get_uncollapsed_matches_lower_bound(),<=,3);
00483     TEST_REL(mymset.get_uncollapsed_matches_upper_bound(),>=,3);
00484     TEST_REL(mymset.get_uncollapsed_matches_upper_bound(),<=,6);
00485     TEST_REL(mymset.get_uncollapsed_matches_estimated(),>,0);
00486     TEST_REL(mymset.get_uncollapsed_matches_estimated(),<=,6);
00487 
00488     // And now with both a collapse key and percentage cutoff.
00489     enquire.set_collapse_key(99);
00490     mymset = enquire.get_mset(0, 1, 0, &myfunctor);
00491     TEST_EQUAL(mymset.size(), 1);
00492     TEST_REL(mymset.get_matches_lower_bound(),>=,1);
00493     TEST_REL(mymset.get_matches_lower_bound(),<=,3);
00494     TEST_REL(mymset.get_matches_upper_bound(),>=,3);
00495     TEST_REL(mymset.get_matches_upper_bound(),<=,6);
00496     TEST_REL(mymset.get_matches_estimated(),>,0);
00497     TEST_REL(mymset.get_matches_estimated(),<=,6);
00498     TEST_REL(mymset.get_uncollapsed_matches_lower_bound(),>=,1);
00499     TEST_REL(mymset.get_uncollapsed_matches_lower_bound(),<=,3);
00500     TEST_REL(mymset.get_uncollapsed_matches_upper_bound(),>=,3);
00501     TEST_REL(mymset.get_uncollapsed_matches_upper_bound(),<=,6);
00502     TEST_REL(mymset.get_uncollapsed_matches_estimated(),>,0);
00503     TEST_REL(mymset.get_uncollapsed_matches_estimated(),<=,6);
00504 
00505     return true;
00506 }
00507 
00508 // Test Xapian::MatchDecider functor used as a match spy.
00509 DEFINE_TESTCASE(matchdecider2, backend && !remote) {
00510     Xapian::Database db(get_database("apitest_simpledata"));
00511     Xapian::Enquire enquire(db);
00512     enquire.set_query(Xapian::Query("this"));
00513 
00514     myMatchDecider myfunctor;
00515 
00516     Xapian::MSet mymset = enquire.get_mset(0, 100, 0, NULL, &myfunctor);
00517 
00518     vector<bool> docid_checked(db.get_lastdocid());
00519 
00520     // Check that we get the expected number of matches, and that they
00521     // satisfy the condition.
00522     Xapian::MSetIterator i = mymset.begin();
00523     TEST(i != mymset.end());
00524     TEST_EQUAL(mymset.size(), 3);
00525     for ( ; i != mymset.end(); ++i) {
00526         const Xapian::Document doc(i.get_document());
00527         TEST(myfunctor(doc));
00528         docid_checked[*i] = true;
00529     }
00530 
00531     // Check that the other documents don't satisfy the condition.
00532     for (Xapian::docid did = 1; did < docid_checked.size(); ++did) {
00533         if (!docid_checked[did]) {
00534             TEST(!myfunctor(db.get_document(did)));
00535         }
00536     }
00537 
00538     return true;
00539 }
00540 
00541 class myMatchDecider2 : public Xapian::MatchDecider {
00542     public:
00543         bool operator()(const Xapian::Document &doc) const {
00544             // Note that this is not recommended usage of get_data()
00545             return doc.get_data().find("We produce") == string::npos;
00546         }
00547 };
00548 
00549 
00550 // Regression test for lower bound using functor, sorting and collapsing.
00551 DEFINE_TESTCASE(matchdecider3, backend && !remote) {
00552     Xapian::Database db(get_database("etext"));
00553     Xapian::Enquire enquire(db);
00554     enquire.set_query(Xapian::Query(""));
00555     enquire.set_collapse_key(12);
00556     enquire.set_sort_by_value(11, true);
00557 
00558     myMatchDecider2 myfunctor;
00559 
00560     Xapian::MSet mset1 = enquire.get_mset(0, 2, 0, NULL, &myfunctor);
00561     Xapian::MSet mset2 = enquire.get_mset(0, 1000, 0, NULL, &myfunctor);
00562 
00563     // mset2 should contain all the hits, so the statistics should be exact.
00564     TEST_EQUAL(mset2.get_matches_estimated(), mset2.size());
00565     TEST_EQUAL(mset2.get_matches_lower_bound(), mset2.get_matches_estimated());
00566     TEST_EQUAL(mset2.get_matches_estimated(), mset2.get_matches_upper_bound());
00567 
00568     TEST_REL(mset2.get_uncollapsed_matches_lower_bound(),<=,mset2.get_uncollapsed_matches_estimated());
00569     TEST_REL(mset2.get_uncollapsed_matches_estimated(),<=,mset2.get_uncollapsed_matches_upper_bound());
00570 
00571     // Check that the lower bound in mset1 is not greater than the known
00572     // number of hits.  This failed until revision 10811.
00573     TEST_REL(mset1.get_matches_lower_bound(),<=,mset2.size());
00574 
00575     // Check that the bounds for mset1 make sense.
00576     TEST_REL(mset1.get_matches_lower_bound(),<=,mset1.get_matches_estimated());
00577     TEST_REL(mset1.get_matches_estimated(),<=,mset1.get_matches_upper_bound());
00578     TEST_REL(mset1.size(),<=,mset1.get_matches_upper_bound());
00579 
00580     TEST_REL(mset1.get_uncollapsed_matches_lower_bound(),<=,mset1.get_uncollapsed_matches_estimated());
00581     TEST_REL(mset1.get_uncollapsed_matches_estimated(),<=,mset1.get_uncollapsed_matches_upper_bound());
00582 
00583     // The uncollapsed match would match all documents but the one the
00584     // matchdecider rejects.
00585     TEST_REL(mset1.get_uncollapsed_matches_upper_bound(),>=,db.get_doccount() - 1);
00586     TEST_REL(mset1.get_uncollapsed_matches_upper_bound(),<=,db.get_doccount());
00587     TEST_REL(mset2.get_uncollapsed_matches_upper_bound(),>=,db.get_doccount() - 1);
00588     TEST_REL(mset2.get_uncollapsed_matches_upper_bound(),<=,db.get_doccount());
00589 
00590     return true;
00591 }
00592 
00593 // tests that mset iterators on msets compare correctly.
00594 DEFINE_TESTCASE(msetiterator1, backend) {
00595     Xapian::Enquire enquire(get_database("apitest_simpledata"));
00596     enquire.set_query(Xapian::Query("this"));
00597     Xapian::MSet mymset = enquire.get_mset(0, 2);
00598 
00599     Xapian::MSetIterator j;
00600     j = mymset.begin();
00601     Xapian::MSetIterator k = mymset.end();
00602     Xapian::MSetIterator l(j);
00603     Xapian::MSetIterator m(k);
00604     Xapian::MSetIterator n = mymset.begin();
00605     Xapian::MSetIterator o = mymset.begin();
00606     TEST_NOT_EQUAL(j, k);
00607     TEST_NOT_EQUAL(l, m);
00608     TEST_EQUAL(k, m);
00609     TEST_EQUAL(j, l);
00610     TEST_EQUAL(j, j);
00611     TEST_EQUAL(k, k);
00612 
00613     k = j;
00614     TEST_EQUAL(j, k);
00615     TEST_EQUAL(j, o);
00616     k++;
00617     TEST_NOT_EQUAL(j, k);
00618     TEST_NOT_EQUAL(k, l);
00619     TEST_NOT_EQUAL(k, m);
00620     TEST_NOT_EQUAL(k, o);
00621     o++;
00622     TEST_EQUAL(k, o);
00623     k++;
00624     TEST_NOT_EQUAL(j, k);
00625     TEST_NOT_EQUAL(k, l);
00626     TEST_EQUAL(k, m);
00627     TEST_EQUAL(n, l);
00628 
00629     n = m;
00630     TEST_NOT_EQUAL(n, l);
00631     TEST_EQUAL(n, m);
00632     TEST_NOT_EQUAL(n, mymset.begin());
00633     TEST_EQUAL(n, mymset.end());
00634 
00635     return true;
00636 }
00637 
00638 // tests that mset iterators on empty msets compare equal.
00639 DEFINE_TESTCASE(msetiterator2, backend) {
00640     Xapian::Enquire enquire(get_database("apitest_simpledata"));
00641     enquire.set_query(Xapian::Query("this"));
00642     Xapian::MSet mymset = enquire.get_mset(0, 0);
00643 
00644     Xapian::MSetIterator j = mymset.begin();
00645     Xapian::MSetIterator k = mymset.end();
00646     Xapian::MSetIterator l(j);
00647     Xapian::MSetIterator m(k);
00648     TEST_EQUAL(j, k);
00649     TEST_EQUAL(l, m);
00650     TEST_EQUAL(k, m);
00651     TEST_EQUAL(j, l);
00652     TEST_EQUAL(j, j);
00653     TEST_EQUAL(k, k);
00654 
00655     return true;
00656 }
00657 
00658 // tests that begin().get_document() works when first != 0
00659 DEFINE_TESTCASE(msetiterator3, backend) {
00660     Xapian::Database mydb(get_database("apitest_simpledata"));
00661     Xapian::Enquire enquire(mydb);
00662     enquire.set_query(Xapian::Query("this"));
00663 
00664     Xapian::MSet mymset = enquire.get_mset(2, 10);
00665 
00666     TEST(!mymset.empty());
00667     Xapian::Document doc(mymset.begin().get_document());
00668     TEST(!doc.get_data().empty());
00669 
00670     return true;
00671 }
00672 
00673 // tests that eset iterators on empty esets compare equal.
00674 DEFINE_TESTCASE(esetiterator1, backend) {
00675     Xapian::Enquire enquire(get_database("apitest_simpledata"));
00676     enquire.set_query(Xapian::Query("this"));
00677 
00678     Xapian::MSet mymset = enquire.get_mset(0, 10);
00679     TEST(mymset.size() >= 2);
00680 
00681     Xapian::RSet myrset;
00682     Xapian::MSetIterator i = mymset.begin();
00683     myrset.add_document(*i);
00684     myrset.add_document(*(++i));
00685 
00686     Xapian::ESet myeset = enquire.get_eset(2, myrset);
00687     Xapian::ESetIterator j;
00688     j = myeset.begin();
00689     Xapian::ESetIterator k = myeset.end();
00690     Xapian::ESetIterator l(j);
00691     Xapian::ESetIterator m(k);
00692     Xapian::ESetIterator n = myeset.begin();
00693 
00694     TEST_NOT_EQUAL(j, k);
00695     TEST_NOT_EQUAL(l, m);
00696     TEST_EQUAL(k, m);
00697     TEST_EQUAL(j, l);
00698     TEST_EQUAL(j, j);
00699     TEST_EQUAL(k, k);
00700 
00701     k = j;
00702     TEST_EQUAL(j, k);
00703     k++;
00704     TEST_NOT_EQUAL(j, k);
00705     TEST_NOT_EQUAL(k, l);
00706     TEST_NOT_EQUAL(k, m);
00707     k++;
00708     TEST_NOT_EQUAL(j, k);
00709     TEST_NOT_EQUAL(k, l);
00710     TEST_EQUAL(k, m);
00711     TEST_EQUAL(n, l);
00712 
00713     n = m;
00714     TEST_NOT_EQUAL(n, l);
00715     TEST_EQUAL(n, m);
00716     TEST_NOT_EQUAL(n, myeset.begin());
00717     TEST_EQUAL(n, myeset.end());
00718 
00719     return true;
00720 }
00721 
00722 // tests that eset iterators on empty esets compare equal.
00723 DEFINE_TESTCASE(esetiterator2, backend) {
00724     Xapian::Enquire enquire(get_database("apitest_simpledata"));
00725     enquire.set_query(Xapian::Query("this"));
00726 
00727     Xapian::MSet mymset = enquire.get_mset(0, 10);
00728     TEST(mymset.size() >= 2);
00729 
00730     Xapian::RSet myrset;
00731     Xapian::MSetIterator i = mymset.begin();
00732     myrset.add_document(*i);
00733     myrset.add_document(*(++i));
00734 
00735     Xapian::ESet myeset = enquire.get_eset(0, myrset);
00736     Xapian::ESetIterator j = myeset.begin();
00737     Xapian::ESetIterator k = myeset.end();
00738     Xapian::ESetIterator l(j);
00739     Xapian::ESetIterator m(k);
00740     TEST_EQUAL(j, k);
00741     TEST_EQUAL(l, m);
00742     TEST_EQUAL(k, m);
00743     TEST_EQUAL(j, l);
00744     TEST_EQUAL(j, j);
00745     TEST_EQUAL(k, k);
00746 
00747     return true;
00748 }
00749 
00750 // tests the collapse-on-key
00751 DEFINE_TESTCASE(collapsekey1, backend) {
00752     Xapian::Enquire enquire(get_database("apitest_simpledata"));
00753     enquire.set_query(Xapian::Query("this"));
00754 
00755     Xapian::MSet mymset1 = enquire.get_mset(0, 100);
00756     Xapian::doccount mymsize1 = mymset1.size();
00757 
00758     for (Xapian::valueno value_no = 1; value_no < 7; ++value_no) {
00759         enquire.set_collapse_key(value_no);
00760         Xapian::MSet mymset = enquire.get_mset(0, 100);
00761 
00762         TEST_AND_EXPLAIN(mymsize1 > mymset.size(),
00763                          "Had no fewer items when performing collapse: don't know whether it worked.");
00764 
00765         map<string, Xapian::docid> values;
00766         Xapian::MSetIterator i = mymset.begin();
00767         for ( ; i != mymset.end(); ++i) {
00768             string value = i.get_document().get_value(value_no);
00769             TEST(values[value] == 0 || value.empty());
00770             values[value] = *i;
00771         }
00772     }
00773 
00774     return true;
00775 }
00776 
00777 // tests that collapse-on-key modifies the predicted bounds for the number of
00778 // matches appropriately.
00779 DEFINE_TESTCASE(collapsekey2, backend) {
00780     SKIP_TEST("Don't have a suitable database currently");
00781     // FIXME: this needs an appropriate database creating, but that's quite
00782     // subtle to do it seems.
00783     Xapian::Enquire enquire(get_database("apitest_simpledata2"));
00784     enquire.set_query(Xapian::Query("this"));
00785 
00786     Xapian::MSet mset1 = enquire.get_mset(0, 1);
00787 
00788     // Test that if no duplicates are found, then the upper bound remains
00789     // unchanged and the lower bound drops.
00790     {
00791         enquire.set_query(Xapian::Query("this"));
00792         Xapian::valueno value_no = 3;
00793         enquire.set_collapse_key(value_no);
00794         Xapian::MSet mset = enquire.get_mset(0, 1);
00795 
00796         TEST_REL(mset.get_matches_lower_bound(),<,mset1.get_matches_lower_bound());
00797         TEST_EQUAL(mset.get_matches_upper_bound(), mset1.get_matches_upper_bound());
00798     }
00799 
00800     return true;
00801 }
00802 
00803 // tests that collapse-on-key modifies the predicted bounds for the number of
00804 // matches appropriately.
00805 DEFINE_TESTCASE(collapsekey3, backend) {
00806     Xapian::Enquire enquire(get_database("apitest_simpledata"));
00807     enquire.set_query(Xapian::Query("this"));
00808 
00809     Xapian::MSet mymset1 = enquire.get_mset(0, 3);
00810 
00811     for (Xapian::valueno value_no = 1; value_no < 7; ++value_no) {
00812         enquire.set_collapse_key(value_no);
00813         Xapian::MSet mymset = enquire.get_mset(0, 3);
00814 
00815         TEST_AND_EXPLAIN(mymset1.get_matches_lower_bound() > mymset.get_matches_lower_bound(),
00816                          "Lower bound was not lower when performing collapse: don't know whether it worked.");
00817         TEST_AND_EXPLAIN(mymset1.get_matches_upper_bound() > mymset.get_matches_upper_bound(),
00818                          "Upper bound was not lower when performing collapse: don't know whether it worked.");
00819 
00820         map<string, Xapian::docid> values;
00821         Xapian::MSetIterator i = mymset.begin();
00822         for ( ; i != mymset.end(); ++i) {
00823             string value = i.get_document().get_value(value_no);
00824             TEST(values[value] == 0 || value.empty());
00825             values[value] = *i;
00826         }
00827     }
00828 
00829     // Test that if the collapse value is always empty, then the upper bound
00830     // remains unchanged, and the lower bound is the same or lower (it can be
00831     // lower because the matcher counts the number of documents with empty
00832     // collapse keys, but may have rejected a document because its weight is
00833     // too low for the proto-MSet before it even looks at its collapse key).
00834     {
00835         Xapian::valueno value_no = 1000;
00836         enquire.set_collapse_key(value_no);
00837         Xapian::MSet mymset = enquire.get_mset(0, 3);
00838 
00839         TEST(mymset.get_matches_lower_bound() <= mymset1.get_matches_lower_bound());
00840         TEST_EQUAL(mymset.get_matches_upper_bound(), mymset1.get_matches_upper_bound());
00841 
00842         map<string, Xapian::docid> values;
00843         Xapian::MSetIterator i = mymset.begin();
00844         for ( ; i != mymset.end(); ++i) {
00845             string value = i.get_document().get_value(value_no);
00846             TEST(values[value] == 0 || value.empty());
00847             values[value] = *i;
00848         }
00849     }
00850 
00851     return true;
00852 }
00853 
00854 // tests that collapse-on-key modifies the predicted bounds for the number of
00855 // matches appropriately even when no results are requested.
00856 DEFINE_TESTCASE(collapsekey4, backend) {
00857     Xapian::Enquire enquire(get_database("apitest_simpledata"));
00858     enquire.set_query(Xapian::Query("this"));
00859 
00860     Xapian::MSet mymset1 = enquire.get_mset(0, 0);
00861 
00862     for (Xapian::valueno value_no = 1; value_no < 7; ++value_no) {
00863         enquire.set_collapse_key(value_no);
00864         Xapian::MSet mymset = enquire.get_mset(0, 0);
00865 
00866         TEST_AND_EXPLAIN(mymset.get_matches_lower_bound() == 1,
00867                          "Lower bound was not 1 when performing collapse but not asking for any results.");
00868         TEST_AND_EXPLAIN(mymset1.get_matches_upper_bound() == mymset.get_matches_upper_bound(),
00869                          "Upper bound was changed when performing collapse but not asking for any results.");
00870 
00871         map<string, Xapian::docid> values;
00872         Xapian::MSetIterator i = mymset.begin();
00873         for ( ; i != mymset.end(); ++i) {
00874             string value = i.get_document().get_value(value_no);
00875             TEST(values[value] == 0 || value.empty());
00876             values[value] = *i;
00877         }
00878     }
00879 
00880     return true;
00881 }
00882 
00883 // test for keepalives
00884 DEFINE_TESTCASE(keepalive1, remote) {
00885     Xapian::Database db(get_remote_database("apitest_simpledata", 5000));
00886 
00887     /* Test that keep-alives work */
00888     for (int i = 0; i < 10; ++i) {
00889         sleep(2);
00890         db.keep_alive();
00891     }
00892     Xapian::Enquire enquire(db);
00893     enquire.set_query(Xapian::Query("word"));
00894     enquire.get_mset(0, 10);
00895 
00896     /* Test that things break without keepalives */
00897     sleep(10);
00898     enquire.set_query(Xapian::Query("word"));
00899     TEST_EXCEPTION(Xapian::NetworkError,
00900                    enquire.get_mset(0, 10));
00901 
00902     return true;
00903 }
00904 
00905 // test that iterating through all terms in a database works.
00906 DEFINE_TESTCASE(allterms1, backend) {
00907     Xapian::Database db(get_database("apitest_allterms"));
00908     Xapian::TermIterator ati = db.allterms_begin();
00909     TEST(ati != db.allterms_end());
00910     TEST_EQUAL(*ati, "one");
00911     TEST_EQUAL(ati.get_termfreq(), 1);
00912 
00913     Xapian::TermIterator ati2 = ati;
00914 
00915     ati++;
00916     TEST(ati != db.allterms_end());
00917     if (verbose) {
00918         tout << "*ati = `" << *ati << "'\n";
00919         tout << "*ati.length = `" << (*ati).length() << "'\n";
00920         tout << "*ati == \"one\" = " << (*ati == "one") << "\n";
00921         tout << "*ati[3] = " << ((*ati)[3]) << "\n";
00922         tout << "*ati = `" << *ati << "'\n";
00923     }
00924     TEST(*ati == "three");
00925     TEST(ati.get_termfreq() == 3);
00926 
00927 #if 0
00928     TEST(ati2 != db.allterms_end());
00929     TEST(*ati2 == "one");
00930     TEST(ati2.get_termfreq() == 1);
00931 #endif
00932 
00933     ++ati;
00934 #if 0
00935     ++ati2;
00936 #endif
00937     TEST(ati != db.allterms_end());
00938     TEST(*ati == "two");
00939     TEST(ati.get_termfreq() == 2);
00940 
00941 #if 0
00942     TEST(ati2 != db.allterms_end());
00943     TEST(*ati2 == "three");
00944     TEST(ati2.get_termfreq() == 3);
00945 #endif
00946 
00947     ati++;
00948     TEST(ati == db.allterms_end());
00949 
00950     return true;
00951 }
00952 
00953 // test that iterating through all terms in two databases works.
00954 DEFINE_TESTCASE(allterms2, backend) {
00955     Xapian::Database db;
00956     db.add_database(get_database("apitest_allterms"));
00957     db.add_database(get_database("apitest_allterms2"));
00958     Xapian::TermIterator ati = db.allterms_begin();
00959 
00960     TEST(ati != db.allterms_end());
00961     TEST(*ati == "five");
00962     TEST(ati.get_termfreq() == 2);
00963     ati++;
00964 
00965     TEST(ati != db.allterms_end());
00966     TEST(*ati == "four");
00967     TEST(ati.get_termfreq() == 1);
00968 
00969     ati++;
00970     TEST(ati != db.allterms_end());
00971     TEST(*ati == "one");
00972     TEST(ati.get_termfreq() == 1);
00973 
00974     ++ati;
00975     TEST(ati != db.allterms_end());
00976     TEST(*ati == "six");
00977     TEST(ati.get_termfreq() == 3);
00978 
00979     ati++;
00980     TEST(ati != db.allterms_end());
00981     TEST(*ati == "three");
00982     TEST(ati.get_termfreq() == 3);
00983 
00984     ati++;
00985     TEST(ati != db.allterms_end());
00986     TEST(*ati == "two");
00987     TEST(ati.get_termfreq() == 2);
00988 
00989     ati++;
00990     TEST(ati == db.allterms_end());
00991 
00992     return true;
00993 }
00994 
00995 // test that skip_to sets at_end (regression test)
00996 DEFINE_TESTCASE(allterms3, backend) {
00997     Xapian::Database db;
00998     db.add_database(get_database("apitest_allterms"));
00999     Xapian::TermIterator ati = db.allterms_begin();
01000 
01001     ati.skip_to(string("zzzzzz"));
01002     TEST(ati == db.allterms_end());
01003 
01004     return true;
01005 }
01006 
01007 // test that next ignores extra entries due to long posting lists being
01008 // chunked (regression test for quartz)
01009 DEFINE_TESTCASE(allterms4, backend) {
01010     // apitest_allterms4 contains 682 documents each containing just the word
01011     // "foo".  682 was the magic number which started to cause Quartz problems.
01012     Xapian::Database db = get_database("apitest_allterms4");
01013 
01014     Xapian::TermIterator i = db.allterms_begin();
01015     TEST(i != db.allterms_end());
01016     TEST(*i == "foo");
01017     TEST(i.get_termfreq() == 682);
01018     ++i;
01019     TEST(i == db.allterms_end());
01020 
01021     return true;
01022 }
01023 
01024 // test that skip_to with an exact match sets the current term (regression test
01025 // for quartz)
01026 DEFINE_TESTCASE(allterms5, backend) {
01027     Xapian::Database db;
01028     db.add_database(get_database("apitest_allterms"));
01029     Xapian::TermIterator ati = db.allterms_begin();
01030     ati.skip_to("three");
01031     TEST(ati != db.allterms_end());
01032     TEST_EQUAL(*ati, "three");
01033 
01034     return true;
01035 }
01036 
01037 // test allterms iterators with prefixes
01038 DEFINE_TESTCASE(allterms6, backend) {
01039     Xapian::Database db;
01040     db.add_database(get_database("apitest_allterms"));
01041     db.add_database(get_database("apitest_allterms2"));
01042 
01043     Xapian::TermIterator ati = db.allterms_begin("three");
01044     TEST(ati != db.allterms_end("three"));
01045     TEST_EQUAL(*ati, "three");
01046     ati.skip_to("three");
01047     TEST(ati != db.allterms_end("three"));
01048     TEST_EQUAL(*ati, "three");
01049     ati++;
01050     TEST(ati == db.allterms_end("three"));
01051 
01052     ati = db.allterms_begin("thre");
01053     TEST(ati != db.allterms_end("thre"));
01054     TEST_EQUAL(*ati, "three");
01055     ati.skip_to("three");
01056     TEST(ati != db.allterms_end("thre"));
01057     TEST_EQUAL(*ati, "three");
01058     ati++;
01059     TEST(ati == db.allterms_end("thre"));
01060 
01061     ati = db.allterms_begin("f");
01062     TEST(ati != db.allterms_end("f"));
01063     TEST_EQUAL(*ati, "five");
01064     TEST(ati != db.allterms_end("f"));
01065     ati.skip_to("three");
01066     TEST(ati == db.allterms_end("f"));
01067 
01068     ati = db.allterms_begin("f");
01069     TEST(ati != db.allterms_end("f"));
01070     TEST_EQUAL(*ati, "five");
01071     ati++;
01072     TEST(ati != db.allterms_end("f"));
01073     TEST_EQUAL(*ati, "four");
01074     ati++;
01075     TEST(ati == db.allterms_end("f"));
01076 
01077     ati = db.allterms_begin("absent");
01078     TEST(ati == db.allterms_end("absent"));
01079 
01080     return true;
01081 }
01082 
01083 // test that searching for a term with a special characters in it works
01084 DEFINE_TESTCASE(specialterms1, backend) {
01085     Xapian::Enquire enquire(get_database("apitest_space"));
01086     Xapian::MSet mymset;
01087     Xapian::doccount count;
01088     Xapian::MSetIterator m;
01089     Xapian::Stem stemmer("english");
01090 
01091     enquire.set_query(stemmer("new\nline"));
01092     mymset = enquire.get_mset(0, 10);
01093     TEST_MSET_SIZE(mymset, 1);
01094     count = 0;
01095     for (m = mymset.begin(); m != mymset.end(); ++m) ++count;
01096     TEST_EQUAL(count, 1);
01097 
01098     for (Xapian::valueno value_no = 0; value_no < 7; ++value_no) {
01099         string value = mymset.begin().get_document().get_value(value_no);
01100         TEST_NOT_EQUAL(value, "");
01101         if (value_no == 0) {
01102             TEST(value.size() > 263);
01103             TEST_EQUAL(static_cast<unsigned char>(value[262]), 255);
01104             for (int k = 0; k < 256; k++) {
01105                 TEST_EQUAL(static_cast<unsigned char>(value[k+7]), k);
01106             }
01107         }
01108     }
01109 
01110     enquire.set_query(stemmer(string("big\0zero", 8)));
01111     mymset = enquire.get_mset(0, 10);
01112     TEST_MSET_SIZE(mymset, 1);
01113     count = 0;
01114     for (m = mymset.begin(); m != mymset.end(); ++m) ++count;
01115     TEST_EQUAL(count, 1);
01116 
01117     return true;
01118 }
01119 
01120 // test that terms with a special characters in appear correctly when iterating
01121 // allterms
01122 DEFINE_TESTCASE(specialterms2, backend) {
01123     Xapian::Database db(get_database("apitest_space"));
01124 
01125     // Check the terms are all as expected (after stemming) and that allterms
01126     // copes with iterating over them.
01127     Xapian::TermIterator t;
01128     t = db.allterms_begin();
01129     TEST_EQUAL(*t, "back\\slash"); ++t; TEST_NOT_EQUAL(t, db.allterms_end());
01130     TEST_EQUAL(*t, string("big\0zero", 8)); ++t; TEST_NOT_EQUAL(t, db.allterms_end());
01131     TEST_EQUAL(*t, "new\nlin"); ++t; TEST_NOT_EQUAL(t, db.allterms_end());
01132     TEST_EQUAL(*t, "one\x01on"); ++t; TEST_NOT_EQUAL(t, db.allterms_end());
01133     TEST_EQUAL(*t, "space man"); ++t; TEST_NOT_EQUAL(t, db.allterms_end());
01134     TEST_EQUAL(*t, "tab\tbi"); ++t; TEST_NOT_EQUAL(t, db.allterms_end());
01135     TEST_EQUAL(*t, "tu\x02tu"); ++t; TEST_EQUAL(t, db.allterms_end());
01136 
01137     // Now check that skip_to exactly a term containing a zero byte works.
01138     // This is a regression test for flint and quartz - an Assert() used to
01139     // fire in debug builds (the Assert was wrong - the actual code handled
01140     // this OK).
01141     t = db.allterms_begin();
01142     t.skip_to(string("big\0zero", 8));
01143     TEST_NOT_EQUAL(t, db.allterms_end());
01144     TEST_EQUAL(*t, string("big\0zero", 8));
01145 
01146     return true;
01147 }
01148 
01149 // test that rsets behave correctly with multiDBs
01150 DEFINE_TESTCASE(rsetmultidb2, backend && !multi) {
01151     Xapian::Database mydb1(get_database("apitest_rset", "apitest_simpledata2"));
01152     Xapian::Database mydb2(get_database("apitest_rset"));
01153     mydb2.add_database(get_database("apitest_simpledata2"));
01154 
01155     Xapian::Enquire enquire1(mydb1);
01156     Xapian::Enquire enquire2(mydb2);
01157 
01158     Xapian::Query myquery = query("is");
01159 
01160     enquire1.set_query(myquery);
01161     enquire2.set_query(myquery);
01162 
01163     Xapian::RSet myrset1;
01164     Xapian::RSet myrset2;
01165     myrset1.add_document(4);
01166     myrset2.add_document(2);
01167 
01168     Xapian::MSet mymset1a = enquire1.get_mset(0, 10);
01169     Xapian::MSet mymset1b = enquire1.get_mset(0, 10, &myrset1);
01170     Xapian::MSet mymset2a = enquire2.get_mset(0, 10);
01171     Xapian::MSet mymset2b = enquire2.get_mset(0, 10, &myrset2);
01172 
01173     mset_expect_order(mymset1a, 4, 3);
01174     mset_expect_order(mymset1b, 4, 3);
01175     mset_expect_order(mymset2a, 2, 5);
01176     mset_expect_order(mymset2b, 2, 5);
01177 
01178     TEST(mset_range_is_same_weights(mymset1a, 0, mymset2a, 0, 2));
01179     TEST(mset_range_is_same_weights(mymset1b, 0, mymset2b, 0, 2));
01180     TEST_NOT_EQUAL(mymset1a, mymset1b);
01181     TEST_NOT_EQUAL(mymset2a, mymset2b);
01182 
01183     return true;
01184 }
01185 
01186 // tests an expand across multiple databases
01187 DEFINE_TESTCASE(multiexpand1, backend && !multi) {
01188     Xapian::Database mydb1(get_database("apitest_simpledata", "apitest_simpledata2"));
01189     Xapian::Enquire enquire1(mydb1);
01190 
01191     Xapian::Database mydb2(get_database("apitest_simpledata"));
01192     mydb2.add_database(get_database("apitest_simpledata2"));
01193     Xapian::Enquire enquire2(mydb2);
01194 
01195     // make simple equivalent rsets, with a document from each database in each.
01196     Xapian::RSet rset1;
01197     Xapian::RSet rset2;
01198     rset1.add_document(1);
01199     rset1.add_document(7);
01200     rset2.add_document(1);
01201     rset2.add_document(2);
01202 
01203     // Retrieve all the ESet results in each of the three setups:
01204 
01205     // This is the single database one.
01206     Xapian::ESet eset1 = enquire1.get_eset(1000, rset1);
01207 
01208     // This is the multi database with approximation
01209     Xapian::ESet eset2 = enquire2.get_eset(1000, rset2);
01210 
01211     // This is the multi database without approximation
01212     Xapian::ESet eset3 = enquire2.get_eset(1000, rset2, Xapian::Enquire::USE_EXACT_TERMFREQ);
01213 
01214     TEST_EQUAL(eset1.size(), eset3.size());
01215 
01216     Xapian::ESetIterator i = eset1.begin();
01217     Xapian::ESetIterator j = eset3.begin();
01218     while (i != eset1.end() && j != eset3.end()) {
01219         TEST_EQUAL(*i, *j);
01220         TEST_EQUAL(i.get_weight(), j.get_weight());
01221         ++i;
01222         ++j;
01223     }
01224     TEST(i == eset1.end());
01225     TEST(j == eset3.end());
01226 
01227     bool eset1_eq_eset2 = true;
01228     i = eset1.begin();
01229     j = eset2.begin();
01230     while (i != eset1.end() && j != eset2.end()) {
01231         if (i.get_weight() != j.get_weight()) {
01232             eset1_eq_eset2 = false;
01233             break;
01234         }
01235         ++i;
01236         ++j;
01237     }
01238     TEST(!eset1_eq_eset2);
01239 
01240     return true;
01241 }
01242 
01243 // tests that opening a non-existent postlist returns an empty list
01244 DEFINE_TESTCASE(postlist1, backend) {
01245     Xapian::Database db(get_database("apitest_simpledata"));
01246 
01247     TEST_EQUAL(db.postlist_begin("rosebud"), db.postlist_end("rosebud"));
01248 
01249     string s = "let_us_see_if_we_can_break_it_with_a_really_really_long_term.";
01250     for (int i = 0; i < 8; ++i) {
01251         s += s;
01252         TEST_EQUAL(db.postlist_begin(s), db.postlist_end(s));
01253     }
01254 
01255     // A regression test (no, really!)
01256     TEST_NOT_EQUAL(db.postlist_begin("a"), db.postlist_end("a"));
01257 
01258     return true;
01259 }
01260 
01261 // tests that a Xapian::PostingIterator works as an STL iterator
01262 DEFINE_TESTCASE(postlist2, backend) {
01263     Xapian::Database db(get_database("apitest_simpledata"));
01264     Xapian::PostingIterator p;
01265     p = db.postlist_begin("this");
01266     Xapian::PostingIterator pend = db.postlist_end("this");
01267 
01268     TEST(p.get_description() != "Xapian::PostingIterator(pos=END)");
01269 
01270     // test operator= creates a copy which compares equal
01271     Xapian::PostingIterator p_copy = p;
01272     TEST_EQUAL(p, p_copy);
01273 
01274     TEST(p_copy.get_description() != "Xapian::PostingIterator(pos=END)");
01275 
01276     // test copy constructor creates a copy which compares equal
01277     Xapian::PostingIterator p_clone(p);
01278     TEST_EQUAL(p, p_clone);
01279 
01280     TEST(p_clone.get_description() != "Xapian::PostingIterator(pos=END)");
01281 
01282     vector<Xapian::docid> v(p, pend);
01283 
01284     p = db.postlist_begin("this");
01285     pend = db.postlist_end("this");
01286     vector<Xapian::docid>::const_iterator i;
01287     for (i = v.begin(); i != v.end(); i++) {
01288         TEST_NOT_EQUAL(p, pend);
01289         TEST_EQUAL(*i, *p);
01290         p++;
01291     }
01292     TEST_EQUAL(p, pend);
01293 
01294     TEST_STRINGS_EQUAL(p.get_description(),
01295                        "Xapian::PostingIterator(pos=END)");
01296     TEST_STRINGS_EQUAL(pend.get_description(),
01297                        "Xapian::PostingIterator(pos=END)");
01298 
01299     return true;
01300 }
01301 
01302 // tests that a Xapian::PostingIterator still works when the DB is deleted
01303 DEFINE_TESTCASE(postlist3, backend) {
01304     Xapian::PostingIterator u;
01305     {
01306         Xapian::Database db_temp(get_database("apitest_simpledata"));
01307         u = db_temp.postlist_begin("this");
01308     }
01309 
01310     Xapian::Database db(get_database("apitest_simpledata"));
01311     Xapian::PostingIterator p = db.postlist_begin("this");
01312     Xapian::PostingIterator pend = db.postlist_end("this");
01313 
01314     while (p != pend) {
01315         TEST_EQUAL(*p, *u);
01316         p++;
01317         u++;
01318     }
01319     return true;
01320 }
01321 
01322 // tests skip_to
01323 DEFINE_TESTCASE(postlist4, backend) {
01324     Xapian::Database db(get_database("apitest_simpledata"));
01325     Xapian::PostingIterator i = db.postlist_begin("this");
01326     i.skip_to(1);
01327     i.skip_to(999999999);
01328     TEST(i == db.postlist_end("this"));
01329     return true;
01330 }
01331 
01332 // tests long postlists
01333 DEFINE_TESTCASE(postlist5, backend) {
01334     Xapian::Database db(get_database("apitest_manydocs"));
01335     // Allow for databases which don't support length
01336     if (db.get_avlength() != 1)
01337         TEST_EQUAL_DOUBLE(db.get_avlength(), 4);
01338     Xapian::PostingIterator i = db.postlist_begin("this");
01339     unsigned int j = 1;
01340     while (i != db.postlist_end("this")) {
01341         TEST_EQUAL(*i, j);
01342         i++;
01343         j++;
01344     }
01345     TEST_EQUAL(j, 513);
01346     return true;
01347 }
01348 
01349 // tests document length in postlists
01350 DEFINE_TESTCASE(postlist6, backend) {
01351     Xapian::Database db(get_database("apitest_simpledata"));
01352     Xapian::PostingIterator i = db.postlist_begin("this");
01353     TEST(i != db.postlist_end("this"));
01354     while (i != db.postlist_end("this")) {
01355         TEST_EQUAL(i.get_doclength(), db.get_doclength(*i));
01356         TEST_REL(i.get_wdf(),<=,i.get_doclength());
01357         ++i;
01358     }
01359     return true;
01360 }
01361 
01362 // tests collection frequency
01363 DEFINE_TESTCASE(collfreq1, backend) {
01364     Xapian::Database db(get_database("apitest_simpledata"));
01365 
01366     TEST_EQUAL(db.get_collection_freq("this"), 11);
01367     TEST_EQUAL(db.get_collection_freq("first"), 1);
01368     TEST_EQUAL(db.get_collection_freq("last"), 0);
01369     TEST_EQUAL(db.get_collection_freq("word"), 9);
01370 
01371     Xapian::Database db1(get_database("apitest_simpledata", "apitest_simpledata2"));
01372     Xapian::Database db2(get_database("apitest_simpledata"));
01373     db2.add_database(get_database("apitest_simpledata2"));
01374 
01375     TEST_EQUAL(db1.get_collection_freq("this"), 15);
01376     TEST_EQUAL(db1.get_collection_freq("first"), 1);
01377     TEST_EQUAL(db1.get_collection_freq("last"), 0);
01378     TEST_EQUAL(db1.get_collection_freq("word"), 11);
01379     TEST_EQUAL(db2.get_collection_freq("this"), 15);
01380     TEST_EQUAL(db2.get_collection_freq("first"), 1);
01381     TEST_EQUAL(db2.get_collection_freq("last"), 0);
01382     TEST_EQUAL(db2.get_collection_freq("word"), 11);
01383 
01384     return true;
01385 }
01386 
01387 // Regression test for split msets being incorrect when sorting
01388 DEFINE_TESTCASE(sortvalue1, backend) {
01389     Xapian::Enquire enquire(get_database("apitest_simpledata"));
01390     enquire.set_query(Xapian::Query("this"));
01391 
01392     for (int pass = 1; pass <= 2; ++pass) {
01393         for (Xapian::valueno value_no = 1; value_no < 7; ++value_no) {
01394             tout << "Sorting on value " << value_no << endl;
01395             enquire.set_sort_by_value(value_no, true);
01396             Xapian::MSet allbset = enquire.get_mset(0, 100);
01397             Xapian::MSet partbset1 = enquire.get_mset(0, 3);
01398             Xapian::MSet partbset2 = enquire.get_mset(3, 97);
01399             TEST_EQUAL(allbset.size(), partbset1.size() + partbset2.size());
01400 
01401             bool ok = true;
01402             int n = 0;
01403             Xapian::MSetIterator i, j;
01404             j = allbset.begin();
01405             for (i = partbset1.begin(); i != partbset1.end(); ++i) {
01406                 tout << "Entry " << n << ": " << *i << " | " << *j << endl;
01407                 TEST(j != allbset.end());
01408                 if (*i != *j) ok = false;
01409                 ++j;
01410                 ++n;
01411             }
01412             tout << "===\n";
01413             for (i = partbset2.begin(); i != partbset2.end(); ++i) {
01414                 tout << "Entry " << n << ": " << *i << " | " << *j << endl;
01415                 TEST(j != allbset.end());
01416                 if (*i != *j) ok = false;
01417                 ++j;
01418                 ++n;
01419             }
01420             TEST(j == allbset.end());
01421             if (!ok)
01422                 FAIL_TEST("Split msets aren't consistent with unsplit");
01423         }
01424         enquire.set_docid_order(Xapian::Enquire::DESCENDING);
01425     }
01426 
01427     return true;
01428 }
01429 
01430 // consistency check match - vary mset size and check results agree.
01431 // consistency1 will run on the remote backend, but it's particularly slow
01432 // with that, and testing it there doesn't actually improve the test
01433 // coverage really.
01434 DEFINE_TESTCASE(consistency1, backend && !remote) {
01435     Xapian::Database db(get_database("etext"));
01436     Xapian::Enquire enquire(db);
01437     enquire.set_query(Xapian::Query(Xapian::Query::OP_OR, Xapian::Query("the"), Xapian::Query("sky")));
01438     Xapian::doccount lots = 214;
01439     Xapian::MSet bigmset = enquire.get_mset(0, lots);
01440     TEST_EQUAL(bigmset.size(), lots);
01441     try {
01442         for (Xapian::doccount start = 0; start < lots; ++start) {
01443             for (Xapian::doccount size = 0; size < lots - start; ++size) {
01444                 Xapian::MSet mset = enquire.get_mset(start, size);
01445                 if (mset.size()) {
01446                     TEST_EQUAL(start + mset.size(),
01447                                min(start + size, bigmset.size()));
01448                 } else if (size) {
01449 //              tout << start << mset.size() << bigmset.size() << endl;
01450                     TEST(start >= bigmset.size());
01451                 }
01452                 for (Xapian::doccount i = 0; i < mset.size(); ++i) {
01453                     TEST_EQUAL(*mset[i], *bigmset[start + i]);
01454                     TEST_EQUAL_DOUBLE(mset[i].get_weight(),
01455                                       bigmset[start + i].get_weight());
01456                 }
01457             }
01458         }
01459     }
01460     catch (const Xapian::NetworkTimeoutError &) {
01461         // consistency1 is a long test - may timeout with the remote backend...
01462         SKIP_TEST("Test taking too long");
01463     }
01464     return true;
01465 }
01466 
01467 // tests that specifying a nonexistent input file throws an exception.
01468 DEFINE_TESTCASE(flintdatabaseopeningerror1, flint) {
01469 #ifdef XAPIAN_HAS_FLINT_BACKEND
01470     mkdir(".flint", 0755);
01471 
01472     TEST_EXCEPTION(Xapian::DatabaseOpeningError,
01473                    Xapian::Flint::open(".flint/nosuchdirectory"));
01474     TEST_EXCEPTION(Xapian::DatabaseOpeningError,
01475                    Xapian::Flint::open(".flint/nosuchdirectory", Xapian::DB_OPEN));
01476 
01477     mkdir(".flint/emptydirectory", 0700);
01478     TEST_EXCEPTION(Xapian::DatabaseOpeningError,
01479                    Xapian::Flint::open(".flint/emptydirectory"));
01480 
01481     touch(".flint/somefile");
01482     TEST_EXCEPTION(Xapian::DatabaseOpeningError,
01483                    Xapian::Flint::open(".flint/somefile"));
01484     TEST_EXCEPTION(Xapian::DatabaseOpeningError,
01485                    Xapian::Flint::open(".flint/somefile", Xapian::DB_OPEN));
01486     TEST_EXCEPTION(Xapian::DatabaseCreateError,
01487                    Xapian::Flint::open(".flint/somefile", Xapian::DB_CREATE));
01488     TEST_EXCEPTION(Xapian::DatabaseCreateError,
01489                    Xapian::Flint::open(".flint/somefile", Xapian::DB_CREATE_OR_OPEN));
01490     TEST_EXCEPTION(Xapian::DatabaseCreateError,
01491                    Xapian::Flint::open(".flint/somefile", Xapian::DB_CREATE_OR_OVERWRITE));
01492 #endif
01493 
01494     return true;
01495 }
01496 
01498 DEFINE_TESTCASE(flintdatabaseformaterror1, flint) {
01499 #ifdef XAPIAN_HAS_FLINT_BACKEND
01500     string dbdir = test_driver::get_srcdir();
01501     dbdir += "/testdata/flint-0.9.9";
01502 
01503     // We should get a version error when we try and open the database for
01504     // reading now.
01505     TEST_EXCEPTION(Xapian::DatabaseVersionError,
01506                    Xapian::Database db(dbdir));
01507 
01508     // Also test when explicitly opening as a flint database.
01509     TEST_EXCEPTION(Xapian::DatabaseVersionError,
01510                    (void)Xapian::Flint::open(dbdir));
01511 
01512     // Clean up the "flintlock" file that we will have created while trying
01513     // to open the database.
01514     unlink((dbdir + "/flintlock").c_str());
01515 #endif
01516 
01517     return true;
01518 }
01519 
01521 // Xapian::DB_CREATE_OR_OVERWRITE.
01522 DEFINE_TESTCASE(flintdatabaseformaterror2, flint) {
01523 #ifdef XAPIAN_HAS_FLINT_BACKEND
01524     string flint099 = test_driver::get_srcdir();
01525     flint099 += "/testdata/flint-0.9.9";
01526 
01527     mkdir(".flint", 0755);
01528     string dbdir = ".flint/test_flintdatabaseformaterror2";
01529 
01530     rm_rf(dbdir);
01531     cp_R(flint099, dbdir);
01532 
01533     (void)Xapian::WritableDatabase(dbdir, Xapian::DB_CREATE_OR_OVERWRITE);
01534 
01535     rm_rf(dbdir);
01536     cp_R(flint099, dbdir);
01537 
01538     // Also test when explicitly opening as a flint database.
01539     (void)Xapian::Flint::open(dbdir, Xapian::DB_CREATE_OR_OVERWRITE);
01540 #endif
01541 
01542     return true;
01543 }
01544 
01545 // regression test for not releasing lock on error.
01546 DEFINE_TESTCASE(flintdatabaseformaterror3, flint) {
01547 #ifdef XAPIAN_HAS_FLINT_BACKEND
01548     string flint099 = test_driver::get_srcdir();
01549     flint099 += "/testdata/flint-0.9.9";
01550 
01551     mkdir(".flint", 0755);
01552     string dbdir = ".flint/test_flintdatabaseformaterror3";
01553 
01554     rm_rf(dbdir);
01555     cp_R(flint099, dbdir);
01556 
01557     TEST_EXCEPTION(Xapian::DatabaseVersionError,
01558                    Xapian::WritableDatabase(dbdir, Xapian::DB_CREATE_OR_OPEN));
01559 
01560     // This used to throw a DatabaseLockError: "Unable to acquire database
01561     // write lock on .flint/formatdb: already locked"
01562     Xapian::WritableDatabase(dbdir, Xapian::DB_CREATE_OR_OVERWRITE);
01563 #endif
01564 
01565     return true;
01566 }
01567 
01568 // Test that 1.0.2 and later can open 1.0.1 databases.
01569 DEFINE_TESTCASE(flintbackwardcompat1, flint) {
01570 #ifdef XAPIAN_HAS_FLINT_BACKEND
01571     string flint101 = test_driver::get_srcdir();
01572     flint101 += "/testdata/flint-1.0.1";
01573 
01574     mkdir(".flint", 0755);
01575     string dbdir = ".flint/test_flintbackwardcompat1";
01576 
01577     rm_rf(dbdir);
01578     cp_R(flint101, dbdir);
01579 
01580     // Check we can open the older format for reading.
01581     {
01582         Xapian::Database db(dbdir);
01583         TEST_EQUAL(db.get_doccount(), 0);
01584     }
01585 
01586     // Check we can open the older format for update.
01587     {
01588         Xapian::WritableDatabase db(dbdir, Xapian::DB_OPEN);
01589         TEST_EQUAL(db.get_doccount(), 0);
01590     }
01591 #endif
01592 
01593     return true;
01594 }
01595 
01596 // Test that 1.0.3 and later can open 1.0.2 databases.
01597 DEFINE_TESTCASE(flintbackwardcompat2, flint) {
01598 #ifdef XAPIAN_HAS_FLINT_BACKEND
01599     string flint102 = test_driver::get_srcdir();
01600     flint102 += "/testdata/flint-1.0.2";
01601 
01602     mkdir(".flint", 0755);
01603     string dbdir = ".flint/test_flintbackwardcompat2";
01604 
01605     rm_rf(dbdir);
01606     cp_R(flint102, dbdir);
01607 
01608     // Check we can open the older format for reading.
01609     {
01610         Xapian::Database db(dbdir);
01611         TEST_EQUAL(db.get_doccount(), 0);
01612     }
01613 
01614     // Check we can open the older format for update.
01615     {
01616         Xapian::WritableDatabase db(dbdir, Xapian::DB_OPEN);
01617         TEST_EQUAL(db.get_doccount(), 0);
01618     }
01619 #endif
01620 
01621     return true;
01622 }
01623 
01625 DEFINE_TESTCASE(flintdatabaseopen1, flint) {
01626 #ifdef XAPIAN_HAS_FLINT_BACKEND
01627     const string dbdir = ".flint/test_flintdatabaseopen1";
01628     mkdir(".flint", 0755);
01629 
01630     {
01631         rm_rf(dbdir);
01632         Xapian::WritableDatabase wdb =
01633             Xapian::Flint::open(dbdir, Xapian::DB_CREATE);
01634         TEST_EXCEPTION(Xapian::DatabaseLockError,
01635             Xapian::Flint::open(dbdir, Xapian::DB_OPEN));
01636         Xapian::Flint::open(dbdir);
01637     }
01638 
01639     {
01640         rm_rf(dbdir);
01641         Xapian::WritableDatabase wdb =
01642             Xapian::Flint::open(dbdir, Xapian::DB_CREATE_OR_OPEN);
01643         TEST_EXCEPTION(Xapian::DatabaseLockError,
01644             Xapian::Flint::open(dbdir, Xapian::DB_CREATE_OR_OVERWRITE));
01645         Xapian::Flint::open(dbdir);
01646     }
01647 
01648     {
01649         rm_rf(dbdir);
01650         Xapian::WritableDatabase wdb =
01651             Xapian::Flint::open(dbdir, Xapian::DB_CREATE_OR_OVERWRITE);
01652         TEST_EXCEPTION(Xapian::DatabaseLockError,
01653             Xapian::Flint::open(dbdir, Xapian::DB_CREATE_OR_OPEN));
01654         Xapian::Flint::open(dbdir);
01655     }
01656 
01657     {
01658         TEST_EXCEPTION(Xapian::DatabaseCreateError,
01659             Xapian::Flint::open(dbdir, Xapian::DB_CREATE));
01660         Xapian::WritableDatabase wdb =
01661             Xapian::Flint::open(dbdir, Xapian::DB_CREATE_OR_OVERWRITE);
01662         Xapian::Flint::open(dbdir);
01663     }
01664 
01665     {
01666         Xapian::WritableDatabase wdb =
01667             Xapian::Flint::open(dbdir, Xapian::DB_CREATE_OR_OPEN);
01668         Xapian::Flint::open(dbdir);
01669     }
01670 
01671     {
01672         Xapian::WritableDatabase wdb =
01673             Xapian::Flint::open(dbdir, Xapian::DB_OPEN);
01674         Xapian::Flint::open(dbdir);
01675     }
01676 #endif
01677 
01678     return true;
01679 }
01680 
01681 // feature test for Enquire:
01682 // set_sort_by_value
01683 // set_sort_by_value_then_relevance
01684 // set_sort_by_relevance_then_value
01685 DEFINE_TESTCASE(sortrel1, backend) {
01686     Xapian::Enquire enquire(get_database("apitest_sortrel"));
01687     enquire.set_sort_by_value(1, true);
01688     enquire.set_query(Xapian::Query("woman"));
01689 
01690     const Xapian::docid order1[] = { 1,2,3,4,5,6,7,8,9 };
01691     const Xapian::docid order2[] = { 2,1,3,6,5,4,7,9,8 };
01692     const Xapian::docid order3[] = { 3,2,1,6,5,4,9,8,7 };
01693     const Xapian::docid order4[] = { 7,8,9,4,5,6,1,2,3 };
01694     const Xapian::docid order5[] = { 9,8,7,6,5,4,3,2,1 };
01695     const Xapian::docid order6[] = { 7,9,8,6,5,4,2,1,3 };
01696     const Xapian::docid order7[] = { 7,9,8,6,5,4,2,1,3 };
01697     const Xapian::docid order8[] = { 7,6,2,9,5,1,8,4,3 };
01698     const Xapian::docid order9[] = { 2,6,7,1,5,9,3,4,8 };
01699 
01700     Xapian::MSet mset;
01701     size_t i;
01702 
01703     mset = enquire.get_mset(0, 10);
01704     TEST_EQUAL(mset.size(), sizeof(order1) / sizeof(Xapian::docid));
01705     for (i = 0; i < sizeof(order1) / sizeof(Xapian::docid); ++i) {
01706         TEST_EQUAL(*mset[i], order1[i]);
01707     }
01708 
01709     enquire.set_sort_by_value_then_relevance(1, true);
01710 
01711     mset = enquire.get_mset(0, 10);
01712     TEST_EQUAL(mset.size(), sizeof(order2) / sizeof(Xapian::docid));
01713     for (i = 0; i < sizeof(order2) / sizeof(Xapian::docid); ++i) {
01714         TEST_EQUAL(*mset[i], order2[i]);
01715     }
01716 
01717     enquire.set_sort_by_value(1, true);
01718 
01719     mset = enquire.get_mset(0, 10);
01720     TEST_EQUAL(mset.size(), sizeof(order1) / sizeof(Xapian::docid));
01721     for (i = 0; i < sizeof(order1) / sizeof(Xapian::docid); ++i) {
01722         TEST_EQUAL(*mset[i], order1[i]);
01723     }
01724 
01725     enquire.set_sort_by_value_then_relevance(1, true);
01726     enquire.set_docid_order(Xapian::Enquire::DESCENDING);
01727 
01728     mset = enquire.get_mset(0, 10);
01729     TEST_EQUAL(mset.size(), sizeof(order2) / sizeof(Xapian::docid));
01730     for (i = 0; i < sizeof(order2) / sizeof(Xapian::docid); ++i) {
01731         TEST_EQUAL(*mset[i], order2[i]);
01732     }
01733 
01734     enquire.set_sort_by_value(1, true);
01735     enquire.set_docid_order(Xapian::Enquire::DESCENDING);
01736 
01737     mset = enquire.get_mset(0, 10);
01738     TEST_EQUAL(mset.size(), sizeof(order3) / sizeof(Xapian::docid));
01739     for (i = 0; i < sizeof(order3) / sizeof(Xapian::docid); ++i) {
01740         TEST_EQUAL(*mset[i], order3[i]);
01741     }
01742 
01743     enquire.set_sort_by_value(1, false);
01744     enquire.set_docid_order(Xapian::Enquire::ASCENDING);
01745     mset = enquire.get_mset(0, 10);
01746     TEST_EQUAL(mset.size(), sizeof(order4) / sizeof(Xapian::docid));
01747     for (i = 0; i < sizeof(order4) / sizeof(Xapian::docid); ++i) {
01748         TEST_EQUAL(*mset[i], order4[i]);
01749     }
01750 
01751     enquire.set_sort_by_value(1, false);
01752     enquire.set_docid_order(Xapian::Enquire::DESCENDING);
01753     mset = enquire.get_mset(0, 10);
01754     TEST_EQUAL(mset.size(), sizeof(order5) / sizeof(Xapian::docid));
01755     for (i = 0; i < sizeof(order5) / sizeof(Xapian::docid); ++i) {
01756         TEST_EQUAL(*mset[i], order5[i]);
01757     }
01758 
01759     enquire.set_sort_by_value_then_relevance(1, false);
01760     enquire.set_docid_order(Xapian::Enquire::ASCENDING);
01761     mset = enquire.get_mset(0, 10);
01762     TEST_EQUAL(mset.size(), sizeof(order6) / sizeof(Xapian::docid));
01763     for (i = 0; i < sizeof(order6) / sizeof(Xapian::docid); ++i) {
01764         TEST_EQUAL(*mset[i], order6[i]);
01765     }
01766 
01767     enquire.set_sort_by_value_then_relevance(1, false);
01768     enquire.set_docid_order(Xapian::Enquire::DESCENDING);
01769     mset = enquire.get_mset(0, 10);
01770     TEST_EQUAL(mset.size(), sizeof(order7) / sizeof(Xapian::docid));
01771     for (i = 0; i < sizeof(order7) / sizeof(Xapian::docid); ++i) {
01772         TEST_EQUAL(*mset[i], order7[i]);
01773     }
01774 
01775     enquire.set_sort_by_relevance_then_value(1, true);
01776     enquire.set_docid_order(Xapian::Enquire::ASCENDING);
01777     mset = enquire.get_mset(0, 10);
01778     TEST_EQUAL(mset.size(), sizeof(order8) / sizeof(Xapian::docid));
01779     for (i = 0; i < sizeof(order8) / sizeof(Xapian::docid); ++i) {
01780         TEST_EQUAL(*mset[i], order8[i]);
01781     }
01782 
01783     enquire.set_sort_by_relevance_then_value(1, true);
01784     enquire.set_docid_order(Xapian::Enquire::DESCENDING);
01785     mset = enquire.get_mset(0, 10);
01786     TEST_EQUAL(mset.size(), sizeof(order8) / sizeof(Xapian::docid));
01787     for (i = 0; i < sizeof(order8) / sizeof(Xapian::docid); ++i) {
01788         TEST_EQUAL(*mset[i], order8[i]);
01789     }
01790 
01791     enquire.set_sort_by_relevance_then_value(1, false);
01792     enquire.set_docid_order(Xapian::Enquire::ASCENDING);
01793     mset = enquire.get_mset(0, 10);
01794     TEST_EQUAL(mset.size(), sizeof(order9) / sizeof(Xapian::docid));
01795     for (i = 0; i < sizeof(order9) / sizeof(Xapian::docid); ++i) {
01796         TEST_EQUAL(*mset[i], order9[i]);
01797     }
01798 
01799     enquire.set_sort_by_relevance_then_value(1, false);
01800     enquire.set_docid_order(Xapian::Enquire::DESCENDING);
01801     mset = enquire.get_mset(0, 10);
01802     TEST_EQUAL(mset.size(), sizeof(order9) / sizeof(Xapian::docid));
01803     for (i = 0; i < sizeof(order9) / sizeof(Xapian::docid); ++i) {
01804         TEST_EQUAL(*mset[i], order9[i]);
01805     }
01806 
01807     return true;
01808 }
01809 
01810 // Test network stats and local stats give the same results.
01811 DEFINE_TESTCASE(netstats1, remote) {
01812     BackendManagerLocal local_manager;
01813     local_manager.set_datadir(test_driver::get_srcdir() + "/testdata/");
01814 
01815     const char * words[] = { "paragraph", "word" };
01816     Xapian::Query query(Xapian::Query::OP_OR, words, words + 2);
01817     const size_t MSET_SIZE = 10;
01818 
01819     Xapian::RSet rset;
01820     rset.add_document(4);
01821     rset.add_document(9);
01822 
01823     Xapian::MSet mset_alllocal;
01824     {
01825         Xapian::Database db;
01826         db.add_database(local_manager.get_database("apitest_simpledata"));
01827         db.add_database(local_manager.get_database("apitest_simpledata2"));
01828 
01829         Xapian::Enquire enq(db);
01830         enq.set_query(query);
01831         mset_alllocal = enq.get_mset(0, MSET_SIZE, &rset);
01832     }
01833 
01834     {
01835         Xapian::Database db;
01836         db.add_database(local_manager.get_database("apitest_simpledata"));
01837         db.add_database(get_database("apitest_simpledata2"));
01838 
01839         Xapian::Enquire enq(db);
01840         enq.set_query(query);
01841         Xapian::MSet mset = enq.get_mset(0, MSET_SIZE, &rset);
01842         TEST_EQUAL(mset.get_matches_lower_bound(), mset_alllocal.get_matches_lower_bound());
01843         TEST_EQUAL(mset.get_matches_upper_bound(), mset_alllocal.get_matches_upper_bound());
01844         TEST_EQUAL(mset.get_matches_estimated(), mset_alllocal.get_matches_estimated());
01845         TEST_EQUAL(mset.get_max_attained(), mset_alllocal.get_max_attained());
01846         TEST_EQUAL(mset.size(), mset_alllocal.size());
01847         TEST(mset_range_is_same(mset, 0, mset_alllocal, 0, mset.size()));
01848     }
01849 
01850     {
01851         Xapian::Database db;
01852         db.add_database(get_database("apitest_simpledata"));
01853         db.add_database(local_manager.get_database("apitest_simpledata2"));
01854 
01855         Xapian::Enquire enq(db);
01856         enq.set_query(query);
01857         Xapian::MSet mset = enq.get_mset(0, MSET_SIZE, &rset);
01858         TEST_EQUAL(mset.get_matches_lower_bound(), mset_alllocal.get_matches_lower_bound());
01859         TEST_EQUAL(mset.get_matches_upper_bound(), mset_alllocal.get_matches_upper_bound());
01860         TEST_EQUAL(mset.get_matches_estimated(), mset_alllocal.get_matches_estimated());
01861         TEST_EQUAL(mset.get_max_attained(), mset_alllocal.get_max_attained());
01862         TEST_EQUAL(mset.size(), mset_alllocal.size());
01863         TEST(mset_range_is_same(mset, 0, mset_alllocal, 0, mset.size()));
01864     }
01865 
01866     {
01867         Xapian::Database db;
01868         db.add_database(get_database("apitest_simpledata"));
01869         db.add_database(get_database("apitest_simpledata2"));
01870 
01871         Xapian::Enquire enq(db);
01872         enq.set_query(query);
01873         Xapian::MSet mset = enq.get_mset(0, MSET_SIZE, &rset);
01874         TEST_EQUAL(mset.get_matches_lower_bound(), mset_alllocal.get_matches_lower_bound());
01875         TEST_EQUAL(mset.get_matches_upper_bound(), mset_alllocal.get_matches_upper_bound());
01876         TEST_EQUAL(mset.get_matches_estimated(), mset_alllocal.get_matches_estimated());
01877         TEST_EQUAL(mset.get_max_attained(), mset_alllocal.get_max_attained());
01878         TEST_EQUAL(mset.size(), mset_alllocal.size());
01879         TEST(mset_range_is_same(mset, 0, mset_alllocal, 0, mset.size()));
01880     }
01881 
01882     return true;
01883 }
01884 
01885 // Coordinate matching - scores 1 for each matching term
01886 class MyWeight : public Xapian::Weight {
01887     double scale_factor;
01888 
01889   public:
01890     MyWeight * clone() const {
01891         return new MyWeight;
01892     }
01893     void init(double factor) {
01894         scale_factor = factor;
01895     }
01896     MyWeight() { }
01897     ~MyWeight() { }
01898     std::string name() const { return "MyWeight"; }
01899     string serialise() const { return string(); }
01900     MyWeight * unserialise(const string &) const { return new MyWeight; }
01901     Xapian::weight get_sumpart(Xapian::termcount, Xapian::termcount) const {
01902         return scale_factor;
01903     }
01904     Xapian::weight get_maxpart() const { return scale_factor; }
01905 
01906     Xapian::weight get_sumextra(Xapian::termcount) const { return 0; }
01907     Xapian::weight get_maxextra() const { return 0; }
01908 };
01909 
01910 // tests user weighting scheme.
01911 // Would work with remote if we registered the weighting scheme.
01912 // FIXME: do this so we also test that functionality...
01913 DEFINE_TESTCASE(userweight1, backend && !remote) {
01914     Xapian::Enquire enquire(get_database("apitest_simpledata"));
01915     enquire.set_weighting_scheme(MyWeight());
01916     const char * query[] = { "this", "line", "paragraph", "rubbish" };
01917     enquire.set_query(Xapian::Query(Xapian::Query::OP_OR, query,
01918                                     query + sizeof(query) / sizeof(query[0])));
01919     Xapian::MSet mymset1 = enquire.get_mset(0, 100);
01920     // MyWeight scores 1 for each matching term, so the weight should equal
01921     // the number of matching terms.
01922     for (Xapian::MSetIterator i = mymset1.begin(); i != mymset1.end(); ++i) {
01923         Xapian::termcount matching_terms = 0;
01924         Xapian::TermIterator t = enquire.get_matching_terms_begin(i);
01925         while (t != enquire.get_matching_terms_end(i)) {
01926             ++matching_terms;
01927             ++t;
01928         }
01929         TEST_EQUAL(i.get_weight(), matching_terms);
01930     }
01931 
01932     return true;
01933 }
01934 
01935 // tests MatchAll queries
01936 // This is a regression test, which failed with assertion failures in
01937 // revision 9094.  Also check that the results aren't ranked by relevance
01938 // (regression test for bug fixed in 1.0.9).
01939 DEFINE_TESTCASE(matchall1, backend) {
01940     Xapian::Database db(get_database("apitest_simpledata"));
01941     Xapian::Enquire enquire(db);
01942     enquire.set_query(Xapian::Query::MatchAll);
01943     Xapian::MSet mset = enquire.get_mset(0, 10);
01944     TEST_EQUAL(mset.get_matches_lower_bound(), db.get_doccount());
01945     TEST_EQUAL(mset.get_uncollapsed_matches_lower_bound(), db.get_doccount());
01946 
01947     enquire.set_query(Xapian::Query(Xapian::Query::OP_OR,
01948                                     Xapian::Query("nosuchterm"),
01949                                     Xapian::Query::MatchAll));
01950     mset = enquire.get_mset(0, 10);
01951     TEST_EQUAL(mset.get_matches_lower_bound(), db.get_doccount());
01952     TEST_EQUAL(mset.get_uncollapsed_matches_lower_bound(), db.get_doccount());
01953 
01954     // Check that the results aren't ranked by relevance (fixed in 1.0.9).
01955     TEST(mset.size() > 1);
01956     TEST_EQUAL(mset[mset.size() - 1].get_weight(), 0);
01957     TEST_EQUAL(*mset[0], 1);
01958     TEST_EQUAL(*mset[mset.size() - 1], mset.size());
01959  
01960     return true;
01961 }
01962 
01963 // Test using a ValueSetMatchDecider
01964 DEFINE_TESTCASE(valuesetmatchdecider2, backend && !remote) {
01965     Xapian::Database db(get_database("apitest_phrase"));
01966     Xapian::Enquire enq(db);
01967     enq.set_query(Xapian::Query("leav"));
01968 
01969     Xapian::ValueSetMatchDecider vsmd1(1, true);
01970     vsmd1.add_value("n");
01971     Xapian::ValueSetMatchDecider vsmd2(1, false);
01972     vsmd2.add_value("n");
01973 
01974     Xapian::MSet mymset = enq.get_mset(0, 20);
01975     mset_expect_order(mymset, 8, 6, 4, 5, 7, 10, 12, 11, 13, 9, 14);
01976     mymset = enq.get_mset(0, 20, 0, NULL, &vsmd1);
01977     mset_expect_order(mymset, 6, 12);
01978     mymset = enq.get_mset(0, 20, 0, NULL, &vsmd2);
01979     mset_expect_order(mymset, 8, 4, 5, 7, 10, 11, 13, 9, 14);
01980 
01981     return true;
01982 }
tests/api_db.cc
