FM / Tests

/usr/lib64/python2.6/site-packages/Cheetah/Tests/

/usr/lib64/python2.6/site-packages/Cheetah/Tests

Name	Size	Mode	Actions
Analyzer.py	604	0644	edit dl rm
Analyzer.pyc	1238	0644	edit dl rm
Analyzer.pyo	1238	0644	edit dl rm
CheetahWrapper.py	18895	0644	edit dl rm
CheetahWrapper.pyc	29731	0644	edit dl rm
CheetahWrapper.pyo	29731	0644	edit dl rm
Cheps.py	1056	0644	edit dl rm
Cheps.pyc	1808	0644	edit dl rm
Cheps.pyo	1757	0644	edit dl rm
Filters.py	1987	0644	edit dl rm
Filters.pyc	2813	0644	edit dl rm
Filters.pyo	2638	0644	edit dl rm
Misc.py	493	0644	edit dl rm
Misc.pyc	1055	0644	edit dl rm
Misc.pyo	1055	0644	edit dl rm
NameMapper.py	14258	0644	edit dl rm
NameMapper.pyc	26124	0644	edit dl rm
NameMapper.pyo	25558	0644	edit dl rm
Parser.py	1228	0644	edit dl rm
Parser.pyc	2126	0644	edit dl rm
Parser.pyo	2126	0644	edit dl rm
Performance.py	7321	0644	edit dl rm
Performance.pyc	9646	0644	edit dl rm
Performance.pyo	9627	0644	edit dl rm
Regressions.py	8375	0644	edit dl rm
Regressions.pyc	9542	0644	edit dl rm
Regressions.pyo	8862	0644	edit dl rm
SyntaxAndOutput.py	93214	0644	edit dl rm
SyntaxAndOutput.pyc	146005	0644	edit dl rm
SyntaxAndOutput.pyo	145570	0644	edit dl rm
Template.py	12052	0644	edit dl rm
Template.pyc	14177	0644	edit dl rm
Template.pyo	12329	0644	edit dl rm
Test.py	1513	0644	edit dl rm
Test.pyc	1592	0644	edit dl rm
Test.pyo	1592	0644	edit dl rm
Unicode.py	7298	0644	edit dl rm
Unicode.pyc	11079	0644	edit dl rm
Unicode.pyo	10370	0644	edit dl rm
xmlrunner.py	12721	0644	edit dl rm
xmlrunner.pyc	17926	0644	edit dl rm
xmlrunner.pyo	17926	0644	edit dl rm
__init__.py	2	0644	edit dl rm
__init__.pyc	147	0644	edit dl rm
__init__.pyo	147	0644	edit dl rm

Edit: /usr/lib64/python2.6/site-packages/Cheetah/Tests/NameMapper.py (14258B)

import sys
import types
import os
import os.path

import unittest
from Cheetah.NameMapper import NotFound, valueForKey, \
     valueForName, valueFromSearchList, valueFromFrame, valueFromFrameOrSearchList

class DummyClass:
    classVar1 = 123

def __init__(self):
        self.instanceVar1 = 123
        
    def __str__(self):
        return 'object'

def meth(self, arg="arff"):
        return str(arg)

def meth1(self, arg="doo"):
        return arg

def meth2(self, arg1="a1", arg2="a2"):
        raise ValueError

def meth3(self):
        """Tests a bug that Jeff Johnson reported on Oct 1, 2001"""
        
        x = 'A string'
        try:
            for i in [1, 2, 3, 4]:
                if x == 2:	
                    pass
                
                if x == 'xx':
                    pass
            return x
        except:
            raise

def dummyFunc(arg="Scooby"):
    return arg

def funcThatRaises():
    raise ValueError

