mirror of
https://github.com/JakeHillion/drgn.git
synced 2024-12-25 18:23:07 +00:00
baba1ff3f0
Currently, programs can be created for three main use-cases: core dumps, the running kernel, and a running process. However, internally, the program memory, types, and symbols are pluggable. Expose that as a callback API, which makes it possible to use drgn in much more creative ways.
121 lines
4.7 KiB
Python
121 lines
4.7 KiB
Python
import itertools
|
|
import os.path
|
|
import unittest
|
|
|
|
from drgn import filename_matches
|
|
from tests.libdrgn import PathIterator, path_ends_with
|
|
|
|
|
|
# normpath("//") returns "//". See https://bugs.python.org/issue26329.
|
|
def my_normpath(path):
|
|
path = os.path.normpath(path)
|
|
if path[:2] == '//':
|
|
return path[1:]
|
|
else:
|
|
return path
|
|
|
|
|
|
# Given a sequence of components, generate all of the possible combinations of
|
|
# joining or not joining those components with '/'.
|
|
def join_combinations(components):
|
|
if len(components) > 1:
|
|
for join in itertools.product([False, True],
|
|
repeat=len(components) - 1):
|
|
combination = [components[0]]
|
|
for i in range(1, len(components)):
|
|
if join[i - 1]:
|
|
combination[-1] += '/' + components[i]
|
|
else:
|
|
combination.append(components[i])
|
|
yield combination
|
|
else:
|
|
yield components
|
|
|
|
|
|
class TestPathIterator(unittest.TestCase):
|
|
def assertComponents(self, path_components, expected, combinations=True):
|
|
if combinations:
|
|
cases = join_combinations(path_components)
|
|
else:
|
|
cases = (path_components,)
|
|
for case in cases:
|
|
with self.subTest(case=case):
|
|
self.assertEqual(list(PathIterator(*case)), expected)
|
|
|
|
def test_empty(self):
|
|
self.assertEqual(list(PathIterator()), [])
|
|
self.assertEqual(list(PathIterator('')), [])
|
|
self.assertEqual(list(PathIterator('', '')), [])
|
|
|
|
def test_simple(self):
|
|
self.assertComponents(('a',), ['a'])
|
|
self.assertComponents(('abc', 'def'), ['def', 'abc'])
|
|
self.assertComponents(('abc', 'def', 'ghi'), ['ghi', 'def', 'abc'])
|
|
|
|
def test_root(self):
|
|
self.assertComponents(('/',), [''])
|
|
self.assertComponents(('/', ''), [''])
|
|
self.assertComponents(('', '/'), [''])
|
|
self.assertComponents(('', '/', ''), [''])
|
|
|
|
def test_absolute(self):
|
|
self.assertComponents(('/root',), ['root', ''])
|
|
self.assertComponents(('/./usr',), ['usr', ''])
|
|
self.assertComponents(('/home', 'user'), ['user', 'home', ''])
|
|
self.assertComponents(('foo', '/root'), ['root', ''],
|
|
combinations=False)
|
|
|
|
def test_redundant_slash(self):
|
|
self.assertComponents(('a/',), ['a'])
|
|
self.assertComponents(('a//',), ['a'])
|
|
self.assertComponents(('//',), [''])
|
|
self.assertComponents(('//a',), ['a', ''])
|
|
self.assertComponents(('///a',), ['a', ''])
|
|
|
|
def test_dot(self):
|
|
self.assertComponents(('a', '.'), ['a'])
|
|
self.assertComponents(('.', 'a'), ['a'])
|
|
self.assertComponents(('.', 'a', '.'), ['a'])
|
|
|
|
def test_dot_dot(self):
|
|
self.assertComponents(('a', 'b', '..'), ['a'])
|
|
self.assertComponents(('a', '..', 'b'), ['b'])
|
|
|
|
def test_relative_dot_dot(self):
|
|
self.assertComponents(('..', 'one', 'two'), ['two', 'one', '..'])
|
|
self.assertComponents(('one', '..', '..', 'two'), ['two', '..'])
|
|
self.assertComponents(('one', 'two', '..', '..', '..'), ['..'])
|
|
|
|
def test_dot_dot_above_root(self):
|
|
self.assertComponents(('/..', 'one', 'two'), ['two', 'one', ''])
|
|
self.assertComponents(('/one', '..', '..', 'two'), ['two', ''])
|
|
self.assertComponents(('/one', 'two', '..', '..', '..'), [''])
|
|
|
|
def test_current_directory(self):
|
|
self.assertComponents(('.',), [])
|
|
self.assertComponents(('', '.'), [], combinations=False)
|
|
self.assertComponents(('.', ''), [])
|
|
self.assertComponents(('.', '.'), [])
|
|
self.assertComponents(('foo', '..'), [])
|
|
self.assertComponents(('a', 'b', '..', '..'), [])
|
|
|
|
def assertPathEndsWith(self, haystack, needle):
|
|
self.assertTrue(path_ends_with(PathIterator(*haystack),
|
|
PathIterator(*needle)))
|
|
self.assertTrue(filename_matches(os.path.join(*haystack),
|
|
os.path.join(*needle)))
|
|
|
|
def assertNotPathEndsWith(self, haystack, needle):
|
|
self.assertFalse(path_ends_with(PathIterator(*haystack),
|
|
PathIterator(*needle)))
|
|
self.assertFalse(filename_matches(os.path.join(*haystack),
|
|
os.path.join(*needle)))
|
|
|
|
def test_path_ends_with(self):
|
|
self.assertPathEndsWith(('ab/cd/ef',), ('ef',))
|
|
self.assertPathEndsWith(('ab/cd/ef',), ('cd/ef',))
|
|
self.assertNotPathEndsWith(('ab/cd/ef',), ('d/ef',))
|
|
self.assertNotPathEndsWith(('ab/cd', '/ef'), ('cd/ef',))
|
|
self.assertPathEndsWith(('/abc',), ('abc',))
|
|
self.assertNotPathEndsWith(('abc',), ('/abc',))
|