soaktest_queries.cc

Go to the documentation of this file.

 
/* Copyright (C) 2010 Richard Boulton
 * Copyright (C) 2015 Olly Betts
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see
 * <https://www.gnu.org/licenses/>.
 */
 
#include <config.h>
 
#include "soaktest/soaktest.h"
#include "soaktest/soaktest_queries.h"
 
#include <xapian.h>
 
#include "backendmanager.h"
#include "str.h"
#include "testrunner.h"
#include "testsuite.h"
#include "testutils.h"
 
#include <list>
 
using namespace std;
 
static void
builddb_queries1(Xapian::WritableDatabase &db, const string &arg)
{
    unsigned int doccount = 1000;
    unsigned int maxtermsperfield = atoi(arg.c_str());
    for (unsigned int i = 0; i < doccount; ++i) {
        Xapian::Document doc;
        for (unsigned int j = randint(maxtermsperfield) + 1; j != 0; --j) {
            doc.add_term("N" + str(j));
        }
        db.add_document(doc);
    }
    db.commit();
}
 
struct QueryBuilderEnv {
    list<Xapian::Query> pieces;
 
    unsigned int maxtermsperfield;
    unsigned int maxchildren;
 
    QueryBuilderEnv(unsigned int maxtermsperfield_,
                    unsigned int maxchildren_)
            : maxtermsperfield(maxtermsperfield_),
              maxchildren(maxchildren_)
    {}
 
    Xapian::Query pop() {
        if (pieces.empty()) return Xapian::Query();
        Xapian::Query result = pieces.front();
        pieces.pop_front();
        return result;
    }
 
    list<Xapian::Query>::iterator pick(unsigned int num) {
        list<Xapian::Query>::iterator i = pieces.begin();
        for (unsigned int c = 0; c != num && i != pieces.end(); ++c, ++i) {}
        return i;
    }
};
 
typedef void (*QueryStep)(QueryBuilderEnv &);
 
static void push_leaf_N(QueryBuilderEnv & env)
{
    env.pieces.push_back(Xapian::Query(
        "N" + str(randint(env.maxtermsperfield) + 1)));
}
 
static void combine_OR(QueryBuilderEnv & env)
{
    list<Xapian::Query>::iterator i = env.pick(randint(env.maxchildren));
    Xapian::Query combined(Xapian::Query::OP_OR, env.pieces.begin(), i);
    env.pieces.erase(env.pieces.begin(), i);
    env.pieces.push_back(combined);
}
 
static void combine_AND(QueryBuilderEnv & env)
{
    list<Xapian::Query>::iterator i = env.pick(randint(env.maxchildren));
    Xapian::Query combined(Xapian::Query::OP_AND, env.pieces.begin(), i);
    env.pieces.erase(env.pieces.begin(), i);
    env.pieces.push_back(combined);
}
 
static void combine_XOR(QueryBuilderEnv & env)
{
    list<Xapian::Query>::iterator i = env.pick(randint(env.maxchildren));
    Xapian::Query combined(Xapian::Query::OP_XOR, env.pieces.begin(), i);
    env.pieces.erase(env.pieces.begin(), i);
    env.pieces.push_back(combined);
}
 
static void combine_NOT(QueryBuilderEnv & env)
{
    if (env.pieces.size() < 2) return;
    list<Xapian::Query>::iterator i = env.pick(2);
    Xapian::Query combined(Xapian::Query::OP_AND_NOT, env.pieces.begin(), i);
    env.pieces.erase(env.pieces.begin(), i);
    env.pieces.push_back(combined);
}
 
class QueryBuilder {
    vector<QueryStep> options;
 
    QueryBuilderEnv env;
 
    unsigned int maxsteps;
 
  public:
    QueryBuilder(unsigned int maxtermsperfield_,
                 unsigned int maxchildren_,
                 unsigned int maxsteps_)
            : env(maxtermsperfield_, maxchildren_),
              maxsteps(maxsteps_)
    {
        // Build up the set of options.
        // Some options are added multiple times to make them more likely.
        options.push_back(push_leaf_N);
        options.push_back(push_leaf_N);
        options.push_back(push_leaf_N);
        options.push_back(push_leaf_N);
        options.push_back(combine_OR);
        options.push_back(combine_AND);
        options.push_back(combine_XOR);
        options.push_back(combine_NOT);
    }
 
    Xapian::Query make_query() {
        unsigned int steps = randint(maxsteps) + 1;
        while (steps-- != 0) {
            QueryStep & step = options[randint(options.size())];
            step(env);
        }
        return env.pop();
    }
};
 
// Generate a load of random queries, and run them checking that the first
// returned result is the same when asking for 1 result as it is when asking
// for all results.  This is a basic test that early-termination query
// optimisations aren't causing different results to be returned.
DEFINE_TESTCASE(queries1, writable && !remote && !inmemory) {
    unsigned int seed = initrand();
    unsigned int maxtermsperfield = 100;
    unsigned int repetitions = 10000;
    QueryBuilder builder(maxtermsperfield, 10, 10);
 
    Xapian::Database db;
    string arg(str(maxtermsperfield));
    db = backendmanager->get_database("queries1_" + str(seed) + "_" + arg,
                                      builddb_queries1, arg);
 
    // Reset the random seed, to make results repeatable whether database was
    // created or not.
    initrand();
 
    Xapian::Enquire enquire(db);
 
    unsigned int count = 0;
    while (++count != repetitions) {
        Xapian::Query query(builder.make_query());
        tout.str(string());
        tout << "query " << count << ": " << query << "\n";
 
        enquire.set_query(query);
        Xapian::MSet mset1 = enquire.get_mset(0, 1);
        Xapian::MSet mset10 = enquire.get_mset(0, 10);
        Xapian::MSet msetall = enquire.get_mset(0, db.get_doccount());
        tout << mset1 << "\n";
        tout << mset10 << "\n";
        tout << msetall << "\n";
        if (mset1.empty()) {
            TEST(mset10.empty());
            TEST(msetall.empty());
            continue;
        }
        TEST(mset_range_is_same(mset1, 0, msetall, 0, mset1.size()));
        TEST(mset_range_is_same(mset10, 0, msetall, 0, mset10.size()));
    }
}