From 0a12b50e881f6c35a4836344ea10b32e9d0969a2ff50cc7d5abd38e0762550dd Mon Sep 17 00:00:00 2001 From: Matej Cepl Date: Mon, 7 Jan 2019 14:16:05 +0000 Subject: [PATCH] - Add nose_to_unittest.patch to avoid nose BR and rewrite tests to work (gh#pyparsing/pyparsing#64) OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-pyparsing?expand=0&rev=52 --- nose_to_unittest.patch | 378 +++++++++++++++++++++++++++++++++++++++ python-pyparsing.changes | 6 + python-pyparsing.spec | 15 +- 3 files changed, 395 insertions(+), 4 deletions(-) create mode 100644 nose_to_unittest.patch diff --git a/nose_to_unittest.patch b/nose_to_unittest.patch new file mode 100644 index 0000000..8b0c77f --- /dev/null +++ b/nose_to_unittest.patch @@ -0,0 +1,378 @@ +--- a/examples/test_bibparse.py ++++ b/examples/test_bibparse.py +@@ -1,195 +1,193 @@ + """ Test for bibparse grammar """ + ++import unittest + from os.path import join as pjoin, dirname + + from pyparsing import ParseException + from .btpyparse import Macro + from . import btpyparse as bp + +-from nose.tools import assert_true, assert_false, assert_equal, assert_raises ++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_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) ++ 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__': +- import nose +- nose.main() ++ unittest.main() diff --git a/python-pyparsing.changes b/python-pyparsing.changes index 6efa560..fe6f764 100644 --- a/python-pyparsing.changes +++ b/python-pyparsing.changes @@ -1,3 +1,9 @@ +------------------------------------------------------------------- +Mon Jan 7 12:36:20 UTC 2019 - Matěj Cepl + +- Add nose_to_unittest.patch to avoid nose BR and rewrite tests + to work (gh#pyparsing/pyparsing#64) + ------------------------------------------------------------------- Fri Dec 28 09:57:56 UTC 2018 - Martin Pluskal diff --git a/python-pyparsing.spec b/python-pyparsing.spec index eb4853d..a5a7aa7 100644 --- a/python-pyparsing.spec +++ b/python-pyparsing.spec @@ -1,7 +1,7 @@ # # spec file for package python-pyparsing # -# Copyright (c) 2018 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -16,6 +16,7 @@ # +%define modname pyparsing %define oldpython python %{?!python_module:%define python_module() python-%{**} python3-%{**}} %global flavor @BUILD_FLAVOR@%{nil} @@ -37,8 +38,9 @@ Group: Development/Languages/Python URL: https://github.com/pyparsing/pyparsing/ # Upstream tarball from the master branch with gh#pyparsing/pyparsing#47 Source: pyparsing-%{version}.tar.gz +# Remove dependency on nose, gh#pyparsing/pyparsing#64 +Patch: nose_to_unittest.patch BuildRequires: %{python_module base} -BuildRequires: %{python_module nose} # Source: https://files.pythonhosted.org/packages/source/p/pyparsing/pyparsing-%%{version}.tar.gz BuildRequires: fdupes BuildRequires: python-rpm-macros @@ -61,7 +63,8 @@ expressions. The pyparsing module provides a library of classes that client code uses to construct the grammar directly in Python code. %prep -%setup -q -n pyparsing-2.3.1 +%setup -q -n %{modname}-2.3.1 +%autopatch -p1 %build %python_build @@ -79,7 +82,11 @@ cp -r pyparsing.egg-info %{buildroot}%{$python_sitelib}/pyparsing-%{version}-py% %check %if %{with test} export PYTHONPATH=.:example -%python_exec setup.py nosetests -v +# unittest from Python 2.7 doesn't load tests correctly +python2 -munittest2 -v simple_unit_tests.py examples.test_bibparse examples.antlr_grammar_tests +python3 -munittest -v simple_unit_tests.py examples.test_bibparse examples.antlr_grammar_tests +# Fails with python2 gh#pyparsing/pyparsing#63 +python3 unitTests.py %endif %files %{python_files}