testNamespace = {
    'aStr': 'blarg',
    'anInt': 1,
    'aFloat': 1.5,
    'aDict': {'one': 'item1',
              'two': 'item2',
              'nestedDict': {'one': 'nestedItem1',
                            'two': 'nestedItem2',
                            'funcThatRaises': funcThatRaises,
                            'aClass': DummyClass,
                            },
              'nestedFunc': dummyFunc,
              },
    'aClass': DummyClass,    
    'aFunc': dummyFunc,
    'anObj': DummyClass(),
    'aMeth': DummyClass().meth1,
    'none': None,  
    'emptyString': '',
    'funcThatRaises': funcThatRaises,
    }
    
autoCallResults = {'aFunc': 'Scooby',
                   'aMeth': 'doo',
                   }

results = testNamespace.copy()
results.update({'anObj.meth1': 'doo',
                'aDict.one': 'item1',
                'aDict.nestedDict': testNamespace['aDict']['nestedDict'],
                'aDict.nestedDict.one': 'nestedItem1',
                'aDict.nestedDict.aClass': DummyClass,
                'aDict.nestedFunc': 'Scooby',
                'aClass.classVar1': 123,
                'anObj.instanceVar1': 123,
                'anObj.meth3': 'A string',
                })

for k in testNamespace.keys():
    # put them in the globals for the valueFromFrame tests
    exec('%s = testNamespace[k]'%k)

##################################################
## TEST BASE CLASSES

class NameMapperTest(unittest.TestCase):
    failureException = (NotFound, AssertionError)
    _testNamespace = testNamespace
    _results = results
    
    def namespace(self):
        return self._testNamespace

def VFN(self, name, autocall=True):
        return valueForName(self.namespace(), name, autocall)

def VFS(self, searchList, name, autocall=True):
        return valueFromSearchList(searchList, name, autocall)

# alias to be overriden later
    get = VFN

def check(self, name):
        got = self.get(name)
        if name in autoCallResults:
            expected = autoCallResults[name]
        else:
            expected = self._results[name]
        assert got == expected

##################################################
## TEST CASE CLASSES

class VFN(NameMapperTest):

def test1(self):
        """string in dict lookup"""
        self.check('aStr')

def test2(self):
        """string in dict lookup in a loop"""
        for i in range(10):
            self.check('aStr')
            
    def test3(self):
        """int in dict lookup"""
        self.check('anInt')

def test4(self):
        """int in dict lookup in a loop"""
        for i in range(10):
            self.check('anInt')

def test5(self):
        """float in dict lookup"""
        self.check('aFloat')

def test6(self):
        """float in dict lookup in a loop"""
        for i in range(10):
            self.check('aFloat')
          
    def test7(self):
        """class in dict lookup"""
        self.check('aClass')

def test8(self):
        """class in dict lookup in a loop"""
        for i in range(10):
            self.check('aClass')
            
    def test9(self):
        """aFunc in dict lookup"""
        self.check('aFunc')

def test10(self):
        """aFunc in dict lookup in a loop"""
        for i in range(10):
            self.check('aFunc')

def test11(self):
        """aMeth in dict lookup"""
        self.check('aMeth')

def test12(self):
        """aMeth in dict lookup in a loop"""
        for i in range(10):
            self.check('aMeth')

def test13(self):
        """aMeth in dict lookup"""
        self.check('aMeth')

def test14(self):
        """aMeth in dict lookup in a loop"""
        for i in range(10):
            self.check('aMeth')

def test15(self):
        """anObj in dict lookup"""
        self.check('anObj')

def test16(self):
        """anObj in dict lookup in a loop"""
        for i in range(10):
            self.check('anObj')

def test17(self):
        """aDict in dict lookup"""
        self.check('aDict')

def test18(self):
        """aDict in dict lookup in a loop"""
        for i in range(10):
            self.check('aDict')

def test17(self):
        """aDict in dict lookup"""
        self.check('aDict')

def test18(self):
        """aDict in dict lookup in a loop"""
        for i in range(10):
            self.check('aDict')

def test19(self):
        """aClass.classVar1 in dict lookup"""
        self.check('aClass.classVar1')

