Skip to content

Commit

Permalink
Merge pull request #64 from mcepl/denose
Browse files Browse the repository at this point in the history 
Denose
  • Loading branch information
@ptmcg
ptmcg committed Jan 10, 2019
2 parents afddc54 + fb23d63 commit 349637f
Showing 1 changed file with 190 additions and 193 deletions.
383 changes: 190 additions & 193 deletions examples/test_bibparse.py
View file
Original file line number Diff line number Diff line change
@@ -1,193 +1,190 @@
""" Test for bibparse grammar """

from pyparsing import ParseException
from .btpyparse import Macro
from . import btpyparse as bp

from nose.tools import assert_equal, assert_raises


def test_names():
# check various types of names
# All names can contains alphas, but not some special chars
bad_chars = '"#%\'(),={}'
for name_type, dig1f in ((bp.macro_def, False),
(bp.field_name, False),
(bp.entry_type, False),
(bp.cite_key, True)):
if dig1f: # can start with digit
assert_equal(name_type.parseString('2t')[0], '2t')
else:
assert_raises(ParseException, name_type.parseString, '2t')
# All of the names cannot contain some characters
for char in bad_chars:
assert_raises(ParseException, name_type.parseString, char)
# standard strings all OK
assert_equal(name_type.parseString('simple_test')[0], 'simple_test')
# Test macro ref
mr = bp.macro_ref
# can't start with digit
assert_raises(ParseException, mr.parseString, '2t')
for char in bad_chars:
assert_raises(ParseException, mr.parseString, char)
assert_equal(mr.parseString('simple_test')[0].name, 'simple_test')


def test_numbers():
assert_equal(bp.number.parseString('1066')[0], '1066')
assert_equal(bp.number.parseString('0')[0], '0')
assert_raises(ParseException, bp.number.parseString, '-4')
assert_raises(ParseException, bp.number.parseString, '+4')
assert_raises(ParseException, bp.number.parseString, '.4')
# something point something leaves a trailing .4 unmatched
assert_equal(bp.number.parseString('0.4')[0], '0')


def test_parse_string():
# test string building blocks
assert_equal(bp.chars_no_quotecurly.parseString('x')[0], 'x')
assert_equal(bp.chars_no_quotecurly.parseString("a string")[0], 'a string')
assert_equal(bp.chars_no_quotecurly.parseString('a "string')[0], 'a ')
assert_equal(bp.chars_no_curly.parseString('x')[0], 'x')
assert_equal(bp.chars_no_curly.parseString("a string")[0], 'a string')
assert_equal(bp.chars_no_curly.parseString('a {string')[0], 'a ')
assert_equal(bp.chars_no_curly.parseString('a }string')[0], 'a ')
# test more general strings together
for obj in (bp.curly_string, bp.string, bp.field_value):
assert_equal(obj.parseString('{}').asList(), [])
assert_equal(obj.parseString('{a "string}')[0], 'a "string')
assert_equal(obj.parseString('{a {nested} string}').asList(),
['a ', ['nested'], ' string'])
assert_equal(obj.parseString('{a {double {nested}} string}').asList(),
['a ', ['double ', ['nested']], ' string'])
for obj in (bp.quoted_string, bp.string, bp.field_value):
assert_equal(obj.parseString('""').asList(), [])
assert_equal(obj.parseString('"a string"')[0], 'a string')
assert_equal(obj.parseString('"a {nested} string"').asList(),
['a ', ['nested'], ' string'])
assert_equal(obj.parseString('"a {double {nested}} string"').asList(),
['a ', ['double ', ['nested']], ' string'])
# check macro def in string
assert_equal(bp.string.parseString('someascii')[0], Macro('someascii'))
assert_raises(ParseException, bp.string.parseString, '%#= validstring')
# check number in string
assert_equal(bp.string.parseString('1994')[0], '1994')


def test_parse_field():
# test field value - hashes included
fv = bp.field_value
# Macro
assert_equal(fv.parseString('aname')[0], Macro('aname'))
assert_equal(fv.parseString('ANAME')[0], Macro('aname'))
# String and macro
assert_equal(fv.parseString('aname # "some string"').asList(),
[Macro('aname'), 'some string'])
# Nested string
assert_equal(fv.parseString('aname # {some {string}}').asList(),
[Macro('aname'), 'some ', ['string']])
# String and number
assert_equal(fv.parseString('"a string" # 1994').asList(),
['a string', '1994'])
# String and number and macro
assert_equal(fv.parseString('"a string" # 1994 # a_macro').asList(),
['a string', '1994', Macro('a_macro')])


def test_comments():
res = bp.comment.parseString('@Comment{about something}')
assert_equal(res.asList(), ['comment', '{about something}'])
assert_equal(
bp.comment.parseString('@COMMENT{about something').asList(),
['comment', '{about something'])
assert_equal(
bp.comment.parseString('@comment(about something').asList(),
['comment', '(about something'])
assert_equal(
bp.comment.parseString('@COMment about something').asList(),
['comment', ' about something'])
assert_raises(ParseException, bp.comment.parseString,
'@commentabout something')
assert_raises(ParseException, bp.comment.parseString,
'@comment+about something')
assert_raises(ParseException, bp.comment.parseString,
'@comment"about something')


