def test_two_digits(self):
"""
Does it return an expression to match exactly two digits?
"""
expression = Numbers.two_digits
test = str(Randomizer.integer(minimum=10,maximum=99))
fail = random.choice([str(Randomizer.integer(0,9)), str(Randomizer.integer(100,1000))])
self.assertIsNotNone(re.search(expression, test))
self.assertIsNone(re.search(expression, fail))
return
def test_single_digit(self):
"""
Does it return an expression to match only one digit?
"""
expression = Numbers.single_digit
test = str(Randomizer.integer(maximum=9))
two_many = str(Randomizer.integer(minimum=10))
self.assertIsNotNone(re.search(expression, test))
self.assertIsNone(re.search(expression, two_many))
return
def test_exactly(self):
"""
Does it return the repetition suffix?
"""
repetitions = Randomizer.integer(minimum=1, maximum=5)
repeater = Randomizer.letters()
expected = "{" + "{0}".format(repetitions) + "}"
quantifier = Quantifier.exactly(repetitions)
self.assertEqual(expected, quantifier)
expression = "(" + repeater + ")" + quantifier
text = Randomizer.letters() + repeater * (repetitions + Randomizer.integer(minimum=0))
self.assertIsNotNone(re.search(expression, text))
self.assertEqual(re.search(expression, text).groups(), (repeater,))
return
def test_non_digit(self):
"""
Does it return the anything-but-a-digit metacharacter?
"""
metacharacter = CharacterClass.non_digit
test = str(Randomizer.integer(maximum=9))
self.assertIsNone(re.search(metacharacter, test))
return
def test_digit(self):
"""
Does it return the digit character class?
"""
metacharacter = CharacterClass.digit
test = Randomizer.integer(maximum=9)
self.assertIsNotNone(re.search(metacharacter, str(test)))
self.assertIsNone(re.search(metacharacter, Randomizer.letters()))
return
def test_m_to_n(self):
"""
Does it return the expression to match m-to-n repetitions
"""
m = Randomizer.integer(minimum=5)
n = Randomizer.integer(minimum=m+1)
substring = Randomizer.letters()
quantifier = Quantifier.m_to_n(m,n)
expression = '(' + substring + ')' + quantifier
self.assertEqual("{" + str(m) + ',' + str(n) + '}',quantifier)
text = Randomizer.letters() + substring * Randomizer.integer(m, n)
complement = (Randomizer.letters_complement(substring) +
substring * Randomizer.integer(0,m-1))
too_many = substring * Randomizer.integer(n+1, n*2)
self.assertIsNotNone(re.search(expression, text))
self.assertIsNone(re.search(expression, complement))
self.assertEqual(re.search(expression, too_many).groups(), (substring,))
return
