py_tests/unit_tools/lcompare.py

''' Text comparison functions for Radiance unit testing.

This allows differences in whitespace, which is why the text
corpora are split into tokens first.
Tokens are then converted into an appropriate data type, so
that floating point items will still be considered correct
even if they are slightly different, eg. as a consequence of
binary rounding errors.
'''

import string
import types

class error(Exception): pass

# internal functions
def _icompare(itest, iref):
        '''compare ints (not public)'''
        if type(itest) == str:
                iftest = int(itest)
        else: iftest = itest
        if iftest == iref: return 1
        return 0

def _fcompare(ftest, fref):
        '''compare floats (not public)'''
        FUZZ = 0.0000001 # XXX heuristically determined
        if type(ftest) == str:
                fftest = float(ftest)
        else: fftest = ftest
        if (fftest < (fref + FUZZ)) and (fftest > (fref - FUZZ)):
                return 1
        return 0

def _typify_token(t):
        '''return the token as int resp. float if possible (not public)'''
        try: return int(t)
        except ValueError: pass
        try: return float(t)
        except ValueError: pass
        return t


# public comparison functions

def lcompare(ltest, lref):
        '''compare a list of tokens
                raise an error if there are intolerable differences
                the reference tokens in lref should already be of the correct type.
        '''
        if len(ltest) != len(lref):
                raise error, ('List comparision failed: Different number of tokens'
                        ' (%d, %d)' % (len(ltest), len(lref)))
        for i in range(len(lref)):
                tref = lref[i]
                ttest = ltest[i]
                if type(tref) == str and tref != ttest:
                        raise error, 'Token comparison failed: "%s" != "%s"' % (ttest, tref)
                elif type(tref) == int and not _icompare(ttest, tref):
                        raise error, 'Token comparison failed: %s != %s' % (ttest, tref)
                elif type(tref) == float and not _fcompare(ttest, tref):
                        raise error, 'Token comparison failed: %s != %s' % (ttest, tref)

def llcompare(lltest, llref, ignore_empty=0, recurse=[]):
        '''compare a list of lists of tokens recursively
                raise an error if there are intolerable differences
                the reference tokens in lref should already be of the correct type.
                if ignore_empty is true, empty lines are not included in the comparison
                the recurse argument is only used internally
        '''
        if ignore_empty:
                lltest = filter(None, lltest)
                llref = filter(None, llref)
        if len(lltest) != len(llref):
                raise error, 'Comparision failed: Different number of lines (%d,%d)' %(
                        len(lltest), len(llref))
        for i in range(len(llref)):
                if llref[i]:
                        rtype = type(llref[i][0])
                        if rtype == list or rtype == tuple:
                                return llcompare(lltest[i], llref[i],
                                                recurse=recurse.append(i), ignore_empty=ignore_empty)
                try: lcompare(lltest[i], llref[i])
                except error, e:
                        if recurse:
                                raise error, '%s (line %s)' % (str(e), recurse.append(i + 1))
                        else: raise error, '%s (line %d)' % (str(e), i + 1)
        
def split_headers(s):
        '''split Radiance file headers
                return a list of lists of tokens suitable for llcompare()
                this is useful to check the output of getinfo'''
        ll = map(string.strip,string.split(s, '\n'))
        nll = []
        for l in ll:
                parts = string.split(l, '=', 1)
                if len(parts) == 2:
                        left = map(_typify_token, string.split(parts[0]))
                        right = map(_typify_token, string.split(parts[1]))
                        nll.append(left + ['='] + right)
                else: nll.append(map(_typify_token, string.split(l)))
        return nll

def split_rad(s):
        '''Split the contents of a scene description string
                return a list of list of tokens suitable for llcompare()'''
        ll = map(string.strip,string.split(s, '\n'))
        nll = []
        for l in ll:
                nll.append(map(_typify_token, string.split(l)))
        return nll

def split_radfile(fn):
        '''Split the contents of a file object containing a scene description
                return a list of list of tokens suitable for llcompare()'''
        f = open(fn, 'r')
        ll = split_rad(f.read())
        f.close()
        return ll
        
