def __runTest3(self, scale, setMin, setMax, useInt, stepInt):
if useInt:
step = random.randint(1,3)
else:
step = random.uniform(0.5, 1.5)
min = random.uniform(-1*(10**scale), 10**scale) if not useInt else random.randint(-1*(10**scale), 10**scale)
max = random.uniform(min, min + 5**scale) if not useInt else random.randint(min, min + 5**scale)
format = "%0.{0}lf".format(scale)
min = float(self.__sliceFloat(float(min), scale))
max = float(self.__sliceFloat(float(max), scale))
regexp = regexpgen.real(format, min if setMin else None, max if setMax else None)
info = lambda value: self.__getInfo(value, regexp, format, min if setMin else None, max if setMax else None)
(rangeLeft, rangeRight) = self.__getRanges(min, max)
i = rangeLeft
if setMin:
while float(self.__str(i)) < float(self.__str(min)) - step:
x = self.__sliceFloat(i, scale - 1 if scale > 1 else 0)
y = self.__sliceFloat(i, scale)
z = self.__sliceFloat(i, scale + 1)
if scale > 1:
self.assertFalse(re.match(regexp, self.__str(x)), info(self.__str(x)))
self.assertFalse(re.match(regexp, self.__str(y)), info(self.__str(y)))
self.assertFalse(re.match(regexp, self.__str(z)), info(self.__str(z)))
i = i + step
i = i + step
while float(self.__str(i)) <= float(self.__str(max)):
if i >= 0:
a = "0" + self.__str(i); b = "00" + self.__str(i); c = "000" + self.__str(i); d = "0000" + self.__str(i);
else:
a = "-0" + self.__str(-i); b = "-00" + self.__str(-i); c = "-000" + self.__str(-i); d = "-0000" + self.__str(-i);
x = self.__sliceFloat(i, scale - 1 if scale > 1 else 0)
y = self.__sliceFloat(i, scale)
z = self.__sliceFloat(i, scale + 1)
self.assertTrue(re.match(regexp, self.__str(y)), info(self.__str(y)))
self.assertFalse(re.match(regexp, self.__str(z)), info(self.__str(z)))
self.assertFalse(re.match(regexp, a), info(a))
self.assertFalse(re.match(regexp, b), info(b))
self.assertFalse(re.match(regexp, c), info(c))
self.assertFalse(re.match(regexp, d), info(d))
i = i + step
if setMax:
i = i + step
while i <= rangeRight:
x = self.__sliceFloat(i, scale - 1 if scale > 0 else 0)
y = self.__sliceFloat(i, scale)
z = self.__sliceFloat(i, scale + 1)
if scale > 1:
self.assertFalse(re.match(regexp, self.__str(x)), info(self.__str(x)))
self.assertFalse(re.match(regexp, self.__str(y)), info(self.__str(y)))
self.assertFalse(re.match(regexp, self.__str(z)), info(self.__str(z)))
i = i + step
def testPhase1Stage3(self):
# 20 March 2013: real %lf and %0lf
func = regexpgen.real
self.assertRaises(ValueError, func, "%lf", 'a', 'a')
self.assertRaises(ValueError, func, "%lf", 10, 10)
self.assertRaises(ValueError, func, None) # ISSUE 5
self.assertRaises(ValueError, func, None, None)
self.assertRaises(ValueError, func, None, None, None) # ISSUE 5
self.assertTrue (re.match(func("%lf", None), "10.01"))
self.assertTrue (re.match(func("%lf", None), "-10.01987"))
self.assertFalse(re.match(func("%lf", None), "10.0.0"))
self.assertTrue (re.match(func("%lf", None, 13.0), "12.999"))
self.assertTrue (re.match(func("%lf", None, 13.0), "13.000"))
self.assertFalse(re.match(func("%lf", None, 13.0), "13.001"))
self.assertTrue (re.match(func("%lf", 11.999), "11.9999"))
self.assertTrue (re.match(func("%lf", 11.999, None), "11.9999"))
self.assertTrue (re.match(func("%lf", 12.0, None), "12.000"))
self.assertTrue (re.match(func("%lf", 12.0, None), "12.001"))
self.assertTrue (re.match(func("%lf", None, None), "-0000.0001"))
self.assertTrue (re.match(func("%lf", -12.7, 23.5), "-0000.0001"))
self.assertTrue (re.match(func("%lf", -100.0, 100.0), "0.0"))
self.assertTrue (re.match(func("%lf", 0.0, 10.1), "0000.0000"))
self.assertTrue (re.match(func("%lf", -0.01, 1.5), "1.5")) # ISSUE 6
self.assertFalse(re.match(func("%lf", -0.01, 1.5), "1.51"))
self.assertTrue (re.match(func("%lf", -0.01, 1.512), "1.5"))
self.assertTrue (re.match(func("%lf", -0.01, 1.512), "1.512"))
self.assertFalse(re.match(func("%lf", -0.01, 1.512), "1.5121"))
self.assertTrue (re.match(func("%lf", -0.01, 1.50), "1.5"))
self.assertTrue (re.match(func("%lf", -102.0, 100.0), "100.0"))
self.assertFalse(re.match(func("%lf", 88.7653193745, 88.920716654), "88.0"))
self.assertTrue (re.match(func("%lf", 88.7653193745, 88.920716654), "88.9")) # ISSUE 14
self.assertTrue (re.match(func("%lf", 88.7653193745, 88.920716654), "88.92")) # ISSUE 14
self.assertTrue (re.match(func("%lf", 88.7653193745, 88.920716654), "88.920")) # ISSUE 14
self.assertTrue (re.match(func("%lf", 88.7653193745, 88.920716654), "88.9207")) # ISSUE 14
self.assertTrue (re.match(func("%lf", 88.7653193745, 88.920716654), "88.92071")) # ISSUE 14
self.assertTrue (re.match(func("%lf", 88.7653193745, 88.920716654), "88.920716")) # ISSUE 14
self.assertTrue (re.match(func("%lf", 88.7653193745, 88.920716654), "88.9207166")) # ISSUE 14
self.assertTrue (re.match(func("%lf", 88.7653193745, 88.920716654), "88.92071665")) # ISSUE 14
self.assertTrue (re.match(func("%lf", 88.7653193745, 88.920716654), "88.920716654"))
self.assertTrue (re.match(func("%lf", 88.7653193745, 88.920716654), "88.9207166540"))
self.assertTrue (re.match(func("%lf", 88.7653193745, 88.920716654), "88.92071665400"))
self.assertFalse(re.match(regexpgen.real("%0lf", 0.0, 10.11), "010.11"))
def __runTest2(self, scale, setMin, setMax, useInt, stepInt):
if useInt:
step = random.randint(1,3)
else:
step = random.uniform(0.5, 1.5)
min = random.uniform(-1*(10**scale), 10**scale) if not useInt else random.randint(-1*(10**scale), 10**scale)
max = random.uniform(min, min + 5**scale) if not useInt else random.randint(min, min + 5**scale)
min = float(min)
max = float(max)
format = "%0lf"
regexp = regexpgen.real(format, min if setMin else None, max if setMax else None)
info = lambda value: self.__getInfo(value, regexp, format, min if setMin else None, max if setMax else None)
(rangeLeft, rangeRight) = self.__getRanges(min, max)
i = rangeLeft
if setMin:
self.assertTrue(re.search(regexp, self.__str(min)), info(self.__str(min)))
while float(self.__str(i)) < float(self.__str(min)):
self.assertFalse(re.match(regexp, self.__str(i)), info(self.__str(i)))
i = i + step
while float(self.__str(i)) <= float(self.__str(max)):
if i >= 0:
a = "0" + self.__str(i); b = "00" + self.__str(i); c = "000" + self.__str(i); d = "0000" + self.__str(i);
else:
a = "-0" + self.__str(-i); b = "-00" + self.__str(-i); c = "-000" + self.__str(-i); d = "-0000" + self.__str(-i);
self.assertTrue(re.match(regexp, self.__str(i)), info(self.__str(i)))
self.assertFalse(re.match(regexp, a), info(a))
self.assertFalse(re.match(regexp, b), info(b))
self.assertFalse(re.match(regexp, c), info(c))
self.assertFalse(re.match(regexp, d), info(d))
i = i + step
if setMax:
self.assertTrue(re.search(regexp, self.__str(max)), info(self.__str(max)))
while i <= rangeRight:
self.assertFalse(re.search(regexp, self.__str(i)), info(self.__str(i)))
i = i + step
if setMax and float(max) > 0:
splitted = self.__str(max).split(".")
if len(splitted[1]) > 1:
test = splitted[0] + "." + splitted[1][:-1]
test = float(test)
self.assertTrue(re.match(regexp, self.__str(test)), info(self.__str(test)))
def testPhase2Stage2(self):
# move validation to RegexBuilder
from regexpgen.builder import RegexpBuilder
r = RegexpBuilder()
self.assertRaises(ValueError, r.createIntegerRegex, "%d", 'a', 'a')
self.assertRaises(ValueError, regexpgen.nnint, 1111) # ISSUE 12
self.assertRaises(ValueError, regexpgen.integer, 1111) # ISSUE 12
self.assertRaises(ValueError, regexpgen.real, 1111) # ISSUE 12
self.assertFalse(re.match(regexpgen.real("%lf"), "000-22.0")) # ISSUE 13
# 03 April 2013: real %X.Ylf
func = regexpgen.real
self.assertRaises(ValueError, func, "%2.2lf", 13, -13)
self.assertRaises(ValueError, func, "%2.2lf", None, -13)
self.assertRaises(ValueError, func, "%2.2lf", 13, None)
self.assertTrue (re.match(func("%2.2lf", 0.0, 10.11), "10.11"))
self.assertTrue (re.match(func("%2.2lf", 0.0, 10.11), "00010.11"))
self.assertFalse(re.match(func("%0lf", 0.0, 10.11), "00010.11"))
self.assertTrue (re.match(func("%0lf", 0.0, 10.11), "10.110"))
self.assertFalse(re.match(func("%0lf", 0.0, 10.11), "10.110001"))
'''
Created on Apr 27, 2011
@authors: Joanna Binczewska, Dawid Kowalski
'''
import regexpgen
print regexpgen.nnint("%04d", 71, 2319)
print regexpgen.integer("%0d", -521, 132)
print regexpgen.real("%lf", -12.7, 23.5)
print regexpgen.real("%lf", -100.0, 100.0)
print regexpgen.real("%lf", 0.0, 10.1)
print regexpgen.concatenate([
('int', "%d", 100, 105),
('\.',),
('int', "%d", 250, 255),
('\.',),
('int', "%d", 122, 122),
('\.',),
('int', "%d", 0, 240)
])
print regexpgen.time("%H:%M", "12:24", "17:59")
print regexpgen.date("%Y-%m-%d", "2013-03-15", "2013-04-24")
print regexpgen.date("%d/%m", "15/09")
def __testForBoundaryReal(self):
self.assertTrue(re.match(regexpgen.real("%03.1lf", 5.1, None), "8.9"))
self.assertTrue(re.match(regexpgen.real("%03.1lf", 5.1, None), "88.9"))
self.assertTrue(re.match(regexpgen.real("%03.1lf", -5.1, None), "-4.9"))
self.assertTrue(re.match(regexpgen.real("%03.1lf", -5.1, None), "55.9"))
self.assertFalse(re.match(regexpgen.real("%03.1lf", -5.1, None), "-55.1"))
self.assertTrue(re.match(regexpgen.real("%04.1lf", 5.9, None), "05.9"))
self.assertFalse(re.match(regexpgen.real("%05.1lf", 5.9, None), "05.9"))
self.assertTrue(re.match(regexpgen.real("%06.2lf", 5.9, None), "005.90"))
self.assertFalse(re.match(regexpgen.real("%04.2lf", 5.9, None), "3335.9"))
self.assertFalse(re.match(regexpgen.real("%05.1lf", -5.9, None), "-05.9"))
self.assertTrue(re.match(regexpgen.real("%06.2lf", -5.9, None), "-005.90"))
self.assertTrue(re.match(regexpgen.real("%03.1lf",None, 5.1), "4.9"))
self.assertTrue(re.match(regexpgen.real("%03.1lf",None, 5.1), "-88.9"))
self.assertTrue(re.match(regexpgen.real("%03.1lf",None, -5.1), "-5.9"))
self.assertTrue(re.match(regexpgen.real("%03.1lf",None, -5.1), "-55.9"))
self.assertFalse(re.match(regexpgen.real("%03.1lf",None, -5.1), "55.1"))
self.assertTrue(re.match(regexpgen.real("%04.1lf",None, 5.9), "05.9"))
self.assertFalse(re.match(regexpgen.real("%05.1lf",None, 5.9), "05.9"))
self.assertTrue(re.match(regexpgen.real("%06.2lf",None, 5.9), "005.90"))
self.assertFalse(re.match(regexpgen.real("%06.2lf",None, 5.9), "05.90"))
self.assertFalse(re.match(regexpgen.real("%04.2lf",None, 5.9), "3335.91"))
self.assertFalse(re.match(regexpgen.real("%05.1lf",None, -5.9), "-05.9"))
self.assertTrue(re.match(regexpgen.real("%06.2lf",None, -5.9), "-005.90"))
self.assertFalse(re.match(regexpgen.real("%03.1lf",None, -9.1), "99.1"))
self.assertTrue(re.match(regexpgen.real("%04.1lf",None, 9.9), "09.9"))
self.assertFalse(re.match(regexpgen.real("%05.1lf",None, 9.9), "09.9"))
self.assertTrue(re.match(regexpgen.real("%06.2lf",None, 9.9), "009.90"))
self.assertTrue(re.match(regexpgen.real("%03.1lf",3.1, 5.1), "4.9"))
self.assertTrue(re.match(regexpgen.real("%03.1lf",-7.3, 5.1), "-6.9"))
self.assertTrue(re.match(regexpgen.real("%03.1lf",-8.9, -5.1), "-5.9"))
self.assertFalse(re.match(regexpgen.real("%03.1lf",-5.1, -5.0), "55.1"))
self.assertTrue(re.match(regexpgen.real("%04.1lf",4.1, 5.9), "05.9"))
self.assertFalse(re.match(regexpgen.real("%05.1lf",1.0, 5.9), "05.9"))
self.assertTrue(re.match(regexpgen.real("%06.2lf",1.0, 5.9), "005.90"))
self.assertFalse(re.match(regexpgen.real("%06.2lf",1.2, 5.9), "05.90"))
self.assertFalse(re.match(regexpgen.real("%04.2lf",2.8, 5.9), "3335.91"))
self.assertFalse(re.match(regexpgen.real("%05.1lf",-22.8, -5.9), "-05.9"))
self.assertTrue(re.match(regexpgen.real("%06.2lf",-22.8, -5.9), "-005.90"))
self.assertFalse(re.match(regexpgen.real("%03.1lf",-9.3, -9.1), "99.1"))
self.assertTrue(re.match(regexpgen.real("%04.1lf",1.2, 9.9), "09.9"))
self.assertFalse(re.match(regexpgen.real("%05.1lf",1.2, 9.9), "09.9"))
self.assertTrue(re.match(regexpgen.real("%06.2lf",1.2, 9.9), "009.90"))
self.assertFalse(re.match(regexpgen.real("%06.4lf", 1.3399, 9.9434), "009.9044"))
self.assertTrue(re.match(regexpgen.real("%08.4lf", 1.3399, 9.9434), "009.9044"))
self.assertTrue(re.match(regexpgen.real("%03.1lf", None, -3.0), "-12.0"))
def __testForShorterReal(self):
x = regexpgen.real("%lf", 7.009, 7.698)
self.assertTrue(re.match(x, "7.69")) # powinno byc match
x = regexpgen.real("%lf", 7.09, 7.98)
self.assertTrue(re.match(x, "7.69")) # powinno byc match
x = regexpgen.real("%lf", None, 0.02)
self.assertFalse(re.match(x, "0.04")) # powinno byc None
x = regexpgen.real("%lf", -25.2691864655, -25.0697582645)
self.assertFalse(re.match(x, "-25.8042065349")) # powinno byc None
x = regexpgen.real("%lf", 6.063, 9.493)
self.assertTrue(re.match(x, "9.49")) # powinno byc match
x = regexpgen.real("%lf", 15.07, None)
self.assertTrue(re.match(x, "15.3")) # powinno byc match
x = regexpgen.real("%lf", None, 0.4)
self.assertFalse(re.match(x, "0.8")) # powinno byc None
x = regexpgen.real("%lf", None, 14.00)
self.assertTrue(re.match(x, "0.519")) # powinno byc match
x = regexpgen.real("%lf", 40.822, 46.202)
self.assertFalse(re.match(x, "46.21")) # powinno byc None
x = regexpgen.real("%lf", 0.97, 1.04)
self.assertFalse(re.match(x, "0.9")) # powinno byc None
x = regexpgen.real("%lf", None, 13.077)
self.assertFalse(re.match(x, "13.088")) # powinno byc None
x = regexpgen.real("%lf", None, 13.93)
self.assertTrue(re.match(x, "13.9")) # powinno byc match
x = regexpgen.real("%lf", -6.1, -3.3)
self.assertFalse(re.match(x, "-6.8")) # powinno byc None
self.assertFalse(re.match(regexpgen.real("%lf", 88.7653193745, 88.920716654), "88.0"))
self.assertTrue(re.match(regexpgen.real("%lf", 88.7653193745, 88.920716654), "88.9"))
self.assertTrue(re.match(regexpgen.real("%lf", 88.7653193745, 88.920716654), "88.92"))
self.assertTrue(re.match(regexpgen.real("%lf", 88.7653193745, 88.920716654), "88.920"))
self.assertTrue(re.match(regexpgen.real("%lf", 88.7653193745, 88.920716654), "88.9207"))
self.assertTrue(re.match(regexpgen.real("%lf", 88.7653193745, 88.920716654), "88.92071"))
self.assertTrue(re.match(regexpgen.real("%lf", 88.7653193745, 88.920716654), "88.920716"))
self.assertTrue(re.match(regexpgen.real("%lf", 88.7653193745, 88.920716654), "88.9207166"))
self.assertTrue(re.match(regexpgen.real("%lf", 88.7653193745, 88.920716654), "88.92071665"))
def __runTest6(self, scale, setMin, setMax, useInt, stepInt):
if useInt:
step = random.randint(1,3)
else:
step = random.uniform(0.5, 1.5)
scaleR = scale
scaleI = scale + 1
min = random.uniform(-1*(10**scale), 10**scale) if not useInt else random.randint(-1*(10**scale), 10**scale)
max = random.uniform(min, min + 5**scale) if not useInt else random.randint(min, min + 5**scale)
format = "%0{0}.{1}lf".format(scaleI + 1, scaleR) # +1 because dot is included
min = float(self.__sliceFloat(float(min), scaleR))
max = float(self.__sliceFloat(float(max), scaleR))
scaleI = scaleI - scaleR
min = float(self.__sliceFloatIntPart(float(min), scaleI))
max = float(self.__sliceFloatIntPart(float(max), scaleI))
regexp = regexpgen.real(format, min if setMin else None, max if setMax else None)
info = lambda value: self.__getInfo(value, regexp, format, min if setMin else None, max if setMax else None)
(rangeLeft, rangeRight) = self.__getRanges(min, max)
i = rangeLeft
if setMin:
while float(self.__str(i)) < float(self.__str(min)) - step:
x = self.__sliceFloat(i, scaleR - 1 if scaleR > 0 else 0)
y = self.__sliceFloat(i, scaleR)
z = self.__sliceFloat(i, scaleR + 1)
x = self.__sliceFloatIntPart(x, scaleI)
y = self.__sliceFloatIntPart(y, scaleI)
z = self.__sliceFloatIntPart(z, scaleI)
if scale > 1:
self.assertFalse(re.match(regexp, self.__str(x)), info(self.__str(x)))
self.assertFalse(re.match(regexp, self.__str(y)), info(self.__str(y)))
self.assertFalse(re.match(regexp, self.__str(z)), info(self.__str(z)))
i = i + step
i = i + step
while float(self.__str(i)) <= float(self.__str(max)):
x = self.__sliceFloat(i, scaleR - 1 if scaleR > 1 else 0)
y = self.__sliceFloat(i, scaleR)
z = self.__sliceFloat(i, scaleR + 1)
x = self.__sliceFloatIntPart(x, scaleI)
y = self.__sliceFloatIntPart(y, scaleI)
z = self.__sliceFloatIntPart(z, scaleI)
self.assertTrue(re.match(regexp, self.__str(y)), info(self.__str(y)))
if scale > 2:
self.assertFalse(re.match(regexp, self.__str(x)), info(self.__str(x)))
self.assertFalse(re.match(regexp, self.__str(z)), info(self.__str(z)))
x = self.__sliceFloat(i, scaleR)
y = self.__sliceFloat(i, scaleR)
z = self.__sliceFloat(i, scaleR)
if not setMin and not setMax:
x = self.__sliceFloatIntPart(x, scaleI - 1 if scaleI > 1 else 0)
y = self.__sliceFloatIntPart(y, scaleI)
z = self.__sliceFloatIntPart(z, scaleI + 1, "1")
self.assertTrue(re.match(regexp, self.__str(y)), info(self.__str(y)))
if scaleI > 2:
self.assertTrue(re.match(regexp, self.__str(x)), info(self.__str(x)))
if i > 0:
self.assertTrue(re.match(regexp, self.__str(z)), info(self.__str(z)))
if setMin and not setMax:
x = self.__sliceFloatIntPart(x, scaleI - 1 if scaleI > 1 else 0)
y = self.__sliceFloatIntPart(y, scaleI)
z = self.__sliceFloatIntPart(z, scaleI + 1, "1")
self.assertTrue(re.match(regexp, self.__str(y)), info(self.__str(y)))
if scaleI > 2:
self.assertFalse(re.match(regexp, self.__str(x)), info(self.__str(x)))
if i > 0:
self.assertTrue(re.match(regexp, self.__str(z)), info(self.__str(z)))
if setMax and not setMin:
x = self.__sliceFloatIntPart(x, scaleI - 1 if scaleI > 1 else 0)
y = self.__sliceFloatIntPart(y, scaleI)
z = self.__sliceFloatIntPart(z, scaleI + 1, "1")
self.assertTrue(re.match(regexp, self.__str(y)), info(self.__str(y)))
if scaleI > 2:
self.assertFalse(re.match(regexp, self.__str(x)), info(self.__str(x)))
if i < 0:
self.assertTrue(re.match(regexp, self.__str(z)), info(self.__str(z)))
if setMax and setMin:
x = self.__sliceFloatIntPart(x, scaleI - 1 if scaleI > 1 else 0)
y = self.__sliceFloatIntPart(y, scaleI)
self.assertTrue(re.match(regexp, self.__str(y)), info(self.__str(y)))
if scaleI > 2:
self.assertFalse(re.match(regexp, self.__str(x)), info(self.__str(x)))
i = i + step
if setMax:
i = i + step
while i <= rangeRight:
x = self.__sliceFloat(i, scaleR - 1 if scaleR > 0 else 0)
y = self.__sliceFloat(i, scaleR)
z = self.__sliceFloat(i, scaleR + 1)
x = self.__sliceFloatIntPart(x, scaleI - 1 if scaleI > 0 else 0)
y = self.__sliceFloatIntPart(y, scaleI)
z = self.__sliceFloatIntPart(z, scaleI + 1)
if scale > 1:
self.assertFalse(re.match(regexp, self.__str(x)), info(self.__str(x)))
self.assertFalse(re.match(regexp, self.__str(y)), info(self.__str(y)))
self.assertFalse(re.match(regexp, self.__str(z)), info(self.__str(z)))
i = i + step