def test_preamble():
res = bp.preamble.parseString('@preamble{"about something"}')
assert_equal(res.asList(), ['preamble', 'about something'])
assert_equal(bp.preamble.parseString(
'@PREamble{{about something}}').asList(),
['preamble', 'about something'])
assert_equal(bp.preamble.parseString("""@PREamble{
{about something}
}""").asList(),
['preamble', 'about something'])


def test_macro():
res = bp.macro.parseString('@string{ANAME = "about something"}')
assert_equal(res.asList(), ['string', 'aname', 'about something'])
assert_equal(
bp.macro.parseString('@string{aname = {about something}}').asList(),
['string', 'aname', 'about something'])


def test_entry():
txt = """@some_entry{akey, aname = "about something",
another={something else}}"""
res = bp.entry.parseString(txt)
assert_equal(res.asList(),
['some_entry', 'akey',
['aname', 'about something'], ['another', 'something else']])
# Case conversion
txt = """@SOME_ENTRY{akey, ANAME = "about something",
another={something else}}"""
res = bp.entry.parseString(txt)
assert_equal(res.asList(),
['some_entry', 'akey',
['aname', 'about something'], ['another', 'something else']])


def test_bibfile():
txt = """@some_entry{akey, aname = "about something",
another={something else}}"""
res = bp.bibfile.parseString(txt)
assert_equal(res.asList(),
[['some_entry', 'akey',
['aname', 'about something'],
['another', 'something else']]])


def test_bib1():
# First pass whole bib-like tests
txt = """
Some introductory text
(implicit comment)
@ARTICLE{Brett2002marsbar,
author = {Matthew Brett and Jean-Luc Anton and Romain Valabregue and Jean-Baptise
Poline},
title = {{Region of interest analysis using an SPM toolbox}},
journal = {Neuroimage},
year = {2002},
volume = {16},
pages = {1140--1141},
number = {2}
}
@some_entry{akey, aname = "about something",
another={something else}}
"""
res = bp.bibfile.parseString(txt)
assert_equal(len(res), 3)
res2 = bp.parse_str(txt)
assert_equal(res.asList(), res2.asList())
res3 = [r.asList()[0] for r, start, end in bp.definitions.scanString(txt)]
assert_equal(res.asList(), res3)


if __name__ == '__main__':
import nose
nose.main()
""" Test for bibparse grammar """

import unittest
from pyparsing import ParseException
from .btpyparse import Macro
from . import btpyparse as bp

class TestBibparse(unittest.TestCase):
def test_names(self):
# check various types of names
# All names can contains alphas, but not some special chars
bad_chars = '"#%\'(),={}'
for name_type, dig1f in ((bp.macro_def, False),
(bp.field_name, False),
(bp.entry_type, False),
(bp.cite_key, True)):
if dig1f: # can start with digit
self.assertEqual(name_type.parseString('2t')[0], '2t')
else:
self.assertRaises(ParseException, name_type.parseString, '2t')
# All of the names cannot contain some characters
for char in bad_chars:
self.assertRaises(ParseException, name_type.parseString, char)
# standard strings all OK
self.assertEqual(name_type.parseString('simple_test')[0], 'simple_test')
# Test macro ref
mr = bp.macro_ref
# can't start with digit
self.assertRaises(ParseException, mr.parseString, '2t')
for char in bad_chars:
self.assertRaises(ParseException, mr.parseString, char)
self.assertEqual(mr.parseString('simple_test')[0].name, 'simple_test')

def test_numbers(self):
self.assertEqual(bp.number.parseString('1066')[0], '1066')
self.assertEqual(bp.number.parseString('0')[0], '0')
self.assertRaises(ParseException, bp.number.parseString, '-4')
self.assertRaises(ParseException, bp.number.parseString, '+4')
self.assertRaises(ParseException, bp.number.parseString, '.4')
# something point something leaves a trailing .4 unmatched
self.assertEqual(bp.number.parseString('0.4')[0], '0')