def test20(self):
        """aClass.classVar1 in dict lookup in a loop"""
        for i in range(10):
            self.check('aClass.classVar1')

def test23(self):
        """anObj.instanceVar1 in dict lookup"""
        self.check('anObj.instanceVar1')

def test24(self):
        """anObj.instanceVar1 in dict lookup in a loop"""
        for i in range(10):
            self.check('anObj.instanceVar1')

## tests 22, 25, and 26 removed when the underscored lookup was removed

def test27(self):
        """anObj.meth1 in dict lookup"""
        self.check('anObj.meth1')

def test28(self):
        """anObj.meth1 in dict lookup in a loop"""
        for i in range(10):
            self.check('anObj.meth1')

def test29(self):
        """aDict.one in dict lookup"""
        self.check('aDict.one')

def test30(self):
        """aDict.one in dict lookup in a loop"""
        for i in range(10):
            self.check('aDict.one')

def test31(self):
        """aDict.nestedDict in dict lookup"""
        self.check('aDict.nestedDict')

def test32(self):
        """aDict.nestedDict in dict lookup in a loop"""
        for i in range(10):
            self.check('aDict.nestedDict')
            
    def test33(self):
        """aDict.nestedDict.one in dict lookup"""
        self.check('aDict.nestedDict.one')

def test34(self):
        """aDict.nestedDict.one in dict lookup in a loop"""
        for i in range(10):
            self.check('aDict.nestedDict.one')
            
    def test35(self):
        """aDict.nestedFunc in dict lookup"""
        self.check('aDict.nestedFunc')

def test36(self):
        """aDict.nestedFunc in dict lookup in a loop"""
        for i in range(10):
            self.check('aDict.nestedFunc')

def test37(self):
        """aDict.nestedFunc in dict lookup - without autocalling"""
        assert self.get('aDict.nestedFunc', False) == dummyFunc

def test38(self):
        """aDict.nestedFunc in dict lookup in a loop - without autocalling"""
        for i in range(10):
            assert self.get('aDict.nestedFunc', False) == dummyFunc

def test39(self):
        """aMeth in dict lookup - without autocalling"""
        assert self.get('aMeth', False) == self.namespace()['aMeth']

def test40(self):
        """aMeth in dict lookup in a loop - without autocalling"""
        for i in range(10):
            assert self.get('aMeth', False) == self.namespace()['aMeth']

def test41(self):
        """anObj.meth3 in dict lookup"""
        self.check('anObj.meth3')

def test42(self):
        """aMeth in dict lookup in a loop"""
        for i in range(10):
            self.check('anObj.meth3')

def test43(self):
        """NotFound test"""

def test(self=self):
            self.get('anObj.methX')    
        self.assertRaises(NotFound, test)
        
    def test44(self):
        """NotFound test in a loop"""
        def test(self=self):
            self.get('anObj.methX')

for i in range(10):
            self.assertRaises(NotFound, test)
            
    def test45(self):
        """Other exception from meth test"""

def test(self=self):
            self.get('anObj.meth2')    
        self.assertRaises(ValueError, test)
        
    def test46(self):
        """Other exception from meth test in a loop"""
        def test(self=self):
            self.get('anObj.meth2')

for i in range(10):
            self.assertRaises(ValueError, test)

def test47(self):
        """None in dict lookup"""
        self.check('none')

def test48(self):
        """None in dict lookup in a loop"""
        for i in range(10):
            self.check('none')
            
    def test49(self):
        """EmptyString in dict lookup"""
        self.check('emptyString')

def test50(self):
        """EmptyString in dict lookup in a loop"""
        for i in range(10):
            self.check('emptyString')

def test51(self):
        """Other exception from func test"""

def test(self=self):
            self.get('funcThatRaises')    
        self.assertRaises(ValueError, test)
        
    def test52(self):
        """Other exception from func test in a loop"""
        def test(self=self):
            self.get('funcThatRaises')

