[Cpptool-cvs] rfta/src/pyrfta/test/rfta __init__.py,NONE,1.1 alltests.py,NONE,1.1 codeanalysis.py,NONE,1.1 codeanalysistest.py,NONE,1.1

[<bl...@us...>]

Update of /cvsroot/cpptool/rfta/src/pyrfta/test/rfta
In directory sc8-pr-cvs1:/tmp/cvs-serv13378/test/rfta

Added Files:
	__init__.py alltests.py codeanalysis.py codeanalysistest.py 
Log Message:
* added initial structure for python extension

--- NEW FILE: __init__.py ---
from _pyrfta import *

##source = "void f() { return; }"
##parser = Parser( source )
##fn = parser.getFunctionAt( 16 )
##print fn.functionName.name
##body = fn.body
##for statement in body.getStatements():
##    print statement
    


--- NEW FILE: alltests.py ---
#!/usr/bin/env python
#
# Example of assembling all available unit tests into one suite. This usually
# varies greatly from one project to the next, so the code shown below will not
# be incorporated into the 'unittest' module. Instead, modify it for your own
# purposes.
# 
# $Id: alltests.py,v 1.1 2003/05/29 14:05:56 blep Exp $

import unittest
import rfta.codeanalysistest

def suite():
#    modules_to_test = ('rfta.codeanalysistest') # and so on
    alltests = unittest.TestSuite()
    alltests.addTest(unittest.findTestCases(rfta.codeanalysistest))
#    for module in map(__import__, modules_to_test):
#        alltests.addTest(unittest.findTestCases(module))
    return alltests

#if __name__ == '__main__':
#    unittest.main(defaultTest='suite')

--- NEW FILE: codeanalysis.py ---
import rfta

class LocalVariableDeclarator(rfta.StatementVisitor):
    def __init__( self, resolver ):
        self.resolver = resolver

    def declare(self, functionBody):
        functionBody.accept(self)

    def visitCompoundStatement(self,compound):
        self.resolver.enterScope()
        self.resolver.exitScope()

class LocalVariableResolver:
    def isLocaleVariable(self, variableName):
        return false

    def declareVariable(self, variableName):
        pass

    def enterScope(self):
        pass

    def exitScope(self):
        pass


class Analyser:
    def getFunctionResolver( function ):
        resolver = LocaleVariableResolver()
        declarator = LocalVariableDeclarator( resolver )
        declarator.visitCompoundStatement( function.body )
        return resolver


--- NEW FILE: codeanalysistest.py ---
import unittest
import mock
import rfta
from rfta.codeanalysis import *
from mock import MockFactory

class LocaleVariableDeclaratorTest(unittest.TestCase):
    """LocaleVariableDeclarator tests"""

    def setUp( self ):
        self.resolver = self.createMockInstance( LocalVariableResolver, [] )
        self.declarator = LocalVariableDeclarator( self.resolver )
        self.body = rfta.CompoundStatement()

    def tearDown( self ):
        self.declarator = None
        self.resolver = None

    def testConstruction( self ):
        pass

    def testEmptyBody( self ):
        self.resolver.declareVariable.setExpectNoCall()
        self.declarator.visitCompoundStatement( self.body )
        
        self.assertEqual( self.resolver.enterScope.argsPassed, [()] )
        self.assertEqual( self.resolver.exitScope.argsPassed, [()] )

def suite():
    return unittest.makeSuite(IdentifierResolverTestCase)

if __name__ == '__main__':
    unittest.TextTestRunner().run(suite())