Revision:	1.1
Committed:	Sun Dec 7 20:40:51 2003 UTC (20 years, 5 months ago) by schorsch
Content type:	text/x-python
Branch:	MAIN
CVS Tags:	rad4R2P2, rad5R0, rad3R7P2, rad3R7P1, rad4R2, rad4R1, rad4R0, rad3R6, rad3R6P1, rad3R8, rad3R9, rad4R2P1
Log Message:	First attempt at testing framework.
#	User	Rev	Content
1	schorsch	1.1	''' Text comparison functions for Radiance unit testing.
2
3			This allows differences in whitespace, which is why the text
4			corpora are split into tokens first.
5			Tokens are then converted into an appropriate data type, so
6			that floating point items will still be considered correct
7			even if they are slightly different, eg. as a consequence of
8			binary rounding errors.
9			'''
10
11			import string
12			import types
13
14			class error(Exception): pass
15
16			# internal functions
17			def _icompare(itest, iref):
18			'''compare ints (not public)'''
19			if type(itest) == str:
20			iftest = int(itest)
21			else: iftest = itest
22			if iftest == iref: return 1
23			return 0
24
25			def _fcompare(ftest, fref):
26			'''compare floats (not public)'''
27			FUZZ = 0.0000001 # XXX heuristically determined
28			if type(ftest) == str:
29			fftest = float(ftest)
30			else: fftest = ftest
31			if (fftest < (fref + FUZZ)) and (fftest > (fref - FUZZ)):
32			return 1
33			return 0
34
35			def _typify_token(t):
36			'''return the token as int resp. float if possible (not public)'''
37			try: return int(t)
38			except ValueError: pass
39			try: return float(t)
40			except ValueError: pass
41			return t
42
43
44			# public comparison functions
45
46			def lcompare(ltest, lref):
47			'''compare a list of tokens
48			raise an error if there are intolerable differences
49			the reference tokens in lref should already be of the correct type.
50			'''
51			if len(ltest) != len(lref):
52			raise error, ('List comparision failed: Different number of tokens'
53			' (%d, %d)' % (len(ltest), len(lref)))
54			for i in range(len(lref)):
55			tref = lref[i]
56			ttest = ltest[i]
57			if type(tref) == str and tref != ttest:
58			raise error, 'Token comparison failed: "%s" != "%s"' % (ttest, tref)
59			elif type(tref) == int and not _icompare(ttest, tref):
60			raise error, 'Token comparison failed: %s != %s' % (ttest, tref)
61			elif type(tref) == float and not _fcompare(ttest, tref):
62			raise error, 'Token comparison failed: %s != %s' % (ttest, tref)
63
64			def llcompare(lltest, llref, ignore_empty=0, recurse=[]):
65			'''compare a list of lists of tokens recursively
66			raise an error if there are intolerable differences
67			the reference tokens in lref should already be of the correct type.
68			if ignore_empty is true, empty lines are not included in the comparison
69			the recurse argument is only used internally
70			'''
71			if ignore_empty:
72			lltest = filter(None, lltest)
73			llref = filter(None, llref)
74			if len(lltest) != len(llref):
75			raise error, 'Comparision failed: Different number of lines (%d,%d)' %(
76			len(lltest), len(llref))
77			for i in range(len(llref)):
78			if llref[i]:
79			rtype = type(llref[i][0])
80			if rtype == list or rtype == tuple:
81			return llcompare(lltest[i], llref[i],
82			recurse=recurse.append(i), ignore_empty=ignore_empty)
83			try: lcompare(lltest[i], llref[i])
84			except error, e:
85			if recurse:
86			raise error, '%s (line %s)' % (str(e), recurse.append(i + 1))
87			else: raise error, '%s (line %d)' % (str(e), i + 1)
88
89			def split_headers(s):
90			'''split Radiance file headers
91			return a list of lists of tokens suitable for llcompare()
92			this is useful to check the output of getinfo'''
93			ll = map(string.strip,string.split(s, '\n'))
94			nll = []
95			for l in ll:
96			parts = string.split(l, '=', 1)
97			if len(parts) == 2:
98			left = map(_typify_token, string.split(parts[0]))
99			right = map(_typify_token, string.split(parts[1]))
100			nll.append(left + ['='] + right)
101			else: nll.append(map(_typify_token, string.split(l)))
102			return nll
103
104			def split_rad(s):
105			'''Split the contents of a scene description string
106			return a list of list of tokens suitable for llcompare()'''
107			ll = map(string.strip,string.split(s, '\n'))
108			nll = []
109			for l in ll:
110			nll.append(map(_typify_token, string.split(l)))
111			return nll
112
113			def split_radfile(fn):
114			'''Split the contents of a file object containing a scene description
115			return a list of list of tokens suitable for llcompare()'''
116			f = open(fn, 'r')
117			ll = split_rad(f.read())
118			f.close()
119			return ll
120