def testlookup_symbol_with_complex_global_that_exists(self):
st = symbols.SymbolTable()
node, module = self._add_symbol(st, 'foo', ['ns1', 'ns2'])
self.assertEqual((node, module),
st.lookup_symbol('::ns1::ns2::foo', None))
self.assertEqual((node, module),
st.lookup_symbol('ns1::ns2::foo', None))
def testlookup_symbol_in_namespaces(self):
st = symbols.SymbolTable()
# 3 nested namespaces, all contain the same symbol (foo).
ns = ['ns1', 'ns2', 'ns3']
add_symbol = self._add_symbol
# Also add foo to the global namespace.
ns_symbols = [add_symbol(st, 'foo', None)] + \
[add_symbol(st, 'foo', ns[:i + 1])
for i in range(len(ns))]
# Verify global lookup works.
self.assertEqual(ns_symbols[0], st.lookup_symbol('::foo', ns))
# Verify looking up relative symbols work.
self.assertEqual(ns_symbols[1], st.lookup_symbol('foo', ns[:1]))
self.assertEqual(ns_symbols[2], st.lookup_symbol('foo', ns[:2]))
self.assertEqual(ns_symbols[3], st.lookup_symbol('foo', ns[:3]))
bigger = ns + ['ns4', 'ns5']
self.assertEqual(ns_symbols[3], st.lookup_symbol('foo', bigger))
# Remove ns2 and verify that when looking for foo in ns2 it finds ns1.
ns1 = st.namespaces['ns1']
del ns1['ns2']
self.assertEqual(ns_symbols[1], st.lookup_symbol('foo', ns[:2]))
def testLookupSymbolWithComplexGlobalThatExists(self):
st = symbols.SymbolTable()
node, module = self._AddSymbol(st, 'foo', ['ns1', 'ns2'])
self.assertEqual((node, module),
st.LookupSymbol('::ns1::ns2::foo', None))
self.assertEqual((node, module),
st.LookupSymbol('ns1::ns2::foo', None))
def __init__(self, filename, source, ast_list):
self.filename = filename
self.normalized_filename = os.path.abspath(filename)
self.source = source
self.ast_list = ast_list
self.symbol_table = symbols.SymbolTable()
self.metrics = metrics.Metrics(source)
self.warnings = []
if filename not in self._module_cache:
self._module_cache[filename] = Module(filename, ast_list)
def test_add(self):
st = symbols.SymbolTable()
node = object()
module = object()
namespace = {}
symbol_name = 'foo'
self.assertEqual(True, st._add(symbol_name, namespace, node, module))
self.assertEqual(1, len(namespace))
self.assertEqual(['foo'], list(namespace.keys()))
# Adding again should return False.
self.assertEqual(False, st._add(symbol_name, namespace, node, module))
def testadd_symbol_in_global_namespace(self):
st = symbols.SymbolTable()
node = object()
module = object()
ns_stack = None
name = 'foo'
self.assertEqual(True, st.add_symbol(name, ns_stack, node, module))
# Verify the symbol was added properly to the symbol table namespaces.
self.assertTrue('foo' in st.namespaces[None])
self.assertEqual((node, module), st.namespaces[None]['foo'])
# Already added, verify we get false.
self.assertEqual(False, st.add_symbol(name, ns_stack, node, module))
def testAddSymbolInNamespaceWithOneLevel(self):
st = symbols.SymbolTable()
node = object()
module = object()
ns_stack = ['ns-foo']
name = 'foo'
self.assertEqual(True, st.AddSymbol(name, ns_stack, node, module))
# Verify the symbol was added properly to the symbol table namespaces.
self.assert_('ns-foo' in st.namespaces)
self.assert_('foo' in st.namespaces['ns-foo'])
self.assertEqual((node, module), st.namespaces['ns-foo']['foo'])
# Already added, verify we get false.
self.assertEqual(False, st.AddSymbol(name, ns_stack, node, module))
def testadd_symbol_in_namespace_with_three_levels(self):
st = symbols.SymbolTable()
node = object()
module = object()
ns_stack = ['ns1', 'ns2', 'ns3']
name = 'foo'
self.assertEqual(True, st.add_symbol(name, ns_stack, node, module))
# Verify the symbol was added properly to the symbol table namespaces.
self.assertTrue('ns1' in st.namespaces)
self.assertTrue('ns2' in st.namespaces['ns1'])
self.assertTrue('ns3' in st.namespaces['ns1']['ns2'])
self.assertTrue('foo' in st.namespaces['ns1']['ns2']['ns3'])
self.assertEqual((node, module),
st.namespaces['ns1']['ns2']['ns3']['foo'])
# Now add something to ns1 and verify.
ns_stack = ['ns1']
name = 'something'
self.assertEqual(True, st.add_symbol(name, ns_stack, node, module))
self.assertTrue('something' in st.namespaces['ns1'])
self.assertEqual((node, module), st.namespaces['ns1']['something'])
# Now add something to ns1::ns2 and verify.
ns_stack = ['ns1', 'ns2']
name = 'else'
self.assertEqual(True, st.add_symbol(name, ns_stack, node, module))
self.assertTrue('else' in st.namespaces['ns1']['ns2'])
self.assertEqual((node, module), st.namespaces['ns1']['ns2']['else'])
# Now add something to the global namespace and verify.
ns_stack = None
name = 'global'
self.assertEqual(True, st.add_symbol(name, ns_stack, node, module))
self.assertTrue('global' in st.namespaces[None])
self.assertEqual((node, module), st.namespaces[None]['global'])
# Verify table still has 2 elements (global namespace and ::ns1).
self.assertEqual(2, len(st.namespaces))
# Verify ns1 still has 2 elements (ns2 and 'something').
self.assertEqual(2, len(st.namespaces['ns1']))
# Verify ns2 still has 2 elements (ns3 and 'else').
self.assertEqual(2, len(st.namespaces['ns1']['ns2']))
# Verify ns3 still has 1 element ('foo').
self.assertEqual(1, len(st.namespaces['ns1']['ns2']['ns3']))
def testget_namespace(self):
# Setup.
st = symbols.SymbolTable()
node = object()
module = object()
ns_stack = ['ns1', 'ns2', 'ns3']
name = 'foo'
self.assertEqual(True, st.add_symbol(name, ns_stack, node, module))
# Verify.
self.assertEqual([], st.get_namespace([]))
self.assertEqual(['ns1'], st.get_namespace(['ns1']))
self.assertEqual(['ns1'], st.get_namespace(['ns1', 'foo']))
self.assertEqual(['ns1'], st.get_namespace(['ns1', 'foo']))
self.assertEqual(['ns1'], st.get_namespace(['ns1', 'foo', 'ns2']))
self.assertEqual(['ns1', 'ns2'], st.get_namespace(['ns1', 'ns2']))
self.assertEqual(['ns1', 'ns2'], st.get_namespace(['ns1', 'ns2', 'f']))
self.assertEqual(['ns1', 'ns2'], st.get_namespace(['ns1', 'ns2', 'f']))
self.assertEqual(['ns1', 'ns2', 'ns3'],
st.get_namespace(['ns1', 'ns2', 'ns3', 'f']))
def testlookup_symbol_with_global_that_exists(self):
st = symbols.SymbolTable()
node, module = self._add_symbol(st, 'foo', None)
self.assertEqual((node, module), st.lookup_symbol('foo', None))
def testlookup_symbol_with_namespace_that_does_not_exist(self):
st = symbols.SymbolTable()
self.assertRaises(symbols.Error, st.lookup_symbol, 'foo', ['n'])
def testlookup_symbol_with_global_that_does_not_exist(self):
st = symbols.SymbolTable()
self.assertRaises(symbols.Error, st.lookup_symbol, 'foo', None)
def testLookupSymbolWithGlobalThatExists(self):
st = symbols.SymbolTable()
node, module = self._AddSymbol(st, 'foo', None)
self.assertEqual((node, module), st.LookupSymbol('foo', None))
def testLookupSymbolWithNamespaceThatDoesNotExist(self):
st = symbols.SymbolTable()
self.assertRaises(symbols.Error, st.LookupSymbol, 'foo', ['n'])
def testLookupSymbolWithGlobalThatDoesNotExist(self):
st = symbols.SymbolTable()
self.assertRaises(symbols.Error, st.LookupSymbol, 'foo', None)
