[Python-modules-commits] [fparser] 01/09: py3 changes
Alastair McKinstry
mckinstry at moszumanska.debian.org
Fri Jul 28 10:45:31 UTC 2017
This is an automated email from the git hooks/post-receive script.
mckinstry pushed a commit to branch dev-python3
in repository fparser.
commit 2486b38291facfb8bf64297573f4e1f8e1ea8a4a
Author: Alastair McKinstry <mckinstry at debian.org>
Date: Tue Jul 25 14:00:06 2017 +0100
py3 changes
---
src/fparser/parsefortran.py | 24 +-
src/fparser/pattern_tools.py | 24 +-
src/fparser/tests/test_Fortran2003.py | 1058 ++++++++++++++++-----------------
src/fparser/tests/test_blank_lines.py | 3 +-
src/fparser/tests/test_issue11.py | 3 +-
src/fparser/tests/test_issue25.py | 2 +-
src/fparser/tests/test_issue26.py | 2 +-
7 files changed, 561 insertions(+), 555 deletions(-)
diff --git a/src/fparser/parsefortran.py b/src/fparser/parsefortran.py
index 31f3729..8169607 100644
--- a/src/fparser/parsefortran.py
+++ b/src/fparser/parsefortran.py
@@ -68,6 +68,8 @@
#Author: Pearu Peterson <pearu at cens.ioc.ee>
#Created: May 2006
+from __future__ import print_function
+
__autodoc__ = ['FortranParser']
__all__ = ['FortranParser']
@@ -77,9 +79,9 @@ import traceback
import logging
from numpy.distutils.misc_util import yellow_text, red_text
-from readfortran import FortranFileReader, FortranStringReader
-from block_statements import BeginSource
-from utils import AnalyzeError
+from .readfortran import FortranFileReader, FortranStringReader
+from .block_statements import BeginSource
+from .utils import AnalyzeError
logger = logging.getLogger('fparser')
@@ -177,7 +179,7 @@ end python module foo
reader = FortranStringReader(string, True, True)
parser = FortranParser(reader)
block = parser.parse()
- print block
+ print (block)
def test_free90():
string = """
@@ -208,7 +210,7 @@ end module foo
reader = FortranStringReader(string, True, False)
parser = FortranParser(reader)
block = parser.parse()
- print block
+ print (block)
def test_f77():
string = """\
@@ -225,7 +227,7 @@ def test_f77():
reader = FortranStringReader(string, False, True)
parser = FortranParser(reader)
block = parser.parse()
- print block
+ print (block)
def simple_main():
import sys
@@ -233,12 +235,12 @@ def simple_main():
return parse_all_f()
for filename in sys.argv[1:]:
reader = FortranFileReader(filename)
- print yellow_text('Processing '+filename+' (mode=%r)' % (reader.mode))
+ print (yellow_text('Processing '+filename+' (mode=%r)' % (reader.mode)))
parser = FortranParser(reader)
parser.parse()
parser.analyze()
- print parser.block.torepr(4)
- #print parser.block
+ print (parser.block.torepr(4))
+ #print (parser.block)
def profile_main():
import hotshot, hotshot.stats
@@ -254,10 +256,10 @@ def parse_all_f():
for filename in open('opt_all_f.txt'):
filename = filename.strip()
reader = FortranFileReader(filename)
- print yellow_text('Processing '+filename+' (mode=%r)' % (reader.mode))
+ print (yellow_text('Processing '+filename+' (mode=%r)' % (reader.mode)))
parser = FortranParser(reader)
block = parser.parse()
- print block
+ print (block)
if __name__ == "__main__":
#test_f77()
diff --git a/src/fparser/pattern_tools.py b/src/fparser/pattern_tools.py
index 71c0f44..31e9130 100644
--- a/src/fparser/pattern_tools.py
+++ b/src/fparser/pattern_tools.py
@@ -75,6 +75,8 @@ Created: Oct 2006
-----
"""
+from __future__ import print_function
+
dollar_ok = True
import re
@@ -157,7 +159,7 @@ class Pattern(object):
if '' in t[1:-1]: return
rhs = t[-1].strip()
pattern_match = t[-2].strip()
- assert abs(self).match(pattern_match),`self,string,t,pattern_match`
+ assert abs(self).match(pattern_match),repr(self,string,t,pattern_match)
lhs = (''.join(t[:-2])).strip()
return lhs, pattern_match, rhs
@@ -174,7 +176,7 @@ class Pattern(object):
lhs = t[0].strip()
pattern_match = t[1].strip()
rhs = (''.join(t[2:])).strip()
- assert abs(self).match(pattern_match),`pattern_match`
+ assert abs(self).match(pattern_match),repr(pattern_match)
return lhs, pattern_match, rhs
def __abs__(self):
@@ -199,14 +201,14 @@ class Pattern(object):
pattern = self.pattern + other.pattern
flags = self._flags | other._flags
else:
- assert isinstance(other,str),`other`
+ assert isinstance(other,str),repr(other)
label = '%s%s' % (self.label, other)
pattern = self.pattern + other
flags = self._flags
return Pattern(label, pattern, flags=flags)
def __rand__(self, other):
- assert isinstance(other,str),`other`
+ assert isinstance(other,str),repr(other)
label = '%s%s' % (other, self.label)
pattern = other + self.pattern
return Pattern(label, pattern, flags=self._flags)
@@ -229,7 +231,7 @@ class Pattern(object):
pattern = self.pattern + r'\s*' + other.pattern
flags = self._flags | other._flags
else:
- assert isinstance(other,str),`other`
+ assert isinstance(other,str),repr(other)
label = '%s %s' % (self.label, other)
other = self._special_symbol_map.get(other, other)
pattern = self.pattern + r'\s*' + other
@@ -237,7 +239,7 @@ class Pattern(object):
return Pattern(label, pattern, flags = flags)
def __radd__(self, other):
- assert isinstance(other,str),`other`
+ assert isinstance(other,str),repr(other)
label = '%s %s' % (other, self.label)
other = self._special_symbol_map.get(other, other)
pattern = other + r'\s*' + self.pattern
@@ -246,7 +248,7 @@ class Pattern(object):
def named(self, name = None):
if name is None:
label = self.label
- assert label[0]+label[-1]=='<>' and ' ' not in label,`label`
+ assert label[0]+label[-1]=='<>' and ' ' not in label,repr(label)
else:
label = '<%s>' % (name)
pattern = '(?P%s%s)' % (label.replace('-','_'), self.pattern)
@@ -449,9 +451,9 @@ def _test():
def assert_equal(result, expect):
try:
assert result==expect
- except AssertionError, msg:
- raise AssertionError,"Expected %r but got %r: %s" \
- % (expect, result, msg)
+ except AssertionError as msg:
+ raise AssertionError("Expected %r but got %r: %s" \
+ % (expect, result, msg))
m = mult_op.named()
assert m.rsplit('a * b')
@@ -468,7 +470,7 @@ def _test():
assert_equal(m.rsplit('a * b ** c'),('a * b','**','c'))
assert_equal(m.lsplit('a ** b ** c'),('a','**','b ** c'))
assert_equal(m.rsplit('a ** b ** c'),('a ** b','**','c'))
- print 'ok'
+ print ('ok')
if __name__ == '__main__':
_test()
diff --git a/src/fparser/tests/test_Fortran2003.py b/src/fparser/tests/test_Fortran2003.py
index 21fe25e..3788980 100644
--- a/src/fparser/tests/test_Fortran2003.py
+++ b/src/fparser/tests/test_Fortran2003.py
@@ -90,7 +90,7 @@ def test_Program(): # R201
end
''')
a = cls(reader)
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert "SUBROUTINE foo\nEND SUBROUTINE Foo\nSUBROUTINE bar\n" \
"END SUBROUTINE bar" == str(a)
@@ -99,7 +99,7 @@ def test_Program(): # R201
end subroutine foo
''')
a = cls(reader)
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a), 'SUBROUTINE foo(*)\nEND SUBROUTINE foo')
def test_Specification_Part(): # R204
@@ -108,7 +108,7 @@ def test_Specification_Part(): # R204
integer a''')
cls = Specification_Part
a = cls(reader)
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'INTEGER :: a')
assert_equal(repr(a), "Specification_Part(Type_Declaration_Stmt(Intrinsic_Type_Spec('INTEGER', None), None, Entity_Decl(Name('a'), None, None, None)))")
@@ -118,7 +118,7 @@ end type a
type b
end type b
'''))
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'TYPE :: a\nEND TYPE a\nTYPE :: b\nEND TYPE b')
###############################################################################
@@ -128,28 +128,28 @@ end type b
def test_Name(): # R304
a = Name('a')
- assert isinstance(a,Name),`a`
+ assert isinstance(a,Name),repr(a)
a = Name('a2')
- assert isinstance(a,Name),`a`
+ assert isinstance(a,Name),repr(a)
a = Designator('a')
- assert isinstance(a,Name),`a`
+ assert isinstance(a,Name),repr(a)
a = Constant('a')
- assert isinstance(a,Name),`a`
+ assert isinstance(a,Name),repr(a)
a = Expr('a')
- assert isinstance(a,Name),`a`
+ assert isinstance(a,Name),repr(a)
def test_Literal_Constant(): # R305
cls = Constant
a = cls('.false.')
- assert isinstance(a, Logical_Literal_Constant), `a`
+ assert isinstance(a, Logical_Literal_Constant), repr(a)
assert str(a)=='.FALSE.'
def test_Literal_Constant(): # R306
cls = Literal_Constant
a = cls('.false.')
- assert isinstance(a, Logical_Literal_Constant), `a`
+ assert isinstance(a, Logical_Literal_Constant), repr(a)
assert str(a)=='.FALSE.'
###############################################################################
@@ -160,118 +160,118 @@ def test_Type_Param_Value(): # 402
cls = Type_Param_Value
a = cls('*')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'*')
assert_equal(repr(a),"Type_Param_Value('*')")
a = cls(':')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),':')
a = cls('1+2')
- assert isinstance(a,Level_2_Expr),`a`
+ assert isinstance(a,Level_2_Expr),repr(a)
assert_equal(str(a),'1 + 2')
def test_Intrinsic_Type_Spec(): # R403
cls = Intrinsic_Type_Spec
a = cls('INTEGER')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'INTEGER')
assert_equal(repr(a), "Intrinsic_Type_Spec('INTEGER', None)")
a = cls('Integer*2')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'INTEGER*2')
a = cls('real*2')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'REAL*2')
a = cls('logical*2')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'LOGICAL*2')
a = cls('complex*2')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'COMPLEX*2')
a = cls('character*2')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'CHARACTER*2')
a = cls('double complex')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'DOUBLE COMPLEX')
a = cls('double precision')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'DOUBLE PRECISION')
def test_Kind_Selector(): # R404
cls = Kind_Selector
a = cls('(1)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(KIND = 1)')
assert_equal(repr(a),"Kind_Selector('(', Int_Literal_Constant('1', None), ')')")
a = cls('(kind=1+2)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(KIND = 1 + 2)')
a = cls('* 1')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'*1')
def test_Signed_Int_Literal_Constant(): # R405
cls = Signed_Int_Literal_Constant
a = cls('1')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'1')
assert_equal(repr(a),"%s('1', None)" % (cls.__name__))
a = cls('+ 21_2')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'+21_2')
assert_equal(repr(a),"%s('+21', '2')" % (cls.__name__))
a = cls('-21_SHORT')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'-21_SHORT')
a = cls('21_short')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'21_short')
a = cls('+1976354279568241_8')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'+1976354279568241_8')
def test_Int_Literal_Constant(): # R406
cls = Int_Literal_Constant
a = cls('1')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'1')
assert_equal(repr(a),"%s('1', None)" % (cls.__name__))
a = cls('21_2')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'21_2')
assert_equal(repr(a),"%s('21', '2')" % (cls.__name__))
a = cls('21_SHORT')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'21_SHORT')
a = cls('21_short')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'21_short')
a = cls('1976354279568241_8')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'1976354279568241_8')
def test_Binary_Constant(): # R412
@@ -279,7 +279,7 @@ def test_Binary_Constant(): # R412
cls = Boz_Literal_Constant
bcls = Binary_Constant
a = cls('B"01"')
- assert isinstance(a,bcls),`a`
+ assert isinstance(a,bcls),repr(a)
assert_equal(str(a),'B"01"')
assert_equal(repr(a),"%s('B\"01\"')" % (bcls.__name__))
@@ -288,7 +288,7 @@ def test_Octal_Constant(): # R413
cls = Boz_Literal_Constant
ocls = Octal_Constant
a = cls('O"017"')
- assert isinstance(a,ocls),`a`
+ assert isinstance(a,ocls),repr(a)
assert_equal(str(a),'O"017"')
assert_equal(repr(a),"%s('O\"017\"')" % (ocls.__name__))
@@ -297,7 +297,7 @@ def test_Hex_Constant(): # R414
cls = Boz_Literal_Constant
zcls = Hex_Constant
a = cls('Z"01A"')
- assert isinstance(a,zcls),`a`
+ assert isinstance(a,zcls),repr(a)
assert_equal(str(a),'Z"01A"')
assert_equal(repr(a),"%s('Z\"01A\"')" % (zcls.__name__))
@@ -305,161 +305,161 @@ def test_Signed_Real_Literal_Constant(): # R416
cls = Signed_Real_Literal_Constant
a = cls('12.78')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'12.78')
assert_equal(repr(a),"%s('12.78', None)" % (cls.__name__))
a = cls('+12.78_8')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'+12.78_8')
assert_equal(repr(a),"%s('+12.78', '8')" % (cls.__name__))
a = cls('- 12.')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'-12.')
a = cls('1.6E3')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'1.6E3')
a = cls('+1.6E3_8')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'+1.6E3_8')
a = cls('1.6D3')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'1.6D3')
a = cls('-1.6E-3')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'-1.6E-3')
a = cls('1.6E+3')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'1.6E+3')
a = cls('3E4')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'3E4')
a = cls('.123')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'.123')
a = cls('+1.6E-3')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'+1.6E-3')
a = cls('10.9E7_QUAD')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'10.9E7_QUAD')
a = cls('-10.9e-17_quad')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'-10.9E-17_quad')
def test_Real_Literal_Constant(): # R417
cls = Real_Literal_Constant
a = cls('12.78')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'12.78')
assert_equal(repr(a),"%s('12.78', None)" % (cls.__name__))
a = cls('12.78_8')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'12.78_8')
assert_equal(repr(a),"%s('12.78', '8')" % (cls.__name__))
a = cls('12.')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'12.')
a = cls('1.6E3')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'1.6E3')
a = cls('1.6E3_8')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'1.6E3_8')
a = cls('1.6D3')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'1.6D3')
a = cls('1.6E-3')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'1.6E-3')
a = cls('1.6E+3')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'1.6E+3')
a = cls('3E4')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'3E4')
a = cls('.123')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'.123')
a = cls('1.6E-3')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'1.6E-3')
a = cls('10.9E7_QUAD')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'10.9E7_QUAD')
a = cls('10.9e-17_quad')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'10.9E-17_quad')
a = cls('0.0D+0')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'0.0D+0')
def test_Char_Selector(): # R424
cls = Char_Selector
a = cls('(len=2, kind=8)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(LEN = 2, KIND = 8)')
assert_equal(repr(a),"Char_Selector(Int_Literal_Constant('2', None), Int_Literal_Constant('8', None))")
a = cls('(2, kind=8)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(LEN = 2, KIND = 8)')
a = cls('(2, 8)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(LEN = 2, KIND = 8)')
a = cls('(kind=8)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(KIND = 8)')
a = cls('(kind=8,len=2)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(LEN = 2, KIND = 8)')
def test_Complex_Literal_Constant(): # R421
cls = Complex_Literal_Constant
a = cls('(1.0, -1.0)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(1.0, -1.0)')
assert_equal(repr(a),"Complex_Literal_Constant(Signed_Real_Literal_Constant('1.0', None), Signed_Real_Literal_Constant('-1.0', None))")
a = cls('(3,3.1E6)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(3, 3.1E6)')
a = cls('(4.0_4, 3.6E7_8)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(4.0_4, 3.6E7_8)')
a = cls('( 0., PI)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(0., PI)')
@@ -467,7 +467,7 @@ def test_Type_Name(): # C424
cls = Type_Name
a = cls('a')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'a')
assert_equal(repr(a),"Type_Name('a')")
@@ -478,112 +478,112 @@ def test_Length_Selector(): # R425
cls = Length_Selector
a = cls('( len = *)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(LEN = *)')
assert_equal(repr(a),"Length_Selector('(', Type_Param_Value('*'), ')')")
a = cls('*2,')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'*2')
def test_Char_Length(): # R426
cls = Char_Length
a = cls('(1)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(1)')
assert_equal(repr(a),"Char_Length('(', Int_Literal_Constant('1', None), ')')")
a = cls('1')
- assert isinstance(a,Int_Literal_Constant),`a`
+ assert isinstance(a,Int_Literal_Constant),repr(a)
assert_equal(str(a),'1')
a = cls('(*)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(*)')
a = cls('(:)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'(:)')
def test_Char_Literal_Constant(): # R427
cls = Char_Literal_Constant
a = cls('NIH_"DO"')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'NIH_"DO"')
assert_equal(repr(a),'Char_Literal_Constant(\'"DO"\', \'NIH\')')
a = cls("'DO'")
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),"'DO'")
assert_equal(repr(a),'Char_Literal_Constant("\'DO\'", None)')
a = cls("'DON''T'")
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),"'DON''T'")
a = cls('"DON\'T"')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'"DON\'T"')
a = cls('""')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'""')
a = cls("''")
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),"''")
a = cls('"hey ha(ada)\t"')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'"hey ha(ada)\t"')
def test_Logical_Literal_Constant(): # R428
cls = Logical_Literal_Constant
a = cls('.TRUE.')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'.TRUE.')
assert_equal(repr(a),"%s('.TRUE.', None)" % (cls.__name__))
a = cls('.True.')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'.TRUE.')
a = cls('.FALSE.')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'.FALSE.')
a = cls('.false.')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'.FALSE.')
a = cls('.TRUE._HA')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'.TRUE._HA')
def test_Derived_Type_Stmt(): # R430
cls = Derived_Type_Stmt
a = cls('type a')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'TYPE :: a')
assert_equal(repr(a),"Derived_Type_Stmt(None, Type_Name('a'), None)")
a = cls('type ::a(b,c)')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'TYPE :: a(b, c)')
a = cls('type, private, abstract::a(b,c)')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'TYPE, PRIVATE, ABSTRACT :: a(b, c)')
def test_Type_Name(): # C423
cls = Type_Name
a = cls('a')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'a')
assert_equal(repr(a),"Type_Name('a')")
@@ -591,20 +591,20 @@ def test_Type_Attr_Spec(): # R431
cls = Type_Attr_Spec
a = cls('abstract')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'ABSTRACT')
assert_equal(repr(a),"Type_Attr_Spec('ABSTRACT', None)")
a = cls('bind (c )')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'BIND(C)')
a = cls('extends(a)')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'EXTENDS(a)')
a = cls('private')
- assert isinstance(a, Access_Spec),`a`
+ assert isinstance(a, Access_Spec),repr(a)
assert_equal(str(a),'PRIVATE')
@@ -612,19 +612,19 @@ def test_End_Type_Stmt(): # R433
cls = End_Type_Stmt
a = cls('end type')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'END TYPE')
assert_equal(repr(a),"End_Type_Stmt('TYPE', None)")
a = cls('end type a')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'END TYPE a')
def test_Sequence_Stmt(): # R434
cls = Sequence_Stmt
a = cls('sequence')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'SEQUENCE')
assert_equal(repr(a),"Sequence_Stmt('SEQUENCE')")
@@ -632,86 +632,86 @@ def test_Type_Param_Def_Stmt(): # R435
cls = Type_Param_Def_Stmt
a = cls('integer ,kind :: a')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'INTEGER, KIND :: a')
assert_equal(repr(a),"Type_Param_Def_Stmt(None, Type_Param_Attr_Spec('KIND'), Name('a'))")
a = cls('integer*2 ,len :: a=3, b=2+c')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'INTEGER*2, LEN :: a = 3, b = 2 + c')
def test_Type_Param_Decl(): # R436
cls = Type_Param_Decl
a = cls('a=2')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'a = 2')
assert_equal(repr(a),"Type_Param_Decl(Name('a'), '=', Int_Literal_Constant('2', None))")
a = cls('a')
- assert isinstance(a, Name),`a`
+ assert isinstance(a, Name),repr(a)
assert_equal(str(a),'a')
def test_Type_Param_Attr_Spec(): # R437
cls = Type_Param_Attr_Spec
a = cls('kind')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'KIND')
assert_equal(repr(a),"Type_Param_Attr_Spec('KIND')")
a = cls('len')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'LEN')
def test_Component_Attr_Spec(): # R441
cls = Component_Attr_Spec
a = cls('pointer')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'POINTER')
assert_equal(repr(a),"Component_Attr_Spec('POINTER')")
a = cls('allocatable')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'ALLOCATABLE')
a = cls('dimension(a)')
- assert isinstance(a, Dimension_Component_Attr_Spec),`a`
+ assert isinstance(a, Dimension_Component_Attr_Spec),repr(a)
assert_equal(str(a),'DIMENSION(a)')
a = cls('private')
- assert isinstance(a, Access_Spec),`a`
+ assert isinstance(a, Access_Spec),repr(a)
assert_equal(str(a),'PRIVATE')
def test_Component_Decl(): # R442
cls = Component_Decl
a = cls('a(1)')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'a(1)')
assert_equal(repr(a),"Component_Decl(Name('a'), Explicit_Shape_Spec(None, Int_Literal_Constant('1', None)), None, None)")
a = cls('a(1)*(3)')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'a(1)*(3)')
a = cls('a(1)*(3) = 2')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'a(1)*(3) = 2')
a = cls('a(1) => NULL')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'a(1) => NULL')
def test_Proc_Component_Def_Stmt(): # R445
cls = Proc_Component_Def_Stmt
a = cls('procedure(), pointer :: a')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'PROCEDURE(), POINTER :: a')
a = cls('procedure(real*8), pointer, pass(n) :: a, b')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'PROCEDURE(REAL*8), POINTER, PASS(n) :: a, b')
def test_Type_Bound_Procedure_Part(): # R448
@@ -720,77 +720,77 @@ def test_Type_Bound_Procedure_Part(): # R448
contains
procedure, pass :: length => point_length
'''))
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'CONTAINS\nPROCEDURE, PASS :: length => point_length')
def test_Proc_Binding_Stmt(): # R450
cls = Proc_Binding_Stmt
a = cls('procedure, pass :: length => point_length')
- assert isinstance(a, Specific_Binding),`a`
+ assert isinstance(a, Specific_Binding),repr(a)
assert_equal(str(a),'PROCEDURE, PASS :: length => point_length')
def test_Specific_Binding(): # R451
cls = Specific_Binding
a = cls('procedure, pass :: length => point_length')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'PROCEDURE, PASS :: length => point_length')
def test_Generic_Binding(): # R452
cls = Generic_Binding
a = cls('generic :: a => b')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'GENERIC :: a => b')
a = cls('generic, private :: read(formatted) => b,c')
- assert isinstance(a, cls),`a`
+ assert isinstance(a, cls),repr(a)
assert_equal(str(a),'GENERIC, PRIVATE :: READ(FORMATTED) => b, c')
def test_Final_Binding(): # R454
cls = Final_Binding
a = cls('final a, b')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'FINAL :: a, b')
assert_equal(repr(a),"Final_Binding('FINAL', Final_Subroutine_Name_List(',', (Name('a'), Name('b'))))")
a = cls('final::a')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'FINAL :: a')
def test_Derived_Type_Spec(): # R455
cls = Derived_Type_Spec
a = cls('a(b)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'a(b)')
assert_equal(repr(a),"Derived_Type_Spec(Type_Name('a'), Name('b'))")
a = cls('a(b,c,g=1)')
- assert isinstance(a,cls),`a`
+ assert isinstance(a,cls),repr(a)
assert_equal(str(a),'a(b, c, g = 1)')
a = cls('a')
- assert isinstance(a,Name),`a`
+ assert isinstance(a,Name),repr(a)
assert_equal(str(a),'a')
... 2740 lines suppressed ...
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/python-modules/packages/fparser.git
More information about the Python-modules-commits
mailing list