mirror of https://gitee.com/bigwinds/arangodb
342 lines
11 KiB
Python
342 lines
11 KiB
Python
# Copyright Bruno da Silva de Oliveira 2003. Use, modification and
|
|
# distribution is subject to the Boost Software License, Version 1.0.
|
|
# (See accompanying file LICENSE_1_0.txt or copy at
|
|
# http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
import sys
|
|
sys.path.append('../src')
|
|
import unittest
|
|
import tempfile
|
|
import os.path
|
|
from Pyste import GCCXMLParser
|
|
from Pyste.declarations import *
|
|
|
|
|
|
class Tester(unittest.TestCase):
|
|
|
|
def TestConstructor(self, class_, method, visib):
|
|
self.assert_(isinstance(method, Constructor))
|
|
self.assertEqual(method.FullName(), class_.FullName() + '::' + method.name)
|
|
self.assertEqual(method.result, None)
|
|
self.assertEqual(method.visibility, visib)
|
|
self.assert_(not method.virtual)
|
|
self.assert_(not method.abstract)
|
|
self.assert_(not method.static)
|
|
|
|
def TestDefaultConstructor(self, class_, method, visib):
|
|
self.TestConstructor(class_, method, visib)
|
|
self.assert_(method.IsDefault())
|
|
|
|
def TestCopyConstructor(self, class_, method, visib):
|
|
self.TestConstructor(class_, method, visib)
|
|
self.assertEqual(len(method.parameters), 1)
|
|
param = method.parameters[0]
|
|
self.TestType(
|
|
param,
|
|
ReferenceType,
|
|
class_.FullName(),
|
|
'const %s&' % class_.FullName(),
|
|
True)
|
|
self.assert_(method.IsCopy())
|
|
|
|
|
|
def TestType(self, type_, classtype_, name, fullname, const):
|
|
self.assert_(isinstance(type_, classtype_))
|
|
self.assertEqual(type_.name, name)
|
|
self.assertEqual(type_.namespace, None)
|
|
self.assertEqual(type_.FullName(), fullname)
|
|
self.assertEqual(type_.const, const)
|
|
|
|
|
|
class ClassBaseTest(Tester):
|
|
|
|
def setUp(self):
|
|
self.base = GetDecl('Base')
|
|
|
|
def testClass(self):
|
|
'test the properties of the class Base'
|
|
self.assert_(isinstance(self.base, Class))
|
|
self.assert_(self.base.abstract)
|
|
|
|
|
|
def testFoo(self):
|
|
'test function foo in class Base'
|
|
foo = GetMember(self.base, 'foo')
|
|
self.assert_(isinstance(foo, Method))
|
|
self.assertEqual(foo.visibility, Scope.public)
|
|
self.assert_(foo.virtual)
|
|
self.assert_(foo.abstract)
|
|
self.failIf(foo.static)
|
|
self.assertEqual(foo.class_, 'test::Base')
|
|
self.failIf(foo.const)
|
|
self.assertEqual(foo.FullName(), 'test::Base::foo')
|
|
self.assertEqual(foo.result.name, 'void')
|
|
self.assertEqual(len(foo.parameters), 1)
|
|
param = foo.parameters[0]
|
|
self.TestType(param, FundamentalType, 'int', 'int', False)
|
|
self.assertEqual(foo.namespace, None)
|
|
self.assertEqual(
|
|
foo.PointerDeclaration(1), '(void (test::Base::*)(int) )&test::Base::foo')
|
|
|
|
def testX(self):
|
|
'test the member x in class Base'
|
|
x = GetMember(self.base, 'x')
|
|
self.assertEqual(x.class_, 'test::Base')
|
|
self.assertEqual(x.FullName(), 'test::Base::x')
|
|
self.assertEqual(x.namespace, None)
|
|
self.assertEqual(x.visibility, Scope.private)
|
|
self.TestType(x.type, FundamentalType, 'int', 'int', False)
|
|
self.assertEqual(x.static, False)
|
|
|
|
def testConstructors(self):
|
|
'test constructors in class Base'
|
|
constructors = GetMembers(self.base, 'Base')
|
|
for cons in constructors:
|
|
if len(cons.parameters) == 0:
|
|
self.TestDefaultConstructor(self.base, cons, Scope.public)
|
|
elif len(cons.parameters) == 1: # copy constructor
|
|
self.TestCopyConstructor(self.base, cons, Scope.public)
|
|
elif len(cons.parameters) == 2: # other constructor
|
|
intp, floatp = cons.parameters
|
|
self.TestType(intp, FundamentalType, 'int', 'int', False)
|
|
self.TestType(floatp, FundamentalType, 'float', 'float', False)
|
|
|
|
def testSimple(self):
|
|
'test function simple in class Base'
|
|
simple = GetMember(self.base, 'simple')
|
|
self.assert_(isinstance(simple, Method))
|
|
self.assertEqual(simple.visibility, Scope.protected)
|
|
self.assertEqual(simple.FullName(), 'test::Base::simple')
|
|
self.assertEqual(len(simple.parameters), 1)
|
|
param = simple.parameters[0]
|
|
self.TestType(param, ReferenceType, 'std::string', 'const std::string&', True)
|
|
self.TestType(simple.result, FundamentalType, 'bool', 'bool', False)
|
|
self.assertEqual(
|
|
simple.PointerDeclaration(1),
|
|
'(bool (test::Base::*)(const std::string&) )&test::Base::simple')
|
|
|
|
|
|
def testZ(self):
|
|
z = GetMember(self.base, 'z')
|
|
self.assert_(isinstance(z, Variable))
|
|
self.assertEqual(z.visibility, Scope.public)
|
|
self.assertEqual(z.FullName(), 'test::Base::z')
|
|
self.assertEqual(z.type.name, 'int')
|
|
self.assertEqual(z.type.const, False)
|
|
self.assert_(z.static)
|
|
|
|
|
|
class ClassTemplateTest(Tester):
|
|
|
|
def setUp(self):
|
|
self.template = GetDecl('Template<int>')
|
|
|
|
def testClass(self):
|
|
'test the properties of the Template<int> class'
|
|
self.assert_(isinstance(self.template, Class))
|
|
self.assert_(not self.template.abstract)
|
|
self.assertEqual(self.template.FullName(), 'Template<int>')
|
|
self.assertEqual(self.template.namespace, '')
|
|
self.assertEqual(self.template.name, 'Template<int>')
|
|
|
|
def testConstructors(self):
|
|
'test the automatic constructors of the class Template<int>'
|
|
constructors = GetMembers(self.template, 'Template')
|
|
for cons in constructors:
|
|
if len(cons.parameters) == 0:
|
|
self.TestDefaultConstructor(self.template, cons, Scope.public)
|
|
elif len(cons.parameters) == 1:
|
|
self.TestCopyConstructor(self.template, cons, Scope.public)
|
|
|
|
|
|
def testValue(self):
|
|
'test the class variable value'
|
|
value = GetMember(self.template, 'value')
|
|
self.assert_(isinstance(value, ClassVariable))
|
|
self.assert_(value.name, 'value')
|
|
self.TestType(value.type, FundamentalType, 'int', 'int', False)
|
|
self.assert_(not value.static)
|
|
self.assertEqual(value.visibility, Scope.public)
|
|
self.assertEqual(value.class_, 'Template<int>')
|
|
self.assertEqual(value.FullName(), 'Template<int>::value')
|
|
|
|
def testBase(self):
|
|
'test the superclasses of Template<int>'
|
|
bases = self.template.bases
|
|
self.assertEqual(len(bases), 1)
|
|
base = bases[0]
|
|
self.assert_(isinstance(base, Base))
|
|
self.assertEqual(base.name, 'test::Base')
|
|
self.assertEqual(base.visibility, Scope.protected)
|
|
|
|
|
|
|
|
class FreeFuncTest(Tester):
|
|
|
|
def setUp(self):
|
|
self.func = GetDecl('FreeFunc')
|
|
|
|
def testFunc(self):
|
|
'test attributes of FreeFunc'
|
|
self.assert_(isinstance(self.func, Function))
|
|
self.assertEqual(self.func.name, 'FreeFunc')
|
|
self.assertEqual(self.func.FullName(), 'test::FreeFunc')
|
|
self.assertEqual(self.func.namespace, 'test')
|
|
self.assertEqual(
|
|
self.func.PointerDeclaration(1),
|
|
'(const test::Base& (*)(const std::string&, int))&test::FreeFunc')
|
|
|
|
|
|
def testResult(self):
|
|
'test the return value of FreeFunc'
|
|
res = self.func.result
|
|
self.TestType(res, ReferenceType, 'test::Base', 'const test::Base&', True)
|
|
|
|
def testParameters(self):
|
|
'test the parameters of FreeFunc'
|
|
self.assertEqual(len(self.func.parameters), 2)
|
|
strp, intp = self.func.parameters
|
|
self.TestType(strp, ReferenceType, 'std::string', 'const std::string&', True)
|
|
self.assertEqual(strp.default, None)
|
|
self.TestType(intp, FundamentalType, 'int', 'int', False)
|
|
self.assertEqual(intp.default, '10')
|
|
|
|
|
|
|
|
class testFunctionPointers(Tester):
|
|
|
|
def testMethodPointer(self):
|
|
'test declaration of a pointer-to-method'
|
|
meth = GetDecl('MethodTester')
|
|
param = meth.parameters[0]
|
|
fullname = 'void (test::Base::*)(int)'
|
|
self.TestType(param, PointerType, fullname, fullname, False)
|
|
|
|
def testFunctionPointer(self):
|
|
'test declaration of a pointer-to-function'
|
|
func = GetDecl('FunctionTester')
|
|
param = func.parameters[0]
|
|
fullname = 'void (*)(int)'
|
|
self.TestType(param, PointerType, fullname, fullname, False)
|
|
|
|
|
|
|
|
# =============================================================================
|
|
# Support routines
|
|
# =============================================================================
|
|
|
|
cppcode = '''
|
|
namespace std {
|
|
class string;
|
|
}
|
|
namespace test {
|
|
class Base
|
|
{
|
|
public:
|
|
Base();
|
|
Base(const Base&);
|
|
Base(int, float);
|
|
|
|
virtual void foo(int = 0.0) = 0;
|
|
static int z;
|
|
protected:
|
|
bool simple(const std::string&);
|
|
private:
|
|
int x;
|
|
};
|
|
|
|
void MethodTester( void (Base::*)(int) );
|
|
void FunctionTester( void (*)(int) );
|
|
|
|
|
|
const Base & FreeFunc(const std::string&, int=10);
|
|
|
|
}
|
|
|
|
template <class T>
|
|
struct Template: protected test::Base
|
|
{
|
|
T value;
|
|
virtual void foo(int);
|
|
};
|
|
|
|
Template<int> __aTemplateInt;
|
|
'''
|
|
|
|
def GetXMLFile():
|
|
'''Generates an gccxml file using the code from the global cppcode.
|
|
Returns the xml's filename.'''
|
|
# write the code to a header file
|
|
tmpfile = tempfile.mktemp() + '.h'
|
|
f = file(tmpfile, 'w')
|
|
f.write(cppcode)
|
|
f.close()
|
|
# run gccxml
|
|
outfile = tmpfile + '.xml'
|
|
if os.system('gccxml "%s" "-fxml=%s"' % (tmpfile, outfile)) != 0:
|
|
raise RuntimeError, 'Error executing GCCXML.'
|
|
# read the output file into the xmlcode
|
|
f = file(outfile)
|
|
xmlcode = f.read()
|
|
#print xmlcode
|
|
f.close()
|
|
# remove the header
|
|
os.remove(tmpfile)
|
|
return outfile
|
|
|
|
|
|
|
|
def GetDeclarations():
|
|
'Uses the GCCXMLParser module to get the declarations.'
|
|
xmlfile = GetXMLFile()
|
|
declarations = GCCXMLParser.ParseDeclarations(xmlfile)
|
|
os.remove(xmlfile)
|
|
return declarations
|
|
|
|
# the declarations to be analysed
|
|
declarations = GetDeclarations()
|
|
|
|
|
|
def GetDecl(name):
|
|
'returns one of the top declarations given its name'
|
|
for decl in declarations:
|
|
if decl.name == name:
|
|
return decl
|
|
else:
|
|
raise RuntimeError, 'Declaration not found: %s' % name
|
|
|
|
|
|
def GetMember(class_, name):
|
|
'gets the member of the given class by its name'
|
|
|
|
res = None
|
|
multipleFound = False
|
|
for member in class_:
|
|
if member.name == name:
|
|
if res is not None:
|
|
multipleFound = True
|
|
break
|
|
res = member
|
|
if res is None or multipleFound:
|
|
raise RuntimeError, \
|
|
'No member or more than one member found in class %s: %s' \
|
|
% (class_.name, name)
|
|
return res
|
|
|
|
|
|
def GetMembers(class_, name):
|
|
'gets the members of the given class by its name'
|
|
res = []
|
|
for member in class_:
|
|
if member.name == name:
|
|
res.append(member)
|
|
if len(res) in (0, 1):
|
|
raise RuntimeError, \
|
|
'GetMembers: 0 or 1 members found in class %s: %s' \
|
|
% (class_.name, name)
|
|
return res
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|