void unitTestMatcher(FSA &fsa)
{
std::string haystack("qereneederqrrrqerneqwrwrwerneedlqewrqrwrneedlerqereeeneedlemqrrqwerneedle");
Matcher matcher(fsa);
int matches;
assert(matcher.find(haystack, matches));
assert(matches == 3);
std::cout << "Matcher passed unit tests" << std::endl;
}
GTEST_TEST(StrUtil, searchBackwards) {
static const byte kHaystack[] = { 'a','x',' ','a','b','c',' ','a','x','y',' ','a','z','x' };
Common::MemoryReadStream haystack(kHaystack, sizeof(kHaystack));
static const byte kNeedle1[] = { 'a','x' };
static const byte kNeedle2[] = { 'n','o' };
EXPECT_EQ(Common::searchBackwards(haystack, kNeedle1, sizeof(kNeedle1)), 7);
EXPECT_EQ(Common::searchBackwards(haystack, kNeedle1, sizeof(kNeedle1), 3), SIZE_MAX);
EXPECT_EQ(Common::searchBackwards(haystack, kNeedle2, sizeof(kNeedle2)), SIZE_MAX);
EXPECT_EQ(Common::searchBackwards(haystack, 0, 0), SIZE_MAX);
}
int main () {
int mychars[] = {'a','b','c','A','B','C'};
std::vector<char> haystack (mychars,mychars+6);
std::vector<char>::iterator it;
int needle[] = {'A','B','C'};
// using default comparison:
it = std::find_first_of(haystack.begin(), haystack.end(), needle, needle+3);
if (it!=haystack.end())
std::cout << "The first match is: " << *it << '\n';
// using predicate comparison:
it = std::find_first_of(haystack.begin(), haystack.end(),needle, needle+3, comp_case_insensitive);
if (it!=haystack.end())
std::cout << "The first match is: " << *it << '\n';
return 0;
}
void tst_QByteArrayMatcher::indexIn()
{
const char p_data[] = { 0x0, 0x0, 0x1 };
QByteArray pattern(p_data, sizeof(p_data));
QByteArray haystack(8, '\0');
haystack[7] = 0x1;
matcher = QByteArrayMatcher(pattern);
QCOMPARE(matcher.indexIn(haystack, 0), 5);
QCOMPARE(matcher.indexIn(haystack, 1), 5);
QCOMPARE(matcher.indexIn(haystack, 2), 5);
matcher.setPattern(pattern);
QCOMPARE(matcher.indexIn(haystack, 0), 5);
QCOMPARE(matcher.indexIn(haystack, 1), 5);
QCOMPARE(matcher.indexIn(haystack, 2), 5);
}
// Match passed string against specified item descriptions and return details for matches
// Element in results array set to zero if their description matches the passed string
//
void List::filter_by_description(Uint8 *storage_items_filter, const ground_item *storage_items, const char *filter_item_text, int no_storage)
{
if (!info_available() || (no_storage<=0) || !storage_items_filter || !storage_items)
return;
std::string needle(filter_item_text);
std::transform(needle.begin(), needle.end(), needle.begin(), tolower);
for (size_t i=0; i<static_cast<size_t>(no_storage); i++)
{
storage_items_filter[i] = 1;
Item *item = get_item(storage_items[i].id, storage_items[i].image_id);
if (item)
{
std::string haystack(item->get_description());
std::transform(haystack.begin(), haystack.end(), haystack.begin(), tolower);
if (haystack.find(needle) != std::string::npos)
storage_items_filter[i] = 0;
}
}
}
void tst_QByteArrayMatcher::interface()
{
const char needle[] = "abc123";
QByteArray haystack(500, 'a');
haystack.insert(6, "123");
haystack.insert(31, "abc");
haystack.insert(42, "abc123");
haystack.insert(84, "abc123");
matcher1 = QByteArrayMatcher(QByteArray(needle));
QByteArrayMatcher matcher2;
matcher2.setPattern(QByteArray(needle));
QByteArrayMatcher matcher3 = QByteArrayMatcher(QByteArray(needle));
QByteArrayMatcher matcher4(needle, sizeof(needle) - 1);
QByteArrayMatcher matcher5(matcher2);
QByteArrayMatcher matcher6;
matcher6 = matcher3;
QCOMPARE(matcher1.indexIn(haystack), 42);
QCOMPARE(matcher2.indexIn(haystack), 42);
QCOMPARE(matcher3.indexIn(haystack), 42);
QCOMPARE(matcher4.indexIn(haystack), 42);
QCOMPARE(matcher5.indexIn(haystack), 42);
QCOMPARE(matcher6.indexIn(haystack), 42);
QCOMPARE(matcher1.indexIn(haystack.constData(), haystack.length()), 42);
QCOMPARE(matcher1.indexIn(haystack, 43), 84);
QCOMPARE(matcher1.indexIn(haystack.constData(), haystack.length(), 43), 84);
QCOMPARE(matcher1.indexIn(haystack, 85), -1);
QCOMPARE(matcher1.indexIn(haystack.constData(), haystack.length(), 85), -1);
QByteArrayMatcher matcher7(QByteArray("123"));
QCOMPARE(matcher7.indexIn(haystack), 6);
matcher7 = QByteArrayMatcher(QByteArray("abc"));
QCOMPARE(matcher7.indexIn(haystack), 31);
matcher7.setPattern(matcher4.pattern());
QCOMPARE(matcher7.indexIn(haystack), 42);
}
int main () {
int myints[] = {1,2,3,4,5,1,2,3,4,5};
std::vector<int> haystack (myints,myints+10);
int needle1[] = {1,2,3};
// using default comparison:
std::vector<int>::iterator it;
it = std::find_end (haystack.begin(), haystack.end(), needle1, needle1+3);
if (it!=haystack.end())
std::cout << "needle1 last found at position " << (it-haystack.begin()) << '\n';
int needle2[] = {4,5,1};
// using predicate comparison:
it = std::find_end (haystack.begin(), haystack.end(), needle2, needle2+3, myfunction);
if (it!=haystack.end())
std::cout << "needle2 last found at position " << (it-haystack.begin()) << '\n';
return 0;
}
/* Attempt to set some of the unknowns to reasonable defaults */
static void itdb_track_set_defaults (Itdb_Track *tr)
{
gchar *mp3_desc[] = {"MPEG", "MP3", "mpeg", "mp3", NULL};
gchar *mp4_desc[] = {"AAC", "MP4", "M4A", "aac", "mp4", "m4a", NULL};
gchar *audible_subdesc[] = {"Audible", "audible", "Book", "book", NULL};
gchar *wav_desc[] = {"WAV", "wav", NULL};
gchar *m4v_desc[] = {"M4V", "MP4", "MP4V", "m4v", "mp4", "mp4v", NULL};
gchar *mov_desc[] = {"MOV", "mov", NULL};
g_return_if_fail (tr);
g_return_if_fail (tr->itdb);
if (tr->mark_unplayed == 0)
{
/* don't have the iPod mark this track with a bullet as
unplayed. Should be set to 0x02 for podcasts that have not
yet been played. */
tr->mark_unplayed = 0x01;
}
/* The exact meaning of unk126 is unknown, but always seems to be
0xffff for MP3/AAC tracks, 0x0 for uncompressed tracks (like WAVE
format), 0x1 for Audible. */
if (tr->unk126 == 0)
{
if (haystack (tr->filetype, mp3_desc))
{
tr->unk126 = 0xffff;
}
else if (haystack (tr->filetype, mp4_desc))
{
if (haystack (tr->filetype, audible_subdesc))
{
tr->unk126 = 0x01;
}
else
{
tr->unk126 = 0xffff;
}
}
else if (haystack (tr->filetype, wav_desc))
{
tr->unk126 = 0x00;
}
else
{
tr->unk126 = 0x00; /* default value */
}
}
/* The exact meaning of unk144 is unknown, but MP3 tracks appear to
be always 0x0000000c or 0x0100000c (if played one or more times
in iTunes), AAC tracks are always 0x01000033, Audible files are
0x01000029, WAV files are 0x0. */
if (tr->unk144 == 0)
{
if (haystack (tr->filetype, mp3_desc))
{
tr->unk144 = 0x000c;
}
else if (haystack (tr->filetype, mp4_desc))
{
if (haystack (tr->filetype, audible_subdesc))
{
tr->unk144 = 0x0029;
}
else
{
tr->unk144 = 0x0033;
}
}
else if (haystack (tr->filetype, wav_desc))
{
tr->unk144 = 0x0000;
}
else
{
tr->unk144 = 0x0000; /* default value */
}
}
if (itdb_device_supports_video (tr->itdb->device))
{
/* The unk208 field seems to denote whether the file is a
video or not. It seems that it must be set to 0x00000002
for video files. */
/* Only doing that for iPod videos since it remains to be
* proven that setting unk208 to non-0 doesn't upset older
* ipod models
*/
if (tr->mediatype == 0)
{
if (haystack (tr->filetype, m4v_desc)
|| haystack (tr->filetype, mov_desc))
{
/* set type to video (0x00000002) */
tr->mediatype = 0x00000002;
}
else
{
/* set type to audio */
tr->mediatype = 0x00000001;
}
}
}
/* The sample rate of the track expressed as an IEEE 32 bit
floating point number. It's uncertain why this is here. itdb
will set this when adding a track */
tr->samplerate2 = tr->samplerate;
/* set unique ID when not yet set */
if (tr->dbid == 0)
{
GList *gl;
guint64 id;
do
{
id = ((guint64)g_random_int () << 32) |
((guint64)g_random_int ());
/* check if id is really unique */
for (gl=tr->itdb->tracks; id && gl; gl=gl->next)
{
Itdb_Track *g_tr = gl->data;
g_return_if_fail (g_tr);
if (id == g_tr->dbid) id = 0;
}
} while (id == 0);
tr->dbid = id;
tr->dbid2= id;
}
if (tr->dbid2 == 0) tr->dbid2 = tr->dbid;
}
