forked from KolibriOS/kolibrios
tinypy: added re and random modules, not adapted for Kolibri yet.
git-svn-id: svn://kolibrios.org@2043 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
jaeger
parent
3653a07ac3
commit
6c55e4b3c3
52
programs/develop/tinypy/modules/random/init.c
Normal file
52
programs/develop/tinypy/modules/random/init.c
Normal file
@ -0,0 +1,52 @@
|
||||
#include "random.c"
|
||||
|
||||
/*
|
||||
* random_mod_init()
|
||||
*
|
||||
* random module initialization function
|
||||
*/
|
||||
void random_init(TP)
|
||||
{
|
||||
/*
|
||||
* module dict for random
|
||||
*/
|
||||
tp_obj random_mod = tp_dict(tp);
|
||||
|
||||
/*
|
||||
* bind functions to random module
|
||||
*/
|
||||
tp_set(tp, random_mod, tp_string("seed"), tp_fnc(tp, random_seed));
|
||||
tp_set(tp, random_mod, tp_string("getstate"), tp_fnc(tp, random_getstate));
|
||||
tp_set(tp, random_mod, tp_string("setstate"), tp_fnc(tp, random_setstate));
|
||||
tp_set(tp, random_mod, tp_string("jumpahead"), tp_fnc(tp, random_jumpahead));
|
||||
tp_set(tp, random_mod, tp_string("random"), tp_fnc(tp, random_random));
|
||||
|
||||
/*
|
||||
* bind usual distribution random variable generator
|
||||
*/
|
||||
tp_set(tp, random_mod, tp_string("uniform"), tp_fnc(tp, random_uniform));
|
||||
tp_set(tp, random_mod, tp_string("normalvariate"), tp_fnc(tp, random_normalvariate));
|
||||
tp_set(tp, random_mod, tp_string("lognormvariate"), tp_fnc(tp, random_lognormvariate));
|
||||
tp_set(tp, random_mod, tp_string("expovariate"), tp_fnc(tp, random_expovariate));
|
||||
tp_set(tp, random_mod, tp_string("vonmisesvariate"), tp_fnc(tp, random_vonmisesvariate));
|
||||
tp_set(tp, random_mod, tp_string("gammavariate"), tp_fnc(tp, random_gammavariate));
|
||||
tp_set(tp, random_mod, tp_string("betavariate"), tp_fnc(tp, random_betavariate));
|
||||
tp_set(tp, random_mod, tp_string("paretovariate"), tp_fnc(tp, random_paretovariate));
|
||||
tp_set(tp, random_mod, tp_string("weibullvariate"), tp_fnc(tp, random_weibullvariate));
|
||||
tp_set(tp, random_mod, tp_string("randrange"), tp_fnc(tp, random_randrange));
|
||||
tp_set(tp, random_mod, tp_string("randint"), tp_fnc(tp, random_randint));
|
||||
tp_set(tp, random_mod, tp_string("choice"), tp_fnc(tp, random_choice));
|
||||
tp_set(tp, random_mod, tp_string("shuffle"), tp_fnc(tp, random_shuffle));
|
||||
|
||||
/*
|
||||
* bind special attributes to random module
|
||||
*/
|
||||
tp_set(tp, random_mod, tp_string("__doc__"), tp_string("Random variable generators."));
|
||||
tp_set(tp, random_mod, tp_string("__name__"), tp_string("random"));
|
||||
tp_set(tp, random_mod, tp_string("__file__"), tp_string(__FILE__));
|
||||
|
||||
/*
|
||||
* bind random module to tinypy modules[]
|
||||
*/
|
||||
tp_set(tp, tp->modules, tp_string("random"), random_mod);
|
||||
}
|
||||
1107
programs/develop/tinypy/modules/random/random.c
Normal file
1107
programs/develop/tinypy/modules/random/random.c
Normal file
File diff suppressed because it is too large
Load Diff
176
programs/develop/tinypy/modules/random/tests.py
Normal file
176
programs/develop/tinypy/modules/random/tests.py
Normal file
@ -0,0 +1,176 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
import random
|
||||
#from math import log, exp, sqrt, pi
|
||||
|
||||
def test_seed_state():
|
||||
"""test seed() and getstate()/setstate()
|
||||
"""
|
||||
# random ought to be able to deal with seeds in any form, of follows.
|
||||
# following code shouldn't cause an exception.
|
||||
random.seed()
|
||||
random.seed(0)
|
||||
random.seed(-1)
|
||||
random.seed(0.1)
|
||||
random.seed(-0.1)
|
||||
random.seed("a")
|
||||
random.seed("abc")
|
||||
random.seed("abcd")
|
||||
random.seed("fasdfasdfasdfadgaldhgldahlgahdlghadlgladh")
|
||||
random.seed("lxhlh90yowhldshlgah;")
|
||||
|
||||
# state1 and state2 should be different for different seeds
|
||||
random.seed(1)
|
||||
state1 = random.getstate()
|
||||
random.seed(2)
|
||||
state2 = random.getstate()
|
||||
rep = 0
|
||||
for ind in range(len(state1)):
|
||||
elem1 = state1[ind]
|
||||
elem2 = state2[ind]
|
||||
if (elem1 == elem2): rep += 1
|
||||
if (rep > len(state1) / 2):
|
||||
print("rep = ", rep, "len(state1) = ", len(state1))
|
||||
raise "state1 and state2 should be different"
|
||||
|
||||
# for the same seeds, state1 and state2 should be the same
|
||||
random.seed(100)
|
||||
state1 = random.getstate()
|
||||
random.seed(100)
|
||||
state2 = random.getstate()
|
||||
rep = 0
|
||||
for ind in range(len(state1)):
|
||||
elem1 = state1[ind]
|
||||
elem2 = state2[ind]
|
||||
if (elem1 == elem2): rep += 1
|
||||
if (rep != len(state1)):
|
||||
raise "state1 and state2 should be the same"
|
||||
|
||||
def test_jumpahead():
|
||||
"""jumpahead will change the pseudo-number generator's internal state
|
||||
"""
|
||||
random.seed()
|
||||
state1 = random.getstate()
|
||||
random.jumpahead(20)
|
||||
state2 = random.getstate()
|
||||
rep = 0
|
||||
for ind in range(len(state1)):
|
||||
elem1 = state1[ind]
|
||||
elem2 = state2[ind]
|
||||
if (elem1 == elem2): rep += 1
|
||||
if (rep > len(state1) / 2):
|
||||
raise "state1 and state2 can't be the same"
|
||||
|
||||
def test_setstate():
|
||||
"""
|
||||
"""
|
||||
random.seed()
|
||||
oldState = random.getstate()
|
||||
oldRandSeq = [random.random() for i in range(10)]
|
||||
random.setstate(oldState)
|
||||
newRandSeq = [random.random() for i in range(10)]
|
||||
rep = 0
|
||||
for ind in range(len(oldRandSeq)):
|
||||
elem1 = oldRandSeq[ind]
|
||||
elem2 = newRandSeq[ind]
|
||||
if (elem1 == elem2): rep += 1
|
||||
if (rep != len(oldRandSeq)):
|
||||
raise "oldRandSeq and newRandSeq should be the same"
|
||||
|
||||
def test_random():
|
||||
"""generate a random number list
|
||||
"""
|
||||
x = [random.random() for i in range(100)]
|
||||
|
||||
def test_distribution():
|
||||
"""these lines are borrowed from python, they shouldn't
|
||||
cause any exception.
|
||||
"""
|
||||
g = random
|
||||
g.uniform(1,10)
|
||||
g.paretovariate(1.0)
|
||||
g.expovariate(1.0)
|
||||
g.weibullvariate(1.0, 1.0)
|
||||
g.normalvariate(0.0, 1.0)
|
||||
g.lognormvariate(0.0, 1.0)
|
||||
g.vonmisesvariate(0.0, 1.0)
|
||||
g.gammavariate(0.01, 1.0)
|
||||
g.gammavariate(1.0, 1.0)
|
||||
g.gammavariate(200.0, 1.0)
|
||||
g.betavariate(3.0, 3.0)
|
||||
|
||||
def test_randrange():
|
||||
"""these input to randrange() shouldn't cause any exception.
|
||||
"""
|
||||
random.randrange(100000)
|
||||
random.randrange(-100000)
|
||||
random.randrange(0)
|
||||
random.randrange(-10.2)
|
||||
|
||||
random.randrange(-10, 10)
|
||||
random.randrange(2, 1000)
|
||||
random.randrange(0, 1)
|
||||
random.randrange(-1, 0)
|
||||
|
||||
random.randrange(10, 2000, 2)
|
||||
random.randrange(-2000, 100, 5)
|
||||
random.randrange(-1000.3, 1000.7, 2)
|
||||
|
||||
def test_randint():
|
||||
"""for any valid pair (a, b), randint(a, b) should lay between [a, b]
|
||||
"""
|
||||
for i in range(1000):
|
||||
r = random.randint(-10000, 10000)
|
||||
if (-10000 <= r <= 10000): continue
|
||||
else: raise "error: random.randint()"
|
||||
|
||||
def test_choice():
|
||||
"""random.choice() should be able to deal with string, list.
|
||||
"""
|
||||
S = "abcdefg123*@#$%)("
|
||||
L = [1, 2, 3, -1, 0.2, -0.1, -10000, "cyc"]
|
||||
|
||||
if random.choice(S) not in S:
|
||||
raise "error: random.choice(S)"
|
||||
|
||||
if random.choice(L) not in L:
|
||||
raise "error: random.choice(L)"
|
||||
|
||||
def test_shuffle():
|
||||
"""test random.shuffle() on list. since string is not writable in-place,
|
||||
random.shuffle() can not be applied on string.
|
||||
Note: to copy items from a list to a new list, must use syntax like:
|
||||
newList = oldList[:]
|
||||
if use syntax like: newList = oldList, newList is just an alias of oldList.
|
||||
"""
|
||||
oldL = [1, 2, 3, -1, 0.2, -0.1, -10000, "cyc"]
|
||||
newL = oldL[:]
|
||||
|
||||
random.shuffle(newL)
|
||||
|
||||
rep = 0
|
||||
for ind in range(len(oldL)):
|
||||
elem1 = oldL[ind]
|
||||
elem2 = newL[ind]
|
||||
if (elem1 == elem2): rep += 1
|
||||
if (rep > len(oldL) / 2):
|
||||
raise "oldL and newL shouldn't be the same"
|
||||
|
||||
def test_53_bits_per_float():
|
||||
pass
|
||||
|
||||
def main():
|
||||
test_seed_state()
|
||||
test_jumpahead()
|
||||
test_setstate()
|
||||
test_random()
|
||||
test_distribution()
|
||||
test_randrange()
|
||||
test_randint()
|
||||
test_choice()
|
||||
test_shuffle()
|
||||
test_53_bits_per_float()
|
||||
print("#OK")
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
710
programs/develop/tinypy/modules/re/init.c
Normal file
710
programs/develop/tinypy/modules/re/init.c
Normal file
@ -0,0 +1,710 @@
|
||||
/*
|
||||
* regular expression module
|
||||
*
|
||||
* Important Note: do not support group name index
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include "regexpr.c"
|
||||
|
||||
/* tinypy API to be use in this unit */
|
||||
extern tp_obj tp_data(TP,int magic,void *v);
|
||||
extern tp_obj tp_object_new(TP);
|
||||
extern tp_obj tp_object(TP);
|
||||
extern tp_obj tp_method(TP,tp_obj self,tp_obj v(TP));
|
||||
extern tp_obj tp_string_copy(TP, const char *s, int n);
|
||||
extern tp_obj tp_list(TP);
|
||||
extern tp_obj tp_copy(TP);
|
||||
|
||||
/* last error message */
|
||||
static const char * LastError = NULL;
|
||||
|
||||
/* lower level regex object */
|
||||
typedef struct {
|
||||
struct re_pattern_buffer re_patbuf; /* The compiled expression */
|
||||
struct re_registers re_regs; /* The registers from the last match */
|
||||
char re_fastmap[256]; /* Storage for fastmap */
|
||||
unsigned char *re_translate; /* String object for translate table */
|
||||
unsigned char *re_lastok; /* String object last matched/searched */
|
||||
|
||||
/* supplementary */
|
||||
int re_errno; /* error num */
|
||||
int re_syntax; /* syntax */
|
||||
} regexobject;
|
||||
|
||||
/* local declarations */
|
||||
static regexobject* getre(TP, tp_obj rmobj);
|
||||
static tp_obj match_obj_group(TP);
|
||||
static tp_obj match_obj_groups(TP);
|
||||
static tp_obj match_obj_start(TP);
|
||||
static tp_obj match_obj_end(TP);
|
||||
static tp_obj match_obj_span(TP);
|
||||
|
||||
/*
|
||||
* helper function: return lower level regex object
|
||||
* rmobj - regex or match object
|
||||
*/
|
||||
static regexobject * getre(TP, tp_obj rmobj)
|
||||
{
|
||||
tp_obj reobj_data = tp_get(tp, rmobj, tp_string("__data__"));
|
||||
regexobject *re = NULL;
|
||||
|
||||
/* validate magic */
|
||||
if (reobj_data.data.magic != sizeof(regexobject)) {
|
||||
LastError = "broken regex object";
|
||||
return (NULL);
|
||||
}
|
||||
re = (regexobject*)reobj_data.data.val;
|
||||
assert(re);
|
||||
|
||||
return (re);
|
||||
}
|
||||
|
||||
/*
|
||||
* derive match object from regex object
|
||||
*/
|
||||
static tp_obj match_object(TP, tp_obj reobj)
|
||||
{
|
||||
tp_obj mo = tp_object(tp); /* match object */
|
||||
tp_obj redata; /* regex object data */
|
||||
tp_obj madata; /* match object data */
|
||||
regexobject *re = NULL; /* lower level regex object */
|
||||
|
||||
redata = tp_get(tp, reobj, tp_string("__data__"));
|
||||
re = (regexobject *)redata.data.val;
|
||||
assert(re);
|
||||
madata = tp_data(tp, (int)sizeof(regexobject), re);
|
||||
|
||||
tp_set(tp, mo, tp_string("group"), tp_method(tp, mo, match_obj_group));
|
||||
tp_set(tp, mo, tp_string("groups"), tp_method(tp, mo, match_obj_groups));
|
||||
tp_set(tp, mo, tp_string("start"), tp_method(tp, mo, match_obj_start));
|
||||
tp_set(tp, mo, tp_string("end"), tp_method(tp, mo, match_obj_end));
|
||||
tp_set(tp, mo, tp_string("span"), tp_method(tp, mo, match_obj_span));
|
||||
tp_set(tp, mo, tp_string("__data__"), madata);
|
||||
|
||||
return (mo);
|
||||
}
|
||||
|
||||
/*
|
||||
* FUNC: regexobj.search(str[,pos=0])
|
||||
* self - regex object
|
||||
* str - string to be searched
|
||||
* pos - optional starting offset
|
||||
*
|
||||
* RETURN:
|
||||
* match object - when matched
|
||||
* None - not matched
|
||||
*/
|
||||
static tp_obj regex_obj_search(TP)
|
||||
{
|
||||
tp_obj self = TP_OBJ(); /* regex object */
|
||||
tp_obj str = TP_STR();
|
||||
tp_obj pos = TP_DEFAULT(tp_number(0));
|
||||
tp_obj maobj; /* match object */
|
||||
regexobject *re = NULL;
|
||||
int r = -2; /* -2 indicate exception */
|
||||
int range;
|
||||
|
||||
if (pos.number.val < 0 || pos.number.val > str.string.len) {
|
||||
LastError = "search offset out of range";
|
||||
goto exception;
|
||||
}
|
||||
range = str.string.len - pos.number.val;
|
||||
|
||||
re = getre(tp, self);
|
||||
re->re_lastok = NULL;
|
||||
r = re_search(&re->re_patbuf, (unsigned char *)str.string.val,
|
||||
str.string.len, pos.number.val, range, &re->re_regs);
|
||||
|
||||
/* cannot match pattern */
|
||||
if (r == -1)
|
||||
goto notfind;
|
||||
|
||||
/* error occurred */
|
||||
if (r == -2)
|
||||
goto exception;
|
||||
|
||||
/* matched */
|
||||
re->re_lastok = (unsigned char *)str.string.val;
|
||||
|
||||
/* match obj */
|
||||
maobj = match_object(tp, self);
|
||||
|
||||
return (maobj);
|
||||
|
||||
notfind:
|
||||
re->re_lastok = NULL;
|
||||
return (tp_None);
|
||||
exception:
|
||||
re->re_lastok = NULL;
|
||||
tp_raise(tp_None, tp_string("regex search error"));
|
||||
}
|
||||
|
||||
/*
|
||||
* FUNC: regexobj.match(str[,pos=0])
|
||||
* self - regex object
|
||||
* str - string to be matched
|
||||
* pos - optional starting position
|
||||
*
|
||||
* RETURN:
|
||||
* match object - when matched
|
||||
* None - not matched
|
||||
*/
|
||||
static tp_obj regex_obj_match(TP)
|
||||
{
|
||||
tp_obj self = TP_OBJ(); /* regex object */
|
||||
tp_obj str = TP_STR();
|
||||
tp_obj pos = TP_DEFAULT(tp_number(0));
|
||||
tp_obj maobj; /* match object */
|
||||
regexobject *re = NULL;
|
||||
int r = -2; /* -2 indicate exception */
|
||||
|
||||
re = getre(tp, self);
|
||||
re->re_lastok = NULL;
|
||||
r = re_match(&re->re_patbuf, (unsigned char *)str.string.val,
|
||||
str.string.len, pos.number.val, &re->re_regs);
|
||||
|
||||
/* cannot match pattern */
|
||||
if (r == -1)
|
||||
goto nomatch;
|
||||
|
||||
/* error occurred */
|
||||
if (r == -2)
|
||||
goto exception;
|
||||
|
||||
/* matched */
|
||||
re->re_lastok = (unsigned char *)str.string.val;
|
||||
|
||||
/* match obj */
|
||||
maobj = match_object(tp, self);
|
||||
|
||||
return (maobj);
|
||||
|
||||
nomatch:
|
||||
re->re_lastok = NULL;
|
||||
return (tp_None);
|
||||
exception:
|
||||
re->re_lastok = NULL;
|
||||
tp_raise(tp_None, tp_string("regex match error"));
|
||||
}
|
||||
|
||||
/*
|
||||
* regex object split()
|
||||
* self - regex object
|
||||
* restr - regex string
|
||||
* maxsplit - max split field, default 0, mean no limit
|
||||
*/
|
||||
static tp_obj regex_obj_split(TP)
|
||||
{
|
||||
tp_obj self = TP_OBJ(); /* regex object */
|
||||
tp_obj restr = TP_OBJ(); /* string */
|
||||
tp_obj maxsplit = TP_DEFAULT(tp_number(0));
|
||||
tp_obj maobj; /* match object */
|
||||
regexobject *re = NULL; /* lower level regex object */
|
||||
tp_obj result = tp_list(tp);
|
||||
tp_obj grpstr; /* group string */
|
||||
int slen; /* string length */
|
||||
int srchloc; /* search location */
|
||||
|
||||
/* maxsplit == 0 means no limit */
|
||||
if ((int)maxsplit.number.val == 0)
|
||||
maxsplit.number.val = RE_NREGS;
|
||||
assert(maxsplit.number.val > 0);
|
||||
|
||||
srchloc = 0;
|
||||
slen = strlen((char *)restr.string.val);
|
||||
|
||||
do {
|
||||
/* generate a temp match object */
|
||||
tp_params_v(tp, 3, self, restr, tp_number(srchloc));
|
||||
maobj = regex_obj_search(tp);
|
||||
if (!tp_bool(tp, maobj))
|
||||
break;
|
||||
|
||||
re = getre(tp, maobj);
|
||||
if (re->re_lastok == NULL) {
|
||||
tp_raise(tp_None, tp_string("no match for split()"));
|
||||
}
|
||||
|
||||
/* extract fields */
|
||||
if ((int)maxsplit.number.val > 0) {
|
||||
int start = re->re_regs.start[0];
|
||||
int end = re->re_regs.end[0];
|
||||
/*printf("%s:start(%d),end(%d)\n", __func__, start, end);*/
|
||||
if (start < 0 || end < 0)
|
||||
break;
|
||||
|
||||
grpstr = tp_string_copy(tp,
|
||||
(const char *)re->re_lastok + srchloc, start - srchloc);
|
||||
|
||||
if (tp_bool(tp, grpstr)) {
|
||||
tp_set(tp, result, tp_None, grpstr);
|
||||
maxsplit.number.val--;
|
||||
}
|
||||
|
||||
srchloc = end;
|
||||
}
|
||||
} while (srchloc < slen && (int)maxsplit.number.val > 0);
|
||||
|
||||
/* collect remaining string, if necessary */
|
||||
if (srchloc < slen) {
|
||||
grpstr = tp_string_copy(tp,
|
||||
(const char *)restr.string.val + srchloc, slen - srchloc);
|
||||
if (tp_bool(tp, grpstr))
|
||||
tp_set(tp, result, tp_None, grpstr);
|
||||
}
|
||||
|
||||
return (result);
|
||||
}
|
||||
|
||||
/*
|
||||
* regex object findall()
|
||||
* self - regex object
|
||||
* restr - regex string
|
||||
* pos - starting position, default 0
|
||||
*/
|
||||
static tp_obj regex_obj_findall(TP)
|
||||
{
|
||||
tp_obj self = TP_OBJ(); /* regex object */
|
||||
tp_obj restr = TP_OBJ(); /* string */
|
||||
tp_obj pos = TP_DEFAULT(tp_number(0));
|
||||
tp_obj maobj; /* match object */
|
||||
regexobject *re = NULL; /* lower level regex object */
|
||||
tp_obj result = tp_list(tp);
|
||||
tp_obj grpstr; /* group string */
|
||||
int slen; /* string length */
|
||||
int srchloc; /* search location */
|
||||
|
||||
srchloc = (int)pos.number.val;
|
||||
slen = strlen((char *)restr.string.val);
|
||||
if (srchloc < 0 || srchloc >= slen)
|
||||
tp_raise(tp_None, tp_string("starting position out of range"));
|
||||
|
||||
do {
|
||||
/* generate a temp match object */
|
||||
tp_params_v(tp, 3, self, restr, tp_number(srchloc));
|
||||
maobj = regex_obj_search(tp);
|
||||
if (!tp_bool(tp, maobj))
|
||||
break;
|
||||
|
||||
re = getre(tp, maobj);
|
||||
if (re->re_lastok == NULL) {
|
||||
tp_raise(tp_None, tp_string("no match for findall()"));
|
||||
}
|
||||
|
||||
/* extract fields */
|
||||
if (srchloc < slen) {
|
||||
int start = re->re_regs.start[0];
|
||||
int end = re->re_regs.end[0];
|
||||
/*printf("%s:start(%d),end(%d)\n", __func__, start, end);*/
|
||||
if (start < 0 || end < 0)
|
||||
break;
|
||||
|
||||
grpstr = tp_string_copy(tp,
|
||||
(const char *)re->re_lastok + start, end - start);
|
||||
|
||||
if (tp_bool(tp, grpstr)) {
|
||||
tp_set(tp, result, tp_None, grpstr);
|
||||
}
|
||||
|
||||
srchloc = end;
|
||||
}
|
||||
} while (srchloc < slen);
|
||||
|
||||
return (result);
|
||||
}
|
||||
|
||||
/*
|
||||
* FUNC: matchobj.group([group1, ...])
|
||||
* self - match object
|
||||
* args - optional group indices, default 0
|
||||
*
|
||||
* return specified group.
|
||||
*/
|
||||
static tp_obj match_obj_group(TP)
|
||||
{
|
||||
tp_obj self = TP_OBJ(); /* match object */
|
||||
tp_obj grpidx; /* a group index */
|
||||
regexobject *re = NULL;
|
||||
int indices[RE_NREGS];
|
||||
int start;
|
||||
int end;
|
||||
int i;
|
||||
int single = 0; /* single group index? */
|
||||
tp_obj result;
|
||||
|
||||
/* get lower level regex object representation */
|
||||
re = getre(tp, self);
|
||||
if (re->re_lastok == NULL)
|
||||
tp_raise(tp_None,
|
||||
tp_string("group() only valid after successful match/search"));
|
||||
|
||||
for (i = 0; i < RE_NREGS; i++)
|
||||
indices[i] = -1;
|
||||
|
||||
/*
|
||||
* if no group index provided, supply default group index 0; else
|
||||
* fill in indices[] with provided group index list.
|
||||
*/
|
||||
if (tp->params.list.val->len == 0) {
|
||||
indices[0] = 0;
|
||||
single = 1;
|
||||
} else if (tp->params.list.val->len == 1) {
|
||||
indices[0] = (int)TP_NUM();
|
||||
single = 1;
|
||||
} else {
|
||||
i = 0;
|
||||
TP_LOOP(grpidx)
|
||||
if (grpidx.number.val < 0 || grpidx.number.val > RE_NREGS)
|
||||
tp_raise(tp_None, tp_string("group() grpidx out of range"));
|
||||
indices[i++] = (int)grpidx.number.val;
|
||||
TP_END
|
||||
}
|
||||
|
||||
/* generate result string list */
|
||||
result = tp_list(tp);
|
||||
for (i = 0; i < RE_NREGS && indices[i] >= 0; i++) {
|
||||
tp_obj grpstr;
|
||||
start = re->re_regs.start[indices[i]];
|
||||
end = re->re_regs.end[indices[i]];
|
||||
if (start < 0 || end < 0) {
|
||||
grpstr = tp_None;
|
||||
} else {
|
||||
grpstr = tp_string_copy(tp, (const char *)re->re_lastok + start,
|
||||
end - start);
|
||||
}
|
||||
tp_set(tp, result, tp_None, grpstr);
|
||||
}
|
||||
return (single ? tp_get(tp, result, tp_number(0)) : result);
|
||||
}
|
||||
|
||||
/*
|
||||
* FUNC: matchobj.groups()
|
||||
* self - match object.
|
||||
* return all groups.
|
||||
* Note: CPython allow a 'default' argument, but we disallow it.
|
||||
*/
|
||||
static tp_obj match_obj_groups(TP)
|
||||
{
|
||||
tp_obj self = TP_OBJ(); /* match object */
|
||||
regexobject *re = NULL;
|
||||
int start;
|
||||
int end;
|
||||
int i;
|
||||
tp_obj result = tp_list(tp);
|
||||
|
||||
re = getre(tp, self);
|
||||
if (re->re_lastok == NULL) {
|
||||
tp_raise(tp_None,
|
||||
tp_string("groups() only valid after successful match/search"));
|
||||
}
|
||||
|
||||
for (i = 1; i < RE_NREGS; i++) {
|
||||
start = re->re_regs.start[i];
|
||||
end = re->re_regs.end[i];
|
||||
if (start < 0 || end < 0)
|
||||
break;
|
||||
|
||||
tp_obj grpstr = tp_string_copy(tp,
|
||||
(const char *)re->re_lastok + start, end - start);
|
||||
|
||||
if (tp_bool(tp, grpstr))
|
||||
tp_set(tp, result, tp_None, grpstr);
|
||||
}
|
||||
|
||||
return (result);
|
||||
}
|
||||
|
||||
/*
|
||||
* FUNC: matchobj.start([group])
|
||||
* self - match object
|
||||
* group - group index
|
||||
* return starting position of matched 'group' substring.
|
||||
*/
|
||||
static tp_obj match_obj_start(TP)
|
||||
{
|
||||
tp_obj self = TP_OBJ(); /* match object */
|
||||
tp_obj group = TP_DEFAULT(tp_number(0)); /* group */
|
||||
regexobject *re = NULL;
|
||||
int start;
|
||||
|
||||
re = getre(tp, self);
|
||||
if (re->re_lastok == NULL) {
|
||||
tp_raise(tp_None,
|
||||
tp_string("start() only valid after successful match/search"));
|
||||
}
|
||||
|
||||
if (group.number.val < 0 || group.number.val > RE_NREGS)
|
||||
tp_raise(tp_None, tp_string("IndexError: group index out of range"));
|
||||
|
||||
start = re->re_regs.start[(int)group.number.val];
|
||||
|
||||
return (tp_number(start));
|
||||
}
|
||||
|
||||
/*
|
||||
* FUNC: matchobj.end([group])
|
||||
* self - match object
|
||||
* group - group index
|
||||
* return ending position of matched 'group' substring.
|
||||
*/
|
||||
static tp_obj match_obj_end(TP)
|
||||
{
|
||||
tp_obj self = TP_OBJ(); /* match object */
|
||||
tp_obj group = TP_DEFAULT(tp_number(0)); /* group */
|
||||
regexobject *re = NULL;
|
||||
int end;
|
||||
|
||||
re = getre(tp, self);
|
||||
if (re->re_lastok == NULL) {
|
||||
tp_raise(tp_None,
|
||||
tp_string("end() only valid after successful match/search"));
|
||||
}
|
||||
|
||||
if (group.number.val < 0 || group.number.val > RE_NREGS)
|
||||
tp_raise(tp_None, tp_string("IndexError: group index out of range"));
|
||||
|
||||
end = re->re_regs.end[(int)group.number.val];
|
||||
|
||||
return (tp_number(end));
|
||||
}
|
||||
|
||||
/*
|
||||
* FUNC: matchobj.span([group])
|
||||
* self - match object
|
||||
* group - group index
|
||||
* return [start,end] position pair of matched 'group' substring.
|
||||
*/
|
||||
static tp_obj match_obj_span(TP)
|
||||
{
|
||||
tp_obj self = TP_OBJ(); /* match object */
|
||||
tp_obj group = TP_DEFAULT(tp_number(0)); /* group */
|
||||
regexobject *re = NULL;
|
||||
int start;
|
||||
int end;
|
||||
tp_obj result;
|
||||
|
||||
re = getre(tp, self);
|
||||
if (re->re_lastok == NULL) {
|
||||
tp_raise(tp_None,
|
||||
tp_string("span() only valid after successful match/search"));
|
||||
}
|
||||
|
||||
if (group.number.val < 0 || group.number.val > RE_NREGS)
|
||||
tp_raise(tp_None, tp_string("IndexError: group index out of range"));
|
||||
|
||||
start = re->re_regs.start[(int)group.number.val];
|
||||
end = re->re_regs.end[(int)group.number.val];
|
||||
|
||||
result = tp_list(tp);
|
||||
tp_set(tp, result, tp_None, tp_number(start));
|
||||
tp_set(tp, result, tp_None, tp_number(end));
|
||||
|
||||
return (result);
|
||||
}
|
||||
|
||||
/*
|
||||
* compile out a re object
|
||||
* repat - regex pattern
|
||||
* resyn - regex syntax
|
||||
*/
|
||||
static tp_obj regex_compile(TP)
|
||||
{
|
||||
char *error = NULL;
|
||||
char const *pat = NULL;
|
||||
int size = 0;
|
||||
tp_obj reobj_data;
|
||||
tp_obj repat = TP_TYPE(TP_STRING); /* pattern */
|
||||
tp_obj resyn = TP_DEFAULT(tp_number(RE_SYNTAX_EMACS)); /* syntax */
|
||||
tp_obj reobj; /* regex object */
|
||||
regexobject *re;
|
||||
|
||||
/*
|
||||
* create regex object, its parent is builtin 'object'
|
||||
*/
|
||||
reobj = tp_object(tp);
|
||||
|
||||
re = (regexobject *)malloc(sizeof(regexobject));
|
||||
if (!re) {
|
||||
error = "malloc lower level regex object failed";
|
||||
goto finally;
|
||||
}
|
||||
|
||||
re->re_patbuf.buffer = NULL;
|
||||
re->re_patbuf.allocated = 0;
|
||||
re->re_patbuf.fastmap = (unsigned char *)re->re_fastmap;
|
||||
re->re_patbuf.translate = NULL;
|
||||
re->re_translate = NULL;
|
||||
re->re_lastok = NULL;
|
||||
|
||||
re->re_errno = 0;
|
||||
re->re_syntax = (int)resyn.number.val;
|
||||
|
||||
pat = repat.string.val;
|
||||
size = repat.string.len;
|
||||
error = re_compile_pattern((unsigned char *)pat, size, &re->re_patbuf);
|
||||
if (error != NULL) {
|
||||
LastError = error;
|
||||
goto finally;
|
||||
}
|
||||
|
||||
/* regexobject's size as magic */
|
||||
reobj_data = tp_data(tp, (int)sizeof(regexobject), re);
|
||||
|
||||
/*
|
||||
* bind to regex object
|
||||
*/
|
||||
tp_set(tp, reobj, tp_string("search"),
|
||||
tp_method(tp, reobj, regex_obj_search));
|
||||
tp_set(tp, reobj, tp_string("match"),
|
||||
tp_method(tp, reobj, regex_obj_match));
|
||||
tp_set(tp, reobj, tp_string("split"),
|
||||
tp_method(tp, reobj, regex_obj_split));
|
||||
tp_set(tp, reobj, tp_string("findall"),
|
||||
tp_method(tp, reobj, regex_obj_findall));
|
||||
tp_set(tp, reobj, tp_string("__data__"), reobj_data);
|
||||
|
||||
tp_set(tp, reobj, tp_string("__name__"),
|
||||
tp_string("regular expression object"));
|
||||
tp_set(tp, reobj, tp_string("__doc__"), tp_string(
|
||||
"regular expression object, support methods:\n"
|
||||
"search(str[,pos=0])-search 'str' from 'pos'\n"
|
||||
"match(str[,pos=0]) -match 'str' from 'pos'\n"
|
||||
));
|
||||
|
||||
return (reobj);
|
||||
|
||||
finally:
|
||||
tp_raise(tp_None, tp_string(error));
|
||||
}
|
||||
|
||||
/*
|
||||
* module level search()
|
||||
*/
|
||||
static tp_obj regex_search(TP)
|
||||
{
|
||||
tp_obj repat = TP_OBJ(); /* pattern */
|
||||
tp_obj restr = TP_OBJ(); /* string */
|
||||
tp_obj resyn = TP_DEFAULT(tp_number(RE_SYNTAX_EMACS));
|
||||
tp_obj reobj; /* regex object */
|
||||
tp_obj maobj; /* match object */
|
||||
|
||||
/* compile out regex object */
|
||||
tp_params_v(tp, 2, repat, resyn);
|
||||
reobj = regex_compile(tp);
|
||||
|
||||
/* call r.search() */
|
||||
tp_params_v(tp, 3, reobj, restr, tp_number(0));
|
||||
maobj = regex_obj_search(tp);
|
||||
|
||||
return (maobj);
|
||||
}
|
||||
|
||||
/*
|
||||
* module level match()
|
||||
*/
|
||||
static tp_obj regex_match(TP)
|
||||
{
|
||||
tp_obj repat = TP_OBJ(); /* pattern */
|
||||
tp_obj restr = TP_OBJ(); /* string */
|
||||
tp_obj resyn = TP_DEFAULT(tp_number(RE_SYNTAX_EMACS));
|
||||
tp_obj reobj; /* regex object */
|
||||
tp_obj maobj; /* match object */
|
||||
|
||||
/* compile out regex object */
|
||||
tp_params_v(tp, 2, repat, resyn);
|
||||
reobj = regex_compile(tp);
|
||||
|
||||
/* call r.search() */
|
||||
tp_params_v(tp, 3, reobj, restr, tp_number(0));
|
||||
maobj = regex_obj_match(tp);
|
||||
|
||||
return (maobj);
|
||||
}
|
||||
|
||||
/*
|
||||
* module level split()
|
||||
* repat - regex pattern
|
||||
* restr - regex string
|
||||
* maxsplit - max split field, default 0, mean no limit
|
||||
*/
|
||||
static tp_obj regex_split(TP)
|
||||
{
|
||||
tp_obj repat = TP_OBJ(); /* pattern */
|
||||
tp_obj restr = TP_OBJ(); /* string */
|
||||
tp_obj maxsplit = TP_DEFAULT(tp_number(0));
|
||||
tp_obj reobj; /* regex object */
|
||||
|
||||
/* generate a temp regex object */
|
||||
tp_params_v(tp, 2, repat, tp_number(RE_SYNTAX_EMACS));
|
||||
reobj = regex_compile(tp);
|
||||
|
||||
tp_params_v(tp, 3, reobj, restr, maxsplit);
|
||||
return regex_obj_split(tp);
|
||||
}
|
||||
|
||||
/*
|
||||
* module level findall()
|
||||
* repat - regex pattern
|
||||
* restr - regex string
|
||||
* resyn - regex syntax, optional, default RE_SYNTAX_EMAC
|
||||
*/
|
||||
static tp_obj regex_findall(TP)
|
||||
{
|
||||
tp_obj repat = TP_OBJ(); /* pattern */
|
||||
tp_obj restr = TP_OBJ(); /* string */
|
||||
tp_obj resyn = TP_DEFAULT(tp_number(RE_SYNTAX_EMACS));
|
||||
tp_obj reobj; /* regex object */
|
||||
|
||||
/* generate a temp regex object */
|
||||
tp_params_v(tp, 2, repat, resyn);
|
||||
reobj = regex_compile(tp);
|
||||
|
||||
tp_params_v(tp, 2, reobj, restr);
|
||||
return regex_obj_findall(tp);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* re mod can only support 'set_syntax', 'get_syntax', and 'compile' functions,
|
||||
* 'compile' function will return a 'reobj', and this 'reobj' will support
|
||||
* methods 'search', 'match', 'group', 'groupall', el al.
|
||||
*/
|
||||
void re_init(TP)
|
||||
{
|
||||
/*
|
||||
* module dict for re
|
||||
*/
|
||||
tp_obj re_mod = tp_dict(tp);
|
||||
|
||||
/*
|
||||
* bind to re module
|
||||
*/
|
||||
tp_set(tp, re_mod, tp_string("compile"), tp_fnc(tp, regex_compile));
|
||||
tp_set(tp, re_mod, tp_string("search"), tp_fnc(tp, regex_search));
|
||||
tp_set(tp, re_mod, tp_string("match"), tp_fnc(tp, regex_match));
|
||||
tp_set(tp, re_mod, tp_string("split"), tp_fnc(tp, regex_split));
|
||||
tp_set(tp, re_mod, tp_string("findall"), tp_fnc(tp, regex_findall));
|
||||
tp_set(tp, re_mod, tp_string("AWK_SYNTAX"), tp_number(RE_SYNTAX_AWK));
|
||||
tp_set(tp, re_mod, tp_string("EGREP_SYNTAX"), tp_number(RE_SYNTAX_EGREP));
|
||||
tp_set(tp, re_mod, tp_string("GREP_SYNTAX"), tp_number(RE_SYNTAX_GREP));
|
||||
tp_set(tp, re_mod, tp_string("EMACS_SYNTAX"), tp_number(RE_SYNTAX_EMACS));
|
||||
|
||||
/*
|
||||
* bind special attibutes to re module
|
||||
*/
|
||||
tp_set(tp, re_mod, tp_string("__name__"),
|
||||
tp_string("regular expression module"));
|
||||
tp_set(tp, re_mod, tp_string("__file__"), tp_string(__FILE__));
|
||||
tp_set(tp, re_mod, tp_string("__doc__"),
|
||||
tp_string("simple regular express implementation"));
|
||||
|
||||
/*
|
||||
* bind regex module to tinypy modules[]
|
||||
*/
|
||||
tp_set(tp, tp->modules, tp_string("re"), re_mod);
|
||||
}
|
||||
|
||||
2124
programs/develop/tinypy/modules/re/regexpr.c
Normal file
2124
programs/develop/tinypy/modules/re/regexpr.c
Normal file
File diff suppressed because it is too large
Load Diff
160
programs/develop/tinypy/modules/re/regexpr.h
Normal file
160
programs/develop/tinypy/modules/re/regexpr.h
Normal file
@ -0,0 +1,160 @@
|
||||
/*
|
||||
* -*- mode: c-mode; c-file-style: python -*-
|
||||
*/
|
||||
|
||||
#ifndef Py_REGEXPR_H
|
||||
#define Py_REGEXPR_H
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* regexpr.h
|
||||
*
|
||||
* Author: Tatu Ylonen <ylo@ngs.fi>
|
||||
*
|
||||
* Copyright (c) 1991 Tatu Ylonen, Espoo, Finland
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies. This
|
||||
* software is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* Created: Thu Sep 26 17:15:36 1991 ylo
|
||||
* Last modified: Mon Nov 4 15:49:46 1991 ylo
|
||||
*/
|
||||
|
||||
/* $Id$ */
|
||||
|
||||
#ifndef REGEXPR_H
|
||||
#define REGEXPR_H
|
||||
|
||||
#define RE_NREGS 100 /* number of registers available */
|
||||
|
||||
typedef struct re_pattern_buffer
|
||||
{
|
||||
unsigned char *buffer; /* compiled pattern */
|
||||
int allocated; /* allocated size of compiled pattern */
|
||||
int used; /* actual length of compiled pattern */
|
||||
unsigned char *fastmap; /* fastmap[ch] is true if ch can start pattern */
|
||||
unsigned char *translate; /* translation to apply during compilation/matching */
|
||||
unsigned char fastmap_accurate; /* true if fastmap is valid */
|
||||
unsigned char can_be_null; /* true if can match empty string */
|
||||
unsigned char uses_registers; /* registers are used and need to be initialized */
|
||||
int num_registers; /* number of registers used */
|
||||
unsigned char anchor; /* anchor: 0=none 1=begline 2=begbuf */
|
||||
} *regexp_t;
|
||||
|
||||
typedef struct re_registers
|
||||
{
|
||||
int start[RE_NREGS]; /* start offset of region */
|
||||
int end[RE_NREGS]; /* end offset of region */
|
||||
} *regexp_registers_t;
|
||||
|
||||
/* bit definitions for syntax */
|
||||
#define RE_NO_BK_PARENS 1 /* no quoting for parentheses */
|
||||
#define RE_NO_BK_VBAR 2 /* no quoting for vertical bar */
|
||||
#define RE_BK_PLUS_QM 4 /* quoting needed for + and ? */
|
||||
#define RE_TIGHT_VBAR 8 /* | binds tighter than ^ and $ */
|
||||
#define RE_NEWLINE_OR 16 /* treat newline as or */
|
||||
#define RE_CONTEXT_INDEP_OPS 32 /* ^$?*+ are special in all contexts */
|
||||
#define RE_ANSI_HEX 64 /* ansi sequences (\n etc) and \xhh */
|
||||
#define RE_NO_GNU_EXTENSIONS 128 /* no gnu extensions */
|
||||
|
||||
#define TP_RE_NOERR 0
|
||||
#define TP_RE_UNKNOWN_OPCODE (-1)
|
||||
#define TP_RE_JUMP_OUT_BOUNDS 1
|
||||
#define TP_RE_QUOTE_ERR 2
|
||||
|
||||
/* definitions for some common regexp styles */
|
||||
#define RE_SYNTAX_AWK (RE_NO_BK_PARENS|RE_NO_BK_VBAR|RE_CONTEXT_INDEP_OPS)
|
||||
#define RE_SYNTAX_EGREP (RE_SYNTAX_AWK|RE_NEWLINE_OR)
|
||||
#define RE_SYNTAX_GREP (RE_BK_PLUS_QM|RE_NEWLINE_OR)
|
||||
#define RE_SYNTAX_EMACS 0
|
||||
|
||||
#define Sword 1
|
||||
#define Swhitespace 2
|
||||
#define Sdigit 4
|
||||
#define Soctaldigit 8
|
||||
#define Shexdigit 16
|
||||
|
||||
/* Rename all exported symbols to avoid conflicts with similarly named
|
||||
symbols in some systems' standard C libraries... */
|
||||
|
||||
#define re_syntax _Py_re_syntax
|
||||
#define re_syntax_table _Py_re_syntax_table
|
||||
#define re_compile_initialize _Py_re_compile_initialize
|
||||
#define re_set_syntax _Py_re_set_syntax
|
||||
#define re_compile_pattern _Py_re_compile_pattern
|
||||
#define re_match _Py_re_match
|
||||
#define re_search _Py_re_search
|
||||
#define re_compile_fastmap _Py_re_compile_fastmap
|
||||
#define re_comp _Py_re_comp
|
||||
#define re_exec _Py_re_exec
|
||||
|
||||
#ifdef HAVE_PROTOTYPES
|
||||
|
||||
extern int re_syntax;
|
||||
/* This is the actual syntax mask. It was added so that Python could do
|
||||
* syntax-dependent munging of patterns before compilation. */
|
||||
|
||||
extern unsigned char re_syntax_table[256];
|
||||
|
||||
void re_compile_initialize(void);
|
||||
|
||||
int re_set_syntax(int syntax);
|
||||
/* This sets the syntax to use and returns the previous syntax. The
|
||||
* syntax is specified by a bit mask of the above defined bits. */
|
||||
|
||||
char *re_compile_pattern(unsigned char *regex, int regex_size, regexp_t compiled);
|
||||
/* This compiles the regexp (given in regex and length in regex_size).
|
||||
* This returns NULL if the regexp compiled successfully, and an error
|
||||
* message if an error was encountered. The buffer field must be
|
||||
* initialized to a memory area allocated by malloc (or to NULL) before
|
||||
* use, and the allocated field must be set to its length (or 0 if
|
||||
* buffer is NULL). Also, the translate field must be set to point to a
|
||||
* valid translation table, or NULL if it is not used. */
|
||||
|
||||
int re_match(regexp_t compiled, unsigned char *string, int size, int pos,
|
||||
regexp_registers_t old_regs);
|
||||
/* This tries to match the regexp against the string. This returns the
|
||||
* length of the matched portion, or -1 if the pattern could not be
|
||||
* matched and -2 if an error (such as failure stack overflow) is
|
||||
* encountered. */
|
||||
|
||||
int re_search(regexp_t compiled, unsigned char *string, int size, int startpos,
|
||||
int range, regexp_registers_t regs);
|
||||
/* This searches for a substring matching the regexp. This returns the
|
||||
* first index at which a match is found. range specifies at how many
|
||||
* positions to try matching; positive values indicate searching
|
||||
* forwards, and negative values indicate searching backwards. mstop
|
||||
* specifies the offset beyond which a match must not go. This returns
|
||||
* -1 if no match is found, and -2 if an error (such as failure stack
|
||||
* overflow) is encountered. */
|
||||
|
||||
void re_compile_fastmap(regexp_t compiled);
|
||||
/* This computes the fastmap for the regexp. For this to have any effect,
|
||||
* the calling program must have initialized the fastmap field to point
|
||||
* to an array of 256 characters. */
|
||||
|
||||
#else /* HAVE_PROTOTYPES */
|
||||
|
||||
extern int re_syntax;
|
||||
extern unsigned char re_syntax_table[256];
|
||||
void re_compile_initialize();
|
||||
int re_set_syntax();
|
||||
char *re_compile_pattern();
|
||||
int re_match();
|
||||
int re_search();
|
||||
void re_compile_fastmap();
|
||||
|
||||
#endif /* HAVE_PROTOTYPES */
|
||||
|
||||
#endif /* REGEXPR_H */
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* !Py_REGEXPR_H */
|
||||
648
programs/develop/tinypy/modules/re/tests.py
Normal file
648
programs/develop/tinypy/modules/re/tests.py
Normal file
@ -0,0 +1,648 @@
|
||||
"""
|
||||
test case for re module
|
||||
"""
|
||||
|
||||
import re
|
||||
import testsuite
|
||||
SUCCEED, FAIL, SYNTAX_ERROR = range(3)
|
||||
|
||||
def RAISE():
|
||||
raise("testing failed")
|
||||
|
||||
def main():
|
||||
#print("begin re tests")
|
||||
|
||||
assert(re.__name__ != None)
|
||||
assert(re.__doc__ != None)
|
||||
assert(re.__file__ != None)
|
||||
|
||||
test_re_obj_search()
|
||||
test_re_obj_match()
|
||||
test_re_mod_search()
|
||||
test_re_mod_match()
|
||||
test_re_obj_split()
|
||||
test_re_mod_split()
|
||||
test_re_obj_findall()
|
||||
test_re_mod_findall()
|
||||
test_mat_obj_groups()
|
||||
test_mat_obj_start()
|
||||
test_mat_obj_end()
|
||||
test_mat_obj_span()
|
||||
|
||||
print("#OK: re tests passed")
|
||||
|
||||
def test_re_obj_search(verbose = None):
|
||||
"""
|
||||
some tests borrowed from cpython
|
||||
testing re.compile(), reobj.search(), and matobj.group()
|
||||
"""
|
||||
regex_tests = testsuite.search_regex_tests
|
||||
for t in regex_tests:
|
||||
pattern=s=outcome=repl=expected=None
|
||||
if len(t)==5:
|
||||
pattern, s, outcome, repl, expected = t
|
||||
elif len(t)==3:
|
||||
pattern, s, outcome = t
|
||||
else:
|
||||
raise ('Test tuples should have 3 or 5 fields',t)
|
||||
|
||||
try:
|
||||
obj=re.compile(pattern)
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR: continue # Expected a syntax error
|
||||
else:
|
||||
# Regex syntax errors aren't yet reported, so for
|
||||
# the official test suite they'll be quietly ignored.
|
||||
pass
|
||||
try:
|
||||
matobj=obj.search(s)
|
||||
except:
|
||||
print('=== Unexpected exception:', obj, matobj, pattern, s)
|
||||
RAISE()
|
||||
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
pass
|
||||
elif outcome==FAIL:
|
||||
if matobj==None: pass # No match, as expected
|
||||
else: print('=== Succeeded incorrectly', obj, matobj, pattern, s)
|
||||
elif outcome==SUCCEED:
|
||||
if matobj!=None:
|
||||
# Matched, as expected, so now we compute the
|
||||
# result string and compare it to our expected result.
|
||||
found=matobj.group(0)
|
||||
repl = repl.replace("found", str(found))
|
||||
for i in range(1,11):
|
||||
if "g"+str(i) in repl:
|
||||
gi = str(matobj.group(i))
|
||||
repl = repl.replace("g"+str(i), gi)
|
||||
if len(t) == 5:
|
||||
repl = repl.replace('+', '')
|
||||
repl = repl.replace('\"', '')
|
||||
if repl!=expected:
|
||||
print( '=== grouping error', t,
|
||||
str(repl)+' should be '+str(expected))
|
||||
RAISE()
|
||||
else:
|
||||
print ('=== Failed incorrectly', t)
|
||||
|
||||
def test_re_obj_match(verbose = None):
|
||||
"""
|
||||
some tests borrowed from cpython
|
||||
testing re.compile(), reobj.match() and matobj.group()
|
||||
"""
|
||||
regex_tests = testsuite.match_regex_tests
|
||||
for t in regex_tests:
|
||||
pattern=s=outcome=repl=expected=None
|
||||
if len(t)==5:
|
||||
pattern, s, outcome, repl, expected = t
|
||||
elif len(t)==3:
|
||||
pattern, s, outcome = t
|
||||
else:
|
||||
raise ('Test tuples should have 3 or 5 fields',t)
|
||||
|
||||
try:
|
||||
obj=re.compile(pattern)
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR: continue # Expected a syntax error
|
||||
else:
|
||||
# Regex syntax errors aren't yet reported, so for
|
||||
# the official test suite they'll be quietly ignored.
|
||||
pass
|
||||
try:
|
||||
matobj=obj.match(s)
|
||||
except:
|
||||
print('=== Unexpected exception:', obj, matobj, pattern, s)
|
||||
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
pass
|
||||
elif outcome==FAIL:
|
||||
if matobj==None: pass # No match, as expected
|
||||
else: print('=== Succeeded incorrectly', obj, matobj, pattern, s)
|
||||
elif outcome==SUCCEED:
|
||||
if matobj!=None:
|
||||
# Matched, as expected, so now we compute the
|
||||
# result string and compare it to our expected result.
|
||||
found=matobj.group(0)
|
||||
repl = repl.replace("found", str(found))
|
||||
for i in range(1,11):
|
||||
if "g"+str(i) in repl:
|
||||
gi = str(matobj.group(i))
|
||||
repl = repl.replace("g"+str(i), gi)
|
||||
if len(t) == 5:
|
||||
repl = repl.replace('+', '')
|
||||
repl = repl.replace('\"', '')
|
||||
if repl!=expected:
|
||||
print( '=== grouping error', t,
|
||||
str(repl)+' should be '+str(expected))
|
||||
RAISE()
|
||||
else:
|
||||
print ('=== Failed incorrectly', obj, matobj, pattern, s)
|
||||
|
||||
def test_re_mod_search(verbose = None):
|
||||
"""
|
||||
some tests borrowed from cpython
|
||||
testing re.search(), and matobj.group()
|
||||
"""
|
||||
regex_tests = testsuite.search_regex_tests
|
||||
for t in regex_tests:
|
||||
pattern=s=outcome=repl=expected=None
|
||||
if len(t)==5:
|
||||
pattern, s, outcome, repl, expected = t
|
||||
elif len(t)==3:
|
||||
pattern, s, outcome = t
|
||||
else:
|
||||
raise ('Test tuples should have 3 or 5 fields',t)
|
||||
|
||||
try:
|
||||
matobj=re.search(pattern, s)
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
pass
|
||||
else:
|
||||
print('=== Unexpected exception:', matobj, pattern, s)
|
||||
|
||||
if outcome==FAIL:
|
||||
if matobj==None: pass # No match, as expected
|
||||
else: print('=== Succeeded incorrectly', obj, matobj, pattern, s)
|
||||
elif outcome==SUCCEED:
|
||||
if matobj!=None:
|
||||
# Matched, as expected, so now we compute the
|
||||
# result string and compare it to our expected result.
|
||||
found=matobj.group(0)
|
||||
repl = repl.replace("found", str(found))
|
||||
for i in range(1,11):
|
||||
if "g"+str(i) in repl:
|
||||
gi = str(matobj.group(i))
|
||||
repl = repl.replace("g"+str(i), gi)
|
||||
if len(t) == 5:
|
||||
repl = repl.replace('+', '')
|
||||
repl = repl.replace('\"', '')
|
||||
if repl!=expected:
|
||||
print( '=== grouping error', t,
|
||||
str(repl)+' should be '+str(expected))
|
||||
RAISE()
|
||||
else:
|
||||
print ('=== Failed incorrectly', t)
|
||||
|
||||
def test_re_mod_match(verbose = None):
|
||||
"""
|
||||
some tests borrowed from cpython
|
||||
testing re.match(), and matobj.group()
|
||||
"""
|
||||
regex_tests = testsuite.match_regex_tests
|
||||
for t in regex_tests:
|
||||
pattern=s=outcome=repl=expected=None
|
||||
if len(t)==5:
|
||||
pattern, s, outcome, repl, expected = t
|
||||
elif len(t)==3:
|
||||
pattern, s, outcome = t
|
||||
else:
|
||||
raise ('Test tuples should have 3 or 5 fields',t)
|
||||
|
||||
try:
|
||||
matobj=re.match(pattern, s)
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
pass
|
||||
else:
|
||||
print('=== Unexpected exception:', matobj, pattern, s)
|
||||
|
||||
if outcome==FAIL:
|
||||
if matobj==None: pass # No match, as expected
|
||||
else: print('=== Succeeded incorrectly', matobj, pattern, s)
|
||||
elif outcome==SUCCEED:
|
||||
if matobj!=None:
|
||||
# Matched, as expected, so now we compute the
|
||||
# result string and compare it to our expected result.
|
||||
found=matobj.group(0)
|
||||
repl = repl.replace("found", str(found))
|
||||
for i in range(1,11):
|
||||
if "g"+str(i) in repl:
|
||||
gi = str(matobj.group(i))
|
||||
repl = repl.replace("g"+str(i), gi)
|
||||
if len(t) == 5:
|
||||
repl = repl.replace('+', '')
|
||||
repl = repl.replace('\"', '')
|
||||
if repl!=expected:
|
||||
print( '=== grouping error', t,
|
||||
str(repl)+' should be '+str(expected))
|
||||
RAISE()
|
||||
else:
|
||||
print ('=== Failed incorrectly', t)
|
||||
|
||||
def test_re_obj_split(verbose = None):
|
||||
"""
|
||||
test re.compile(), and reobj.split()
|
||||
"""
|
||||
regex_tests = testsuite.split_regex_tests
|
||||
for t in regex_tests:
|
||||
pattern, s, outcome, maxsplit, fields = t
|
||||
try:
|
||||
reobj = re.compile(pattern)
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
pass
|
||||
else:
|
||||
print('=== Unexpected exception:', pattern, s,
|
||||
outcome, maxsplit, fields)
|
||||
try:
|
||||
fldlst=reobj.split(s, maxsplit)
|
||||
except:
|
||||
if outcome == SYNTAX_ERROR:
|
||||
continue
|
||||
else:
|
||||
print('=== Unexpected exception:', pattern, s,
|
||||
outcome, maxsplit, fields)
|
||||
|
||||
if outcome==FAIL:
|
||||
pass # No match, as expected
|
||||
elif outcome==SUCCEED:
|
||||
if fldlst:
|
||||
# Matched, as expected, so now we compute the
|
||||
# result string and compare it to our expected result.
|
||||
if verbose:
|
||||
fldstr = fieldstr = ""
|
||||
for item in fldlst:
|
||||
fldstr = fldstr + str(item) + " | "
|
||||
for item in fields:
|
||||
fieldstr = fieldstr + str(item) + " | "
|
||||
print(fldstr, "~~~", fieldstr)
|
||||
if len(fields) != len(fldlst):
|
||||
print('=== Not coherent 1')
|
||||
RAISE()
|
||||
|
||||
for i in range(len(fields)):
|
||||
if fields[i] != fldlst[i]:
|
||||
if verbose:
|
||||
print('=== Not coherent 2', pattern, s,
|
||||
outcome, maxsplit, fields, i,
|
||||
fields[i],'(',len(fields[i]),')', ' | ',
|
||||
fldlst[i],'(',len(fldlst[i]),')')
|
||||
else:
|
||||
print('=== Not coherent 2')
|
||||
RAISE()
|
||||
else:
|
||||
print ('=== Failed incorrectly', pattern, s,
|
||||
outcome, maxsplit, fields)
|
||||
|
||||
def test_re_mod_split(verbose = None):
|
||||
"""
|
||||
test re.split()
|
||||
"""
|
||||
regex_tests = testsuite.split_regex_tests
|
||||
for t in regex_tests:
|
||||
pattern, s, outcome, maxsplit, fields = t
|
||||
try:
|
||||
fldlst=re.split(pattern, s, maxsplit)
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
continue
|
||||
else:
|
||||
print('=== Unexpected exception:', pattern, s,
|
||||
outcome, maxsplit, fields)
|
||||
|
||||
if outcome==FAIL:
|
||||
pass # No match, as expected
|
||||
elif outcome==SUCCEED:
|
||||
if fldlst:
|
||||
# Matched, as expected, so now we compute the
|
||||
# result string and compare it to our expected result.
|
||||
if verbose:
|
||||
fldstr = fieldstr = ""
|
||||
for item in fldlst:
|
||||
fldstr = fldstr + str(item) + " | "
|
||||
for item in fields:
|
||||
fieldstr = fieldstr + str(item) + " | "
|
||||
print(fldstr, "~~~", fieldstr)
|
||||
|
||||
if len(fields) != len(fldlst):
|
||||
print('=== Not coherent 1')
|
||||
RAISE()
|
||||
|
||||
for i in range(len(fields)):
|
||||
if fields[i] != fldlst[i]:
|
||||
if verbose:
|
||||
print('=== Not coherent 2', pattern, s,
|
||||
outcome, maxsplit, fields, i,
|
||||
fields[i],'(',len(fields[i]),')', ' | ',
|
||||
fldlst[i],'(',len(fldlst[i]),')')
|
||||
else:
|
||||
print('=== Not coherent 2')
|
||||
RAISE()
|
||||
else:
|
||||
print ('=== Failed incorrectly', pattern, s,
|
||||
outcome, maxsplit, fields)
|
||||
|
||||
def test_re_obj_findall(verbose = None):
|
||||
"""
|
||||
test re.compile(), and reobj.findall()
|
||||
"""
|
||||
regex_tests = testsuite.findall_regex_tests
|
||||
for t in regex_tests:
|
||||
pattern, s, outcome, pos, fields = t
|
||||
try:
|
||||
reobj = re.compile(pattern)
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
pass
|
||||
else:
|
||||
print('=== Unexpected exception:', pattern, s,
|
||||
outcome, pos, fields)
|
||||
try:
|
||||
fldlst=reobj.findall(s, pos)
|
||||
except:
|
||||
if outcome == SYNTAX_ERROR:
|
||||
continue
|
||||
else:
|
||||
print('=== Unexpected exception:', pattern, s,
|
||||
outcome, pos, fields)
|
||||
|
||||
if outcome==FAIL:
|
||||
pass # No match, as expected
|
||||
elif outcome==SUCCEED:
|
||||
if fldlst:
|
||||
# Matched, as expected, so now we compute the
|
||||
# result string and compare it to our expected result.
|
||||
if verbose:
|
||||
fldstr = fieldstr = ""
|
||||
for item in fldlst:
|
||||
fldstr = fldstr + str(item) + " | "
|
||||
for item in fields:
|
||||
fieldstr = fieldstr + str(item) + " | "
|
||||
print(fldstr, "~~~", fieldstr)
|
||||
|
||||
if len(fields) != len(fldlst):
|
||||
print('=== Not coherent 1')
|
||||
RAISE()
|
||||
|
||||
for i in range(len(fields)):
|
||||
if fields[i] != fldlst[i]:
|
||||
if verbose:
|
||||
print('=== Not coherent 2', pattern, s,
|
||||
outcome, maxsplit, fields, i,
|
||||
fields[i],'(',len(fields[i]),')', ' | ',
|
||||
fldlst[i],'(',len(fldlst[i]),')')
|
||||
else:
|
||||
print('=== Not coherent 2')
|
||||
RAISE()
|
||||
else:
|
||||
print ('=== Failed incorrectly', pattern, s,
|
||||
outcome, pos, fields)
|
||||
|
||||
def test_re_mod_findall(verbose = None):
|
||||
"""
|
||||
test re.findall()
|
||||
"""
|
||||
regex_tests = testsuite.mod_findall_regex_tests
|
||||
for t in regex_tests:
|
||||
pattern, s, outcome, pos, fields = t # pos is not used
|
||||
try:
|
||||
fldlst=re.findall(pattern, s)
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
continue
|
||||
else:
|
||||
print('=== Unexpected exception:', pattern, s,
|
||||
outcome, pos, fields)
|
||||
|
||||
if outcome==FAIL:
|
||||
pass # No match, as expected
|
||||
elif outcome==SUCCEED:
|
||||
if fldlst:
|
||||
# Matched, as expected, so now we compute the
|
||||
# result string and compare it to our expected result.
|
||||
if verbose:
|
||||
fldstr = fieldstr = ""
|
||||
for item in fldlst:
|
||||
fldstr = fldstr + str(item) + " | "
|
||||
for item in fields:
|
||||
fieldstr = fieldstr + str(item) + " | "
|
||||
print(fldstr, "~~~", fieldstr)
|
||||
|
||||
if len(fields) != len(fldlst):
|
||||
print('=== Not coherent 1')
|
||||
RAISE()
|
||||
|
||||
for i in range(len(fields)):
|
||||
if fields[i] != fldlst[i]:
|
||||
if verbose:
|
||||
print('=== Not coherent 2', pattern, s,
|
||||
outcome, maxsplit, fields, i,
|
||||
fields[i],'(',len(fields[i]),')', ' | ',
|
||||
fldlst[i],'(',len(fldlst[i]),')')
|
||||
else:
|
||||
print('=== Not coherent 2')
|
||||
RAISE()
|
||||
else:
|
||||
print ('=== Failed incorrectly', pattern, s,
|
||||
outcome, pos, fields)
|
||||
|
||||
def test_mat_obj_groups(verbose = None):
|
||||
"""
|
||||
test re.search(), and matobj.groups()
|
||||
'verbose' is for debugging, when 'verbose' is true, print extra info
|
||||
"""
|
||||
regex_tests = testsuite.matobj_groups_regex_tests
|
||||
for t in regex_tests:
|
||||
pattern, s, outcome, fields, grpidx, start, end = t
|
||||
try:
|
||||
matobj=re.search(pattern, s)
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
continue
|
||||
else:
|
||||
print('=== Unexpected exception 1:', pattern, s,
|
||||
outcome,fields)
|
||||
|
||||
try:
|
||||
if outcome==SUCCEED: assert(matobj != None)
|
||||
fldlst = matobj.groups()
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
continue
|
||||
else:
|
||||
print('=== Unexpected exception 2:', pattern, s,
|
||||
outcome,fields)
|
||||
|
||||
if outcome==FAIL:
|
||||
pass # No match, as expected
|
||||
elif outcome==SUCCEED:
|
||||
if fldlst and fields:
|
||||
# Matched, as expected, so now we compute the
|
||||
# result string and compare it to our expected result.
|
||||
if verbose:
|
||||
fldstr = fieldstr = ""
|
||||
for item in fldlst:
|
||||
fldstr = fldstr + str(item) + " | "
|
||||
for item in fields:
|
||||
fieldstr = fieldstr + str(item) + " | "
|
||||
print(fldstr, "~~~", fieldstr)
|
||||
|
||||
if len(fields) != len(fldlst):
|
||||
print('=== Not coherent 2')
|
||||
RAISE()
|
||||
|
||||
for i in range(len(fields)):
|
||||
if fields[i] != fldlst[i]:
|
||||
if verbose:
|
||||
print('=== Not coherent', pattern, s,
|
||||
outcome,fields, i,
|
||||
fields[i],'(',len(fields[i]),')', ' | ',
|
||||
fldlst[i],'(',len(fldlst[i]),')')
|
||||
else:
|
||||
print('=== Not coherent')
|
||||
RAISE()
|
||||
elif not len(fldlst) and not len(fields):
|
||||
# output is empty, as expected
|
||||
if verbose:
|
||||
print("output is empty, as expected")
|
||||
continue
|
||||
else:
|
||||
if verbose:
|
||||
for item in fldlst:
|
||||
print(item,)
|
||||
print()
|
||||
for item in fields:
|
||||
print(item,)
|
||||
print()
|
||||
print ('=== Failed incorrectly', pattern, s,
|
||||
outcome,fields,fldlst)
|
||||
|
||||
def test_mat_obj_start(verbose = None):
|
||||
"""
|
||||
test re.search(), and matobj.start()
|
||||
'verbose' is for debugging, when 'verbose' is true, print extra info
|
||||
"""
|
||||
regex_tests = testsuite.matobj_groups_regex_tests
|
||||
for t in regex_tests:
|
||||
pattern, s, outcome, fields, grpidx, start, end = t
|
||||
try:
|
||||
matobj=re.search(pattern, s)
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
continue
|
||||
else:
|
||||
print('=== Unexpected exception 1:', pattern, s,
|
||||
outcome,fields)
|
||||
|
||||
try:
|
||||
if outcome==SUCCEED: assert(matobj != None)
|
||||
fldlst = matobj.groups()
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
continue
|
||||
else:
|
||||
print('=== Unexpected exception 2:', pattern, s,
|
||||
outcome,fields)
|
||||
|
||||
if outcome==FAIL:
|
||||
pass # No match, as expected
|
||||
elif outcome==SUCCEED:
|
||||
if grpidx > 0:
|
||||
if matobj.start(grpidx) == start:
|
||||
pass
|
||||
else:
|
||||
if verbose:
|
||||
print ('=== Failed incorrectly', pattern, s,
|
||||
outcome,fields,fldlst)
|
||||
raise("testing failed")
|
||||
|
||||
|
||||
def test_mat_obj_end(verbose = None):
|
||||
"""
|
||||
test re.search(), and matobj.end()
|
||||
'verbose' is for debugging, when 'verbose' is true, print extra info
|
||||
"""
|
||||
regex_tests = testsuite.matobj_groups_regex_tests
|
||||
for t in regex_tests:
|
||||
pattern, s, outcome, fields, grpidx, start, end = t
|
||||
try:
|
||||
matobj=re.search(pattern, s)
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
continue
|
||||
else:
|
||||
print('=== Unexpected exception 1:', pattern, s,
|
||||
outcome,fields)
|
||||
|
||||
try:
|
||||
if outcome==SUCCEED: assert(matobj != None)
|
||||
fldlst = matobj.groups()
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
continue
|
||||
else:
|
||||
print('=== Unexpected exception 2:', pattern, s,
|
||||
outcome,fields)
|
||||
|
||||
if outcome==FAIL:
|
||||
pass # No match, as expected
|
||||
elif outcome==SUCCEED:
|
||||
if grpidx > 0:
|
||||
if matobj.end(grpidx) == end:
|
||||
pass
|
||||
else:
|
||||
if verbose:
|
||||
print ('=== Failed incorrectly', pattern, s,
|
||||
outcome,fields,fldlst, matobj.end(grpidx), end)
|
||||
raise("testing failed")
|
||||
|
||||
def test_mat_obj_span(verbose = None):
|
||||
"""
|
||||
test re.search(), and matobj.span()
|
||||
'verbose' is for debugging, when 'verbose' is true, print extra info
|
||||
"""
|
||||
regex_tests = testsuite.matobj_groups_regex_tests
|
||||
for t in regex_tests:
|
||||
pattern, s, outcome, fields, grpidx, start, end = t
|
||||
try:
|
||||
matobj=re.search(pattern, s)
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
continue
|
||||
else:
|
||||
print('=== Unexpected exception 1:', pattern, s,
|
||||
outcome,fields)
|
||||
|
||||
try:
|
||||
if outcome==SUCCEED: assert(matobj != None)
|
||||
fldlst = matobj.groups()
|
||||
except:
|
||||
if outcome==SYNTAX_ERROR:
|
||||
# This should have been a syntax error; forget it.
|
||||
continue
|
||||
else:
|
||||
print('=== Unexpected exception 2:', pattern, s,
|
||||
outcome,fields)
|
||||
|
||||
if outcome==FAIL:
|
||||
pass # No match, as expected
|
||||
elif outcome==SUCCEED:
|
||||
if (grpidx > 0):
|
||||
spstart, spend = matobj.span(grpidx)
|
||||
if spstart == start and spend == end:
|
||||
pass
|
||||
else:
|
||||
if verbose:
|
||||
print ('=== Failed incorrectly', pattern, s,
|
||||
outcome,fields,fldlst)
|
||||
raise("testing failed")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
367
programs/develop/tinypy/modules/re/testsuite.py
Normal file
367
programs/develop/tinypy/modules/re/testsuite.py
Normal file
@ -0,0 +1,367 @@
|
||||
# Test suite (for verifying correctness)
|
||||
#
|
||||
# The test suite is a list of 5- or 3-tuples. The 5 parts of a
|
||||
# complete tuple are:
|
||||
# element 0: a string containing the pattern
|
||||
# 1: the string to match against the pattern
|
||||
# 2: the expected result (0 - SUCCEED, 1 - FAIL, 2 - SYNTAX_ERROR)
|
||||
# 3: a string that will be eval()'ed to produce a test string.
|
||||
# This is an arbitrary Python expression; the available
|
||||
# variables are "found" (the whole match), and "g1", "g2", ...
|
||||
# up to "g10" contain the contents of each group, or the
|
||||
# string 'None' if the group wasn't given a value.
|
||||
# 4: The expected result of evaluating the expression.
|
||||
# If the two don't match, an error is reported.
|
||||
#
|
||||
# If the regex isn't expected to work, the latter two elements can be omitted.
|
||||
|
||||
# test suite for search
|
||||
search_regex_tests=[
|
||||
['abc', 'abc', 0, 'found', 'abc'],
|
||||
['abc', 'xbc', 1],
|
||||
['abc', 'axc', 1],
|
||||
['abc', 'abx', 1],
|
||||
['abc', 'xabcy', 0, 'found', 'abc'],
|
||||
['abc', 'ababc', 0, 'found', 'abc'],
|
||||
['ab*c', 'abc', 0, 'found', 'abc'],
|
||||
['ab*bc', 'abc', 0, 'found', 'abc'],
|
||||
['ab*bc', 'abbc', 0, 'found', 'abbc'],
|
||||
['ab*bc', 'abbbbc', 0, 'found', 'abbbbc'],
|
||||
['ab+bc', 'abbc', 0, 'found', 'abbc'],
|
||||
['ab+bc', 'abc', 1],
|
||||
['ab+bc', 'abq', 1],
|
||||
['ab+bc', 'abbbbc', 0, 'found', 'abbbbc'],
|
||||
['ab?bc', 'abbc', 0, 'found', 'abbc'],
|
||||
['ab?bc', 'abc', 0, 'found', 'abc'],
|
||||
['ab?bc', 'abbbbc', 1],
|
||||
['ab?c', 'abc', 0, 'found', 'abc'],
|
||||
['^abc$', 'abc', 0, 'found', 'abc'],
|
||||
['^abc$', 'abcc', 1],
|
||||
['^abc', 'abcc', 0, 'found', 'abc'],
|
||||
['^abc$', 'aabc', 1],
|
||||
['abc$', 'aabc', 0, 'found', 'abc'],
|
||||
['^', 'abc', 0, 'found+"-"', '-'],
|
||||
['$', 'abc', 0, 'found+"-"', '-'],
|
||||
['a.c', 'abc', 0, 'found', 'abc'],
|
||||
['a.c', 'axc', 0, 'found', 'axc'],
|
||||
['a.*c', 'axyzc', 0, 'found', 'axyzc'],
|
||||
['a.*c', 'axyzd', 1],
|
||||
['a[bc]d', 'abc', 1],
|
||||
['a[bc]d', 'abd', 0, 'found', 'abd'],
|
||||
['a[b-d]e', 'abd', 1],
|
||||
['a[b-d]e', 'ace', 0, 'found', 'ace'],
|
||||
['a[b-d]', 'aac', 0, 'found', 'ac'],
|
||||
['a[-b]', 'a-', 0, 'found', 'a-'],
|
||||
['a[b-]', 'a-', 0, 'found', 'a-'],
|
||||
['a[]b', '-', 2],
|
||||
['a[', '-', 2],
|
||||
['a\\', '-', 2],
|
||||
['abc\\)', '-', 2],
|
||||
['\\(abc', '-', 2],
|
||||
['a]', 'a]', 0, 'found', 'a]'],
|
||||
['a[]]b', 'a]b', 0, 'found', 'a]b'],
|
||||
['a[^bc]d', 'aed', 0, 'found', 'aed'],
|
||||
['a[^bc]d', 'abd', 1],
|
||||
['a[^-b]c', 'adc', 0, 'found', 'adc'],
|
||||
['a[^-b]c', 'a-c', 1],
|
||||
['a[^]b]c', 'a]c', 1],
|
||||
['a[^]b]c', 'adc', 0, 'found', 'adc'],
|
||||
['\\ba\\b', 'a-', 0, '"-"', '-'],
|
||||
['\\ba\\b', '-a', 0, '"-"', '-'],
|
||||
['\\ba\\b', '-a-', 0, '"-"', '-'],
|
||||
['\\by\\b', 'xy', 1],
|
||||
['\\by\\b', 'yz', 1],
|
||||
['\\by\\b', 'xyz', 1],
|
||||
['ab\\|cd', 'abc', 0, 'found', 'ab'],
|
||||
['ab\\|cd', 'abcd', 0, 'found', 'ab'],
|
||||
['\\(\\)ef', 'def', 0, 'found+"-"+g1', 'ef-'],
|
||||
['$b', 'b', 1],
|
||||
['a(b', 'a(b', 0, 'found+"-"+g1', 'a(b-None'],
|
||||
['a(*b', 'ab', 0, 'found', 'ab'],
|
||||
['a(*b', 'a((b', 0, 'found', 'a((b'],
|
||||
['a\\\\b', 'a\\b', 0, 'found', 'a\\b'],
|
||||
['\\(\\(a\\)\\)', 'abc', 0, 'found+"-"+g1+"-"+g2', 'a-a-a'],
|
||||
['\\(a\\)b\\(c\\)', 'abc', 0, 'found+"-"+g1+"-"+g2', 'abc-a-c'],
|
||||
['a+b+c', 'aabbabc', 0, 'found', 'abc'],
|
||||
['\\(a+\\|b\\)*', 'ab', 0, 'found+"-"+g1', 'ab-b'],
|
||||
['\\(a+\\|b\\)+', 'ab', 0, 'found+"-"+g1', 'ab-b'],
|
||||
['\\(a+\\|b\\)?', 'ab', 0, 'found+"-"+g1', 'a-a'],
|
||||
['\\)\\(', '-', 2],
|
||||
['[^ab]*', 'cde', 0, 'found', 'cde'],
|
||||
['abc', '', 1],
|
||||
['a*', '', 0, 'found', ''],
|
||||
['a\\|b\\|c\\|d\\|e', 'e', 0, 'found', 'e'],
|
||||
['\\(a\\|b\\|c\\|d\\|e\\)f', 'ef', 0, 'found+"-"+g1', 'ef-e'],
|
||||
['abcd*efg', 'abcdefg', 0, 'found', 'abcdefg'],
|
||||
['ab*', 'xabyabbbz', 0, 'found', 'ab'],
|
||||
['ab*', 'xayabbbz', 0, 'found', 'a'],
|
||||
['\\(ab\\|cd\\)e', 'abcde', 0, 'found+"-"+g1', 'cde-cd'],
|
||||
['[abhgefdc]ij', 'hij', 0, 'found', 'hij'],
|
||||
['^\\(ab\\|cd\\)e', 'abcde', 1, 'xg1y', 'xy'],
|
||||
['\\(abc\\|\\)ef', 'abcdef', 0, 'found+"-"+g1', 'ef-'],
|
||||
['\\(a\\|b\\)c*d', 'abcd', 0, 'found+"-"+g1', 'bcd-b'],
|
||||
['\\(ab\\|ab*\\)bc', 'abc', 0, 'found+"-"+g1', 'abc-a'],
|
||||
['a\\([bc]*\\)c*', 'abc', 0, 'found+"-"+g1', 'abc-bc'],
|
||||
['a\\([bc]*\\)\\(c*d\\)', 'abcd', 0, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'],
|
||||
['a\\([bc]+\\)\\(c*d\\)', 'abcd', 0, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'],
|
||||
['a\\([bc]*\\)\\(c+d\\)', 'abcd', 0, 'found+"-"+g1+"-"+g2', 'abcd-b-cd'],
|
||||
['a[bcd]*dcdcde', 'adcdcde', 0, 'found', 'adcdcde'],
|
||||
['a[bcd]+dcdcde', 'adcdcde', 1],
|
||||
['\\(ab\\|a\\)b*c', 'abc', 0, 'found+"-"+g1', 'abc-ab'],
|
||||
['\\(\\(a\\)\\(b\\)c\\)\\(d\\)', 'abcd', 0, 'g1+"-"+g2+"-"+g3+"-"+g4', 'abc-a-b-d'],
|
||||
['[a-zA-Z_][a-zA-Z0-9_]*', 'alpha', 0, 'found', 'alpha'],
|
||||
['^a\\(bc+\\|b[eh]\\)g\\|.h$', 'abh', 0, 'found+"-"+g1', 'bh-None'],
|
||||
['\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'effgz', 0, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'],
|
||||
['\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'ij', 0, 'found+"-"+g1+"-"+g2', 'ij-ij-j'],
|
||||
['\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'effg', 1],
|
||||
['\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'bcdd', 1],
|
||||
['\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'reffgz', 0, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'],
|
||||
['\\(\\(\\(\\(\\(\\(\\(\\(\\(a\\)\\)\\)\\)\\)\\)\\)\\)\\)', 'a', 0, 'found', 'a'],
|
||||
['multiple words of text', 'uh-uh', 1],
|
||||
['multiple words', 'multiple words, yeah', 0, 'found', 'multiple words'],
|
||||
['\\(.*\\)c\\(.*\\)', 'abcde', 0, 'found+"-"+g1+"-"+g2', 'abcde-ab-de'],
|
||||
['(\\(.*\\), \\(.*\\))', '(a, b)', 0, 'g2+"-"+g1', 'b-a'],
|
||||
['[k]', 'ab', 1],
|
||||
['a[-]?c', 'ac', 0, 'found', 'ac'],
|
||||
['\\(abc\\)\\1', 'abcabc', 0, 'g1', 'abc'],
|
||||
['\\([a-c]*\\)\\1', 'abcabc', 0, 'g1', 'abc'],
|
||||
['^\\(.+\\)?B', 'AB', 0, 'g1', 'A'],
|
||||
['\\(a+\\).\\1$', 'aaaaa', 0, 'found+"-"+g1', 'aaaaa-aa'],
|
||||
['^\\(a+\\).\\1$', 'aaaa', 1],
|
||||
['\\(abc\\)\\1', 'abcabc', 0, 'found+"-"+g1', 'abcabc-abc'],
|
||||
['\\([a-c]+\\)\\1', 'abcabc', 0, 'found+"-"+g1', 'abcabc-abc'],
|
||||
['\\(a\\)\\1', 'aa', 0, 'found+"-"+g1', 'aa-a'],
|
||||
['\\(a+\\)\\1', 'aa', 0, 'found+"-"+g1', 'aa-a'],
|
||||
['\\(a+\\)+\\1', 'aa', 0, 'found+"-"+g1', 'aa-a'],
|
||||
['\\(a\\).+\\1', 'aba', 0, 'found+"-"+g1', 'aba-a'],
|
||||
['\\(a\\)ba*\\1', 'aba', 0, 'found+"-"+g1', 'aba-a'],
|
||||
['\\(aa\\|a\\)a\\1$', 'aaa', 0, 'found+"-"+g1', 'aaa-a'],
|
||||
['\\(a\\|aa\\)a\\1$', 'aaa', 0, 'found+"-"+g1', 'aaa-a'],
|
||||
['\\(a+\\)a\\1$', 'aaa', 0, 'found+"-"+g1', 'aaa-a'],
|
||||
['\\([abc]*\\)\\1', 'abcabc', 0, 'found+"-"+g1', 'abcabc-abc'],
|
||||
['\\(a\\)\\(b\\)c\\|ab', 'ab', 0, 'found+"-"+g1+"-"+g2', 'ab-None-None'],
|
||||
['\\(a\\)+x', 'aaax', 0, 'found+"-"+g1', 'aaax-a'],
|
||||
['\\([ac]\\)+x', 'aacx', 0, 'found+"-"+g1', 'aacx-c'],
|
||||
['\\([^/]*/\\)*sub1/', 'd:msgs/tdir/sub1/trial/away.cpp', 0, 'found+"-"+g1', 'd:msgs/tdir/sub1/-tdir/'],
|
||||
['\\([^.]*\\)\\.\\([^:]*\\):[T ]+\\(.*\\)', 'track1.title:TBlah blah blah', 0, 'found+"-"+g1+"-"+g2+"-"+g3', 'track1.title:TBlah blah blah-track1-title-Blah blah blah'],
|
||||
['\\([^N]*N\\)+', 'abNNxyzN', 0, 'found+"-"+g1', 'abNNxyzN-xyzN'],
|
||||
['\\([^N]*N\\)+', 'abNNxyz', 0, 'found+"-"+g1', 'abNN-N'],
|
||||
['\\([abc]*\\)x', 'abcx', 0, 'found+"-"+g1', 'abcx-abc'],
|
||||
['\\([abc]*\\)x', 'abc', 1],
|
||||
['\\([xyz]*\\)x', 'abcx', 0, 'found+"-"+g1', 'x-'],
|
||||
['\\(a\\)+b\\|aac', 'aac', 0, 'found+"-"+g1', 'aac-None'],
|
||||
['\\<a', 'a', 0, 'found', 'a'],
|
||||
['\\<a', '!', 1],
|
||||
['a\\<b', 'ab', 1],
|
||||
['a\\>', 'ab', 1],
|
||||
['a\\>', 'a!', 0, 'found', 'a'],
|
||||
['a\\>', 'a', 0, 'found', 'a'],
|
||||
]
|
||||
|
||||
|
||||
# test suite for match
|
||||
match_regex_tests=[
|
||||
['abc', 'abc', 0, 'found', 'abc'],
|
||||
['abc', 'xbc', 1],
|
||||
['abc', 'axc', 1],
|
||||
['abc', 'abx', 1],
|
||||
['abc', 'xabcy', 1],
|
||||
['abc', 'ababc', 1],
|
||||
['ab*c', 'abc', 0, 'found', 'abc'],
|
||||
['ab*bc', 'abc', 0, 'found', 'abc'],
|
||||
['ab*bc', 'abbc', 0, 'found', 'abbc'],
|
||||
['ab*bc', 'abbbbc', 0, 'found', 'abbbbc'],
|
||||
['ab+bc', 'abbc', 0, 'found', 'abbc'],
|
||||
['ab+bc', 'abc', 1],
|
||||
['ab+bc', 'abq', 1],
|
||||
['ab+bc', 'abbbbc', 0, 'found', 'abbbbc'],
|
||||
['ab?bc', 'abbc', 0, 'found', 'abbc'],
|
||||
['ab?bc', 'abc', 0, 'found', 'abc'],
|
||||
['ab?bc', 'abbbbc', 1],
|
||||
['ab?c', 'abc', 0, 'found', 'abc'],
|
||||
['^abc$', 'abc', 0, 'found', 'abc'],
|
||||
['^abc$', 'abcc', 1],
|
||||
['^abc', 'abcc', 0, 'found', 'abc'],
|
||||
['^abc$', 'aabc', 1],
|
||||
['abc$', 'aabc', 1],
|
||||
['^', 'abc', 0, 'found+"-"', '-'],
|
||||
['$', 'abc', 1],
|
||||
['a.c', 'abc', 0, 'found', 'abc'],
|
||||
['a.c', 'axc', 0, 'found', 'axc'],
|
||||
['a.*c', 'axyzc', 0, 'found', 'axyzc'],
|
||||
['a.*c', 'axyzd', 1],
|
||||
['a[bc]d', 'abc', 1],
|
||||
['a[bc]d', 'abd', 0, 'found', 'abd'],
|
||||
['a[b-d]e', 'abd', 1],
|
||||
['a[b-d]e', 'ace', 0, 'found', 'ace'],
|
||||
['a[b-d]', 'aac', 1],
|
||||
['a[-b]', 'a-', 0, 'found', 'a-'],
|
||||
['a[b-]', 'a-', 0, 'found', 'a-'],
|
||||
['a[]b', '-', 2],
|
||||
['a[', '-', 2],
|
||||
['a\\', '-', 2],
|
||||
['abc\\)', '-', 2],
|
||||
['\\(abc', '-', 2],
|
||||
['a]', 'a]', 0, 'found', 'a]'],
|
||||
['a[]]b', 'a]b', 0, 'found', 'a]b'],
|
||||
['a[^bc]d', 'aed', 0, 'found', 'aed'],
|
||||
['a[^bc]d', 'abd', 1],
|
||||
['a[^-b]c', 'adc', 0, 'found', 'adc'],
|
||||
['a[^-b]c', 'a-c', 1],
|
||||
['a[^]b]c', 'a]c', 1],
|
||||
['a[^]b]c', 'adc', 0, 'found', 'adc'],
|
||||
['\\ba\\b', 'a-', 0, '"-"', '-'],
|
||||
['\\ba\\b', '-a', 1],
|
||||
['\\ba\\b', '-a-', 1],
|
||||
['\\by\\b', 'xy', 1],
|
||||
['\\by\\b', 'yz', 1],
|
||||
['\\by\\b', 'xyz', 1],
|
||||
['ab\\|cd', 'abc', 0, 'found', 'ab'],
|
||||
['ab\\|cd', 'abcd', 0, 'found', 'ab'],
|
||||
['\\(\\)ef', 'def', 1],
|
||||
['$b', 'b', 1],
|
||||
['a(b', 'a(b', 0, 'found+"-"+g1', 'a(b-None'],
|
||||
['a(*b', 'ab', 0, 'found', 'ab'],
|
||||
['a(*b', 'a((b', 0, 'found', 'a((b'],
|
||||
['a\\\\b', 'a\\b', 0, 'found', 'a\\b'],
|
||||
['\\(\\(a\\)\\)', 'abc', 0, 'found+"-"+g1+"-"+g2', 'a-a-a'],
|
||||
['\\(a\\)b\\(c\\)', 'abc', 0, 'found+"-"+g1+"-"+g2', 'abc-a-c'],
|
||||
['a+b+c', 'aabbabc', 1],
|
||||
['\\(a+\\|b\\)*', 'ab', 0, 'found+"-"+g1', 'ab-b'],
|
||||
['\\(a+\\|b\\)+', 'ab', 0, 'found+"-"+g1', 'ab-b'],
|
||||
['\\(a+\\|b\\)?', 'ab', 0, 'found+"-"+g1', 'a-a'],
|
||||
['\\)\\(', '-', 2],
|
||||
['[^ab]*', 'cde', 0, 'found', 'cde'],
|
||||
['abc', '', 1],
|
||||
['a*', '', 0, 'found', ''],
|
||||
['a\\|b\\|c\\|d\\|e', 'e', 0, 'found', 'e'],
|
||||
['\\(a\\|b\\|c\\|d\\|e\\)f', 'ef', 0, 'found+"-"+g1', 'ef-e'],
|
||||
['abcd*efg', 'abcdefg', 0, 'found', 'abcdefg'],
|
||||
['ab*', 'xabyabbbz', 1],
|
||||
['ab*', 'xayabbbz', 1],
|
||||
['\\(ab\\|cd\\)e', 'abcde', 1],
|
||||
['[abhgefdc]ij', 'hij', 0, 'found', 'hij'],
|
||||
['^\\(ab\\|cd\\)e', 'abcde', 1, 'xg1y', 'xy'],
|
||||
['\\(abc\\|\\)ef', 'abcdef', 1],
|
||||
['\\(a\\|b\\)c*d', 'abcd', 1],
|
||||
['\\(ab\\|ab*\\)bc', 'abc', 0, 'found+"-"+g1', 'abc-a'],
|
||||
['a\\([bc]*\\)c*', 'abc', 0, 'found+"-"+g1', 'abc-bc'],
|
||||
['a\\([bc]*\\)\\(c*d\\)', 'abcd', 0, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'],
|
||||
['a\\([bc]+\\)\\(c*d\\)', 'abcd', 0, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'],
|
||||
['a\\([bc]*\\)\\(c+d\\)', 'abcd', 0, 'found+"-"+g1+"-"+g2', 'abcd-b-cd'],
|
||||
['a[bcd]*dcdcde', 'adcdcde', 0, 'found', 'adcdcde'],
|
||||
['a[bcd]+dcdcde', 'adcdcde', 1],
|
||||
['\\(ab\\|a\\)b*c', 'abc', 0, 'found+"-"+g1', 'abc-ab'],
|
||||
['\\(\\(a\\)\\(b\\)c\\)\\(d\\)', 'abcd', 0, 'g1+"-"+g2+"-"+g3+"-"+g4', 'abc-a-b-d'],
|
||||
['[a-zA-Z_][a-zA-Z0-9_]*', 'alpha', 0, 'found', 'alpha'],
|
||||
['^a\\(bc+\\|b[eh]\\)g\\|.h$', 'abh', 1],
|
||||
['\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'effgz', 0, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'],
|
||||
['\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'ij', 0, 'found+"-"+g1+"-"+g2', 'ij-ij-j'],
|
||||
['\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'effg', 1],
|
||||
['\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'bcdd', 1],
|
||||
['\\(bc+d$\\|ef*g.\\|h?i\\(j\\|k\\)\\)', 'reffgz', 1],
|
||||
['\\(\\(\\(\\(\\(\\(\\(\\(\\(a\\)\\)\\)\\)\\)\\)\\)\\)\\)', 'a', 0, 'found', 'a'],
|
||||
['multiple words of text', 'uh-uh', 1],
|
||||
['multiple words', 'multiple words, yeah', 0, 'found', 'multiple words'],
|
||||
['\\(.*\\)c\\(.*\\)', 'abcde', 0, 'found+"-"+g1+"-"+g2', 'abcde-ab-de'],
|
||||
['(\\(.*\\), \\(.*\\))', '(a, b)', 0, 'g2+"-"+g1', 'b-a'],
|
||||
['[k]', 'ab', 1],
|
||||
['a[-]?c', 'ac', 0, 'found', 'ac'],
|
||||
['\\(abc\\)\\1', 'abcabc', 0, 'g1', 'abc'],
|
||||
['\\([a-c]*\\)\\1', 'abcabc', 0, 'g1', 'abc'],
|
||||
['^\\(.+\\)?B', 'AB', 0, 'g1', 'A'],
|
||||
['\\(a+\\).\\1$', 'aaaaa', 0, 'found+"-"+g1', 'aaaaa-aa'],
|
||||
['^\\(a+\\).\\1$', 'aaaa', 1],
|
||||
['\\(abc\\)\\1', 'abcabc', 0, 'found+"-"+g1', 'abcabc-abc'],
|
||||
['\\([a-c]+\\)\\1', 'abcabc', 0, 'found+"-"+g1', 'abcabc-abc'],
|
||||
['\\(a\\)\\1', 'aa', 0, 'found+"-"+g1', 'aa-a'],
|
||||
['\\(a+\\)\\1', 'aa', 0, 'found+"-"+g1', 'aa-a'],
|
||||
['\\(a+\\)+\\1', 'aa', 0, 'found+"-"+g1', 'aa-a'],
|
||||
['\\(a\\).+\\1', 'aba', 0, 'found+"-"+g1', 'aba-a'],
|
||||
['\\(a\\)ba*\\1', 'aba', 0, 'found+"-"+g1', 'aba-a'],
|
||||
['\\(aa\\|a\\)a\\1$', 'aaa', 0, 'found+"-"+g1', 'aaa-a'],
|
||||
['\\(a\\|aa\\)a\\1$', 'aaa', 0, 'found+"-"+g1', 'aaa-a'],
|
||||
['\\(a+\\)a\\1$', 'aaa', 0, 'found+"-"+g1', 'aaa-a'],
|
||||
['\\([abc]*\\)\\1', 'abcabc', 0, 'found+"-"+g1', 'abcabc-abc'],
|
||||
['\\(a\\)\\(b\\)c\\|ab', 'ab', 0, 'found+"-"+g1+"-"+g2', 'ab-None-None'],
|
||||
['\\(a\\)+x', 'aaax', 0, 'found+"-"+g1', 'aaax-a'],
|
||||
['\\([ac]\\)+x', 'aacx', 0, 'found+"-"+g1', 'aacx-c'],
|
||||
['\\([^/]*/\\)*sub1/', 'd:msgs/tdir/sub1/trial/away.cpp', 0, 'found+"-"+g1', 'd:msgs/tdir/sub1/-tdir/'],
|
||||
['\\([^.]*\\)\\.\\([^:]*\\):[T ]+\\(.*\\)', 'track1.title:TBlah blah blah', 0, 'found+"-"+g1+"-"+g2+"-"+g3', 'track1.title:TBlah blah blah-track1-title-Blah blah blah'],
|
||||
['\\([^N]*N\\)+', 'abNNxyzN', 0, 'found+"-"+g1', 'abNNxyzN-xyzN'],
|
||||
['\\([^N]*N\\)+', 'abNNxyz', 0, 'found+"-"+g1', 'abNN-N'],
|
||||
['\\([abc]*\\)x', 'abcx', 0, 'found+"-"+g1', 'abcx-abc'],
|
||||
['\\([abc]*\\)x', 'abc', 1],
|
||||
['\\([xyz]*\\)x', 'abcx', 1],
|
||||
['\\(a\\)+b\\|aac', 'aac', 0, 'found+"-"+g1', 'aac-None'],
|
||||
['\\<a', 'a', 0, 'found', 'a'],
|
||||
['\\<a', '!', 1],
|
||||
['a\\<b', 'ab', 1],
|
||||
['a\\>', 'ab', 1],
|
||||
['a\\>', 'a!', 0, 'found', 'a'],
|
||||
['a\\>', 'a', 0, 'found', 'a'],
|
||||
]
|
||||
|
||||
# test suite for split()
|
||||
# element 0: pattern
|
||||
# 1: string to split
|
||||
# 3: compile result
|
||||
# 4: maxsplit
|
||||
# 5: splitted fields list
|
||||
split_regex_tests = [
|
||||
["[ |,]", "with you, nothing, and me", 0, 0, ["with","you","nothing","and","me"]],
|
||||
["[ |,]", "with you, nothing, and me", 0, 1, ["with", "you, nothing, and me"]],
|
||||
["\\ ", "send email to apply", 0, 0, ["send", "email", "to", "apply"]],
|
||||
["\\ ", "send email to apply", 0, 2, ["send", "email", "to apply"]],
|
||||
["[+ | -]", "+86-028-83201034", 0, 0, ["86", "028", "83201034"]],
|
||||
["[+ | -]", "+86-028-83201034", 0, 1, ["86", "028-83201034"]],
|
||||
["[*|#]", "slide show", 0, 0, ["slide show"]],
|
||||
["(", "whats ever", 0, 1, ["whats ever"]],
|
||||
["@#!~$%^&*()<>\n", "who knows", 0, 1, ["who knows"]],
|
||||
]
|
||||
|
||||
# test suite for findall()
|
||||
# element 0: pattern
|
||||
# 1: string to match
|
||||
# 3: compile result
|
||||
# 4: starting position
|
||||
# 5: grouped fields list
|
||||
|
||||
# reobj.find()
|
||||
findall_regex_tests = [
|
||||
["\\ ", "send email to apply", 0, 0, [" ", " ", " "]],
|
||||
["\\ ", "send email to apply", 0, 5, [" ", " "]],
|
||||
["[+ | -]", "+86-028-83201034", 0, 0, ["+", "-", "-"]],
|
||||
["[+ | -]", "+86-028-83201034", 0, 1, ["-", "-"]],
|
||||
["sl.*e\\|#", "slide show at Room #3", 0, 0, ["slide", "#"]],
|
||||
["w.+s\\|e.*r", "whats ever", 0, 0, ["whats", "ever"]],
|
||||
["Euler\\|Gauss", "Both Euler and Gauss are great mathematicians", 0, 0, ["Euler", "Gauss"]],
|
||||
]
|
||||
|
||||
# module re.findall()
|
||||
mod_findall_regex_tests = [
|
||||
["\\ ", "send email to apply", 0, 0, [" ", " ", " "]],
|
||||
["\\ ", "send email to apply", 0, 0, [" ", " ", " "]],
|
||||
["[+ | -]", "+86-028-83201034", 0, 0, ["+", "-", "-"]],
|
||||
["[+ | -]", "+86-028-83201034", 0, 0, ["+", "-", "-"]],
|
||||
["sl.*e\\|#", "slide show at Room #3", 0, 0, ["slide", "#"]],
|
||||
["w.+s\\|e.*r", "whats ever", 0, 0, ["whats", "ever"]],
|
||||
["Euler\\|Gauss", "Both Euler and Gauss are great mathematicians", 0, 0, ["Euler", "Gauss"]],
|
||||
]
|
||||
|
||||
# test for match object's groups() method
|
||||
# element 0: pattern
|
||||
# 1: string
|
||||
# 2: compile result
|
||||
# 3: matched fields, for groups()
|
||||
# 4: group index, valid when > 0, for start(), end(), and span()
|
||||
# 5: pattern's starting index in string, for start() and span()
|
||||
# 6: pattern's ending index in string, for end() and span
|
||||
matobj_groups_regex_tests = [
|
||||
["\\(abc\\(.*xyz\\)\\(.*31415926\\)\\)", "where is abc and flurry xyz, which is pi 31415926, derived from ms", 0, ["abc and flurry xyz, which is pi 31415926"," and flurry xyz",", which is pi 31415926"], 2, 12, 27],
|
||||
|
||||
["[a\\|b]\\(.+\\)shoe\\([t]+\\)d", "bbbshoetttdxrznmlkjp", 0, ["bb", "ttt"], 1, 1, 3],
|
||||
|
||||
["abcdef", "xyah2oewoyqe030uabcdefwhalsdewnkhgiohyczb", 0, [], -1, 0, 0],
|
||||
]
|
||||
|
||||
Loading…
Reference in New Issue
Block a user