void
TC_MemFail03::run()
{
MemoryControlWithFailure mc;
mc.resetCounters();
mc.disableLimit();
Alloc<REToken *> alloc;
alloc.setMC(&mc);
{
TokenList tlist(&mc, alloc, "[a-z]");
}
size_t numAllocs = mc.m_numAllocs;
for (size_t lim = 0; lim < numAllocs; lim++) {
mc.resetCounters();
mc.setLimit(lim);
try {
TokenList tlist(&mc, alloc, "[a-z]");
ASSERT_TRUE(false);
}
catch (const bad_alloc &e) {
ASSERT_TRUE(true);
}
}
this->setStatus(true);
}
void
TC_Postfix05::run()
{
MemoryControl mc;
Alloc<REToken *> alloc;
alloc.setMC(&mc);
TokenList2 tlist(&mc, alloc);
tlist.build("a(b|c)d");
TokenList2 tlist2(&mc, alloc);
TokenList2::tmpTokList tmpList;
tlist2.buildPostfix(&tlist, &tmpList);
tlist2.beginIteration();
ASSERT_TRUE(tlist2.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist2.verifyNext(TT_SELF_CHAR, 'b'));
ASSERT_TRUE(tlist2.verifyNext(TT_SELF_CHAR, 'c'));
ASSERT_TRUE(tlist2.verifyNext(TT_PIPE));
ASSERT_TRUE(tlist2.verifyNext(TT_CCAT));
ASSERT_TRUE(tlist2.verifyNext(TT_SELF_CHAR, 'd'));
ASSERT_TRUE(tlist2.verifyNext(TT_CCAT));
ASSERT_TRUE(tlist2.verifyEnd());
this->setStatus(true);
}
void
TC_Tokens05::run()
{
MemoryControl mc;
Alloc<REToken *> alloc;
alloc.setMC(&mc);
{
TokenList tlist(&mc, alloc, "[^abc]");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyCharClassLength(256 - 3));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "[^abc]");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyCharClassMember('z'));
ASSERT_TRUE( ! tlist.verifyCharClassMember('a'));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
this->setStatus(true);
}
void
TC_Tokens207::run()
{
MemoryControl mc;
Alloc<REToken *> alloc;
alloc.setMC(&mc);
try {
TokenList2 tlist(&mc, alloc);
tlist.build("{2 2}");
ASSERT_TRUE(false);
}
catch (const SyntaxError &e) {
ASSERT_TRUE(e.getErrorIndex() == 3);
}
try {
TokenList2 tlist(&mc, alloc);
tlist.build("{2 2}");
ASSERT_TRUE(false);
}
catch (const SyntaxError &e) {
ASSERT_TRUE(e.getErrorIndex() == 4);
}
try {
TokenList2 tlist(&mc, alloc);
tlist.build("{2-}");
ASSERT_TRUE(false);
}
catch (const SyntaxError &e) {
ASSERT_TRUE(e.getErrorIndex() == 2);
}
try {
TokenList2 tlist(&mc, alloc);
tlist.build("{9999999999999999999999999999999999999999999}");
ASSERT_TRUE(false);
}
catch (const SyntaxError &e) {
ASSERT_TRUE(true);
}
try {
TokenList2 tlist(&mc, alloc);
tlist.build("{9, 99999999999999999999999999999999999999999999}");
ASSERT_TRUE(false);
}
catch (const SyntaxError &e) {
ASSERT_TRUE(true);
}
this->setStatus(true);
}
void
TC_Tokens02::run()
{
MemoryControl mc;
Alloc<REToken *> alloc;
alloc.setMC(&mc);
TokenList tlist(&mc, alloc, "a");
TokenList::TokList::iterator iter = tlist.m_toks.begin();
ASSERT_TRUE(tlist.equals(iter, TT_SELF_CHAR, 'a'));
this->setStatus(true);
}
void
TC_Basic02::run()
{
MemoryControl mc;
Alloc<REToken *> alloc;
alloc.setMC(&mc);
TokenList *toks = new (&mc) TokenList(&mc, alloc, "");
toks->~TokenList();
mc.deallocate(toks, 1);
this->setStatus(true);
}
void
TC_MemFail2_05::run()
{
MemoryControlWithFailure mc;
mc.resetCounters();
mc.disableLimit();
Alloc<REToken *> alloc;
alloc.setMC(&mc);
this->expectFailure(mc, alloc, "{2 2}");
this->expectFailure(mc, alloc, "{2 - }");
this->expectFailure(mc, alloc, "{999999999999999999999999999999999");
this->expectFailure(mc, alloc, "a{2,99999999999999999999999999999999999}");
this->setStatus(true);
}
void
TC_MemFail2_04::run()
{
MemoryControlWithFailure mc;
mc.resetCounters();
mc.disableLimit();
Alloc<REToken *> alloc;
alloc.setMC(&mc);
this->checkOneRegex(mc, alloc, "abc");
this->checkOneRegex(mc, alloc, "a{2,10}");
this->checkOneRegex(mc, alloc, "a");
this->checkOneRegex(mc, alloc, "a{2}");
this->setStatus(true);
}
void
TC_MemFail01::run()
{
MemoryControl mc;
Alloc<REToken *> alloc;
alloc.setMC(&mc);
try {
TokenList tlist(&mc, alloc, "a[b");
ASSERT_TRUE(false);
}
catch (const SyntaxError &e) {
ASSERT_TRUE(e.getErrorIndex() == 1);
}
this->setStatus(true);
}
void
TC_Tokens209::run()
{
MemoryControl mc;
Alloc<REToken *> alloc;
alloc.setMC(&mc);
for (char c1 = ' '; c1 <= '~'; c1++) {
TokenList2 tlist(&mc, alloc);
char buf[3];
switch (c1) {
case '(':
case ')':
case '[':
case ']':
case '{':
case '}':
case '\\':
case '*':
case '?':
case '+':
case '|':
buf[0] = '\\';
buf[1] = c1;
buf[2] = '\0';
break;
default:
buf[0] = c1;
buf[1] = '\0';
buf[2] = '\0';
break;
}
tlist.build(buf);
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, c1));
ASSERT_TRUE(tlist.verifyEnd());
}
this->setStatus(true);
}
void
TC_Postfix_MemFail_01::run()
{
MemoryControlWithFailure mc;
mc.resetCounters();
mc.disableLimit();
Alloc<REToken *> alloc;
alloc.setMC(&mc);
{
TokenList2 tlist1(&mc, alloc);
TokenList2 tlist2(&mc, alloc);
TokenList2::tmpTokList tmpList;
tlist1.build("a");
tlist2.buildPostfix(&tlist1, &tmpList);
}
size_t numAllocs = mc.m_numAllocs;
for (size_t lim = 0; lim < numAllocs; lim++) {
mc.resetCounters();
mc.setLimit(lim);
try {
TokenList2 tlist1(&mc, alloc);
tlist1.build("a");
TokenList2 tlist2(&mc, alloc);
TokenList2::tmpTokList tmpList;
tlist2.buildPostfix(&tlist1, &tmpList);
ASSERT_TRUE(false);
}
catch (const bad_alloc &e) {
ASSERT_TRUE(true);
}
}
this->setStatus(true);
}
void
TC_Tokens06::run()
{
MemoryControl mc;
Alloc<REToken *> alloc;
alloc.setMC(&mc);
{
TokenList tlist(&mc, alloc, "a{1,2}");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNextQuantifier(true, 1, true, 2));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "a{10,20}");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNextQuantifier(true, 10, true, 20));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "a{ 10,20}");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNextQuantifier(true, 10, true, 20));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "a{ 10 , 20}");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNextQuantifier(true, 10, true, 20));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "a{ 2 , 3 }");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNextQuantifier(true, 2, true, 3));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "a{2,}");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNextQuantifier(true, 2, false, 0));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "a{ 23 ,}");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNextQuantifier(true, 23, false, 0));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "a{ 23, }");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNextQuantifier(true, 23, false, 0));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "a{2}");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNextQuantifier(true, 2, false, 0));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "a{ 2 }");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNextQuantifier(true, 2, false, 0));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "a{ 22 }");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNextQuantifier(true, 22, false, 0));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "a{,3}");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNextQuantifier(false, 0, true, 3));
tlist.incrementIterator();
ASSERT_TRUE(tlist.verifyEnd());
}
this->setStatus(true);
}
void
TC_Tokens04::run()
{
MemoryControl mc;
Alloc<REToken *> alloc;
alloc.setMC(&mc);
{
TokenList tlist(&mc, alloc, "a|b");
TokenList::TokList::iterator iter = tlist.m_toks.begin();
ASSERT_TRUE(tlist.equals(iter, TT_SELF_CHAR, 'a'));
iter++;
ASSERT_TRUE(tlist.equals(iter, TT_PIPE));
iter++;
ASSERT_TRUE(tlist.equals(iter, TT_SELF_CHAR, 'b'));
iter++;
ASSERT_TRUE(iter == tlist.m_toks.end());
}
{
TokenList tlist(&mc, alloc, "ab");
TokenList::TokList::iterator iter = tlist.m_toks.begin();
ASSERT_TRUE(tlist.equals(iter, TT_SELF_CHAR, 'a'));
iter++;
ASSERT_TRUE(tlist.equals(iter, TT_CCAT));
iter++;
ASSERT_TRUE(tlist.equals(iter, TT_SELF_CHAR, 'b'));
iter++;
ASSERT_TRUE(iter == tlist.m_toks.end());
}
{
TokenList tlist(&mc, alloc, "abc");
TokenList::TokList::iterator iter = tlist.m_toks.begin();
ASSERT_TRUE(tlist.equals(iter, TT_SELF_CHAR, 'a'));
iter++;
ASSERT_TRUE(tlist.equals(iter, TT_CCAT));
iter++;
ASSERT_TRUE(tlist.equals(iter, TT_SELF_CHAR, 'b'));
iter++;
ASSERT_TRUE(tlist.equals(iter, TT_CCAT, 'b'));
iter++;
ASSERT_TRUE(tlist.equals(iter, TT_SELF_CHAR, 'c'));
iter++;
ASSERT_TRUE(iter == tlist.m_toks.end());
}
{
TokenList tlist(&mc, alloc, "(a)");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_LPAREN));
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, 'a'));
ASSERT_TRUE(tlist.verifyNext(TT_RPAREN));
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "[abc]");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNextCharClass("abc", 3));
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "[a-c]");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNextCharClass("abc", 3));
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "[-c]");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNextCharClass("-c", 2));
ASSERT_TRUE(tlist.verifyEnd());
}
{
TokenList tlist(&mc, alloc, "[a-cx-]");
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNextCharClass("abcx-", 5));
ASSERT_TRUE(tlist.verifyEnd());
}
this->setStatus(true);
}
void
TC_Tokens210::run()
{
MemoryControl mc;
Alloc<REToken *> alloc;
alloc.setMC(&mc);
for (char c1 = ' '; c1 <= '~'; c1++) {
char buf[5];
int idx = 0;
switch (c1) {
case '(':
case ')':
case '[':
case ']':
case '{':
case '}':
case '\\':
case '*':
case '?':
case '+':
case '|':
buf[idx++] = '\\';
buf[idx++] = c1;
break;
default:
buf[idx++] = c1;
break;
}
for (char c2 = ' '; c2 <= '~'; c2++) {
TokenList2 tlist(&mc, alloc);
int idx2 = idx;
switch (c2) {
case '(':
case ')':
case '[':
case ']':
case '{':
case '}':
case '\\':
case '*':
case '?':
case '+':
case '|':
buf[idx2++] = '\\';
buf[idx2++] = c2;
break;
default:
buf[idx2++] = c2;
break;
}
while (idx2 <= 4)
buf[idx2++] = '\0';
tlist.build(buf);
tlist.beginIteration();
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, c1));
ASSERT_TRUE(tlist.verifyNext(TT_CCAT));
ASSERT_TRUE(tlist.verifyNext(TT_SELF_CHAR, c2));
ASSERT_TRUE(tlist.verifyEnd());
}
}
this->setStatus(true);
}
