def test_parse_unsignedinteger(self):
# Arrange
txt_succ1 = '1'
txt_succ2 = '1231###'
txt_succ3 = '0'
txt_fail1 = '-423vcxv'
txt_fail2 = '01564'
parser = stp.parse_unsignedinteger()
parser_label = stp.parse_unsignedinteger('spam')
# Act
res_succ1 = parser(txt_succ1)
res_succ2 = parser(txt_succ2)
res_succ3 = parser(txt_succ3)
res_fail1 = parser(txt_fail1)
res_fail2 = parser(txt_fail2)
exp_succ1 = res.Success.unit(("1", ""))
exp_succ2 = res.Success.unit(("1231", "###"))
exp_succ3 = res.Success.unit(("0", ""))
exp_fail = res.Failure.unit("error")
# Assert
self.assertEqual(res_succ1, exp_succ1)
self.assertEqual(res_succ2, exp_succ2)
self.assertEqual(res_succ3, exp_succ3)
self.assertEqual(res_fail1, exp_fail)
self.assertEqual(res_fail2, exp_fail)
self.assertEqual(parser.label, 'UINTEGER')
self.assertEqual(parser_label.label, 'spam')
def test_FailureCase(self):
# Arrange
txt = '123abc lorem ipsum'
parser_l = stp.parse_lowercases()
parser_r = stp.parse_digits()
parser = cmb.rightparser(parser_l, parser_r)
# Act
result = parser(txt)
expected = res.Failure('error')
# Assert
self.assertEqual(result, expected)
def test_SuccessCase(self):
# Arrange
txt = 'abc123 lorem ipsum'
parser_l = stp.parse_lowercases()
parser_r = stp.parse_digits()
parser = cmb.rightparser(parser_l, parser_r)
# Act
result = parser(txt)
expected = res.Success(('123', ' lorem ipsum'))
# Assert
self.assertEqual(result, expected)
def test_FailureCase(self):
# Arrange
txt = 'ABCabc123 lorem ipsum'
parser_l = stp.parse_uppercases()
parser_m = stp.parse_digits()
parser_r = stp.parse_lowercases()
parser = cmb.betweenparsers(parser_l, parser_m, parser_r)
# Act
result = parser(txt)
expected = res.Failure('error')
# Assert
self.assertEqual(result, expected)
def test_SuccessCase(self):
# Arrange
txt = 'ABCabc123 lorem ipsum'
parser_l = stp.parse_uppercases()
parser_m = stp.parse_lowercases()
parser_r = stp.parse_digits()
parser = cmb.betweenparsers(parser_l, parser_m, parser_r)
# Act
result = parser(txt)
expected = res.Success(('abc', ' lorem ipsum'))
# Assert
self.assertEqual(result, expected)
def test_parse_string(self):
# Arrange
txt = 'lorem ipsum'
parser_succ = stp.parse_string('lorem')
parser_fail = stp.parse_string('ipsum', label='FAIL')
# Act
result_succ = parser_succ(txt)
result_fail = parser_fail(txt)
expected_succ = res.Success(('lorem', ' ipsum'))
expected_fail = res.Failure('error')
# Assert
self.assertEqual(result_succ, expected_succ)
self.assertEqual(result_fail, expected_fail)
self.assertEqual(parser_succ.label, 'lorem')
self.assertEqual(parser_fail.label, 'FAIL')
def test_parse_lowercases(self):
# Arrange
txt_succ = 'abcABC'
txt_fail = 'ABC'
parser = stp.parse_lowercases()
parser_label = stp.parse_lowercases('spam')
# Act
res_succ = parser(txt_succ)
res_fail = parser(txt_fail)
exp_succ = res.Success.unit(("abc", "ABC"))
exp_fail = res.Failure.unit("error")
# Assert
self.assertEqual(res_succ, exp_succ)
self.assertEqual(res_fail, exp_fail)
self.assertEqual(parser.label, '[a-z]+')
self.assertEqual(parser_label.label, 'spam')
def test_parse_uppercase(self):
# Arrange
txt_succ = 'ABCabc'
txt_fail = 'abc'
parser = stp.parse_uppercase()
parser_label = stp.parse_uppercase('spam')
# Act
res_succ = parser(txt_succ)
res_fail = parser(txt_fail)
exp_succ = res.Success.unit(("A", "BCabc"))
exp_fail = res.Failure.unit("error")
# Assert
self.assertEqual(res_succ, exp_succ)
self.assertEqual(res_fail, exp_fail)
self.assertEqual(parser.label, '[A-Z]')
self.assertEqual(parser_label.label, 'spam')
def test_parse_digits(self):
# Arrange
txt_succ = '1234abc'
txt_fail = 'abc'
parser = stp.parse_digits()
parser_label = stp.parse_digits('spam')
# Act
res_succ = parser(txt_succ)
res_fail = parser(txt_fail)
exp_succ = res.Success.unit(("1234", "abc"))
exp_fail = res.Failure.unit("error")
# Assert
self.assertEqual(res_succ, exp_succ)
self.assertEqual(res_fail, exp_fail)
self.assertEqual(parser.label, '[0-9]+')
self.assertEqual(parser_label.label, 'spam')
def test_parse_string(self):
# Arrange
txt1 = 'lorem ipsum dolor sit amet'
txt2 = 'ipsum dolor sit amet'
txt3 = 'dolor sit amet'
parser_succ = stp.parse_one_of_strings('lorem', 'ipsum', 'dolor')
parser_fail = stp.parse_one_of_strings('xxx', label='FAIL')
# Act
result_succ1 = parser_succ(txt1)
result_succ2 = parser_succ(txt2)
result_fail = parser_fail(txt3)
expected_succ1 = res.Success(('lorem', ' ipsum dolor sit amet'))
expected_succ2 = res.Success(('ipsum', ' dolor sit amet'))
expected_fail = res.Failure('error')
# Assert
self.assertEqual(result_succ1, expected_succ1)
self.assertEqual(result_succ2, expected_succ2)
self.assertEqual(result_fail, expected_fail)
self.assertEqual(parser_succ.label, '(lorem|ipsum|dolor)')
self.assertEqual(parser_fail.label, 'FAIL')
def test_FailureCase(self):
# Arrange
txt1 = 'ABC'
sep = bpr.LParser(",")
item = stp.parse_lowercases()
parser = cmb.sep_by(item, sep)
# Act
result1 = parser(txt1)
expected1 = res.Failure('error')
# Assert
self.assertEqual(result1, expected1)
def test_parse_letters(self):
# Arrange
txt_succ1 = 'abcd'
txt_succ2 = 'ABCabc123'
txt_fail = '123'
parser = stp.parse_letters()
parser_label = stp.parse_letters('spam')
# Act
res_succ1 = parser(txt_succ1)
res_succ2 = parser(txt_succ2)
res_fail = parser(txt_fail)
exp_succ1 = res.Success.unit(("abcd", ""))
exp_succ2 = res.Success.unit(("ABCabc", "123"))
exp_fail = res.Failure.unit("error")
# Assert
self.assertEqual(res_succ1, exp_succ1)
self.assertEqual(res_succ2, exp_succ2)
self.assertEqual(res_fail, exp_fail)
self.assertEqual(parser.label, '[A-Za-z]+')
self.assertEqual(parser_label.label, 'spam')
def test_parse_character(self):
# Arrange
txt1 = 'aaa'
txt2 = 'bbb'
txt3 = 'ccc'
parser = stp.parse_character('a', 'b')
parser_label = stp.parse_character('ab', label='spam')
# Act
result_succ1 = parser(txt1)
result_succ2 = parser_label(txt2)
result_fail = parser(txt3)
expected_succ1 = res.Success(('a', 'aa'))
expected_succ2 = res.Success(('b', 'bb'))
expected_fail = res.Failure('error')
# Assert
self.assertEqual(result_succ1, expected_succ1)
self.assertEqual(result_succ2, expected_succ2)
self.assertEqual(result_fail, expected_fail)
self.assertEqual(parser.label, '[ab]')
self.assertEqual(parser_label.label, 'spam')
def test_parse_float(self):
# Arrange
txt_succs = [
'0.125', '3.125', '-3.125', '126543.125', '126543.125e9',
'32.125E9', '32.125E-9', '123.0e-10', '123.0E15', '123.0', '.3124',
'.3124E12'
]
txt_fails = ['00.312', '312.', '0012.0']
parser = stp.parse_float()
parser_label = stp.parse_float('spam')
# Act
res_succs = [parser(txt_succ) for txt_succ in txt_succs]
exp_succs = [res.Success((txt_succ, '')) for txt_succ in txt_succs]
res_fails = [parser(txt_fail) for txt_fail in txt_fails]
fail = res.Failure.unit("error")
# Assert
for e, r in zip(res_succs, exp_succs):
self.assertEqual(e, r)
for r in res_fails:
self.assertEqual(fail, r)
self.assertEqual(parser.label, 'FLOAT')
self.assertEqual(parser_label.label, 'spam')
def test_parse_word(self):
# Arrange
txt_succ1 = 'abc__d#123'
txt_succ2 = 'ABCabc_123'
txt_succ3 = '12_#3'
txt_fail = '#abc'
parser = stp.parse_word()
parser_label = stp.parse_word('spam')
# Act
res_succ1 = parser(txt_succ1)
res_succ2 = parser(txt_succ2)
res_succ3 = parser(txt_succ3)
res_fail = parser(txt_fail)
exp_succ1 = res.Success.unit(("abc__d", "#123"))
exp_succ2 = res.Success.unit(("ABCabc_123", ""))
exp_succ3 = res.Success.unit(("12_", "#3"))
exp_fail = res.Failure.unit("error")
# Assert
self.assertEqual(res_succ1, exp_succ1)
self.assertEqual(res_succ2, exp_succ2)
self.assertEqual(res_succ3, exp_succ3)
self.assertEqual(res_fail, exp_fail)
self.assertEqual(parser.label, '[A-Za-z0-9_]+')
self.assertEqual(parser_label.label, 'spam')
def test_parse_alphanumeric(self):
# Arrange
txt_succ1 = 'abcd'
txt_succ2 = 'ABCabc123'
txt_succ3 = '123'
txt_fail = '#abc'
parser = stp.parse_alphanumeric()
parser_label = stp.parse_alphanumeric('spam')
# Act
res_succ1 = parser(txt_succ1)
res_succ2 = parser(txt_succ2)
res_succ3 = parser(txt_succ3)
res_fail = parser(txt_fail)
exp_succ1 = res.Success.unit(("a", "bcd"))
exp_succ2 = res.Success.unit(("A", "BCabc123"))
exp_succ3 = res.Success.unit(("1", "23"))
exp_fail = res.Failure.unit("error")
# Assert
self.assertEqual(res_succ1, exp_succ1)
self.assertEqual(res_succ2, exp_succ2)
self.assertEqual(res_succ3, exp_succ3)
self.assertEqual(res_fail, exp_fail)
self.assertEqual(parser.label, '[A-Za-z0-9]')
self.assertEqual(parser_label.label, 'spam')
def test_SuccessCase(self):
# Arrange
txt1 = 'abc,def,ghi'
txt2 = 'abc'
txt3 = 'abc,def,ghi2132'
sep = bpr.LParser(",")
item = stp.parse_lowercases()
parser = cmb.sep_by1(item, sep)
# Act
result1 = parser(txt1)
expected1 = res.Success(('abc,def,ghi', ''))
result2 = parser(txt2)
expected2 = res.Success(('abc', ''))
result3 = parser(txt3)
expected3 = res.Success(('abc,def,ghi', '2132'))
# Assert
self.assertEqual(result1, expected1)
self.assertEqual(result2, expected2)
self.assertEqual(result3, expected3)
def test_strip(self):
# Arrange
txt1 = ' \n\tLorem \n\tIpsum'
txt2 = ' 12312 \nXYZ'
txt3 = '11Lorem111Ipsum'
exp1 = res.Success(('Lorem', 'Ipsum'))
exp2 = res.Success(('12312', 'XYZ'))
exp3 = res.Success(('Lorem', 'Ipsum'))
parser1 = stp.strip(stp.parse_string("Lorem"))
parser2 = stp.strip(stp.parse_digits(), ignored_lst=[' ', '\n'])
parser3 = stp.strip(stp.parse_string("Lorem"), ignored_lst=['1'])
# Act
res1 = parser1(txt1)
res2 = parser2(txt2)
res3 = parser3(txt3)
# Assert
self.assertEqual(res1, exp1)
self.assertEqual(res2, exp2)
self.assertEqual(res3, exp3)
self.assertEqual(parser1.label, "Lorem")
self.assertEqual(parser2.label, "[0-9]+")
self.assertEqual(parser3.label, "Lorem")