xapian-core/tests/api_nodb.cc

   1 /* api_nodb.cc: tests which don't use any of the backends
   2  *
   3  * Copyright 1999,2000,2001 BrightStation PLC
   4  * Copyright 2002 Ananova Ltd
   5  * Copyright 2002,2003,2004,2005,2006,2007,2008,2009,2010,2015,2016,2017 Olly Betts
   6  * Copyright 2006 Lemur Consulting Ltd
   7  * Copyright (C) 2016 Vivek Pal
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of the
  12  * License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
  22  * USA
  23  */
  24
  25 #include <config.h>
  26
  27 #include "api_nodb.h"
  28
  29 #include <xapian.h>
  30
  31 #include "apitest.h"
  32 #include "testsuite.h"
  33 #include "testutils.h"
  34
  35 #include <list>
  36 #include <string>
  37 #include <vector>
  38
  39 using namespace std;
  40
  41 // always succeeds
  42 DEFINE_TESTCASE(trivial1, !backend) {
  43     return true;
  44 }
  45
  46 // tests that get_query_terms() returns the terms in the right order
  47 DEFINE_TESTCASE(getqterms1, !backend) {
  48     list<string> answers_list;
  49     answers_list.push_back("one");
  50     answers_list.push_back("two");
  51     answers_list.push_back("three");
  52     answers_list.push_back("four");
  53
  54     Xapian::Query myquery(Xapian::Query::OP_OR,
  55             Xapian::Query(Xapian::Query::OP_AND,
  56                     Xapian::Query("one", 1, 1),
  57                     Xapian::Query("three", 1, 3)),
  58             Xapian::Query(Xapian::Query::OP_OR,
  59                     Xapian::Query("four", 1, 4),
  60                     Xapian::Query("two", 1, 2)));
  61
  62     list<string> list1;
  63     {
  64         Xapian::TermIterator t;
  65         for (t = myquery.get_terms_begin(); t != myquery.get_terms_end(); ++t)
  66             list1.push_back(*t);
  67     }
  68     TEST(list1 == answers_list);
  69     list<string> list2(myquery.get_terms_begin(), myquery.get_terms_end());
  70     TEST(list2 == answers_list);
  71     return true;
  72 }
  73
  74 // tests that get_query_terms() doesn't SEGV on an empty query
  75 // (regression test for bug in 0.9.0)
  76 DEFINE_TESTCASE(getqterms2, !backend) {
  77     Xapian::Query empty_query;
  78     TEST_EQUAL(empty_query.get_terms_begin(), empty_query.get_terms_end());
  79     return true;
  80 }
  81
  82 // tests that empty queries work correctly
  83 DEFINE_TESTCASE(emptyquery2, !backend) {
  84     // test that Query::empty() is true for an empty query.
  85     TEST(Xapian::Query().empty());
  86     // test that an empty query has length 0
  87     TEST(Xapian::Query().get_length() == 0);
  88     vector<Xapian::Query> v;
  89     TEST(Xapian::Query(Xapian::Query::OP_OR, v.begin(), v.end()).empty());
  90     TEST(Xapian::Query(Xapian::Query::OP_OR, v.begin(), v.end()).get_length() == 0);
  91     return true;
  92 }
  93
  94 /// Regression test for behaviour for an empty query with AND_NOT.
  95 DEFINE_TESTCASE(emptyquery3, !backend) {
  96     static const Xapian::Query::op ops[] = {
  97         Xapian::Query::OP_AND,
  98         Xapian::Query::OP_OR,
  99         Xapian::Query::OP_XOR,
 100         Xapian::Query::OP_AND_MAYBE,
 101         Xapian::Query::OP_AND_NOT
 102     };
 103
 104     for (size_t i = 0; i < sizeof(ops) / sizeof(ops[0]); ++i) {
 105         tout << "Testing op #" << i << endl;
 106         Xapian::Query empty;
 107         Xapian::Query q("test");
 108         Xapian::Query qcombine(ops[i], empty, q);
 109         tout << qcombine.get_description() << endl;
 110         Xapian::Query qcombine2(ops[i], q, empty);
 111         tout << qcombine2.get_description() << endl;
 112         Xapian::Query qcombine3(ops[i], empty, empty);
 113         tout << qcombine3.get_description() << endl;
 114     }
 115
 116     return true;
 117 }
 118
 119 // tests that query lengths are calculated correctly
 120 DEFINE_TESTCASE(querylen1, !backend) {
 121     // test that a simple query has the right length
 122     Xapian::Query myquery;
 123     myquery = Xapian::Query(Xapian::Query::OP_OR,
 124                       Xapian::Query("foo"),
 125                       Xapian::Query("bar"));
 126     myquery = Xapian::Query(Xapian::Query::OP_AND,
 127                       myquery,
 128                       Xapian::Query(Xapian::Query::OP_OR,
 129                               Xapian::Query("wibble"),
 130                               Xapian::Query("spoon")));
 131
 132     TEST_EQUAL(myquery.get_length(), 4);
 133     TEST(!myquery.empty());
 134     return true;
 135 }
 136
 137 // tests that query lengths are calculated correctly
 138 DEFINE_TESTCASE(querylen2, !backend) {
 139     // test with an even bigger and strange query
 140     string terms[3] = {
 141         "foo",
 142         "bar",
 143         "baz"
 144     };
 145     Xapian::Query queries[3] = {
 146         Xapian::Query("wibble"),
 147         Xapian::Query("wobble"),
 148         Xapian::Query(Xapian::Query::OP_OR, string("jelly"), string("belly"))
 149     };
 150
 151     Xapian::Query myquery;
 152     vector<string> v1(terms, terms + 3);
 153     vector<Xapian::Query> v2(queries, queries + 3);
 154     vector<Xapian::Query *> v3;
 155     Xapian::Query query1(Xapian::Query::OP_AND, string("ball"), string("club"));
 156     Xapian::Query query2("ring");
 157     v3.push_back(&query1);
 158     v3.push_back(&query2);
 159
 160     Xapian::Query myq1 = Xapian::Query(Xapian::Query::OP_AND, v1.begin(), v1.end());
 161     tout << "myq1=" << myq1 << "\n";
 162     TEST_EQUAL(myq1.get_length(), 3);
 163
 164     Xapian::Query myq2_1 = Xapian::Query(Xapian::Query::OP_OR, v2.begin(), v2.end());
 165     tout << "myq2_1=" << myq2_1 << "\n";
 166     TEST_EQUAL(myq2_1.get_length(), 4);
 167
 168     Xapian::Query myq2_2 = Xapian::Query(Xapian::Query::OP_AND, v3.begin(), v3.end());
 169     tout << "myq2_2=" << myq2_2 << "\n";
 170     TEST_EQUAL(myq2_2.get_length(), 3);
 171
 172     Xapian::Query myq2 = Xapian::Query(Xapian::Query::OP_OR, myq2_1, myq2_2);
 173     tout << "myq2=" << myq2 << "\n";
 174     TEST_EQUAL(myq2.get_length(), 7);
 175
 176     myquery = Xapian::Query(Xapian::Query::OP_OR, myq1, myq2);
 177     tout << "myquery=" << myquery << "\n";
 178     TEST_EQUAL(myquery.get_length(), 10);
 179
 180     return true;
 181 }
 182
 183 // tests that queries validate correctly
 184 DEFINE_TESTCASE(queryvalid1, !backend) {
 185     Xapian::Query q2(Xapian::Query::OP_XOR, Xapian::Query("foo"), Xapian::Query("bar"));
 186     tout << "XOR (\"foo\", \"bar\") checked" << endl;
 187     return true;
 188 }
 189
 190 /** Check we no longer flatten subqueries combined with the same operator.
 191  *
 192  *  Prior to 1.3.0 we did flatten these, but it's simpler to just handle this
 193  *  when we convert the query to a PostList tree, and that works better with
 194  *  Query objects being immutable.
 195  */
 196 DEFINE_TESTCASE(dontflattensubqueries1, !backend) {
 197     Xapian::Query queries1[3] = {
 198         Xapian::Query("wibble"),
 199         Xapian::Query("wobble"),
 200         Xapian::Query(Xapian::Query::OP_OR, string("jelly"), string("belly"))
 201     };
 202
 203     Xapian::Query queries2[3] = {
 204         Xapian::Query(Xapian::Query::OP_AND, string("jelly"), string("belly")),
 205         Xapian::Query("wibble"),
 206         Xapian::Query("wobble")
 207     };
 208
 209     vector<Xapian::Query> vec1(queries1, queries1 + 3);
 210     Xapian::Query myquery1(Xapian::Query::OP_OR, vec1.begin(), vec1.end());
 211     TEST_EQUAL(myquery1.get_description(),
 212                "Query((wibble OR wobble OR (jelly OR belly)))");
 213
 214     vector<Xapian::Query> vec2(queries2, queries2 + 3);
 215     Xapian::Query myquery2(Xapian::Query::OP_AND, vec2.begin(), vec2.end());
 216     TEST_EQUAL(myquery2.get_description(),
 217                "Query(((jelly AND belly) AND wibble AND wobble))");
 218
 219     return true;
 220 }
 221
 222 // test behaviour when creating a query from an empty vector
 223 DEFINE_TESTCASE(emptyquerypart1, !backend) {
 224     vector<string> emptyterms;
 225     Xapian::Query query(Xapian::Query::OP_OR, emptyterms.begin(), emptyterms.end());
 226     TEST(Xapian::Query(Xapian::Query::OP_AND, query, Xapian::Query("x")).empty());
 227     TEST(Xapian::Query(Xapian::Query::OP_AND, query, Xapian::Query("x")).get_length() == 0);
 228     TEST(!Xapian::Query(Xapian::Query::OP_OR, query, Xapian::Query("x")).empty());
 229     TEST(Xapian::Query(Xapian::Query::OP_OR, query, Xapian::Query("x")).get_length() == 1);
 230     return true;
 231 }
 232
 233 DEFINE_TESTCASE(stemlangs1, !backend) {
 234     string langs = Xapian::Stem::get_available_languages();
 235     tout << "available languages '" << langs << "'" << endl;
 236     TEST(!langs.empty());
 237
 238     // Also test the language codes and none.
 239     langs += " da nl en fi fr de hu it no pt ro ru es sv tr none";
 240
 241     string::size_type i = 0;
 242     while (true) {
 243         string::size_type spc = langs.find(' ', i);
 244         // The only spaces in langs should be a single one between each pair
 245         // of language names.
 246         TEST_NOT_EQUAL(i, spc);
 247
 248         // Try making a stemmer for this language.  We should be able to create
 249         // it without an exception being thrown.
 250         string language(langs, i, spc - i);
 251         tout << "checking language code '" << language << "' works" << endl;
 252         Xapian::Stem stemmer(language);
 253         if (language.size() > 2) {
 254             string expected("Xapian::Stem(");
 255             expected += language;
 256             expected += ')';
 257             TEST_EQUAL(stemmer.get_description(), expected);
 258         }
 259
 260         if (spc == string::npos) break;
 261         i = spc + 1;
 262     }
 263
 264     // Stem("") should give an object which doesn't change any input.
 265     Xapian::Stem stem_nothing = Xapian::Stem("");
 266     TEST_EQUAL(stem_nothing.get_description(), "Xapian::Stem(none)");
 267
 268     return true;
 269 }
 270
 271 // Some simple tests of the built in weighting schemes.
 272 DEFINE_TESTCASE(weight1, !backend) {
 273     Xapian::Weight * wt;
 274
 275     Xapian::BoolWeight boolweight;
 276     TEST_EQUAL(boolweight.name(), "Xapian::BoolWeight");
 277     wt = Xapian::BoolWeight().unserialise(boolweight.serialise());
 278     TEST_EQUAL(boolweight.serialise(), wt->serialise());
 279     delete wt;
 280
 281     Xapian::CoordWeight coordweight;
 282     TEST_EQUAL(coordweight.name(), "Xapian::CoordWeight");
 283     wt = Xapian::CoordWeight().unserialise(coordweight.serialise());
 284     TEST_EQUAL(coordweight.serialise(), wt->serialise());
 285     delete wt;
 286
 287     Xapian::TradWeight tradweight_dflt;
 288     Xapian::TradWeight tradweight(1.0);
 289     TEST_EQUAL(tradweight.name(), "Xapian::TradWeight");
 290     TEST_EQUAL(tradweight_dflt.serialise(), tradweight.serialise());
 291     wt = Xapian::TradWeight().unserialise(tradweight.serialise());
 292     TEST_EQUAL(tradweight.serialise(), wt->serialise());
 293     delete wt;
 294
 295     Xapian::TradWeight tradweight2(2.0);
 296     TEST_NOT_EQUAL(tradweight.serialise(), tradweight2.serialise());
 297
 298     Xapian::BM25Weight bm25weight_dflt;
 299     Xapian::BM25Weight bm25weight(1, 0, 1, 0.5, 0.5);
 300     TEST_EQUAL(bm25weight.name(), "Xapian::BM25Weight");
 301     TEST_EQUAL(bm25weight_dflt.serialise(), bm25weight.serialise());
 302     wt = Xapian::BM25Weight().unserialise(bm25weight.serialise());
 303     TEST_EQUAL(bm25weight.serialise(), wt->serialise());
 304     delete wt;
 305
 306     Xapian::BM25Weight bm25weight2(1, 0.5, 1, 0.5, 0.5);
 307     TEST_NOT_EQUAL(bm25weight.serialise(), bm25weight2.serialise());
 308
 309     Xapian::BM25PlusWeight bm25plusweight_dflt;
 310     Xapian::BM25PlusWeight bm25plusweight(1, 0, 1, 0.5, 0.5, 1.0);
 311     TEST_EQUAL(bm25plusweight.name(), "Xapian::BM25PlusWeight");
 312     TEST_EQUAL(bm25plusweight_dflt.serialise(), bm25plusweight.serialise());
 313     wt = Xapian::BM25PlusWeight().unserialise(bm25plusweight.serialise());
 314     TEST_EQUAL(bm25plusweight.serialise(), wt->serialise());
 315     delete wt;
 316
 317     Xapian::BM25PlusWeight bm25plusweight2(1, 0, 1, 0.5, 0.5, 2.0);
 318     TEST_NOT_EQUAL(bm25plusweight.serialise(), bm25plusweight2.serialise());
 319
 320     Xapian::TfIdfWeight tfidfweight_dflt;
 321     Xapian::TfIdfWeight tfidfweight("ntn");
 322     TEST_EQUAL(tfidfweight.name(), "Xapian::TfIdfWeight");
 323     TEST_EQUAL(tfidfweight_dflt.serialise(), tfidfweight.serialise());
 324     wt = Xapian::TfIdfWeight().unserialise(tfidfweight.serialise());
 325     TEST_EQUAL(tfidfweight.serialise(), wt->serialise());
 326     delete wt;
 327
 328     Xapian::TfIdfWeight tfidfweight2("bpn");
 329     TEST_NOT_EQUAL(tfidfweight.serialise(), tfidfweight2.serialise());
 330
 331     Xapian::InL2Weight inl2weight_dflt;
 332     Xapian::InL2Weight inl2weight(1.0);
 333     TEST_EQUAL(inl2weight.name(), "Xapian::InL2Weight");
 334     TEST_EQUAL(inl2weight_dflt.serialise(), inl2weight.serialise());
 335     wt = Xapian::InL2Weight().unserialise(inl2weight.serialise());
 336     TEST_EQUAL(inl2weight.serialise(), wt->serialise());
 337     delete wt;
 338
 339     Xapian::InL2Weight inl2weight2(2.0);
 340     TEST_NOT_EQUAL(inl2weight.serialise(), inl2weight2.serialise());
 341
 342     Xapian::IfB2Weight ifb2weight_dflt;
 343     Xapian::IfB2Weight ifb2weight(1.0);
 344     TEST_EQUAL(ifb2weight.name(), "Xapian::IfB2Weight");
 345     TEST_EQUAL(ifb2weight_dflt.serialise(), ifb2weight.serialise());
 346     wt = Xapian::IfB2Weight().unserialise(ifb2weight.serialise());
 347     TEST_EQUAL(ifb2weight.serialise(), wt->serialise());
 348     delete wt;
 349
 350     Xapian::IfB2Weight ifb2weight2(2.0);
 351     TEST_NOT_EQUAL(ifb2weight.serialise(), ifb2weight2.serialise());
 352
 353     Xapian::IneB2Weight ineb2weight_dflt;
 354     Xapian::IneB2Weight ineb2weight(1.0);
 355     TEST_EQUAL(ineb2weight.name(), "Xapian::IneB2Weight");
 356     TEST_EQUAL(ineb2weight_dflt.serialise(), ineb2weight.serialise());
 357     wt = Xapian::IneB2Weight().unserialise(ineb2weight.serialise());
 358     TEST_EQUAL(ineb2weight.serialise(), wt->serialise());
 359     delete wt;
 360
 361     Xapian::IneB2Weight ineb2weight2(2.0);
 362     TEST_NOT_EQUAL(ineb2weight.serialise(), ineb2weight2.serialise());
 363
 364     Xapian::BB2Weight bb2weight_dflt;
 365     Xapian::BB2Weight bb2weight(1.0);
 366     TEST_EQUAL(bb2weight.name(), "Xapian::BB2Weight");
 367     TEST_EQUAL(bb2weight_dflt.serialise(), bb2weight.serialise());
 368     wt = Xapian::BB2Weight().unserialise(bb2weight.serialise());
 369     TEST_EQUAL(bb2weight.serialise(), wt->serialise());
 370     delete wt;
 371
 372     Xapian::BB2Weight bb2weight2(2.0);
 373     TEST_NOT_EQUAL(bb2weight.serialise(), bb2weight2.serialise());
 374
 375     Xapian::DLHWeight dlhweight;
 376     TEST_EQUAL(dlhweight.name(), "Xapian::DLHWeight");
 377     wt = Xapian::DLHWeight().unserialise(dlhweight.serialise());
 378     TEST_EQUAL(dlhweight.serialise(), wt->serialise());
 379     delete wt;
 380
 381     Xapian::PL2Weight pl2weight_dflt;
 382     Xapian::PL2Weight pl2weight(1.0);
 383     TEST_EQUAL(pl2weight.name(), "Xapian::PL2Weight");
 384     TEST_EQUAL(pl2weight_dflt.serialise(), pl2weight.serialise());
 385     wt = Xapian::PL2Weight().unserialise(pl2weight.serialise());
 386     TEST_EQUAL(pl2weight.serialise(), wt->serialise());
 387     delete wt;
 388
 389     Xapian::PL2Weight pl2weight2(2.0);
 390     TEST_NOT_EQUAL(pl2weight.serialise(), pl2weight2.serialise());
 391
 392     Xapian::PL2PlusWeight pl2plusweight_dflt;
 393     Xapian::PL2PlusWeight pl2plusweight(1.0, 0.8);
 394     TEST_EQUAL(pl2plusweight.name(), "Xapian::PL2PlusWeight");
 395     TEST_EQUAL(pl2plusweight_dflt.serialise(), pl2plusweight.serialise());
 396     wt = Xapian::PL2PlusWeight().unserialise(pl2plusweight.serialise());
 397     TEST_EQUAL(pl2plusweight.serialise(), wt->serialise());
 398     delete wt;
 399
 400     Xapian::PL2PlusWeight pl2plusweight2(2.0, 0.9);
 401     TEST_NOT_EQUAL(pl2plusweight.serialise(), pl2plusweight2.serialise());
 402
 403     Xapian::DPHWeight dphweight;
 404     TEST_EQUAL(dphweight.name(), "Xapian::DPHWeight");
 405     wt = Xapian::DPHWeight().unserialise(dphweight.serialise());
 406     TEST_EQUAL(dphweight.serialise(), wt->serialise());
 407     delete wt;
 408
 409     Xapian::LMWeight unigramlmweight_dflt;
 410     Xapian::LMWeight unigramlmweight(32000, Xapian::Weight::DIRICHLET_SMOOTHING, 2034.0, 0.0);
 411     TEST_EQUAL(unigramlmweight.name(), "Xapian::LMWeight");
 412     TEST_NOT_EQUAL(unigramlmweight_dflt.serialise(), unigramlmweight.serialise());
 413     wt = Xapian::LMWeight().unserialise(unigramlmweight.serialise());
 414     TEST_EQUAL(unigramlmweight.serialise(), wt->serialise());
 415     delete wt;
 416
 417     return true;
 418 }
 419
 420 // Regression test.
 421 DEFINE_TESTCASE(nosuchdb1, !backend) {
 422     // This is a "nodb" test because it doesn't test a particular backend.
 423     try {
 424         Xapian::Database db("NOsuChdaTabASe");
 425         FAIL_TEST("Managed to open 'NOsuChdaTabASe'");
 426     } catch (const Xapian::DatabaseOpeningError & e) {
 427         // We don't really require this exact message, but in Xapian <= 1.1.0
 428         // this gave "Couldn't detect type of database".
 429         TEST_STRINGS_EQUAL(e.get_msg(), "Couldn't stat 'NOsuChdaTabASe'");
 430     }
 431
 432     try {
 433         Xapian::Database::check("NOsuChdaTabASe");
 434         FAIL_TEST("Managed to check 'NOsuChdaTabASe'");
 435     } catch (const Xapian::DatabaseOpeningError & e) {
 436         // In 1.4.3 and earlier, this threw DatabaseError with the message:
 437         // "File is not a Xapian database or database table" (confusing as
 438         // there is no file).
 439         TEST_STRINGS_EQUAL(e.get_msg(),
 440                            "Couldn't find Xapian database or table to check");
 441     }
 442
 443     return true;
 444 }
 445
 446 // Feature tests for value manipulations.
 447 DEFINE_TESTCASE(addvalue1, !backend) {
 448     // Regression test for add_value on an existing value (bug#82).
 449     Xapian::Document doc;
 450     doc.add_value(1, "original");
 451     doc.add_value(1, "replacement");
 452     TEST_EQUAL(doc.get_value(1), "replacement");
 453
 454     doc.add_value(2, "too");
 455     doc.add_value(3, "free");
 456     doc.add_value(4, "for");
 457
 458     doc.remove_value(2);
 459     doc.remove_value(4);
 460     TEST_EQUAL(doc.get_value(0), "");
 461     TEST_EQUAL(doc.get_value(1), "replacement");
 462     TEST_EQUAL(doc.get_value(2), "");
 463     TEST_EQUAL(doc.get_value(3), "free");
 464     TEST_EQUAL(doc.get_value(4), "");
 465
 466     return true;
 467 }
 468
 469 // tests that the collapsing on termpos optimisation gives correct query length
 470 DEFINE_TESTCASE(poscollapse2, !backend) {
 471     Xapian::Query q(Xapian::Query::OP_OR, Xapian::Query("this", 1, 1), Xapian::Query("this", 1, 1));
 472     TEST_EQUAL(q.get_length(), 2);
 473     return true;
 474 }
 475
 476 // regression test of querying an uninitialised database: should report an
 477 // error; used to segfault with 1.0.0.
 478 DEFINE_TESTCASE(uninitdb1, !backend) {
 479     Xapian::Database db;
 480     TEST_EXCEPTION(Xapian::InvalidArgumentError,
 481                    Xapian::Enquire enq(db));
 482     return true;
 483 }
 484
 485 // Test a scaleweight query applied to a match nothing query
 486 DEFINE_TESTCASE(scaleweight3, !backend) {
 487     Xapian::Query matchnothing(Xapian::Query::MatchNothing);
 488     Xapian::Query query(Xapian::Query::OP_SCALE_WEIGHT, matchnothing, 3.0);
 489     TEST_EQUAL(query.get_description(), "Query()");
 490     return true;
 491 }
 492
 493 // Regression test - before 1.1.0, you could add docid 0 to an RSet.
 494 DEFINE_TESTCASE(rset3, !backend) {
 495     Xapian::RSet rset;
 496     TEST_EXCEPTION(Xapian::InvalidArgumentError, rset.add_document(0));
 497     TEST(rset.empty());
 498     TEST_EQUAL(rset.size(), 0);
 499     rset.add_document(1);
 500     rset.add_document(static_cast<Xapian::docid>(-1));
 501     TEST_EXCEPTION(Xapian::InvalidArgumentError, rset.add_document(0));
 502     TEST(!rset.empty());
 503     TEST_EQUAL(rset.size(), 2);
 504     return true;
 505 }
 506
 507 // Regression test - RSet::get_description() gave a malformed answer in 1.0.7.
 508 DEFINE_TESTCASE(rset4, !backend) {
 509     Xapian::RSet rset;
 510     rset.add_document(1);
 511     // In 1.0.7 this gave: RSet(RSet(RSet::Internal(, 1))
 512     TEST_STRINGS_EQUAL(rset.get_description(), "RSet(RSet::Internal(1))");
 513     return true;
 514 }
 515
 516 // Direct test of ValueSetMatchDecider
 517 DEFINE_TESTCASE(valuesetmatchdecider1, !backend) {
 518     Xapian::ValueSetMatchDecider vsmd1(0, true);
 519     vsmd1.add_value("42");
 520     Xapian::ValueSetMatchDecider vsmd2(0, false);
 521     vsmd2.remove_value("nosuch"); // Test removing a value which isn't present.
 522     vsmd2.add_value("42");
 523     Xapian::ValueSetMatchDecider vsmd3(0, true);
 524     vsmd3.add_value("42");
 525     vsmd3.add_value("blah");
 526
 527     Xapian::Document doc;
 528     TEST(!vsmd1(doc));
 529     TEST(vsmd2(doc));
 530     TEST(!vsmd3(doc));
 531     doc.add_value(0, "42");
 532     TEST(vsmd1(doc));
 533     TEST(!vsmd2(doc));
 534     TEST(vsmd3(doc));
 535     doc.add_value(0, "blah");
 536     TEST(!vsmd1(doc));
 537     TEST(vsmd2(doc));
 538     TEST(vsmd3(doc));
 539
 540     vsmd3.remove_value("nosuch"); // Test removing a value which isn't present.
 541     vsmd3.remove_value("blah");
 542     TEST(!vsmd1(doc));
 543     TEST(vsmd2(doc));
 544     TEST(!vsmd3(doc));
 545     doc.add_value(0, "42");
 546     TEST(vsmd1(doc));
 547     TEST(!vsmd2(doc));
 548     TEST(vsmd3(doc));
 549
 550     return true;
 551 }
 552
 553 // Test that asking for the termfreq on an empty mset raises an exception.
 554 DEFINE_TESTCASE(emptymset1, !backend) {
 555     Xapian::MSet emptymset;
 556     TEST_EXCEPTION(Xapian::InvalidOperationError,
 557                    emptymset.get_termfreq("foo"));
 558     return true;
 559 }
 560
 561 DEFINE_TESTCASE(expanddeciderfilterprefix1, !backend) {
 562     string prefix = "tw";
 563     Xapian::ExpandDeciderFilterPrefix decider(prefix);
 564     TEST(!decider("one"));
 565     TEST(!decider("t"));
 566     TEST(!decider(""));
 567     TEST(!decider("Two"));
 568     TEST(decider("two"));
 569     TEST(decider("twitter"));
 570     TEST(decider(prefix));
 571
 572     return true;
 573 }