int exhaustive_scrabble_test(const char* filename)
{
long result = errors_counter();
// note that dictsize*keys*3 tests are performed
size_t DICTSIZE = 10000, KEYS = 10;
typedef std::vector<std::string> Dictionary;
extern size_t fill_dictionary(const char*, Dictionary&, size_t, size_t = 0);
Dictionary dictionary;
size_t longest_in_file = fill_dictionary(filename, dictionary, DICTSIZE);
std::random_shuffle(dictionary.begin(), dictionary.end());
ScrabbleTst names;
Dictionary::iterator dit;
for (dit = dictionary.begin(); dit != dictionary.end(); dit += 4) {
const std::string& name(*dit);
names[name] = name.c_str();
}
int skip = dictionary.size() / KEYS;
for(dit = dictionary.begin() + skip; dit != dictionary.end(); dit += skip)
{
std::string name(*dit);
std::sort(name.begin(), name.end());
for (int jokercount = 0; jokercount < 3; ++jokercount) {
ScrabbleTst::search_results_list matchresults = names.create_search_results();
names.combinatorial_search(name, std::back_inserter(matchresults), jokercount);
//if (matchresults.size() == 0)
// std::cout << "couldn't find " << name << '\n';
BOOST_CHECK(matchresults.size() != 0);
ScrabbleTst matches;
ScrabbleTst matchcount;
size_t prevsize = 0;
for (size_t i = 0; i != matchresults.size(); ++i) {
std::string mcopy(matchresults[i].key());
matchcount[mcopy] = mcopy.c_str();
if (matchcount.size() > prevsize) {
BOOST_CHECK(check_scrabble_found(name, mcopy, jokercount));
++prevsize;
}
else {
std::cout << "scrabble found duplicate " << mcopy << "\n";
}
std::sort(mcopy.begin(), mcopy.end());
matches[mcopy] = mcopy.c_str();
}
// check for duplicates
scrabble_findcount += matchresults.size();
scrabble_duplicates += matchresults.size() - matchcount.size();
BOOST_CHECK(matchcount.size() == matchresults.size());
BOOST_CHECK(check_scrabble_missed(names, matches, jokercount));
}
}
//std::cout << "scrabble duplicate matches " << scrabble_duplicates << " of " << scrabble_findcount << "\n";
return errors_counter() - result;
}
int hamming_search_test(const char* filename)
{
long result = errors_counter();
typedef containers::ternary_tree<std::string, const char*> Tst;
Tst names;
names["ABCD"] = "ABCD";
names["Abcd"] = "Abcd";
names["ABcd"] = "ABcd";
names["aBCd"] = "aBCd";
names["abc"] = "abc";
names["abcde"] = "abcde";
names["bcd"] = "bcd";
names["abCD"] = "abCD";
names["abCd"] = "abCd";
names["AbcD"] = "AbcD";
names["ABcD"] = "ABcD";
names["aBCD"] = "aBCD";
names["abCDE"] = "abCDE";
names["abCDd"] = "abCDd";
names["abCcd"] = "abCcd";
names["bcdc"] = "bcdc";
names["aab"] = "aab";
// hamming_search(2): ABcd, AbcD, Abcd, aBCd, abCD, abCd, abc, abcde
// levenshtein_search(2): hamming + abCDd, abCcd bcd, bcdc
Tst::search_results_list matches = names.create_search_results();
typedef Tst::search_results_list::iterator ResultIter;
//names.levenshtein_search_count = 0;
names.levenshtein_search("abcd", std::back_inserter(matches), 2);
//std::cout << "l-count: " << names.levenshtein_search_count << "\n";
//names.levenshtein_search_count = 0;
BOOST_CHECK(matches.size() == 12);
if (matches.size() != 12)
{
// compare with DDJ
{
Tptr root = 0;
for (Tst::iterator it = names.begin(); it != names.end(); ++it) {
insertstr = (char*)*it;
root = insert2(root, insertstr);
}
nearsearch(root, "abcd", 2);
std::cout << "DDJ nearsearch abcd:\n";
for (int i = 0; i != srchtop; i++)
std::cout << srcharr[i] << "\n";
std::cout << "\n";
cleanup2(root);
}
int i = 0;
for (ResultIter rit = matches.begin(); rit != matches.end(); ++rit, ++i) {
std::cout << **rit << " = " << (*rit).key();
std::cout /*<< " = " << matches[i].key()*/ << "\n";
}
}
typedef std::vector<std::string> Dictionary;
extern size_t fill_dictionary(const char*, Dictionary&, size_t, size_t = 0);
Dictionary dictionary;
size_t longest_in_file = fill_dictionary(filename, dictionary, 300);
std::random_shuffle(dictionary.begin(), dictionary.end());
names.clear();
Dictionary wildnames;
// Add names with mini-variations
long zeroes = 0;
Dictionary::iterator dit;
for (dit = dictionary.begin(); dit != dictionary.end(); ++dit) {
const std::string& name(*dit);
std::string namecopy(*dit);
names[namecopy] = name.c_str();
std::string searchstr(name);
for (int i = 0; i < 5; ++i) {
int where = rand() % name.size();
// make string with ? at place of changed char
if (searchstr[where] == '?')
continue;
searchstr[where] = '?';
wildnames.push_back(searchstr);
char c = (char)rand();
if (!c) zeroes++;
namecopy[where] = c;
names[namecopy] = name.c_str();
}
}
for(dit = wildnames.begin(); dit != wildnames.end(); ++dit) {
const std::string& name(*dit);
for (int diff = 1; diff != 3; ++diff) {
Tst::search_results_list matchresults = names.create_search_results();
names.hamming_search(name, std::back_inserter(matchresults), diff);
//if (matchresults.size() == 0)
// std::cout << "couldn't find " << name << '\n';
//BOOST_CHECK(found == matchresults.size());
for (size_t i = 0; i != matchresults.size(); ++i)
BOOST_CHECK(check_hamming_match(matchresults[i].key(), name, diff));
}
}
return errors_counter() - result;
}