for i in range(10):
            self.assertRaises(ValueError, test)

def test53(self):
        """Other exception from func test"""

def test(self=self):
            self.get('aDict.nestedDict.funcThatRaises')    
        self.assertRaises(ValueError, test)
        
    def test54(self):
        """Other exception from func test in a loop"""
        def test(self=self):
            self.get('aDict.nestedDict.funcThatRaises')

for i in range(10):
            self.assertRaises(ValueError, test)

def test55(self):
        """aDict.nestedDict.aClass in dict lookup"""
        self.check('aDict.nestedDict.aClass')

def test56(self):
        """aDict.nestedDict.aClass in dict lookup in a loop"""
        for i in range(10):
            self.check('aDict.nestedDict.aClass')

def test57(self):
        """aDict.nestedDict.aClass in dict lookup - without autocalling"""
        assert self.get('aDict.nestedDict.aClass', False) == DummyClass

def test58(self):
        """aDict.nestedDict.aClass in dict lookup in a loop - without autocalling"""
        for i in range(10):
            assert self.get('aDict.nestedDict.aClass', False) == DummyClass

def test59(self):
        """Other exception from func test -- but without autocalling shouldn't raise"""

self.get('aDict.nestedDict.funcThatRaises', False)    
        
    def test60(self):
        """Other exception from func test in a loop -- but without autocalling shouldn't raise"""

for i in range(10):
            self.get('aDict.nestedDict.funcThatRaises', False)

class VFS(VFN):
    _searchListLength = 1
    
    def searchList(self):
        lng = self._searchListLength
        if lng == 1:
            return [self.namespace()]
        elif lng == 2:
            return [self.namespace(), {'dummy':1234}]
        elif lng == 3:
            # a tuple for kicks
            return ({'dummy':1234}, self.namespace(), {'dummy':1234})
        elif lng == 4:
            # a generator for more kicks
            return self.searchListGenerator()

def searchListGenerator(self):
        class Test:
            pass
        for i in [Test(), {'dummy':1234}, self.namespace(), {'dummy':1234}]:
            yield i
  
    def get(self, name, autocall=True):
        return self.VFS(self.searchList(), name, autocall)
        
class VFS_2namespaces(VFS):
    _searchListLength = 2
    
class VFS_3namespaces(VFS):
    _searchListLength = 3

class VFS_4namespaces(VFS):
    _searchListLength = 4
    
class VFF(VFN): 
    def get(self, name, autocall=True):
        ns = self._testNamespace
        aStr = ns['aStr'] 
        aFloat = ns['aFloat']
        none = 'some'
        return valueFromFrame(name, autocall)

def test_VFF_1(self):
        """Builtins"""
        self.check('True')
        self.check('None')
        self.check('False')
        assert self.get('eval', False)==eval
        assert self.get('range', False)==range

class VFFSL(VFS):
    _searchListLength = 1

def setUp(self):
        """Mod some of the data
        """
        self._testNamespace = ns = self._testNamespace.copy()
        self._results = res = self._results.copy()
        ns['aStr'] = res['aStr'] = 'BLARG'
        ns['aFloat'] = res['aFloat'] = 0.1234
        res['none'] = 'some'
        
        del ns['anInt'] # will be picked up by globals
        
    def VFFSL(self, searchList, name, autocall=True):
        anInt = 1
        none = 'some'
        return valueFromFrameOrSearchList(searchList, name, autocall)
    
    def get(self, name, autocall=True):
        return self.VFFSL(self.searchList(), name, autocall)

class VFFSL_2(VFFSL):
    _searchListLength = 2

class VFFSL_3(VFFSL):
    _searchListLength = 3

class VFFSL_4(VFFSL):
    _searchListLength = 4

if sys.platform.startswith('java'):
    del VFF, VFFSL, VFFSL_2, VFFSL_3, VFFSL_4

##################################################
## if run from the command line ##
        
if __name__ == '__main__':
    unittest.main()

cmd: