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

00001 /* api_wrdb.cc: tests which need a writable backend
00002  *
00003  * Copyright 1999,2000,2001 BrightStation PLC
00004  * Copyright 2001 Hein Ragas
00005  * Copyright 2002 Ananova Ltd
00006  * Copyright 2002,2003,2004,2005,2006,2007,2008,2009,2010 Olly Betts
00007  * Copyright 2006 Richard Boulton
00008  * Copyright 2007 Lemur Consulting Ltd
00009  *
00010  * This program is free software; you can redistribute it and/or
00011  * modify it under the terms of the GNU General Public License as
00012  * published by the Free Software Foundation; either version 2 of the
00013  * License, or (at your option) any later version.
00014  *
00015  * This program is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018  * GNU General Public License for more details.
00019  *
00020  * You should have received a copy of the GNU General Public License
00021  * along with this program; if not, write to the Free Software
00022  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
00023  * USA
00024  */
00025 
00026 #include <config.h>
00027 
00028 #include "api_wrdb.h"
00029 
00030 #include <xapian.h>
00031 
00032 #include "backendmanager.h" // For XAPIAN_BIN_PATH.
00033 #include "omassert.h"
00034 #include "str.h"
00035 #include "testsuite.h"
00036 #include "testutils.h"
00037 #include "unixcmds.h"
00038 #include "utils.h"
00039 
00040 #include "apitest.h"
00041 
00042 #include <cmath>
00043 #include <cstdlib>
00044 #include <map>
00045 #include <string>
00046 
00047 using namespace std;
00048 
00049 // #######################################################################
00050 // # Tests start here
00051 
00052 // test that indexing a term more than once at the same position increases
00053 // the wdf
00054 DEFINE_TESTCASE(adddoc1, writable) {
00055     Xapian::WritableDatabase db = get_writable_database();
00056 
00057     Xapian::Document doc1, doc2, doc3;
00058 
00059     // doc1 should come top, but if term "foo" gets wdf of 1, doc2 will beat it
00060     // doc3 should beat both
00061     // Note: all docs have same length
00062     doc1.set_data(string("tom"));
00063     doc1.add_posting("foo", 1);
00064     doc1.add_posting("foo", 1);
00065     doc1.add_posting("foo", 1);
00066     doc1.add_posting("bar", 3);
00067     doc1.add_posting("bar", 4);
00068     db.add_document(doc1);
00069 
00070     doc2.set_data(string("dick"));
00071     doc2.add_posting("foo", 1);
00072     doc2.add_posting("foo", 2);
00073     doc2.add_posting("bar", 3);
00074     doc2.add_posting("bar", 3);
00075     doc2.add_posting("bar", 3);
00076     db.add_document(doc2);
00077 
00078     doc3.set_data(string("harry"));
00079     doc3.add_posting("foo", 1);
00080     doc3.add_posting("foo", 1);
00081     doc3.add_posting("foo", 2);
00082     doc3.add_posting("foo", 2);
00083     doc3.add_posting("bar", 3);
00084     db.add_document(doc3);
00085 
00086     Xapian::Query query("foo");
00087 
00088     Xapian::Enquire enq(db);
00089     enq.set_query(query);
00090 
00091     Xapian::MSet mset = enq.get_mset(0, 10);
00092 
00093     mset_expect_order(mset, 3, 1, 2);
00094 
00095     return true;
00096 }
00097 
00098 // test that removing a posting and removing a term works
00099 DEFINE_TESTCASE(adddoc2, writable) {
00100     Xapian::WritableDatabase db = get_writable_database();
00101 
00102     Xapian::Document doc1;
00103 
00104     doc1.add_posting("foo", 1);
00105     doc1.add_posting("foo", 1);
00106     doc1.add_posting("foo", 2);
00107     doc1.add_posting("foo", 2);
00108     doc1.add_posting("bar", 3);
00109     doc1.add_posting("gone", 1);
00110     // Quartz had a bug handling a term >= 128 characters longer than the
00111     // preceding term in the sort order - this is "foo" + 130 "X"s
00112     doc1.add_posting("fooXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", 1);
00113     Xapian::docid did;
00114 
00115     Xapian::Document doc2 = db.get_document(did = db.add_document(doc1));
00116     TEST_EQUAL(did, 1);
00117 
00118     Xapian::TermIterator iter1 = doc1.termlist_begin();
00119     Xapian::TermIterator iter2 = doc2.termlist_begin();
00120     TEST(iter1 != doc1.termlist_end());
00121     TEST(iter2 != doc2.termlist_end());
00122     TEST_EQUAL(*iter1, "bar");
00123     TEST_EQUAL(*iter2, *iter1);
00124     TEST_EQUAL(iter1.get_wdf(), 1);
00125     TEST_EQUAL(iter2.get_wdf(), 1);
00126     //TEST_EQUAL(iter1.get_termfreq(), 0);
00127     TEST_EQUAL(iter2.get_termfreq(), 1);
00128 
00129     iter1++;
00130     iter2++;
00131     TEST(iter1 != doc1.termlist_end());
00132     TEST(iter2 != doc2.termlist_end());
00133     TEST_EQUAL(*iter1, "foo");
00134     TEST_EQUAL(*iter2, *iter1);
00135     TEST_EQUAL(iter1.get_wdf(), 4);
00136     TEST_EQUAL(iter2.get_wdf(), 4);
00137     //TEST_EQUAL(iter1.get_termfreq(), 0);
00138     TEST_EQUAL(iter2.get_termfreq(), 1);
00139 
00140     iter1++;
00141     iter2++;
00142     TEST(iter1 != doc1.termlist_end());
00143     TEST(iter2 != doc2.termlist_end());
00144     TEST_EQUAL(*iter1, "fooXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
00145     TEST_EQUAL(*iter2, *iter1);
00146     TEST_EQUAL(iter1.get_wdf(), 1);
00147     TEST_EQUAL(iter2.get_wdf(), 1);
00148     // assertion fails in debug build! TEST_EQUAL(iter1.get_termfreq(), 0);
00149     TEST_EQUAL(iter2.get_termfreq(), 1);
00150 
00151     iter1++;
00152     iter2++;
00153     TEST(iter1 != doc1.termlist_end());
00154     TEST(iter2 != doc2.termlist_end());
00155     TEST_EQUAL(*iter1, "gone");
00156     TEST_EQUAL(*iter2, *iter1);
00157     TEST_EQUAL(iter1.get_wdf(), 1);
00158     TEST_EQUAL(iter2.get_wdf(), 1);
00159     // assertion fails in debug build! TEST_EQUAL(iter1.get_termfreq(), 0);
00160     TEST_EQUAL(iter2.get_termfreq(), 1);
00161 
00162     iter1++;
00163     iter2++;
00164     TEST(iter1 == doc1.termlist_end());
00165     TEST(iter2 == doc2.termlist_end());
00166 
00167     doc2.remove_posting("foo", 1, 5);
00168     doc2.add_term("bat", 0);
00169     doc2.add_term("bar", 8);
00170     doc2.add_term("bag", 0);
00171     doc2.remove_term("gone");
00172     doc2.remove_term("fooXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
00173 
00174     // Should have (doc,wdf) pairs: (bag,0)(bar,9)(bat,0)(foo,0)
00175     // positionlists (bag,none)(bar,3)(bat,none)(foo,2)
00176 
00177     iter2 = doc2.termlist_begin();
00178     TEST(iter2 != doc2.termlist_end());
00179     TEST_EQUAL(*iter2, "bag");
00180     //TEST_EQUAL(iter2.get_termfreq(), 0);
00181     iter2++;
00182     TEST(iter2 != doc2.termlist_end());
00183     TEST_EQUAL(*iter2, "bar");
00184     //TEST_EQUAL(iter2.get_termfreq(), 0);
00185     iter2++;
00186     TEST(iter2 != doc2.termlist_end());
00187     TEST_EQUAL(*iter2, "bat");
00188     //TEST_EQUAL(iter2.get_termfreq(), 0);
00189     iter2++;
00190     TEST(iter2 != doc2.termlist_end());
00191     TEST_EQUAL(*iter2, "foo");
00192     //TEST_EQUAL(iter2.get_termfreq(), 0);
00193     iter2++;
00194     TEST(iter2 == doc2.termlist_end());
00195 
00196     doc1 = db.get_document(did = db.add_document(doc2));
00197     TEST_EQUAL(did, 2);
00198 
00199     iter1 = doc1.termlist_begin();
00200     iter2 = doc2.termlist_begin();
00201     TEST(iter1 != doc1.termlist_end());
00202     TEST(iter2 != doc2.termlist_end());
00203     TEST_EQUAL(*iter1, "bag");
00204     TEST_EQUAL(*iter2, *iter1);
00205     TEST_EQUAL(iter1.get_wdf(), 0);
00206     TEST_EQUAL(iter2.get_wdf(), 0);
00207     TEST_EQUAL(iter1.get_termfreq(), 1);
00208     //TEST_EQUAL(iter2.get_termfreq(), 0);
00209     TEST(iter1.positionlist_begin() == iter1.positionlist_end());
00210     TEST(iter2.positionlist_begin() == iter2.positionlist_end());
00211 
00212     iter1++;
00213     iter2++;
00214     TEST(iter1 != doc1.termlist_end());
00215     TEST(iter2 != doc2.termlist_end());
00216     TEST_EQUAL(*iter1, "bar");
00217     TEST_EQUAL(*iter2, *iter1);
00218     TEST_EQUAL(iter1.get_wdf(), 9);
00219     TEST_EQUAL(iter2.get_wdf(), 9);
00220     TEST_EQUAL(iter1.get_termfreq(), 2);
00221     //TEST_EQUAL(iter2.get_termfreq(), 0);
00222 
00223     Xapian::PositionIterator pi1;
00224     pi1 = iter1.positionlist_begin();
00225     Xapian::PositionIterator pi2 = iter2.positionlist_begin();
00226     TEST_EQUAL(*pi1, 3); pi1++;
00227     TEST_EQUAL(*pi2, 3); pi2++;
00228     TEST(pi1 == iter1.positionlist_end());
00229     TEST(pi2 == iter2.positionlist_end());
00230 
00231     iter1++;
00232     iter2++;
00233     TEST(iter1 != doc1.termlist_end());
00234     TEST(iter2 != doc2.termlist_end());
00235     TEST_EQUAL(*iter1, "bat");
00236     TEST_EQUAL(*iter2, *iter1);
00237     TEST_EQUAL(iter1.get_wdf(), 0);
00238     TEST_EQUAL(iter2.get_wdf(), 0);
00239     TEST_EQUAL(iter1.get_termfreq(), 1);
00240     //TEST_EQUAL(iter2.get_termfreq(), 0);
00241     TEST(iter1.positionlist_begin() == iter1.positionlist_end());
00242     TEST(iter2.positionlist_begin() == iter2.positionlist_end());
00243 
00244     iter1++;
00245     iter2++;
00246     TEST(iter1 != doc1.termlist_end());
00247     TEST(iter2 != doc2.termlist_end());
00248     TEST_EQUAL(*iter1, "foo");
00249     TEST_EQUAL(*iter2, *iter1);
00250     TEST_EQUAL(iter1.get_wdf(), 0);
00251     TEST_EQUAL(iter2.get_wdf(), 0);
00252     TEST_EQUAL(iter1.get_termfreq(), 2);
00253     //TEST_EQUAL(iter2.get_termfreq(), 0);
00254 
00255     Xapian::PositionIterator temp1 = iter1.positionlist_begin();
00256     pi1 = temp1;
00257     Xapian::PositionIterator temp2 = iter2.positionlist_begin();
00258     pi2 = temp2;
00259     TEST_EQUAL(*pi1, 2); pi1++;
00260     TEST_EQUAL(*pi2, 2); pi2++;
00261     TEST(pi1 == iter1.positionlist_end());
00262     TEST(pi2 == iter2.positionlist_end());
00263 
00264     iter1++;
00265     iter2++;
00266     TEST(iter1 == doc1.termlist_end());
00267     TEST(iter2 == doc2.termlist_end());
00268 
00269     return true;
00270 }
00271 
00272 // test that adding lots of documents works, and doesn't leak memory
00273 // REGRESSION FIXED:2003-09-07
00274 DEFINE_TESTCASE(adddoc3, writable) {
00275     Xapian::WritableDatabase db = get_writable_database();
00276 
00277     for (Xapian::doccount i = 0; i < 2100; ++i) {
00278         Xapian::Document doc;
00279         for (Xapian::termcount t = 0; t < 100; ++t) {
00280             string term("foo");
00281             term += char(t ^ 70 ^ i);
00282             doc.add_posting(term, t);
00283         }
00284         db.add_document(doc);
00285     }
00286     return true;
00287 }
00288 
00289 // We want to test that a termlist starting with a 48 character long term works
00290 // OK since this value currently requires special handling in flint for
00291 // historical reasons!)  Also test all other term lengths while we're at it.
00292 DEFINE_TESTCASE(adddoc4, writable) {
00293     Xapian::WritableDatabase db = get_writable_database();
00294 
00295     for (Xapian::doccount i = 1; i <= 240; ++i) {
00296         Xapian::Document doc;
00297         string term(i, 'X');
00298         doc.add_term(term);
00299         db.add_document(doc);
00300     }
00301     db.add_document(Xapian::Document());
00302     db.commit();
00303 
00304     for (Xapian::doccount i = 1; i <= 240; ++i) {
00305         Xapian::Document doc = db.get_document(i);
00306         Xapian::TermIterator t = doc.termlist_begin();
00307         TEST(t != doc.termlist_end());
00308         TEST_EQUAL((*t).size(), i);
00309         ++t;
00310         TEST(t == doc.termlist_end());
00311     }
00312 
00313     // And test a document with no terms.
00314     Xapian::Document doc = db.get_document(241);
00315     TEST(doc.termlist_begin() == doc.termlist_end());
00316 
00317     return true;
00318 }
00319 
00320 // Test adding a document, and checking that it got added correctly.
00321 // This testcase used to be adddoc2 in quartztest.
00322 DEFINE_TESTCASE(adddoc5, writable) {
00323     // Inmemory doesn't support get_writable_database_as_database().
00324     SKIP_TEST_FOR_BACKEND("inmemory");
00325 
00326     Xapian::docid did;
00327     Xapian::Document document_in;
00328     document_in.set_data("Foobar rising");
00329     document_in.add_value(7, "Value7");
00330     document_in.add_value(13, "Value13");
00331     document_in.add_posting("foobar", 1);
00332     document_in.add_posting("rising", 2);
00333     document_in.add_posting("foobar", 3);
00334 
00335     Xapian::Document document_in2;
00336     document_in2.set_data("Foobar falling");
00337     document_in2.add_posting("foobar", 1);
00338     document_in2.add_posting("falling", 2);
00339     {
00340         Xapian::WritableDatabase database(get_writable_database());
00341 
00342         TEST_EQUAL(database.get_doccount(), 0);
00343         TEST_EQUAL(database.get_avlength(), 0);
00344 
00345         did = database.add_document(document_in);
00346         TEST_EQUAL(database.get_doccount(), 1);
00347         TEST_EQUAL(database.get_avlength(), 3);
00348 
00349         TEST_EQUAL(database.get_termfreq("foobar"), 1);
00350         TEST_EQUAL(database.get_collection_freq("foobar"), 2);
00351         TEST_EQUAL(database.get_termfreq("rising"), 1);
00352         TEST_EQUAL(database.get_collection_freq("rising"), 1);
00353         TEST_EQUAL(database.get_termfreq("falling"), 0);
00354         TEST_EQUAL(database.get_collection_freq("falling"), 0);
00355 
00356         Xapian::docid did2 = database.add_document(document_in2);
00357         TEST_EQUAL(database.get_doccount(), 2);
00358         TEST_NOT_EQUAL(did, did2);
00359         TEST_EQUAL(database.get_avlength(), 5.0/2.0);
00360 
00361         TEST_EQUAL(database.get_termfreq("foobar"), 2);
00362         TEST_EQUAL(database.get_collection_freq("foobar"), 3);
00363         TEST_EQUAL(database.get_termfreq("rising"), 1);
00364         TEST_EQUAL(database.get_collection_freq("rising"), 1);
00365         TEST_EQUAL(database.get_termfreq("falling"), 1);
00366         TEST_EQUAL(database.get_collection_freq("falling"), 1);
00367 
00368         database.delete_document(did);
00369         TEST_EQUAL(database.get_doccount(), 1);
00370         TEST_EQUAL(database.get_avlength(), 2);
00371 
00372         TEST_EQUAL(database.get_termfreq("foobar"), 1);
00373         TEST_EQUAL(database.get_collection_freq("foobar"), 1);
00374         TEST_EQUAL(database.get_termfreq("rising"), 0);
00375         TEST_EQUAL(database.get_collection_freq("rising"), 0);
00376         TEST_EQUAL(database.get_termfreq("falling"), 1);
00377         TEST_EQUAL(database.get_collection_freq("falling"), 1);
00378 
00379         did = database.add_document(document_in);
00380         TEST_EQUAL(database.get_doccount(), 2);
00381         TEST_EQUAL(database.get_avlength(), 5.0/2.0);
00382 
00383         TEST_EQUAL(database.get_termfreq("foobar"), 2);
00384         TEST_EQUAL(database.get_collection_freq("foobar"), 3);
00385         TEST_EQUAL(database.get_termfreq("rising"), 1);
00386         TEST_EQUAL(database.get_collection_freq("rising"), 1);
00387         TEST_EQUAL(database.get_termfreq("falling"), 1);
00388         TEST_EQUAL(database.get_collection_freq("falling"), 1);
00389     }
00390 
00391     {
00392         Xapian::Database database(get_writable_database_as_database());
00393         Xapian::Document document_out = database.get_document(did);
00394 
00395         TEST_EQUAL(document_in.get_data(), document_out.get_data());
00396 
00397         {
00398             Xapian::ValueIterator i(document_in.values_begin());
00399             Xapian::ValueIterator j(document_out.values_begin());
00400             for (; i != document_in.values_end(); i++, j++) {
00401                 TEST_NOT_EQUAL(j, document_out.values_end());
00402                 TEST_EQUAL(*i, *j);
00403                 TEST_EQUAL(i.get_valueno(), j.get_valueno());
00404             }
00405             TEST_EQUAL(j, document_out.values_end());
00406         }
00407 
00408         {
00409             // Regression test for bug fixed in 1.0.5 - values_begin() didn't
00410             // ensure that values had been read.  However, values_end() did
00411             // (and so did values_count()) so this wasn't generally an issue
00412             // but it shouldn't happen anyway.
00413             Xapian::Document doc_tmp = database.get_document(did);
00414             Xapian::ValueIterator i = document_in.values_begin();
00415             Xapian::ValueIterator j = doc_tmp.values_begin();
00416             TEST_EQUAL(*i, *j);
00417         }
00418 
00419         {
00420             Xapian::TermIterator i(document_in.termlist_begin());
00421             Xapian::TermIterator j(document_out.termlist_begin());
00422             for (; i != document_in.termlist_end(); i++, j++) {
00423                 TEST_NOT_EQUAL(j, document_out.termlist_end());
00424                 TEST_EQUAL(*i, *j);
00425                 TEST_EQUAL(i.get_wdf(), j.get_wdf());
00426                 TEST_EXCEPTION(Xapian::InvalidOperationError,
00427                                (void)i.get_termfreq());
00428                 TEST_NOT_EQUAL(0, j.get_termfreq());
00429                 if (*i == "foobar") {
00430                     // termfreq of foobar is 2
00431                     TEST_EQUAL(2, j.get_termfreq());
00432                 } else {
00433                     // termfreq of rising is 1
00434                     TEST_EQUAL(*i, "rising");
00435                     TEST_EQUAL(1, j.get_termfreq());
00436                 }
00437                 Xapian::PositionIterator k(i.positionlist_begin());
00438                 Xapian::PositionIterator l(j.positionlist_begin());
00439                 for (; k != i.positionlist_end(); k++, l++) {
00440                     TEST_NOT_EQUAL(l, j.positionlist_end());
00441                     TEST_EQUAL(*k, *l);
00442                 }
00443                 TEST_EQUAL(l, j.positionlist_end());
00444             }
00445             TEST_EQUAL(j, document_out.termlist_end());
00446         }
00447     }
00448 
00449     return true;
00450 }
00451 
00452 // Test adding a document, and checking that it got added correctly.
00453 // This testcase used to be adddoc3 in quartztest.
00454 DEFINE_TESTCASE(adddoc6, writable) {
00455     // Inmemory doesn't support get_writable_database_again().
00456     SKIP_TEST_FOR_BACKEND("inmemory");
00457 
00458     Xapian::docid did;
00459     Xapian::Document document_in;
00460     document_in.set_data("Foobar rising");
00461     document_in.add_value(7, "Value7");
00462     document_in.add_value(13, "Value13");
00463     document_in.add_posting("foo", 1);
00464     document_in.add_posting("bar", 2);
00465 
00466     {
00467         Xapian::WritableDatabase database(get_writable_database());
00468 
00469         did = database.add_document(document_in);
00470         TEST_EQUAL(did, 1);
00471         TEST_EQUAL(database.get_doccount(), 1);
00472         TEST_EQUAL(database.get_avlength(), 2);
00473     }
00474 
00475     {
00476         Xapian::WritableDatabase database(get_writable_database_again());
00477 
00478         document_in.remove_term("foo");
00479         document_in.add_posting("baz", 1);
00480 
00481         database.replace_document(1, document_in);
00482 
00483         database.delete_document(1);
00484 
00485         TEST_EQUAL(database.get_doccount(), 0);
00486         TEST_EQUAL(database.get_avlength(), 0);
00487         TEST_EQUAL(database.get_termfreq("foo"), 0);
00488         TEST_EQUAL(database.get_collection_freq("foo"), 0);
00489         TEST_EQUAL(database.get_termfreq("bar"), 0);
00490         TEST_EQUAL(database.get_collection_freq("bar"), 0);
00491         TEST_EQUAL(database.get_termfreq("baz"), 0);
00492         TEST_EQUAL(database.get_collection_freq("baz"), 0);
00493     }
00494 
00495     return true;
00496 }
00497 
00498 // tests that database destructors commit if it isn't done explicitly
00499 DEFINE_TESTCASE(implicitendsession1, writable) {
00500     Xapian::WritableDatabase db = get_writable_database();
00501 
00502     Xapian::Document doc;
00503 
00504     doc.set_data(string("top secret"));
00505     doc.add_posting("cia", 1);
00506     doc.add_posting("nsa", 2);
00507     doc.add_posting("fbi", 3);
00508     db.add_document(doc);
00509 
00510     return true;
00511 }
00512 
00513 // tests that assignment of Xapian::Database and Xapian::WritableDatabase works
00514 // as expected
00515 DEFINE_TESTCASE(databaseassign1, writable) {
00516     Xapian::WritableDatabase wdb = get_writable_database();
00517     Xapian::Database db = get_database("");
00518     Xapian::Database actually_wdb = wdb;
00519     Xapian::WritableDatabase w1(wdb);
00520     w1 = wdb;
00521     Xapian::Database d1(wdb);
00522     Xapian::Database d2(actually_wdb);
00523     d2 = wdb;
00524     d2 = actually_wdb;
00525     wdb = wdb; // check assign to itself works
00526     db = db; // check assign to itself works
00527     return true;
00528 }
00529 
00530 // tests that deletion and updating of documents works as expected
00531 DEFINE_TESTCASE(deldoc1, writable) {
00532     Xapian::WritableDatabase db = get_writable_database();
00533 
00534     Xapian::Document doc1;
00535 
00536     doc1.add_posting("foo", 1);
00537     doc1.add_posting("foo", 1);
00538     doc1.add_posting("foo", 2);
00539     doc1.add_posting("foo", 2);
00540     doc1.add_posting("bar", 3);
00541     doc1.add_posting("gone", 1);
00542 
00543     Xapian::docid did = db.add_document(doc1);
00544     TEST_EQUAL(did, 1);
00545 
00546     doc1.remove_term("gone");
00547 
00548     did = db.add_document(doc1);
00549     TEST_EQUAL(did, 2);
00550 
00551     doc1.add_term("new", 1);
00552     did = db.add_document(doc1);
00553     TEST_EQUAL(did, 3);
00554 
00555     db.delete_document(1);
00556 
00557     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(1));
00558 
00559     doc1 = db.get_document(2);
00560     doc1.remove_term("foo");
00561     doc1.add_term("fwing");
00562     db.replace_document(2, doc1);
00563 
00564     Xapian::Document doc2 = db.get_document(2);
00565     Xapian::TermIterator tit = doc2.termlist_begin();
00566     TEST_NOT_EQUAL(tit, doc2.termlist_end());
00567     TEST_EQUAL(*tit, "bar");
00568     tit++;
00569     TEST_NOT_EQUAL(tit, doc2.termlist_end());
00570     TEST_EQUAL(*tit, "fwing");
00571     tit++;
00572     TEST_EQUAL(tit, doc2.termlist_end());
00573 
00574     return true;
00575 }
00576 
00577 // tests that deletion and updating of documents works as expected
00578 DEFINE_TESTCASE(deldoc2, writable) {
00579     Xapian::WritableDatabase db = get_writable_database();
00580 
00581     Xapian::Document doc1;
00582 
00583     doc1.add_posting("one", 1);
00584     doc1.add_posting("two", 2);
00585     doc1.add_posting("two", 3);
00586     Xapian::docid did;
00587 
00588     did = db.add_document(doc1);
00589     TEST_EQUAL(did, 1);
00590 
00591     doc1.remove_term("one");
00592     doc1.add_posting("three", 4);
00593 
00594     did = db.add_document(doc1);
00595     TEST_EQUAL(did, 2);
00596 
00597     doc1.add_posting("one", 7);
00598     doc1.remove_term("two");
00599 
00600     did = db.add_document(doc1);
00601     TEST_EQUAL(did, 3);
00602 
00603     db.commit();
00604 
00605     db.reopen();
00606 
00607     db.delete_document(1);
00608     db.delete_document(2);
00609     db.delete_document(3);
00610 
00611     db.commit();
00612 
00613     db.reopen();
00614 
00615     TEST_EQUAL(db.postlist_begin("one"), db.postlist_end("one"));
00616     TEST_EQUAL(db.postlist_begin("two"), db.postlist_end("two"));
00617     TEST_EQUAL(db.postlist_begin("three"), db.postlist_end("three"));
00618 
00619     TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(1));
00620     TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(2));
00621     TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(3));
00622     TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(4));
00623 
00624     // test positionlist_{begin,end}?
00625 
00626     TEST_EQUAL(db.get_doccount(), 0);
00627     TEST_EQUAL(db.get_avlength(), 0);
00628     TEST_EQUAL(db.get_termfreq("one"), 0);
00629     TEST_EQUAL(db.get_termfreq("two"), 0);
00630     TEST_EQUAL(db.get_termfreq("three"), 0);
00631 
00632     TEST(!db.term_exists("one"));
00633     TEST(!db.term_exists("two"));
00634     TEST(!db.term_exists("three"));
00635 
00636     TEST_EQUAL(db.get_collection_freq("one"), 0);
00637     TEST_EQUAL(db.get_collection_freq("two"), 0);
00638     TEST_EQUAL(db.get_collection_freq("three"), 0);
00639 
00640     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_doclength(1));
00641     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_doclength(2));
00642     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_doclength(3));
00643 
00644     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(1));
00645     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(2));
00646     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(3));
00647 
00648     TEST_EQUAL(db.allterms_begin(), db.allterms_end());
00649 
00650     return true;
00651 }
00652 
00653 // another test of deletion of documents, a cut-down version of deldoc2
00654 DEFINE_TESTCASE(deldoc3, writable) {
00655     Xapian::WritableDatabase db = get_writable_database();
00656 
00657     Xapian::Document doc1;
00658 
00659     doc1.add_posting("one", 1);
00660 
00661     Xapian::docid did = db.add_document(doc1);
00662     TEST_EQUAL(did, 1);
00663 
00664     db.commit();
00665 
00666     db.reopen();
00667 
00668     db.delete_document(1);
00669 
00670     db.commit();
00671 
00672     db.reopen();
00673 
00674     TEST_EQUAL(db.postlist_begin("one"), db.postlist_end("one"));
00675 
00676     TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(1));
00677     (void)&db; // gcc 2.95 seems to miscompile without this!!! - Olly
00678     TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(2));
00679 
00680     // test positionlist_{begin,end}?
00681 
00682     TEST_EQUAL(db.get_doccount(), 0);
00683     TEST_EQUAL(db.get_avlength(), 0);
00684     TEST_EQUAL(db.get_termfreq("one"), 0);
00685 
00686     TEST(!db.term_exists("one"));
00687 
00688     TEST_EQUAL(db.get_collection_freq("one"), 0);
00689 
00690     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_doclength(1));
00691     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_doclength(2));
00692 
00693     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(1));
00694     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(2));
00695 
00696     TEST_EQUAL(db.allterms_begin(), db.allterms_end());
00697 
00698     return true;
00699 }
00700 
00701 // tests that deletion and updating of (lots of) documents works as expected
00702 DEFINE_TESTCASE(deldoc4, writable) {
00703     Xapian::WritableDatabase db = get_writable_database();
00704 
00705     Xapian::Document doc1;
00706 
00707     doc1.add_posting("one", 1);
00708     doc1.add_posting("two", 2);
00709     doc1.add_posting("two", 3);
00710 
00711     Xapian::Document doc2 = doc1;
00712     doc2.remove_term("one");
00713     doc2.add_posting("three", 4);
00714 
00715     Xapian::Document doc3 = doc2;
00716     doc3.add_posting("one", 7);
00717     doc3.remove_term("two");
00718 
00719     const Xapian::docid maxdoc = 1000 * 3;
00720     Xapian::docid did;
00721     for (Xapian::docid i = 0; i < maxdoc / 3; ++i) {
00722         did = db.add_document(doc1);
00723         TEST_EQUAL(did, i * 3 + 1);
00724         did = db.add_document(doc2);
00725         TEST_EQUAL(did, i * 3 + 2);
00726         did = db.add_document(doc3);
00727         TEST_EQUAL(did, i * 3 + 3);
00728 
00729         bool is_power_of_two = ((i & (i - 1)) == 0);
00730         if (is_power_of_two) {
00731             db.commit();
00732             db.reopen();
00733         }
00734     }
00735     db.commit();
00736     db.reopen();
00737 
00738     /* delete the documents in a peculiar order */
00739     for (Xapian::docid i = 0; i < maxdoc / 3; ++i) {
00740         db.delete_document(maxdoc - i);
00741         db.delete_document(maxdoc / 3 + i + 1);
00742         db.delete_document(i + 1);
00743     }
00744 
00745     db.commit();
00746 
00747     db.reopen();
00748 
00749     TEST_EQUAL(db.postlist_begin("one"), db.postlist_end("one"));
00750     TEST_EQUAL(db.postlist_begin("two"), db.postlist_end("two"));
00751     TEST_EQUAL(db.postlist_begin("three"), db.postlist_end("three"));
00752 
00753     for (Xapian::docid i = 1; i <= maxdoc; ++i) {
00754         // TEST_EXCEPTION writes to tout each time if the test is run
00755         // in verbose mode and some string stream implementations get
00756         // very inefficient with large strings, so clear tout on each pass of
00757         // the loop to speed up the test since the older information isn't
00758         // interesting anyway.
00759         tout.str(string());
00760         TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(i));
00761         TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_doclength(i));
00762         TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(i));
00763     }
00764 
00765     // test positionlist_{begin,end}?
00766 
00767     TEST_EQUAL(db.get_doccount(), 0);
00768     TEST_EQUAL(db.get_avlength(), 0);
00769     TEST_EQUAL(db.get_termfreq("one"), 0);
00770     TEST_EQUAL(db.get_termfreq("two"), 0);
00771     TEST_EQUAL(db.get_termfreq("three"), 0);
00772 
00773     TEST(!db.term_exists("one"));
00774     TEST(!db.term_exists("two"));
00775     TEST(!db.term_exists("three"));
00776 
00777     TEST_EQUAL(db.get_collection_freq("one"), 0);
00778     TEST_EQUAL(db.get_collection_freq("two"), 0);
00779     TEST_EQUAL(db.get_collection_freq("three"), 0);
00780 
00781     TEST_EQUAL(db.allterms_begin(), db.allterms_end());
00782 
00783     return true;
00784 }
00785 
00786 // Test deleting a document which was added in the same batch.
00787 DEFINE_TESTCASE(deldoc5, writable) {
00788     Xapian::WritableDatabase db = get_writable_database();
00789 
00790     Xapian::Document doc1;
00791 
00792     doc1.add_posting("foo", 1);
00793     doc1.add_posting("bar", 2);
00794     doc1.add_posting("aardvark", 3);
00795 
00796     Xapian::docid did = db.add_document(doc1);
00797     TEST_EQUAL(did, 1);
00798 
00799     doc1.remove_term("bar");
00800     doc1.add_term("hello");
00801 
00802     did = db.add_document(doc1);
00803     TEST_EQUAL(did, 2);
00804 
00805     doc1.add_term("world", 1);
00806     did = db.add_document(doc1);
00807     TEST_EQUAL(did, 3);
00808 
00809     db.delete_document(2);
00810 
00811     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(2));
00812 
00813     db.commit();
00814 
00815     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(2));
00816 
00817     TEST_EQUAL(db.get_termfreq("foo"), 2);
00818     TEST_EQUAL(db.get_termfreq("aardvark"), 2);
00819     TEST_EQUAL(db.get_termfreq("hello"), 1);
00820 
00821     Xapian::PostingIterator p = db.postlist_begin("foo");
00822     TEST_NOT_EQUAL(p, db.postlist_end("foo"));
00823     TEST_EQUAL(*p, 1);
00824     ++p;
00825     TEST_NOT_EQUAL(p, db.postlist_end("foo"));
00826     TEST_EQUAL(*p, 3);
00827     ++p;
00828     TEST_EQUAL(p, db.postlist_end("foo"));
00829 
00830     return true;
00831 }
00832 
00833 // Regression test for bug in quartz and flint, fixed in 1.0.2.
00834 DEFINE_TESTCASE(deldoc6, writable) {
00835     Xapian::WritableDatabase db = get_writable_database();
00836 
00837     Xapian::Document doc1;
00838 
00839     doc1.add_posting("foo", 1);
00840     doc1.add_posting("bar", 2);
00841     doc1.add_posting("aardvark", 3);
00842 
00843     Xapian::docid did = db.add_document(doc1);
00844     TEST_EQUAL(did, 1);
00845 
00846     doc1.remove_term("bar");
00847     doc1.add_term("hello");
00848 
00849     did = db.add_document(doc1);
00850     TEST_EQUAL(did, 2);
00851 
00852     db.commit();
00853 
00854     db.delete_document(2);
00855     TEST_EXCEPTION(Xapian::DocNotFoundError, db.delete_document(3));
00856 
00857     db.commit();
00858 
00859     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(2));
00860 
00861     return true;
00862 }
00863 
00864 DEFINE_TESTCASE(replacedoc1, writable) {
00865     Xapian::WritableDatabase db = get_writable_database();
00866 
00867     Xapian::Document doc1;
00868 
00869     doc1.add_posting("foo", 1);
00870     doc1.add_posting("foo", 2);
00871     doc1.add_posting("gone",3);
00872     doc1.add_posting("bar", 4);
00873     doc1.add_posting("foo", 5);
00874     Xapian::docid did;
00875 
00876     did = db.add_document(doc1);
00877     TEST_EQUAL(did, 1);
00878 
00879     Xapian::Document doc2;
00880 
00881     doc2.add_posting("foo", 1);
00882     doc2.add_posting("pipco", 2);
00883     doc2.add_posting("bar", 4);
00884     doc2.add_posting("foo", 5);
00885 
00886     db.replace_document(did, doc2);
00887 
00888     Xapian::Document doc3 = db.get_document(did);
00889     Xapian::TermIterator tIter = doc3.termlist_begin();
00890     TEST_EQUAL(*tIter, "bar");
00891     Xapian::PositionIterator pIter = tIter.positionlist_begin();
00892     TEST_EQUAL(*pIter, 4);
00893     ++tIter;
00894     TEST_EQUAL(*tIter, "foo");
00895     Xapian::PositionIterator qIter = tIter.positionlist_begin();
00896     TEST_EQUAL(*qIter, 1);
00897     ++qIter;
00898     TEST_EQUAL(*qIter, 5);
00899     ++tIter;
00900     TEST_EQUAL(*tIter, "pipco");
00901     Xapian::PositionIterator rIter = tIter.positionlist_begin();
00902     TEST_EQUAL(*rIter, 2);
00903     ++tIter;
00904     TEST_EQUAL(tIter, doc3.termlist_end());
00905     return true;
00906 }
00907 
00908 // Test of new feature: WritableDatabase::replace_document accepts a docid
00909 // which doesn't yet exist as of Xapian 0.8.2.
00910 DEFINE_TESTCASE(replacedoc2, writable) {
00911     Xapian::WritableDatabase db = get_writable_database();
00912 
00913     Xapian::Document doc1;
00914 
00915     doc1.add_posting("foo", 1);
00916     doc1.add_posting("foo", 2);
00917     doc1.add_posting("gone",3);
00918     doc1.add_posting("bar", 4);
00919     doc1.add_posting("foo", 5);
00920     Xapian::docid did = 31770;
00921 
00922     db.replace_document(did, doc1);
00923 
00924     // Regression tests for bug in the InMemory backend - fixed in 1.0.2.
00925     TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(1));
00926     Xapian::PostingIterator postit = db.postlist_begin("");
00927     TEST(postit != db.postlist_end(""));
00928     TEST_EQUAL(*postit, 31770);
00929 
00930     Xapian::Document doc2;
00931 
00932     doc2.add_posting("foo", 1);
00933     doc2.add_posting("pipco", 2);
00934     doc2.add_posting("bar", 4);
00935     doc2.add_posting("foo", 5);
00936 
00937     db.replace_document(did, doc2);
00938     TEST_EQUAL(db.get_doccount(), 1);
00939 
00940     Xapian::Document doc3 = db.get_document(did);
00941     Xapian::TermIterator tIter = doc3.termlist_begin();
00942     TEST_EQUAL(*tIter, "bar");
00943     Xapian::PositionIterator pIter = tIter.positionlist_begin();
00944     TEST_EQUAL(*pIter, 4);
00945     ++tIter;
00946     TEST_EQUAL(*tIter, "foo");
00947     Xapian::PositionIterator qIter = tIter.positionlist_begin();
00948     TEST_EQUAL(*qIter, 1);
00949     ++qIter;
00950     TEST_EQUAL(*qIter, 5);
00951     ++tIter;
00952     TEST_EQUAL(*tIter, "pipco");
00953     Xapian::PositionIterator rIter = tIter.positionlist_begin();
00954     TEST_EQUAL(*rIter, 2);
00955     ++tIter;
00956     TEST_EQUAL(tIter, doc3.termlist_end());
00957 
00958     did = db.add_document(doc1);
00959     TEST_EQUAL(did, 31771);
00960     TEST_EQUAL(db.get_doccount(), 2);
00961 
00962     TEST_EXCEPTION(Xapian::InvalidArgumentError, db.replace_document(0, doc2));
00963 
00964     return true;
00965 }
00966 
00967 // Test replacing a document which was added in the same batch.
00968 DEFINE_TESTCASE(replacedoc3, writable) {
00969     Xapian::WritableDatabase db = get_writable_database();
00970 
00971     Xapian::Document doc1;
00972 
00973     doc1.add_posting("foo", 1);
00974     doc1.add_posting("bar", 2);
00975     doc1.add_posting("aardvark", 3);
00976 
00977     Xapian::docid did = db.add_document(doc1);
00978     TEST_EQUAL(did, 1);
00979 
00980     doc1.remove_term("bar");
00981     doc1.add_term("hello");
00982 
00983     did = db.add_document(doc1);
00984     TEST_EQUAL(did, 2);
00985 
00986     doc1.add_term("world", 1);
00987     did = db.add_document(doc1);
00988     TEST_EQUAL(did, 3);
00989 
00990     Xapian::Document doc2;
00991     doc2.add_term("world");
00992     db.replace_document(2, doc2);
00993 
00994     db.commit();
00995 
00996     // Check that the document exists (no DocNotFoundError).
00997     doc2 = db.get_document(2);
00998 
00999     TEST_EQUAL(db.get_termfreq("foo"), 2);
01000     TEST_EQUAL(db.get_termfreq("aardvark"), 2);
01001     TEST_EQUAL(db.get_termfreq("hello"), 1);
01002     TEST_EQUAL(db.get_termfreq("world"), 2);
01003 
01004     TEST_EQUAL(db.get_doclength(1), 3);
01005     TEST_EQUAL(db.get_doclength(2), 1);
01006     TEST_EQUAL(db.get_doclength(3), 4);
01007 
01008     Xapian::PostingIterator p = db.postlist_begin("foo");
01009     TEST_NOT_EQUAL(p, db.postlist_end("foo"));
01010     TEST_EQUAL(*p, 1);
01011     TEST_EQUAL(p.get_doclength(), 3);
01012     ++p;
01013     TEST_NOT_EQUAL(p, db.postlist_end("foo"));
01014     TEST_EQUAL(*p, 3);
01015     TEST_EQUAL(p.get_doclength(), 4);
01016     ++p;
01017     TEST_EQUAL(p, db.postlist_end("foo"));
01018 
01019     p = db.postlist_begin("world");
01020     TEST_NOT_EQUAL(p, db.postlist_end("world"));
01021     TEST_EQUAL(*p, 2);
01022     TEST_EQUAL(p.get_doclength(), 1);
01023     ++p;
01024     TEST_NOT_EQUAL(p, db.postlist_end("world"));
01025     TEST_EQUAL(*p, 3);
01026     TEST_EQUAL(p.get_doclength(), 4);
01027     ++p;
01028     TEST_EQUAL(p, db.postlist_end("world"));
01029 
01030     return true;
01031 }
01032 
01033 // Test replacing a document which was deleted in the same batch.
01034 DEFINE_TESTCASE(replacedoc4, writable) {
01035     Xapian::WritableDatabase db = get_writable_database();
01036 
01037     Xapian::Document doc1;
01038 
01039     doc1.add_posting("foo", 1);
01040     doc1.add_posting("bar", 2);
01041     doc1.add_posting("aardvark", 3);
01042 
01043     Xapian::docid did = db.add_document(doc1);
01044     TEST_EQUAL(did, 1);
01045 
01046     doc1.remove_term("bar");
01047     doc1.add_term("hello");
01048 
01049     did = db.add_document(doc1);
01050     TEST_EQUAL(did, 2);
01051 
01052     doc1.add_term("world", 1);
01053     did = db.add_document(doc1);
01054     TEST_EQUAL(did, 3);
01055 
01056     db.delete_document(2);
01057 
01058     Xapian::Document doc2;
01059     doc2.add_term("world");
01060     db.replace_document(2, doc2);
01061 
01062     db.commit();
01063 
01064     // Check that the document exists (no DocNotFoundError).
01065     doc2 = db.get_document(2);
01066 
01067     TEST_EQUAL(db.get_termfreq("foo"), 2);
01068     TEST_EQUAL(db.get_termfreq("aardvark"), 2);
01069     TEST_EQUAL(db.get_termfreq("hello"), 1);
01070     TEST_EQUAL(db.get_termfreq("world"), 2);
01071 
01072     Xapian::PostingIterator p = db.postlist_begin("foo");
01073     TEST_NOT_EQUAL(p, db.postlist_end("foo"));
01074     TEST_EQUAL(*p, 1);
01075     ++p;
01076     TEST_NOT_EQUAL(p, db.postlist_end("foo"));
01077     TEST_EQUAL(*p, 3);
01078     ++p;
01079     TEST_EQUAL(p, db.postlist_end("foo"));
01080 
01081     p = db.postlist_begin("world");
01082     TEST_NOT_EQUAL(p, db.postlist_end("world"));
01083     TEST_EQUAL(*p, 2);
01084     ++p;
01085     TEST_NOT_EQUAL(p, db.postlist_end("world"));
01086     TEST_EQUAL(*p, 3);
01087     ++p;
01088     TEST_EQUAL(p, db.postlist_end("world"));
01089 
01090     return true;
01091 }
01092 
01093 // Test replacing a document with itself without modifying postings.
01094 // Regression test for bug in 0.9.9 and earlier - there flint and quartz
01095 // lose all positional information for the document when you do this.
01096 DEFINE_TESTCASE(replacedoc5, writable) {
01097     Xapian::WritableDatabase db = get_writable_database();
01098 
01099     {
01100         Xapian::Document doc;
01101         doc.add_posting("hello", 1);
01102         doc.add_posting("world", 2);
01103 
01104         Xapian::docid did = db.add_document(doc);
01105         TEST_EQUAL(did, 1);
01106         db.commit();
01107     }
01108 
01109     {
01110         Xapian::Document doc = db.get_document(1);
01111         TEST(db.has_positions());
01112         TEST(db.positionlist_begin(1, "hello") != db.positionlist_end(1, "hello"));
01113         TEST(db.positionlist_begin(1, "world") != db.positionlist_end(1, "world"));
01114         db.replace_document(1, doc);
01115         db.commit();
01116 
01117         TEST(db.has_positions());
01118         TEST(db.positionlist_begin(1, "hello") != db.positionlist_end(1, "hello"));
01119         TEST(db.positionlist_begin(1, "world") != db.positionlist_end(1, "world"));
01120     }
01121 
01122     // Brass, chert and flint now spot simple cases of replacing the same
01123     // document and don't do needless work.  Force them to actually do the
01124     // replacement to make sure that case works.
01125 
01126     {
01127         Xapian::Document doc;
01128         doc.add_term("Q2");
01129         db.add_document(doc);
01130         db.commit();
01131     }
01132 
01133     {
01134         Xapian::Document doc = db.get_document(1);
01135         TEST(db.has_positions());
01136         TEST(db.positionlist_begin(1, "hello") != db.positionlist_end(1, "hello"));
01137         TEST(db.positionlist_begin(1, "world") != db.positionlist_end(1, "world"));
01138         (void)db.get_document(2);
01139         db.replace_document(1, doc);
01140         db.commit();
01141 
01142         TEST(db.has_positions());
01143         TEST(db.positionlist_begin(1, "hello") != db.positionlist_end(1, "hello"));
01144         TEST(db.positionlist_begin(1, "world") != db.positionlist_end(1, "world"));
01145     }
01146 
01147     return true;
01148 }
01149 
01150 // Test replacing a document while adding values, without changing anything
01151 // else.  Regression test for a bug introduced while implementing lazy update,
01152 // and also covers a few other code paths.
01153 DEFINE_TESTCASE(replacedoc6, writable) {
01154     Xapian::WritableDatabase db = get_writable_database();
01155 
01156     Xapian::Document doc;
01157     Xapian::docid did = db.add_document(doc);
01158     TEST_EQUAL(did, 1);
01159     db.commit();
01160 
01161     // Add document
01162     doc = db.get_document(1);
01163     TEST_EQUAL(doc.get_value(1), "");
01164     TEST_EQUAL(doc.get_value(2), "");
01165     doc.add_value(1, "banana1");
01166     db.replace_document(1, doc);
01167 
01168     doc = db.get_document(1);
01169     TEST_EQUAL(doc.get_value(1), "banana1");
01170     TEST_EQUAL(doc.get_value(2), "");
01171     db.commit();
01172 
01173     doc = db.get_document(1);
01174     TEST_EQUAL(doc.get_value(1), "banana1");
01175     TEST_EQUAL(doc.get_value(2), "");
01176     doc.add_value(2, "banana2");
01177     db.replace_document(1, doc);
01178 
01179     TEST_EQUAL(doc.get_value(1), "banana1");
01180     TEST_EQUAL(doc.get_value(2), "banana2");
01181     db.commit();
01182 
01183     doc = db.get_document(1);
01184     TEST_EQUAL(doc.get_value(1), "banana1");
01185     TEST_EQUAL(doc.get_value(2), "banana2");
01186 
01187     return true;
01188 }
01189 
01190 // Test of new feature: WritableDatabase::replace_document and delete_document
01191 // can take a unique termname instead of a document id as of Xapian 0.8.2.
01192 DEFINE_TESTCASE(uniqueterm1, writable) {
01193     Xapian::WritableDatabase db = get_writable_database();
01194 
01195     for (int n = 1; n <= 20; ++n) {
01196         Xapian::Document doc;
01197         string uterm = "U" + str(n % 16);
01198         doc.add_term(uterm);
01199         doc.add_term(str(n));
01200         doc.add_term(str(n ^ 9));
01201         doc.add_term("all");
01202         doc.set_data("pass1");
01203         db.add_document(doc);
01204     }
01205 
01206     TEST_EQUAL(db.get_doccount(), 20);
01207 
01208     static const Xapian::doccount sizes[20] = {
01209         19, 17, 16, 15,
01210         15, 15, 15, 15,
01211         15, 15, 15, 15,
01212         15, 15, 15, 15,
01213         15, 15, 15, 15
01214     };
01215     for (int n = 1; n <= 20; ++n) {
01216         string uterm = "U" + str(n % 16);
01217         if (uterm == "U2") {
01218             db.delete_document(uterm);
01219         } else {
01220             Xapian::Document doc;
01221             doc.add_term(uterm);
01222             doc.add_term(str(n));
01223             doc.add_term(str(n ^ 9));
01224             doc.add_term("all");
01225             doc.set_data("pass2");
01226             db.replace_document(uterm, doc);
01227         }
01228         TEST_EQUAL(db.get_doccount(), sizes[n - 1]);
01229     }
01230 
01231     string uterm = "U571";
01232     Xapian::Document doc;
01233     doc.add_term(uterm);
01234     doc.set_data("pass3");
01235     db.replace_document(uterm, doc);
01236 
01237     TEST_EQUAL(db.get_doccount(), 16);
01238 
01239     db.delete_document("U2");
01240 
01241     TEST_EQUAL(db.get_doccount(), 16);
01242 
01243     return true;
01244 }
01245 
01246 // tests all document postlists
01247 DEFINE_TESTCASE(allpostlist2, writable) {
01248     Xapian::WritableDatabase db(get_writable_database("apitest_manydocs"));
01249     Xapian::PostingIterator i = db.postlist_begin("");
01250     unsigned int j = 1;
01251     while (i != db.postlist_end("")) {
01252         TEST_EQUAL(*i, j);
01253         i++;
01254         j++;
01255     }
01256     TEST_EQUAL(j, 513);
01257 
01258     db.delete_document(1);
01259     db.delete_document(50);
01260     db.delete_document(512);
01261 
01262     i = db.postlist_begin("");
01263     j = 2;
01264     while (i != db.postlist_end("")) {
01265         TEST_EQUAL(*i, j);
01266         i++;
01267         j++;
01268         if (j == 50) j++;
01269     }
01270     TEST_EQUAL(j, 512);
01271 
01272     i = db.postlist_begin("");
01273     j = 2;
01274     while (i != db.postlist_end("")) {
01275         TEST_EQUAL(*i, j);
01276         i++;
01277         j++;
01278         if (j == 40) {
01279             j += 10;
01280             i.skip_to(j);
01281             j++;
01282         }
01283     }
01284     TEST_EQUAL(j, 512);
01285 
01286     return true;
01287 }
01288 
01289 static void test_emptyterm2_helper(Xapian::WritableDatabase & db)
01290 {
01291     // Don't bother with postlist_begin() because allpostlist tests cover that.
01292     TEST_EXCEPTION(Xapian::InvalidArgumentError, db.positionlist_begin(1, ""));
01293     TEST_EQUAL(db.get_doccount(), db.get_termfreq(""));
01294     TEST_EQUAL(db.get_doccount() != 0, db.term_exists(""));
01295     TEST_EQUAL(db.get_doccount(), db.get_collection_freq(""));
01296 }
01297 
01298 // tests results of passing an empty term to various methods
01299 // equivalent of emptyterm1 for a writable database
01300 DEFINE_TESTCASE(emptyterm2, writable) {
01301     {
01302         Xapian::WritableDatabase db(get_writable_database("apitest_manydocs"));
01303         TEST_EQUAL(db.get_doccount(), 512);
01304         test_emptyterm2_helper(db);
01305         db.delete_document(1);
01306         TEST_EQUAL(db.get_doccount(), 511);
01307         test_emptyterm2_helper(db);
01308         db.delete_document(50);
01309         TEST_EQUAL(db.get_doccount(), 510);
01310         test_emptyterm2_helper(db);
01311         db.delete_document(512);
01312         TEST_EQUAL(db.get_doccount(), 509);
01313         test_emptyterm2_helper(db);
01314     }
01315 
01316     {
01317         Xapian::WritableDatabase db(get_writable_database("apitest_onedoc"));
01318         TEST_EQUAL(db.get_doccount(), 1);
01319         test_emptyterm2_helper(db);
01320         db.delete_document(1);
01321         TEST_EQUAL(db.get_doccount(), 0);
01322         test_emptyterm2_helper(db);
01323     }
01324 
01325     {
01326         Xapian::WritableDatabase db(get_writable_database());
01327         TEST_EQUAL(db.get_doccount(), 0);
01328         test_emptyterm2_helper(db);
01329     }
01330 
01331     return true;
01332 }
01333 
01334 // Check that PHRASE/NEAR becomes AND if there's no positional info in the
01335 // database.
01336 DEFINE_TESTCASE(phraseorneartoand1, writable) {
01337     Xapian::WritableDatabase db = get_writable_database();
01338 
01339     for (int n = 1; n <= 20; ++n) {
01340         Xapian::Document doc;
01341         doc.add_term(str(n));
01342         doc.add_term(str(n ^ 9));
01343         doc.add_term("all");
01344         doc.set_data("pass1");
01345         db.add_document(doc);
01346     }
01347     db.commit();
01348 
01349     Xapian::Enquire enquire(db);
01350     Xapian::MSet mymset;
01351 
01352     const char * q1[] = { "all", "1" };
01353     enquire.set_query(Xapian::Query(Xapian::Query::OP_PHRASE, q1, q1 + 2));
01354     mymset = enquire.get_mset(0, 10);
01355     TEST_EQUAL(2, mymset.size());
01356 
01357     enquire.set_query(Xapian::Query(Xapian::Query::OP_NEAR, q1, q1 + 2));
01358     mymset = enquire.get_mset(0, 10);
01359     TEST_EQUAL(2, mymset.size());
01360 
01361     const char * q2[] = { "1", "2" };
01362     enquire.set_query(Xapian::Query(Xapian::Query::OP_PHRASE, q2, q2 + 2));
01363     mymset = enquire.get_mset(0, 10);
01364     TEST_EQUAL(0, mymset.size());
01365 
01366     enquire.set_query(Xapian::Query(Xapian::Query::OP_NEAR, q2, q2 + 2));
01367     mymset = enquire.get_mset(0, 10);
01368     TEST_EQUAL(0, mymset.size());
01369 
01370     return true;
01371 }
01372 
01373 // Check that a large number of position list entries for a particular term
01374 // works - regression test for flint.
01375 DEFINE_TESTCASE(longpositionlist1, writable) {
01376     Xapian::WritableDatabase db = get_writable_database();
01377 
01378     Xapian::Document doc;
01379     Xapian::termpos n;
01380     for (n = 1; n <= 2000; ++n) {
01381         doc.add_posting("fork", n * 3);
01382         doc.add_posting("knife", n * unsigned(log(double(n + 2))));
01383         doc.add_posting("spoon", n * n);
01384     }
01385     doc.set_data("cutlery");
01386     Xapian::docid did = db.add_document(doc);
01387     db.commit();
01388 
01389     doc = db.get_document(did);
01390 
01391     Xapian::TermIterator t, tend;
01392     Xapian::PositionIterator p, pend;
01393 
01394     t = doc.termlist_begin();
01395     tend = doc.termlist_end();
01396 
01397     TEST(t != tend);
01398     TEST_EQUAL(*t, "fork");
01399     p = t.positionlist_begin();
01400     pend = t.positionlist_end();
01401     for (n = 1; n <= 2000; ++n) {
01402         TEST(p != pend);
01403         TEST_EQUAL(*p, n * 3);
01404         ++p;
01405     }
01406     TEST(p == pend);
01407 
01408     ++t;
01409     TEST(t != tend);
01410     TEST_EQUAL(*t, "knife");
01411     p = t.positionlist_begin();
01412     pend = t.positionlist_end();
01413     for (n = 1; n <= 2000; ++n) {
01414         TEST(p != pend);
01415         TEST_EQUAL(*p, n * unsigned(log(double(n + 2))));
01416         ++p;
01417     }
01418     TEST(p == pend);
01419 
01420     ++t;
01421     TEST(t != tend);
01422     TEST_EQUAL(*t, "spoon");
01423     p = t.positionlist_begin();
01424     pend = t.positionlist_end();
01425     for (n = 1; n <= 2000; ++n) {
01426         TEST(p != pend);
01427         TEST_EQUAL(*p, n * n);
01428         ++p;
01429     }
01430     TEST(p == pend);
01431 
01432     ++t;
01433     TEST(t == tend);
01434 
01435     return true;
01436 }
01437 
01438 // Regression test for bug#110: Inconsistent sort order between pages with
01439 // set_sort_by_value_then_relevance.
01440 DEFINE_TESTCASE(consistency2, writable) {
01441     Xapian::WritableDatabase db = get_writable_database();
01442     char buf[2] = "X";
01443     int i = 0;
01444 
01445     // Add 5 documents indexed by "test" with wdf 1.
01446     for (i = 0; i < 5; ++i) {
01447         Xapian::Document doc;
01448         *buf = '0' + i;
01449         doc.add_value(0, buf);
01450         doc.add_term("test");
01451         db.add_document(doc);
01452     }
01453 
01454     // Add 5 documents indexed by "test" with wdf 2.
01455     for (i = 0; i < 5; ++i) {
01456         Xapian::Document doc;
01457         *buf = '0' + i;
01458         doc.add_value(0, buf);
01459         doc.add_term("test", 2);
01460         db.add_document(doc);
01461     }
01462 
01463     db.commit();
01464 
01465     Xapian::Enquire enq(db);
01466     enq.set_query(Xapian::Query("test"));
01467 
01468     enq.set_sort_by_value_then_relevance(0, true);
01469 
01470     // 10 results, unpaged.
01471     Xapian::MSet mset1 = enq.get_mset(0, 10);
01472     TEST_EQUAL(mset1.size(), 10);
01473 
01474     // 10 results, split.
01475     Xapian::MSet mset2a = enq.get_mset(0, 1);
01476     TEST_EQUAL(mset2a.size(), 1);
01477     Xapian::MSet mset2b = enq.get_mset(1, 1);
01478     TEST_EQUAL(mset2b.size(), 1);
01479     Xapian::MSet mset2c = enq.get_mset(2, 8);
01480     TEST_EQUAL(mset2c.size(), 8);
01481 
01482     TEST_EQUAL(*mset1[0], *mset2a[0]);
01483     TEST_EQUAL(*mset1[1], *mset2b[0]);
01484     for (i = 0; i < 8; ++i) {
01485         TEST_EQUAL(*mset1[i + 2], *mset2c[i]);
01486     }
01487 
01488     return true;
01489 }
01490 
01491 DEFINE_TESTCASE(crashrecovery1, brass || chert || flint) {
01492     const string & dbtype = get_dbtype();
01493     string path = ".";
01494     path += dbtype;
01495     path += "/dbw";
01496     const char * base_ext = ".baseB";
01497 
01498     Xapian::Document doc;
01499     {
01500         Xapian::WritableDatabase db = get_writable_database();
01501         Xapian::Database dbr(get_writable_database_as_database());
01502         TEST_EQUAL(dbr.get_doccount(), 0);
01503 
01504         // Xapian::Database has full set of baseA, no baseB
01505 
01506         db.add_document(doc);
01507         db.commit();
01508         dbr.reopen();
01509         TEST_EQUAL(dbr.get_doccount(), 1);
01510 
01511         // Xapian::Database has full set of baseB, old baseA
01512 
01513         db.add_document(doc);
01514         db.commit();
01515         dbr.reopen();
01516         TEST_EQUAL(dbr.get_doccount(), 2);
01517 
01518         // Xapian::Database has full set of baseA, old baseB
01519 
01520         // Simulate a transaction starting, some of the baseB getting removed,
01521         // but then the transaction fails.
01522         unlink(path + "/record" + base_ext);
01523         unlink(path + "/termlist" + base_ext);
01524 
01525         dbr.reopen();
01526         TEST_EQUAL(dbr.get_doccount(), 2);
01527     }
01528 
01529     Xapian::WritableDatabase db(path, Xapian::DB_OPEN);
01530     // Xapian::Database has full set of baseA, some old baseB
01531     Xapian::Database dbr = Xapian::Database(path);
01532 
01533     db.add_document(doc);
01534     db.commit();
01535     dbr.reopen();
01536     TEST_EQUAL(dbr.get_doccount(), 3);
01537 
01538     // Xapian::Database has full set of baseB, old baseA
01539 
01540     db.add_document(doc);
01541     db.commit();
01542     dbr.reopen();
01543     TEST_EQUAL(dbr.get_doccount(), 4);
01544 
01545     return true;
01546 }
01547 
01548 // Check that DatabaseError is thrown if the docid counter would wrap.
01549 // Regression test for bug#152.
01550 DEFINE_TESTCASE(nomoredocids1, writable) {
01551     // The InMemory backend uses a vector for the documents, so trying to add
01552     // document "-1" will fail because we can't allocate enough memory!
01553     SKIP_TEST_FOR_BACKEND("inmemory");
01554 
01555     Xapian::WritableDatabase db = get_writable_database();
01556     Xapian::Document doc;
01557     doc.set_data("prose");
01558     doc.add_term("word");
01559 
01560     db.replace_document(Xapian::docid(-1), doc);
01561 
01562     TEST_EXCEPTION(Xapian::DatabaseError, db.add_document(doc));
01563 
01564     return true;
01565 }
01566 
01567 // Test synonym iterators.
01568 DEFINE_TESTCASE(synonymitor1, writable && synonyms) {
01569     Xapian::WritableDatabase db = get_writable_database();
01570 
01571     // Test iterators for terms which aren't there.
01572     TEST(db.synonyms_begin("abc") == db.synonyms_end("abc"));
01573 
01574     // Test iterating the synonym keys when there aren't any.
01575     TEST(db.synonym_keys_begin() == db.synonym_keys_end());
01576 
01577     db.add_synonym("hello", "howdy");
01578     db.add_synonym("hello", "hi");
01579     db.add_synonym("goodbye", "bye");
01580     db.add_synonym("goodbye", "farewell");
01581 
01582     Xapian::TermIterator t;
01583     string s;
01584 
01585     // Try these tests twice - once before committing and once after.
01586     for (int times = 1; times <= 2; ++times) {
01587         // Test iterators for terms which aren't there.
01588         TEST(db.synonyms_begin("abc") == db.synonyms_end("abc"));
01589         TEST(db.synonyms_begin("ghi") == db.synonyms_end("ghi"));
01590         TEST(db.synonyms_begin("zzzzz") == db.synonyms_end("zzzzz"));
01591 
01592         s = "|";
01593         t = db.synonyms_begin("hello");
01594         while (t != db.synonyms_end("hello")) {
01595             s += *t++;
01596             s += '|';
01597         }
01598         TEST_STRINGS_EQUAL(s, "|hi|howdy|");
01599 
01600         s = "|";
01601         t = db.synonyms_begin("goodbye");
01602         while (t != db.synonyms_end("goodbye")) {
01603             s += *t++;
01604             s += '|';
01605         }
01606         TEST_STRINGS_EQUAL(s, "|bye|farewell|");
01607 
01608         s = "|";
01609         t = db.synonym_keys_begin();
01610         while (t != db.synonym_keys_end()) {
01611             s += *t++;
01612             s += '|';
01613         }
01614         TEST_STRINGS_EQUAL(s, "|goodbye|hello|");
01615 
01616         db.commit();
01617     }
01618 
01619     // Delete a synonym for "hello" and all synonyms for "goodbye".
01620     db.remove_synonym("hello", "hi");
01621     db.clear_synonyms("goodbye");
01622 
01623     // Try these tests twice - once before committing and once after.
01624     for (int times = 1; times <= 2; ++times) {
01625         // Test iterators for terms which aren't there.
01626         TEST(db.synonyms_begin("abc") == db.synonyms_end("abc"));
01627         TEST(db.synonyms_begin("ghi") == db.synonyms_end("ghi"));
01628         TEST(db.synonyms_begin("zzzzz") == db.synonyms_end("zzzzz"));
01629 
01630         s = "|";
01631         t = db.synonyms_begin("hello");
01632         while (t != db.synonyms_end("hello")) {
01633             s += *t++;
01634             s += '|';
01635         }
01636         TEST_STRINGS_EQUAL(s, "|howdy|");
01637 
01638         TEST(db.synonyms_begin("goodbye") == db.synonyms_end("goodbye"));
01639 
01640         s = "|";
01641         t = db.synonym_keys_begin();
01642         while (t != db.synonym_keys_end()) {
01643             s += *t++;
01644             s += '|';
01645         }
01646         TEST_STRINGS_EQUAL(s, "|hello|");
01647 
01648         db.commit();
01649     }
01650 
01651     Xapian::Database db_multi;
01652     db_multi.add_database(db);
01653     db_multi.add_database(get_database("apitest_simpledata"));
01654 
01655     // Test iterators for terms which aren't there.
01656     TEST(db_multi.synonyms_begin("abc") == db_multi.synonyms_end("abc"));
01657     TEST(db_multi.synonyms_begin("ghi") == db_multi.synonyms_end("ghi"));
01658     TEST(db_multi.synonyms_begin("zzzzz") == db_multi.synonyms_end("zzzzz"));
01659 
01660     s = "|";
01661     t = db_multi.synonyms_begin("hello");
01662     while (t != db_multi.synonyms_end("hello")) {
01663         s += *t++;
01664         s += '|';
01665     }
01666     TEST_STRINGS_EQUAL(s, "|howdy|");
01667 
01668     TEST(db_multi.synonyms_begin("goodbye") == db_multi.synonyms_end("goodbye"));
01669 
01670     s = "|";
01671     t = db_multi.synonym_keys_begin();
01672     while (t != db_multi.synonym_keys_end()) {
01673         s += *t++;
01674         s += '|';
01675     }
01676     TEST_STRINGS_EQUAL(s, "|hello|");
01677 
01678     return true;
01679 }
01680 
01681 // Test that adding a document with a really long term gives an error on
01682 // add_document() rather than on commit().
01683 DEFINE_TESTCASE(termtoolong1, writable) {
01684     // Inmemory doesn't impose a limit.
01685     SKIP_TEST_FOR_BACKEND("inmemory");
01686 
01687     Xapian::WritableDatabase db = get_writable_database();
01688 
01689     for (Xapian::doccount i = 246; i <= 290; ++i) {
01690         tout.str(string());
01691         tout << "Term length " << i << endl;
01692         Xapian::Document doc;
01693         string term(i, 'X');
01694         doc.add_term(term);
01695         try {
01696             db.add_document(doc);
01697             TEST_AND_EXPLAIN(false, "Expecting exception InvalidArgumentError");
01698         } catch (const Xapian::InvalidArgumentError &e) {
01699             // Check that the max length is correctly expressed in the
01700             // exception message - we've got this wrong in two different ways
01701             // in the past!
01702             tout << e.get_msg() << endl;
01703             TEST(e.get_msg().find("Term too long (> 245)") != string::npos);
01704         }
01705     }
01706 
01707     for (Xapian::doccount j = 240; j <= 245; ++j) {
01708         tout.str(string());
01709         tout << "Term length " << j << endl;
01710         Xapian::Document doc;
01711         string term(j, 'X');
01712         doc.add_term(term);
01713         db.add_document(doc);
01714     }
01715 
01716     db.commit();
01717 
01718     {
01719         // Currently brass, flint and chert escape zero bytes from terms in
01720         // keys for some tables, so a term with 127 zero bytes won't work
01721         // either.
01722         Xapian::Document doc;
01723         doc.add_term(string(127, '\0'));
01724         db.add_document(doc);
01725         try {
01726             db.commit();
01727             TEST_AND_EXPLAIN(false, "Expecting exception InvalidArgumentError");
01728         } catch (const Xapian::InvalidArgumentError &e) {
01729             // Check that the max length is correctly expressed in the
01730             // exception message - we've got this wrong in two different ways
01731             // in the past!
01732             tout << e.get_msg() << endl;
01733             TEST(e.get_msg().find(" is 252 bytes") != string::npos);
01734         }
01735     }
01736 
01737     return true;
01738 }
01739 
01741 DEFINE_TESTCASE(postlist7, writable) {
01742     Xapian::WritableDatabase db_w = get_writable_database();
01743 
01744     {
01745         Xapian::Document doc;
01746         doc.add_term("foo", 3);
01747         doc.add_term("zz", 4);
01748         db_w.replace_document(5, doc);
01749     }
01750 
01751     Xapian::PostingIterator p;
01752     p = db_w.postlist_begin("foo");
01753     TEST(p != db_w.postlist_end("foo"));
01754     TEST_EQUAL(*p, 5);
01755     TEST_EQUAL(p.get_wdf(), 3);
01756     TEST_EQUAL(p.get_doclength(), 7);
01757     ++p;
01758     TEST(p == db_w.postlist_end("foo"));
01759 
01760     {
01761         Xapian::Document doc;
01762         doc.add_term("foo", 1);
01763         doc.add_term("zz", 1);
01764         db_w.replace_document(6, doc);
01765     }
01766 
01767     p = db_w.postlist_begin("foo");
01768     TEST(p != db_w.postlist_end("foo"));
01769     TEST_EQUAL(*p, 5);
01770     TEST_EQUAL(p.get_wdf(), 3);
01771     TEST_EQUAL(p.get_doclength(), 7);
01772     ++p;
01773     TEST(p != db_w.postlist_end("foo"));
01774     TEST_EQUAL(*p, 6);
01775     TEST_EQUAL(p.get_wdf(), 1);
01776     TEST_EQUAL(p.get_doclength(), 2);
01777     ++p;
01778     TEST(p == db_w.postlist_end("foo"));
01779 
01780     return true;
01781 }
01782 
01783 DEFINE_TESTCASE(lazytablebug1, brass || chert || flint) {
01784     {
01785         Xapian::WritableDatabase db = get_named_writable_database("lazytablebug1", string());
01786 
01787         Xapian::Document doc;
01788         doc.add_term("foo");
01789         db.add_document(doc);
01790         db.commit();
01791 
01792         string synonym(255, 'x');
01793         char buf[] = " iamafish!!!!!!!!!!";
01794         for (int i = 33; i < 120; ++i) {
01795             db.add_synonym(buf, synonym);
01796             ++buf[0];
01797         }
01798 
01799         db.commit();
01800     }
01801 
01802     Xapian::Database db = get_writable_database_as_database();
01803     for (Xapian::TermIterator t = db.synonym_keys_begin(); t != db.synonym_keys_end(); ++t) {
01804         tout << *t << endl;
01805     }
01806 
01807     return true;
01808 }
01809 
01815 DEFINE_TESTCASE(cursordelbug1, brass || chert || flint) {
01816     static const int terms[] = { 219, 221, 222, 223, 224, 225, 226 };
01817     static const int copies[] = { 74, 116, 199, 21, 45, 155, 189 };
01818 
01819     Xapian::WritableDatabase db;
01820     db = get_named_writable_database("cursordelbug1", string());
01821 
01822     for (size_t i = 0; i < sizeof(terms) / sizeof(terms[0]); ++i) {
01823         Xapian::Document doc;
01824         doc.add_term("XC" + str(terms[i]));
01825         doc.add_term("XTabc");
01826         doc.add_term("XAdef");
01827         doc.add_term("XRghi");
01828         doc.add_term("XYabc");
01829         size_t c = copies[i];
01830         while (c--) db.add_document(doc);
01831     }
01832 
01833     db.commit();
01834 
01835     for (size_t i = 0; i < sizeof(terms) / sizeof(terms[0]); ++i) {
01836         db.delete_document("XC" + str(terms[i]));
01837     }
01838 
01839     db.commit();
01840 
01841     string cmd = XAPIAN_BIN_PATH"xapian-check ";
01842     cmd += get_named_writable_database_path("cursordelbug1");
01843 #ifdef __WIN32__
01844     cmd += " >nul";
01845 #else
01846     cmd += " >/dev/null";
01847 #endif
01848     if (system(cmd.c_str()) != 0)
01849         return false;
01850 
01851     return true;
01852 }
01853 
01857 static void
01858 check_vals(const Xapian::Database & db, const map<Xapian::docid, string> & vals)
01859 {
01860     TEST_EQUAL(db.get_doccount(), vals.size());
01861     if (vals.size() == 0) return;
01862     TEST_REL(vals.rbegin()->first,<=,db.get_lastdocid());
01863     map<Xapian::docid, string>::const_iterator i;
01864     for (i = vals.begin(); i != vals.end(); ++i) {
01865         tout.str(string());
01866         tout << "Checking value in doc " << i->first << " - should be '" << i->second << "'\n";
01867         Xapian::Document doc = db.get_document(i->first);
01868         string dbval = doc.get_value(1);
01869         TEST_EQUAL(dbval, i->second);
01870         if (dbval.empty()) {
01871             TEST_EQUAL(0, doc.values_count());
01872             TEST_EQUAL(doc.values_begin(), doc.values_end());
01873         } else {
01874             TEST_EQUAL(1, doc.values_count());
01875             Xapian::ValueIterator valit = doc.values_begin();
01876             TEST_NOT_EQUAL(valit, doc.values_end());
01877             TEST_EQUAL(dbval, *valit);
01878             TEST_EQUAL(1, valit.get_valueno());
01879             ++valit;
01880             TEST_EQUAL(valit, doc.values_end());
01881         }
01882     }
01883 }
01884 
01888 DEFINE_TESTCASE(modifyvalues1, writable) {
01889     unsigned int seed = 7;
01890     Xapian::WritableDatabase db = get_writable_database();
01891     // Note: doccount must be coprime with 13
01892     const Xapian::doccount doccount = 1000;
01893     STATIC_ASSERT(doccount % 13 != 0);
01894 
01895     map<Xapian::docid, string> vals;
01896 
01897     for (Xapian::doccount num = 1; num <= doccount; ++num) {
01898         tout.str(string());
01899         Xapian::Document doc;
01900         string val = "val" + str(num);
01901         tout << "Setting val '" << val << "' in doc " << num << "\n";
01902         doc.add_value(1, val);
01903         db.add_document(doc);
01904         vals[num] = val;
01905     }
01906     check_vals(db, vals);
01907     db.commit();
01908     check_vals(db, vals);
01909 
01910     // Modify one of the values (this is a regression test which failed with
01911     // the initial implementation of streaming values).
01912     {
01913         Xapian::Document doc;
01914         string val = "newval0";
01915         tout << "Setting val '" << val << "' in doc 2\n";
01916         doc.add_value(1, val);
01917         db.replace_document(2, doc);
01918         vals[2] = val;
01919         check_vals(db, vals);
01920         db.commit();
01921         check_vals(db, vals);
01922     }
01923 
01924     // Check that value doesn't get lost when replacing a document with itself.
01925     {
01926         tout << "Replacing document 1 with itself\n";
01927         Xapian::Document doc = db.get_document(1);
01928         db.replace_document(1, doc);
01929         check_vals(db, vals);
01930         db.commit();
01931         check_vals(db, vals);
01932     }
01933 
01934     // Check that value doesn't get lost when replacing a document with itself,
01935     // accessing another document in the meantime.  This is a regression test
01936     // for a bug in the code which implements lazy updates - this used to
01937     // forget the values in the document in this situation.
01938     {
01939         tout << "Replacing document 1 with itself, after reading doc 2.\n";
01940         Xapian::Document doc = db.get_document(1);
01941         db.get_document(2);
01942         db.replace_document(1, doc);
01943         check_vals(db, vals);
01944         db.commit();
01945         check_vals(db, vals);
01946     }
01947 
01948     // Do some random modifications: seed random generator, for repeatable
01949     // results.
01950     tout << "Setting seed to " << seed << "\n";
01951     srand(seed);
01952     for (Xapian::doccount num = 1; num <= doccount * 2; ++num) {
01953         tout.str(string());
01954         Xapian::docid did = ((rand() >> 8) % doccount) + 1;
01955         Xapian::Document doc;
01956         string val;
01957 
01958         if (num % 5 != 0) {
01959             val = "newval" + str(num);
01960             tout << "Setting val '" << val << "' in doc " << did << "\n";
01961             doc.add_value(1, val);
01962         } else {
01963             tout << "Adding/replacing empty document " << did << "\n";
01964         }
01965         db.replace_document(did, doc);
01966         vals[did] = val;
01967     }
01968     check_vals(db, vals);
01969     db.commit();
01970     check_vals(db, vals);
01971 
01972     // Delete all the remaining values, in a slightly shuffled order.
01973     // This is where it's important that doccount is coprime with 13.
01974     for (Xapian::doccount num = 0; num < doccount * 13; num += 13) {
01975         tout.str(string());
01976         Xapian::docid did = (num % doccount) + 1;
01977         tout << "Clearing val in doc " << did << "\n";
01978         Xapian::Document doc;
01979         db.replace_document(did, doc);
01980         vals[did] = string();
01981     }
01982     check_vals(db, vals);
01983     db.commit();
01984     check_vals(db, vals);
01985 
01986     return true;
01987 }
tests/api_wrdb.cc