def test_parse_string(self):
# test string building blocks
self.assertEqual(bp.chars_no_quotecurly.parseString('x')[0], 'x')
self.assertEqual(bp.chars_no_quotecurly.parseString("a string")[0], 'a string')
self.assertEqual(bp.chars_no_quotecurly.parseString('a "string')[0], 'a ')
self.assertEqual(bp.chars_no_curly.parseString('x')[0], 'x')
self.assertEqual(bp.chars_no_curly.parseString("a string")[0], 'a string')
self.assertEqual(bp.chars_no_curly.parseString('a {string')[0], 'a ')
self.assertEqual(bp.chars_no_curly.parseString('a }string')[0], 'a ')
# test more general strings together
for obj in (bp.curly_string, bp.string, bp.field_value):
self.assertEqual(obj.parseString('{}').asList(), [])
self.assertEqual(obj.parseString('{a "string}')[0], 'a "string')
self.assertEqual(obj.parseString('{a {nested} string}').asList(),
['a ', ['nested'], ' string'])
self.assertEqual(obj.parseString('{a {double {nested}} string}').asList(),
['a ', ['double ', ['nested']], ' string'])
for obj in (bp.quoted_string, bp.string, bp.field_value):
self.assertEqual(obj.parseString('""').asList(), [])
self.assertEqual(obj.parseString('"a string"')[0], 'a string')
self.assertEqual(obj.parseString('"a {nested} string"').asList(),
['a ', ['nested'], ' string'])
self.assertEqual(obj.parseString('"a {double {nested}} string"').asList(),
['a ', ['double ', ['nested']], ' string'])
# check macro def in string
self.assertEqual(bp.string.parseString('someascii')[0], Macro('someascii'))
self.assertRaises(ParseException, bp.string.parseString, '%#= validstring')
# check number in string
self.assertEqual(bp.string.parseString('1994')[0], '1994')


def test_parse_field(self):
# test field value - hashes included
fv = bp.field_value
# Macro
self.assertEqual(fv.parseString('aname')[0], Macro('aname'))
self.assertEqual(fv.parseString('ANAME')[0], Macro('aname'))
# String and macro
self.assertEqual(fv.parseString('aname # "some string"').asList(),
[Macro('aname'), 'some string'])
# Nested string
self.assertEqual(fv.parseString('aname # {some {string}}').asList(),
[Macro('aname'), 'some ', ['string']])
# String and number
self.assertEqual(fv.parseString('"a string" # 1994').asList(),
['a string', '1994'])
# String and number and macro
self.assertEqual(fv.parseString('"a string" # 1994 # a_macro').asList(),
['a string', '1994', Macro('a_macro')])


def test_comments(self):
res = bp.comment.parseString('@Comment{about something}')
self.assertEqual(res.asList(), ['comment', '{about something}'])
self.assertEqual(
bp.comment.parseString('@COMMENT{about something').asList(),
['comment', '{about something'])
self.assertEqual(
bp.comment.parseString('@comment(about something').asList(),
['comment', '(about something'])
self.assertEqual(
bp.comment.parseString('@COMment about something').asList(),
['comment', ' about something'])
self.assertRaises(ParseException, bp.comment.parseString,
'@commentabout something')
self.assertRaises(ParseException, bp.comment.parseString,
'@comment+about something')
self.assertRaises(ParseException, bp.comment.parseString,
'@comment"about something')


def test_preamble(self):
res = bp.preamble.parseString('@preamble{"about something"}')
self.assertEqual(res.asList(), ['preamble', 'about something'])
self.assertEqual(bp.preamble.parseString(
'@PREamble{{about something}}').asList(),
['preamble', 'about something'])
self.assertEqual(bp.preamble.parseString("""@PREamble{
{about something}
}""").asList(),
['preamble', 'about something'])


def test_macro(self):
res = bp.macro.parseString('@string{ANAME = "about something"}')
self.assertEqual(res.asList(), ['string', 'aname', 'about something'])
self.assertEqual(
bp.macro.parseString('@string{aname = {about something}}').asList(),
['string', 'aname', 'about something'])


def test_entry(self):
txt = """@some_entry{akey, aname = "about something",
another={something else}}"""
res = bp.entry.parseString(txt)
self.assertEqual(res.asList(),
['some_entry', 'akey',
['aname', 'about something'], ['another', 'something else']])
# Case conversion
txt = """@SOME_ENTRY{akey, ANAME = "about something",
another={something else}}"""
res = bp.entry.parseString(txt)
self.assertEqual(res.asList(),
['some_entry', 'akey',
['aname', 'about something'], ['another', 'something else']])


def test_bibfile(self):
txt = """@some_entry{akey, aname = "about something",
another={something else}}"""
res = bp.bibfile.parseString(txt)
self.assertEqual(res.asList(),
[['some_entry', 'akey',
['aname', 'about something'],
['another', 'something else']]])


def test_bib1(self):
# First pass whole bib-like tests
txt = """
Some introductory text
(implicit comment)
@ARTICLE{Brett2002marsbar,
author = {Matthew Brett and Jean-Luc Anton and Romain Valabregue and Jean-Baptise
Poline},
title = {{Region of interest analysis using an SPM toolbox}},
journal = {Neuroimage},
year = {2002},
volume = {16},
pages = {1140--1141},
number = {2}
}
@some_entry{akey, aname = "about something",
another={something else}}
"""
res = bp.bibfile.parseString(txt)
self.assertEqual(len(res), 3)
res2 = bp.parse_str(txt)
self.assertEqual(res.asList(), res2.asList())
res3 = [r.asList()[0] for r, start, end in bp.definitions.scanString(txt)]
self.assertEqual(res.asList(), res3)


if __name__ == '__main__':
unittest.main()

0 comments on commit 349637f

Please sign in to comment.