class BblfshTests(unittest.TestCase):
BBLFSH_SERVER_EXISTED = None
fixtures_pyfile = "fixtures/test.py"
fixtures_cfile = "fixtures/test.c"
@classmethod
def setUpClass(cls: t.Any) -> None:
cls.BBLFSH_SERVER_EXISTED = ensure_bblfsh_is_running()
@classmethod
def tearDownClass(cls: t.Any) -> None:
if not cls.BBLFSH_SERVER_EXISTED:
client = docker.from_env(version="auto")
client.containers.get("bblfshd").remove(force=True)
client.api.close()
def setUp(self) -> None:
self.client = BblfshClient("localhost:9432")
def _parse_fixture(self) -> ResultContext:
ctx = self.client.parse(self.fixtures_pyfile)
self._validate_ctx(ctx)
return ctx
def testVersion(self) -> None:
version = self.client.version()
self.assertTrue(hasattr(version, "version"))
self.assertTrue(version.version)
self.assertTrue(hasattr(version, "build"))
self.assertTrue(version.build)
def testNativeParse(self) -> None:
ctx = self.client.parse(self.fixtures_pyfile, mode=Modes.NATIVE)
self._validate_ctx(ctx)
self.assertIsNotNone(ctx)
it = ctx.filter("//*[@ast_type='NoopLine']")
self.assertIsNotNone(it)
self.assertIsInstance(it, NodeIterator)
res = list(it)
self.assertGreater(len(res), 1)
for i in res:
t = i.get_dict().get("ast_type")
self.assertIsNotNone(t)
self.assertEqual(t, "NoopLine")
def testNonUTF8ParseError(self) -> None:
self.assertRaises(NonUTF8ContentException, self.client.parse, "",
"Python", b"a = '\x80abc'")
def testUASTDefaultLanguage(self) -> None:
ctx = self._parse_fixture()
self.assertEqual(ctx.language, "python")
def testUASTWithLanguage(self) -> None:
ctx = self.client.parse(self.fixtures_pyfile, language="Python")
self._validate_ctx(ctx)
self.assertEqual(ctx.language, "python")
def testUASTWithLanguageAlias(self) -> None:
ctx = self.client.parse(self.fixtures_cfile)
self._validate_ctx(ctx)
self.assertEqual(ctx.language, "c")
it = ctx.filter(
"//uast:FunctionGroup/Nodes/uast:Alias/Name/uast:Identifier/Name")
self.assertIsInstance(it, NodeIterator)
self.assertEqual(next(it).get(), "main")
self.assertEqual(next(it).get(), "fib")
def testUASTFileContents(self) -> None:
with open(self.fixtures_pyfile, "r") as fin:
contents = fin.read()
ctx = self.client.parse("file.py", contents=contents)
self._validate_ctx(ctx)
def assert_strnode(n: Node, expected: str) -> None:
self.assertEqual(n.get(), expected)
self.assertIsInstance(n.get_str(), str)
self.assertEqual(n.get_str(), expected)
it = ctx.filter("//uast:RuntimeImport/Path/uast:Identifier/Name")
self.assertIsInstance(it, NodeIterator)
assert_strnode(next(it), "os")
assert_strnode(next(it), "resource")
assert_strnode(next(it), "unittest")
assert_strnode(next(it), "docker")
assert_strnode(next(it), "bblfsh")
assert_strnode(next(it), "bblfsh")
self.assertRaises(StopIteration, next, it)
def testBrokenFilter(self) -> None:
ctx = self._parse_fixture()
self.assertRaises(RuntimeError, ctx.filter, "dsdfkj32423#$@#$")
def testFilterToken(self):
ctx = self._parse_fixture()
it = ctx.filter("//*[@token='else']/text()")
first = next(it).get_str()
self.assertEqual(first, "else")
def testFilterRoles(self) -> None:
ctx = self._parse_fixture()
it = ctx.filter("//*[@role='Identifier']")
self.assertIsInstance(it, NodeIterator)
l = list(it)
self.assertGreater(len(l), 0)
it = ctx.filter("//*[@role='Friend']")
self.assertIsInstance(it, NodeIterator)
l = list(it)
self.assertEqual(len(l), 0)
def testFilterProperties(self) -> None:
ctx = uast()
obj = {"k1": "v1", "k2": "v2"}
self.assertTrue(any(ctx.filter("/*[@k1='v1']", obj)))
self.assertTrue(any(ctx.filter("/*[@k2='v2']", obj)))
self.assertFalse(any(ctx.filter("/*[@k2='v1']", obj)))
self.assertFalse(any(ctx.filter("/*[@k1='v2']", obj)))
def testFilterStartOffset(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(
any(
ctx.filter(
"//uast:Positions/start/uast:Position[@offset=11749]")))
self.assertFalse(
any(
ctx.filter(
"//uast:Positions/start/uast:Position[@offset=99999]")))
def testFilterStartLine(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(
any(ctx.filter("//uast:Positions/start/uast:Position[@line=295]")))
self.assertFalse(
any(ctx.filter(
"//uast:Positions/start/uast:Position[@line=99999]")))
def testFilterStartCol(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(
any(ctx.filter("//uast:Positions/start/uast:Position[@col=42]")))
self.assertFalse(
any(ctx.filter(
"//uast:Positions/start/uast:Position[@col=99999]")))
def testFilterEndOffset(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(
any(ctx.filter(
"//uast:Positions/end/uast:Position[@offset=11757]")))
self.assertFalse(
any(ctx.filter(
"//uast:Positions/end/uast:Position[@offset=99999]")))
def testFilterEndLine(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(
any(ctx.filter("//uast:Positions/end/uast:Position[@line=321]")))
self.assertFalse(
any(ctx.filter("//uast:Positions/end/uast:Position[@line=99999]")))
def testFilterEndCol(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(
any(ctx.filter("//uast:Positions/end/uast:Position[@col=49]")))
self.assertFalse(
any(ctx.filter("//uast:Positions/end/uast:Position[@col=99999]")))
def testFilterBool(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(
ctx.filter("boolean(//uast:Positions/end/uast:Position[@col=49])"))
self.assertTrue(
next(
ctx.filter(
"boolean(//uast:Positions/end/uast:Position[@col=49])")).
get())
self.assertTrue(
next(
ctx.filter(
"boolean(//uast:Positions/end/uast:Position[@col=49])")).
get_bool())
self.assertFalse(
next(
ctx.filter(
"boolean(//uast:Positions/end/uast:Position[@col=9999])")).
get())
self.assertFalse(
next(
ctx.filter(
"boolean(//uast:Positions/end/uast:Position[@col=9999])")).
get_bool())
def testFilterNumber(self) -> None:
ctx = self._parse_fixture()
self.assertEqual(
next(
ctx.filter("count(//uast:Positions/end/uast:Position[@col=49])"
)).get(), 2)
self.assertEqual(
next(
ctx.filter("count(//uast:Positions/end/uast:Position[@col=49])"
)).get_int(), 2)
self.assertEqual(
next(
ctx.filter("count(//uast:Positions/end/uast:Position[@col=49])"
)).get_float(), 2.0)
def testFilterString(self) -> None:
ctx = self._parse_fixture()
self.assertEqual(
next(ctx.filter("name(//uast:Positions)")).get(), "uast:Positions")
self.assertEqual(
next(ctx.filter("name(//uast:Positions)")).get_str(),
"uast:Positions")
def testFilterBadQuery(self) -> None:
ctx = uast()
self.assertRaises(RuntimeError, ctx.filter, "//[@roleModule]", {})
def testFilterBadType(self) -> None:
ctx = self._parse_fixture()
res = next(
ctx.filter("count(//uast:Positions/end/uast:Position[@col=49])"))
self.assertRaises(NodeTypedGetException, res.get_str)
def testRoleIdName(self) -> None:
self.assertEqual(role_id(role_name(1)), 1)
self.assertEqual(role_name(role_id("IDENTIFIER")), "IDENTIFIER")
@staticmethod
def _itTestTree() -> dict:
def set_position(node: dict, start_offset: int, start_line: int,
start_col: int, end_offset: int, end_line: int,
end_col: int) -> None:
node["@pos"] = {
"@type": "uast:Positions",
"start": {
"@type": "uast:Position",
"offset": start_offset,
"line": start_line,
"col": start_col
},
"end": {
"@type": "uast:Position",
"offset": end_offset,
"line": end_line,
"col": end_col
}
}
root = {"@type": "root"}
set_position(root, 0, 1, 1, 1, 1, 2)
son1 = {"@type": "son1"}
set_position(son1, 2, 2, 2, 3, 2, 3)
son1_1 = {"@type": "son1_1"}
set_position(son1_1, 10, 10, 1, 12, 2, 2)
son1_2 = {"@type": "son1_2"}
set_position(son1_2, 10, 10, 1, 12, 2, 2)
son1["children"] = [son1_1, son1_2]
son2 = {"@type": "son2"}
set_position(son2, 100, 100, 1, 101, 100, 2)
son2_1 = {"@type": "son2_1"}
set_position(son2_1, 5, 5, 1, 6, 5, 2)
son2_2 = {"@type": "son2_2"}
set_position(son2_2, 15, 15, 1, 16, 15, 2)
son2["children"] = [son2_1, son2_2]
root["children"] = [son1, son2]
return root
@staticmethod
def _get_nodetypes(iterator: NodeIterator) -> t.List[str]:
return [
n["@type"] for n in filter(lambda x: isinstance(x, dict), iterator)
]
def testIteratorPreOrder(self) -> None:
root = self._itTestTree()
it = iterator(root, TreeOrder.PRE_ORDER)
self.assertIsNotNone(it)
expanded = self._get_nodetypes(it)
self.assertListEqual(
expanded,
['root', 'son1', 'son1_1', 'son1_2', 'son2', 'son2_1', 'son2_2'])
def testIteratorPostOrder(self) -> None:
root = self._itTestTree()
it = iterator(root, TreeOrder.POST_ORDER)
self.assertIsNotNone(it)
expanded = self._get_nodetypes(it)
self.assertListEqual(
expanded,
['son1_1', 'son1_2', 'son1', 'son2_1', 'son2_2', 'son2', 'root'])
def testIteratorLevelOrder(self) -> None:
root = self._itTestTree()
it = iterator(root, TreeOrder.LEVEL_ORDER)
self.assertIsNotNone(it)
expanded = self._get_nodetypes(it)
self.assertListEqual(
expanded,
['root', 'son1', 'son2', 'son1_1', 'son1_2', 'son2_1', 'son2_2'])
def testIteratorPositionOrder(self) -> None:
root = self._itTestTree()
it = iterator(root, TreeOrder.POSITION_ORDER)
self.assertIsNotNone(it)
expanded = self._get_nodetypes(it)
self.assertListEqual(
expanded,
['root', 'son1', 'son2_1', 'son1_1', 'son1_2', 'son2_2', 'son2'])
def _validate_ctx(self, ctx: ResultContext) -> None:
self.assertIsNotNone(ctx)
self.assertIsInstance(ctx, ResultContext)
self.assertIsInstance(ctx.uast, Node)
def testFilterInsideIter(self) -> None:
ctx = self._parse_fixture()
c2 = uast()
for n in ctx.iterate(TreeOrder.PRE_ORDER):
c2.filter("//uast:Positions", n)
def testItersMixingIterations(self) -> None:
ctx = self._parse_fixture()
it = ctx.iterate(TreeOrder.PRE_ORDER)
next(it)
next(it)
next(it)
next(it)
it2 = it.iterate(TreeOrder.PRE_ORDER)
next(it2)
a = next(it).get()
b = next(it2).get()
self.assertEqual(a, b)
def testManyFilters(self) -> None:
ctx = self._parse_fixture()
before = resource.getrusage(resource.RUSAGE_SELF)
for _ in range(10000):
ctx.filter("//*[@role='Identifier']")
after = resource.getrusage(resource.RUSAGE_SELF)
# Check that memory usage has not doubled
self.assertLess(after[2] / before[2], 2.0)
def testManyParses(self) -> None:
before = resource.getrusage(resource.RUSAGE_SELF)
for _ in range(100):
self.client.parse(self.fixtures_pyfile)
after = resource.getrusage(resource.RUSAGE_SELF)
# Check that memory usage has not doubled
self.assertLess(after[2] / before[2], 2.0)
def testManyParsesAndFilters(self) -> None:
before = resource.getrusage(resource.RUSAGE_SELF)
for _ in range(100):
ctx = self.client.parse(self.fixtures_pyfile)
ctx.filter("//*[@role='Identifier']")
after = resource.getrusage(resource.RUSAGE_SELF)
# Check that memory usage has not doubled
self.assertLess(after[2] / before[2], 2.0)
def testSupportedLanguages(self) -> None:
res = self.client.supported_languages()
self.assertGreater(len(res), 0)
for l in res:
for key in ('language', 'version', 'status', 'features'):
self.assertTrue(hasattr(l, key))
self.assertIsNotNone(getattr(l, key))
def testEncode(self) -> None:
ctx = self._parse_fixture()
self.assertEqual(ctx.ctx.encode(None, 0), ctx._response.uast)
def testEncodeWithEmptyContext(self) -> None:
ctx = ResultContext()
obj = {"k1": "v1", "k2": "v2"}
fmt = 1 # YAML
data = ctx.ctx.encode(obj, fmt)
self.assertDictEqual(obj, decode(data, format=fmt).load())
def testGetAll(self) -> None:
ctx = self._parse_fixture()
expected = ["os", "resource", "unittest", "docker", "bblfsh"]
actual = []
for k in ctx.get_all()["body"]:
if "@type" in k and k[
"@type"] == "uast:RuntimeImport" and "Path" in k:
path = k["Path"]
if "Name" in path:
actual.append(k["Path"]["Name"])
self.assertListEqual(expected, actual)
def testLoad(self) -> None:
ctx = self._parse_fixture()
it = ctx.iterate(TreeOrder.PRE_ORDER)
next(it)
next(it)
next(it)
next(it)
it2 = it.iterate(TreeOrder.PRE_ORDER)
n = next(it2)
node_ext = n.node_ext
obj = node_ext.load()
typ = obj["@type"]
self.assertEqual("uast:RuntimeImport", typ)
path = obj["Path"]
self.assertEqual("uast:Identifier", path["@type"])
self.assertEqual("os", path["Name"])
class BblfshTests(unittest.TestCase):
BBLFSH_SERVER_EXISTED = None
fixtures_pyfile = "fixtures/test.py"
fixtures_cfile = "fixtures/test.c"
@classmethod
def setUpClass(cls: t.Any) -> None:
cls.BBLFSH_SERVER_EXISTED = ensure_bblfsh_is_running()
@classmethod
def tearDownClass(cls: t.Any) -> None:
if not cls.BBLFSH_SERVER_EXISTED:
client = docker.from_env(version="auto")
client.containers.get("bblfshd").remove(force=True)
client.api.close()
def setUp(self) -> None:
self.client = BblfshClient("localhost:9432")
def _parse_fixture(self) -> ResultContext:
ctx = self.client.parse(self.fixtures_pyfile)
self._validate_ctx(ctx)
return ctx
def testVersion(self) -> None:
version = self.client.version()
self.assertTrue(hasattr(version, "version"))
self.assertTrue(version.version)
self.assertTrue(hasattr(version, "build"))
self.assertTrue(version.build)
def testNativeParse(self) -> None:
ctx = self.client.parse(self.fixtures_pyfile, mode=Modes.NATIVE)
self._validate_ctx(ctx)
self.assertIsNotNone(ctx)
it = ctx.filter("//*[@ast_type='NoopLine']")
self.assertIsNotNone(it)
self.assertIsInstance(it, NodeIterator)
res = list(it)
self.assertGreater(len(res), 1)
for i in res:
t = i.get_dict().get("ast_type")
self.assertIsNotNone(t)
self.assertEqual(t, "NoopLine")
def testNonUTF8ParseError(self) -> None:
self.assertRaises(NonUTF8ContentException,
self.client.parse, "", "Python", b"a = '\x80abc'")
def testUASTDefaultLanguage(self) -> None:
ctx = self._parse_fixture()
self.assertEqual(ctx.language, "python")
def testUASTWithLanguage(self) -> None:
ctx = self.client.parse(self.fixtures_pyfile, language="Python")
self._validate_ctx(ctx)
self.assertEqual(ctx.language, "python")
def testUASTWithLanguageAlias(self) -> None:
ctx = self.client.parse(self.fixtures_cfile)
self._validate_ctx(ctx)
self.assertEqual(ctx.language, "c")
it = ctx.filter("//uast:FunctionGroup/Nodes/uast:Alias/Name/uast:Identifier/Name")
self.assertIsInstance(it, NodeIterator)
self.assertEqual(next(it).get(), "main")
self.assertEqual(next(it).get(), "fib")
def testUASTFileContents(self) -> None:
with open(self.fixtures_pyfile, "r") as fin:
contents = fin.read()
ctx = self.client.parse("file.py", contents=contents)
self._validate_ctx(ctx)
def assert_strnode(n: Node, expected: str) -> None:
self.assertEqual(n.get(), expected)
self.assertIsInstance(n.get_str(), str)
self.assertEqual(n.get_str(), expected)
it = ctx.filter("//uast:RuntimeImport/Path/uast:Identifier/Name")
self.assertIsInstance(it, NodeIterator)
assert_strnode(next(it), "os")
assert_strnode(next(it), "resource")
assert_strnode(next(it), "unittest")
assert_strnode(next(it), "docker")
assert_strnode(next(it), "bblfsh")
assert_strnode(next(it), "bblfsh")
self.assertRaises(StopIteration, next, it)
def testBrokenFilter(self) -> None:
ctx = self._parse_fixture()
self.assertRaises(RuntimeError, ctx.filter, "dsdfkj32423#$@#$")
def testFilterToken(self):
ctx = self._parse_fixture()
it = ctx.filter("//*[@token='else']/text()")
first = next(it).get_str()
self.assertEqual(first, "else")
def testFilterRoles(self) -> None:
ctx = self._parse_fixture()
it = ctx.filter("//*[@role='Identifier']")
self.assertIsInstance(it, NodeIterator)
l = list(it)
self.assertGreater(len(l), 0)
it = ctx.filter("//*[@role='Friend']")
self.assertIsInstance(it, NodeIterator)
l = list(it)
self.assertEqual(len(l), 0)
def testFilterProperties(self) -> None:
ctx = uast()
obj = {"k1": "v1", "k2": "v2"}
self.assertTrue(any(ctx.filter("/*[@k1='v1']", obj)))
self.assertTrue(any(ctx.filter("/*[@k2='v2']", obj)))
self.assertFalse(any(ctx.filter("/*[@k2='v1']", obj)))
self.assertFalse(any(ctx.filter("/*[@k1='v2']", obj)))
def testFilterStartOffset(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(any(ctx.filter("//uast:Positions/start/uast:Position[@offset=11749]")))
self.assertFalse(any(ctx.filter("//uast:Positions/start/uast:Position[@offset=99999]")))
def testFilterStartLine(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(any(ctx.filter("//uast:Positions/start/uast:Position[@line=295]")))
self.assertFalse(any(ctx.filter("//uast:Positions/start/uast:Position[@line=99999]")))
def testFilterStartCol(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(any(ctx.filter("//uast:Positions/start/uast:Position[@col=42]")))
self.assertFalse(any(ctx.filter("//uast:Positions/start/uast:Position[@col=99999]")))
def testFilterEndOffset(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(any(ctx.filter("//uast:Positions/end/uast:Position[@offset=11757]")))
self.assertFalse(any(ctx.filter("//uast:Positions/end/uast:Position[@offset=99999]")))
def testFilterEndLine(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(any(ctx.filter("//uast:Positions/end/uast:Position[@line=321]")))
self.assertFalse(any(ctx.filter("//uast:Positions/end/uast:Position[@line=99999]")))
def testFilterEndCol(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(any(ctx.filter("//uast:Positions/end/uast:Position[@col=49]")))
self.assertFalse(any(ctx.filter("//uast:Positions/end/uast:Position[@col=99999]")))
def testFilterBool(self) -> None:
ctx = self._parse_fixture()
self.assertTrue(ctx.filter("boolean(//uast:Positions/end/uast:Position[@col=49])"))
self.assertTrue(next(ctx.filter("boolean(//uast:Positions/end/uast:Position[@col=49])")).get())
self.assertTrue(next(ctx.filter("boolean(//uast:Positions/end/uast:Position[@col=49])")).get_bool())
self.assertFalse(next(ctx.filter("boolean(//uast:Positions/end/uast:Position[@col=9999])")).get())
self.assertFalse(next(ctx.filter("boolean(//uast:Positions/end/uast:Position[@col=9999])")).get_bool())
def testFilterNumber(self) -> None:
ctx = self._parse_fixture()
self.assertEqual(next(ctx.filter("count(//uast:Positions/end/uast:Position[@col=49])")).get(), 2)
self.assertEqual(next(ctx.filter("count(//uast:Positions/end/uast:Position[@col=49])")).get_int(), 2)
self.assertEqual(next(ctx.filter("count(//uast:Positions/end/uast:Position[@col=49])")).get_float(), 2.0)
def testFilterString(self) -> None:
ctx = self._parse_fixture()
self.assertEqual(next(ctx.filter("name(//uast:Positions)")).get(), "uast:Positions")
self.assertEqual(next(ctx.filter("name(//uast:Positions)")).get_str(), "uast:Positions")
def testFilterBadQuery(self) -> None:
ctx = uast()
self.assertRaises(RuntimeError, ctx.filter, "//[@roleModule]", {})
def testFilterBadType(self) -> None:
ctx = self._parse_fixture()
res = next(ctx.filter("count(//uast:Positions/end/uast:Position[@col=49])"))
self.assertRaises(NodeTypedGetException, res.get_str)
def testRoleIdName(self) -> None:
self.assertEqual(role_id(role_name(1)), 1)
self.assertEqual(role_name(role_id("IDENTIFIER")), "IDENTIFIER")
@staticmethod
def _itTestTree() -> dict:
def set_position(node: dict, start_offset: int, start_line: int, start_col: int,
end_offset: int, end_line: int, end_col: int) -> None:
node["@pos"] = {
"@type": "uast:Positions",
"start": {
"@type": "uast:Position",
"offset": start_offset,
"line": start_line,
"col": start_col
},
"end": {
"@type": "uast:Position",
"offset": end_offset,
"line": end_line,
"col": end_col
}
}
root = {"@type": "root"}
set_position(root, 0,1,1, 1,1,2)
son1 = {"@type": "son1"}
set_position(son1, 2,2,2, 3,2,3)
son1_1 = {"@type": "son1_1"}
set_position(son1_1, 10,10,1, 12,2,2)
son1_2 = {"@type": "son1_2"}
set_position(son1_2, 10,10,1, 12,2,2)
son1["children"] = [son1_1, son1_2]
son2 = {"@type": "son2"}
set_position(son2, 100,100,1, 101,100,2)
son2_1 = {"@type": "son2_1"}
set_position(son2_1, 5,5,1, 6,5,2)
son2_2 = {"@type": "son2_2"}
set_position(son2_2, 15,15,1, 16,15,2)
son2["children"] = [son2_1, son2_2]
root["children"] = [son1, son2]
return root
@staticmethod
def _get_nodetypes(iterator: NodeIterator) -> t.List[str]:
return [n["@type"] for n in
filter(lambda x: isinstance(x, dict), iterator)]
@staticmethod
def _get_nodes(iterator: NodeIterator) -> t.List[dict]:
return [n.get() for n in iterator]
@staticmethod
def _get_positions(iterator: NodeIterator):
startPositions = [ n["@pos"]["start"] for n in
filter(lambda x: isinstance(x, dict) and
"@pos" in x.keys() and
"start" in x["@pos"].keys(), iterator) ]
return [ (int(n["offset"]), int(n["line"]), int(n["col"])) for n in startPositions ]
def decrefAndGC(self, obj) -> None:
del obj
gc.collect()
def testIteratorPreOrder(self) -> None:
root = self._itTestTree()
it = iterator(root, TreeOrder.PRE_ORDER)
self.assertIsNotNone(it)
expanded = self._get_nodetypes(it)
self.assertListEqual(expanded, ['root', 'son1', 'son1_1', 'son1_2',
'son2', 'son2_1', 'son2_2'])
def testIteratorPostOrder(self) -> None:
root = self._itTestTree()
it = iterator(root, TreeOrder.POST_ORDER)
self.assertIsNotNone(it)
expanded = self._get_nodetypes(it)
self.assertListEqual(expanded, ['son1_1', 'son1_2', 'son1', 'son2_1',
'son2_2', 'son2', 'root'])
def testIteratorLevelOrder(self) -> None:
root = self._itTestTree()
it = iterator(root, TreeOrder.LEVEL_ORDER)
self.assertIsNotNone(it)
expanded = self._get_nodetypes(it)
self.assertListEqual(expanded, ['root', 'son1', 'son2', 'son1_1',
'son1_2', 'son2_1', 'son2_2'])
def testIteratorPositionOrder(self) -> None:
# Check first our homemade tree
root = self._itTestTree()
it = iterator(root, TreeOrder.POSITION_ORDER)
self.assertIsNotNone(it)
expanded = self._get_nodetypes(it)
self.assertListEqual(expanded, ['root', 'son1', 'son2_1', 'son1_1',
'son1_2', 'son2_2', 'son2'])
# Check that when using the positional order the positions we get are
# in fact sorted by (offset, line, col)
it = iterator(root, TreeOrder.POSITION_ORDER)
positions = self._get_positions(it)
self.assertListEqual(positions, [(0,1,1), (2,2,2), (5,5,1), (10,10,1),
(10,10,1), (15,15,1), (100,100,1)])
def testAnyOrder(self) -> None:
root = self._itTestTree()
it = iterator(root, TreeOrder.ANY_ORDER)
self.assertIsNotNone(it)
expanded = self._get_nodetypes(it)
# We only can test that the order gives us all the nodes
self.assertEqual(set(expanded), {'root', 'son1', 'son2', 'son1_1',
'son1_2', 'son2_1', 'son2_2'})
def testChildrenOrder(self) -> None:
root = self._itTestTree()
it = iterator(root, TreeOrder.CHILDREN_ORDER)
self.assertIsNotNone(it)
expanded = self._get_nodetypes(it)
# We only can test that the order gives us all the nodes
self.assertEqual(expanded, ['son1', 'son2'])
# Iterating from the root node should give the same result as
# iterating from the tree, for every available node
def testNodeIteratorEqualsCtxIterator(self) -> None:
ctx = self._parse_fixture()
root = ctx.root
for order in TreeOrder:
itCtx = ctx.iterate(order)
itRoot = root.iterate(order)
self.assertListEqual(self._get_nodes(itCtx), self._get_nodes(itRoot))
def _validate_ctx(self, ctx: ResultContext) -> None:
self.assertIsNotNone(ctx)
self.assertIsInstance(ctx, ResultContext)
self.assertIsInstance(ctx.uast, Node)
def testFilterInsideIter(self) -> None:
ctx = self._parse_fixture()
c2 = uast()
for n in ctx.iterate(TreeOrder.PRE_ORDER):
c2.filter("//uast:Positions", n)
def testItersMixingIterations(self) -> None:
ctx = self._parse_fixture()
it = ctx.iterate(TreeOrder.PRE_ORDER)
next(it); next(it); next(it); next(it)
it2 = it.iterate(TreeOrder.PRE_ORDER)
next(it2)
a = next(it).get()
b = next(it2).get()
self.assertEqual(a, b)
def testManyFilters(self) -> None:
ctx = self._parse_fixture()
before = resource.getrusage(resource.RUSAGE_SELF)
for _ in range(10000):
ctx.filter("//*[@role='Identifier']")
after = resource.getrusage(resource.RUSAGE_SELF)
# Check that memory usage has not doubled
self.assertLess(after[2] / before[2], 2.0)
def testManyParses(self) -> None:
before = resource.getrusage(resource.RUSAGE_SELF)
for _ in range(100):
self.client.parse(self.fixtures_pyfile)
after = resource.getrusage(resource.RUSAGE_SELF)
# Check that memory usage has not doubled
self.assertLess(after[2] / before[2], 2.0)
def testManyParsesAndFilters(self) -> None:
before = resource.getrusage(resource.RUSAGE_SELF)
for _ in range(100):
ctx = self.client.parse(self.fixtures_pyfile)
ctx.filter("//*[@role='Identifier']")
after = resource.getrusage(resource.RUSAGE_SELF)
# Check that memory usage has not doubled
self.assertLess(after[2] / before[2], 2.0)
def testSupportedLanguages(self) -> None:
res = self.client.supported_languages()
self.assertGreater(len(res), 0)
for l in res:
for key in ('language', 'version', 'status', 'features'):
self.assertTrue(hasattr(l, key))
self.assertIsNotNone(getattr(l, key))
def testEncode(self) -> None:
ctx = self._parse_fixture()
# This test is here for backward compatibility purposes,
# in case someone was relying on encoding contexts this way
self.assertEqual(ctx.ctx.encode(None, 0), ctx._response.uast)
self.assertEqual(ctx.encode(), ctx._response.uast)
def testEncodeWithEmptyContext(self) -> None:
ctx = ResultContext()
obj = {"k1": "v1", "k2": "v2"}
fmt = 1 # YAML
# This test is here for backward compatibility purposes,
# in case someone was relying on encoding contexts this way
data = ctx.ctx.encode(obj, fmt)
other_data = ctx.encode(obj, fmt)
self.assertDictEqual(obj, decode(data, format = fmt).load())
self.assertDictEqual(obj, decode(other_data, format = fmt).load())
def testGetAll(self) -> None:
ctx = self._parse_fixture()
expected = ["os", "resource", "unittest", "docker", "bblfsh"]
actual = []
for k in ctx.get_all()["body"]:
if "@type" in k and k["@type"] == "uast:RuntimeImport" and "Path" in k:
path = k["Path"]
if "Name" in path:
actual.append(k["Path"]["Name"])
self.assertListEqual(expected, actual)
def testLoad(self) -> None:
ctx = self._parse_fixture()
it = ctx.iterate(TreeOrder.PRE_ORDER)
next(it); next(it); next(it); next(it)
it2 = it.iterate(TreeOrder.PRE_ORDER)
n = next(it2)
node_ext = n.node_ext
obj = node_ext.load()
typ = obj["@type"]
self.assertEqual("uast:RuntimeImport", typ)
path = obj["Path"]
self.assertEqual("uast:Identifier", path["@type"])
self.assertEqual("os", path["Name"])
# The following testOrphan{x} methods verifies that iterators and nodes work
# correctly once the context they come from has been DECREFed. Loading an
# (external) node and filtering it after the context / iterators have been
# DECREFed are also checked. As an example, the following code should work
# in Python:
#
# its = []
# for file in files:
# ctx = client.parse(file)
# it = ctx.filter("blablablah")
# its.append(it)
#
# it = pick a it from its
# node = next(it)
#
# Instead of testing with a while, we can just delete ctx before doing
# something with the iterator
def testOrphanFilter(self) -> None:
ctx = self._parse_fixture()
it = ctx.filter("//uast:RuntimeImport")
self.decrefAndGC(ctx)
# We should be able to retrieve values from the iterator
# after the context has been DECREFed but the iterator
# still exists
obj = next(it).get()
typ = obj["@type"]
self.assertEqual("uast:RuntimeImport", typ)
# Chaining calls has the same effect as splitting
# the effect across different lines as above
self.decrefAndGC(it)
it = self._parse_fixture().filter("//uast:RuntimeImport")
next(it)
obj = next(it).get()
typ = obj["@type"]
self.assertEqual("uast:RuntimeImport", typ)
def testOrphanIterator(self) -> None:
ctx = self._parse_fixture()
it = ctx.iterate(TreeOrder.PRE_ORDER)
self.decrefAndGC(ctx)
# We should be able to retrieve values from the iterator
# after the context has been DECREFed but the iterator
# still exists
obj = next(it).get()
self.assertIsInstance(obj, dict)
# Chaining calls has the same effect as splitting
# the effect across different lines as above
self.decrefAndGC(it)
it = self._parse_fixture().iterate(TreeOrder.POST_ORDER)
obj = next(it)
self.assertIsInstance(obj, Node)
def testLoadOrphanNode(self) -> None:
ctx = self._parse_fixture()
it = ctx.iterate(TreeOrder.PRE_ORDER)
# The underlying ctx should not be deallocated even if ctx goes
# out of scope because the iterator is still alive
self.decrefAndGC(ctx)
next(it); next(it); next(it);
node = next(it)
self.decrefAndGC(it)
# Context should not have been deallocated yet because we
# want to iterate from the node onwards
it2 = node.iterate(TreeOrder.PRE_ORDER)
node_ext = node.node_ext
# node could be deallocated here also, if we by, any chance,
# we happen to be storing only the external nodes
self.decrefAndGC(node)
obj = node_ext.load()
typ = obj["@type"]
self.assertEqual("uast:RuntimeImport", typ)
def testFilterOrphanNode(self) -> None:
ctx = self._parse_fixture()
root = ctx.root
self.decrefAndGC(ctx)
# filter should work here over the tree even if we ctx has
# been DECREFed by the interpreter (it has gone out of scope)
it = root.filter("//uast:RuntimeImport")
obj = next(it).get()
typ = obj["@type"]
self.assertEqual("uast:RuntimeImport", typ)
def testPythonContextIterate(self) -> None:
# C++ memory context
ctxC = self._parse_fixture()
# Python memory context
pyDict = ctxC.root.get()
ctxPy = bblfsh.context(pyDict)
for treeOrder in TreeOrder:
itC = ctxC.iterate(treeOrder)
itPy = ctxPy.iterate(treeOrder)
for nodeC, nodePy in zip(itC, itPy):
self.assertEqual(nodeC.get(), nodePy)
def testPythonContextFilter(self) -> None:
# C++ memory context
ctxC = self._parse_fixture()
# Python memory context
pyDict = ctxC.root.get()
ctxPy = bblfsh.context(pyDict)
itC = ctxC.filter("//*[@role='Identifier']")
itPy = ctxPy.filter("//*[@role='Identifier']")
for nodeC, nodePy in zip(itC, itPy):
self.assertEqual(nodeC.get(), nodePy)
def testBinaryEncodeDecodePythonContext(self) -> None:
# Binary encoding should be invertible
# C++ memory context
ctxC = self._parse_fixture()
# Python memory context
pyDict = ctxC.root.get()
ctxPy = bblfsh.context(pyDict)
encoded = ctxPy.encode(fmt = 0) # Binary encoding
decoded = decode(encoded, format = 0)
self.assertEqual(pyDict, decoded.load())
def testInvalidDecodeBytes(self) -> None:
with self.assertRaises(RuntimeError):
decode(b'', format = 0)
with self.assertRaises(RuntimeError):
decode(b'abcdef', format = 0)
class BblfshTests(unittest.TestCase):
BBLFSH_SERVER_EXISTED = None
@classmethod
def setUpClass(cls):
cls.BBLFSH_SERVER_EXISTED = ensure_bblfsh_is_running()
@classmethod
def tearDownClass(cls):
if not cls.BBLFSH_SERVER_EXISTED:
client = docker.from_env(version="auto")
client.containers.get("bblfshd").remove(force=True)
client.api.close()
def setUp(self):
self.client = BblfshClient("0.0.0.0:9432")
def testVersion(self):
version = self.client.version()
self.assertTrue(hasattr(version, "version"))
self.assertTrue(version.version)
self.assertTrue(hasattr(version, "build"))
self.assertTrue(version.build)
def testNativeParse(self):
reply = self.client.native_parse(__file__)
assert (reply.ast)
def testNonUTF8ParseError(self):
self.assertRaises(NonUTF8ContentException, self.client.parse, "",
"Python", b"a = '\x80abc'")
def testUASTDefaultLanguage(self):
self._validate_resp(self.client.parse(__file__))
def testUASTPython(self):
self._validate_resp(self.client.parse(__file__, language="Python"))
def testUASTFileContents(self):
with open(__file__, "rb") as fin:
contents = fin.read()
resp = self.client.parse("file.py", contents=contents)
self._validate_resp(resp)
self._validate_filter(resp)
def testBrokenFilter(self):
self.assertRaises(RuntimeError, filter, 0, "foo")
def testFilterInternalType(self):
node = Node()
node.internal_type = 'a'
self.assertTrue(any(filter(node, "//a")))
self.assertFalse(any(filter(node, "//b")))
def testFilterToken(self):
node = Node()
node.token = 'a'
self.assertTrue(any(filter(node, "//*[@token='a']")))
self.assertFalse(any(filter(node, "//*[@token='b']")))
def testFilterRoles(self):
node = Node()
node.roles.append(1)
self.assertTrue(any(filter(node, "//*[@roleIdentifier]")))
self.assertFalse(any(filter(node, "//*[@roleQualified]")))
def testFilterProperties(self):
node = Node()
node.properties['k1'] = 'v2'
node.properties['k2'] = 'v1'
self.assertTrue(any(filter(node, "//*[@k2='v1']")))
self.assertTrue(any(filter(node, "//*[@k1='v2']")))
self.assertFalse(any(filter(node, "//*[@k1='v1']")))
def testFilterStartOffset(self):
node = Node()
node.start_position.offset = 100
self.assertTrue(any(filter(node, "//*[@startOffset=100]")))
self.assertFalse(any(filter(node, "//*[@startOffset=10]")))
def testFilterStartLine(self):
node = Node()
node.start_position.line = 10
self.assertTrue(any(filter(node, "//*[@startLine=10]")))
self.assertFalse(any(filter(node, "//*[@startLine=100]")))
def testFilterStartCol(self):
node = Node()
node.start_position.col = 50
self.assertTrue(any(filter(node, "//*[@startCol=50]")))
self.assertFalse(any(filter(node, "//*[@startCol=5]")))
def testFilterEndOffset(self):
node = Node()
node.end_position.offset = 100
self.assertTrue(any(filter(node, "//*[@endOffset=100]")))
self.assertFalse(any(filter(node, "//*[@endOffset=10]")))
def testFilterEndLine(self):
node = Node()
node.end_position.line = 10
self.assertTrue(any(filter(node, "//*[@endLine=10]")))
self.assertFalse(any(filter(node, "//*[@endLine=100]")))
def testFilterEndCol(self):
node = Node()
node.end_position.col = 50
self.assertTrue(any(filter(node, "//*[@endCol=50]")))
self.assertFalse(any(filter(node, "//*[@endCol=5]")))
def testFilterBool(self):
node = Node()
self.assertTrue(
filter_bool(node, "boolean(//*[@startOffset or @endOffset])"))
self.assertFalse(filter_bool(node, "boolean(//*[@blah])"))
def testFilterNumber(self):
node = Node()
node.children.extend([Node(), Node(), Node()])
self.assertEqual(int(filter_number(node, "count(//*)")), 4)
def testFilterString(self):
node = Node()
node.internal_type = "test"
self.assertEqual(filter_string(node, "name(//*[1])"), "test")
def testFilterBadQuery(self):
node = Node()
self.assertRaises(RuntimeError, filter, node, "//*roleModule")
def testFilterBadType(self):
node = Node()
node.end_position.col = 50
self.assertRaises(RuntimeError, filter, node,
"boolean(//*[@startPosition or @endPosition])")
def testRoleIdName(self):
self.assertEqual(role_id(role_name(1)), 1)
self.assertEqual(role_name(role_id("IDENTIFIER")), "IDENTIFIER")
def _itTestTree(self):
root = Node()
root.internal_type = 'root'
root.start_position.offset = 0
root.start_position.line = 0
root.start_position.col = 1
son1 = Node()
son1.internal_type = 'son1'
son1.start_position.offset = 1
son1_1 = Node()
son1_1.internal_type = 'son1_1'
son1_1.start_position.offset = 10
son1_2 = Node()
son1_2.internal_type = 'son1_2'
son1_2.start_position.offset = 10
son1.children.extend([son1_1, son1_2])
son2 = Node()
son2.internal_type = 'son2'
son2.start_position.offset = 100
son2_1 = Node()
son2_1.internal_type = 'son2_1'
son2_1.start_position.offset = 5
son2_2 = Node()
son2_2.internal_type = 'son2_2'
son2_2.start_position.offset = 15
son2.children.extend([son2_1, son2_2])
root.children.extend([son1, son2])
return root
def testIteratorPreOrder(self):
root = self._itTestTree()
it = iterator(root, TreeOrder.PRE_ORDER)
self.assertIsNotNone(it)
expanded = [node.internal_type for node in it]
self.assertListEqual(
expanded,
['root', 'son1', 'son1_1', 'son1_2', 'son2', 'son2_1', 'son2_2'])
def testIteratorPostOrder(self):
root = self._itTestTree()
it = iterator(root, TreeOrder.POST_ORDER)
self.assertIsNotNone(it)
expanded = [node.internal_type for node in it]
self.assertListEqual(
expanded,
['son1_1', 'son1_2', 'son1', 'son2_1', 'son2_2', 'son2', 'root'])
def testIteratorLevelOrder(self):
root = self._itTestTree()
it = iterator(root, TreeOrder.LEVEL_ORDER)
self.assertIsNotNone(it)
expanded = [node.internal_type for node in it]
self.assertListEqual(
expanded,
['root', 'son1', 'son2', 'son1_1', 'son1_2', 'son2_1', 'son2_2'])
def testIteratorPositionOrder(self):
root = self._itTestTree()
it = iterator(root, TreeOrder.POSITION_ORDER)
self.assertIsNotNone(it)
expanded = [node.internal_type for node in it]
self.assertListEqual(
expanded,
['root', 'son1', 'son2_1', 'son1_1', 'son1_2', 'son2_2', 'son2'])
def _validate_resp(self, resp):
self.assertIsNotNone(resp)
self.assertEqual(
type(resp).DESCRIPTOR.full_name,
ParseResponse.DESCRIPTOR.full_name)
self.assertEqual(len(resp.errors), 0)
# self.assertIsInstance() does not work - must be some metaclass magic
# self.assertIsInstance(resp.uast, Node)
# Sometimes its fully qualified, sometimes is just "Node"... ditto
self.assertTrue(resp.uast.__class__.__name__.endswith('Node'))
def testFilterInsideIter(self):
root = self.client.parse(__file__).uast
it = iterator(root, TreeOrder.PRE_ORDER)
self.assertIsNotNone(it)
for n in it:
filter(n, "//*[@roleIdentifier]")
def testItersMixingIterations(self):
root = self.client.parse(__file__).uast
it = iterator(root, TreeOrder.PRE_ORDER)
next(it)
next(it)
next(it)
n = next(it)
it2 = iterator(n, TreeOrder.PRE_ORDER)
next(it2)
assert (next(it) == next(it2))
def testManyFilters(self):
root = self.client.parse(__file__).uast
root.properties['k1'] = 'v2'
root.properties['k2'] = 'v1'
import resource
before = resource.getrusage(resource.RUSAGE_SELF)
for _ in range(100):
filter(root, "//*[@roleIdentifier]")
after = resource.getrusage(resource.RUSAGE_SELF)
# Check that memory usage has not doubled after running the filter
self.assertLess(after[2] / before[2], 2.0)
def _validate_filter(self, resp):
results = filter(resp.uast,
"//Import[@roleImport and @roleDeclaration]//alias")
self.assertEqual(next(results).token, "os")
self.assertEqual(next(results).token, "unittest")
self.assertEqual(next(results).token, "docker")
class BblfshTests(unittest.TestCase):
BBLFSH_SERVER_EXISTED = None
@classmethod
def setUpClass(cls):
cls.BBLFSH_SERVER_EXISTED = ensure_bblfsh_is_running()
@classmethod
def tearDownClass(cls):
if not cls.BBLFSH_SERVER_EXISTED:
client = docker.from_env(version="auto")
client.containers.get("bblfshd").remove(force=True)
client.api.close()
def setUp(self):
self.client = BblfshClient("0.0.0.0:9432")
def testVersion(self):
version = self.client.version()
self.assertTrue(hasattr(version, "version"))
self.assertTrue(version.version)
self.assertTrue(hasattr(version, "build"))
self.assertTrue(version.build)
# def testNativeParse(self):
# reply = self.client.native_parse(__file__)
# assert(reply.ast)
#
def testNonUTF8ParseError(self):
self.assertRaises(NonUTF8ContentException, self.client.parse, "",
"Python", b"a = '\x80abc'")
#
def testUASTDefaultLanguage(self):
self._validate_ctx(self.client.parse(__file__))
def testUASTPython(self):
ctx = self.client.parse(__file__, language="Python")
self._validate_ctx(ctx)
self.assertEqual(ctx.language, "python")
def testUASTFileContents(self):
with open(__file__, "rb") as fin:
contents = fin.read()
ctx = self.client.parse("file.py", contents=contents)
self._validate_ctx(ctx)
self._validate_filter(ctx)
#
# def testBrokenFilter(self):
# self.assertRaises(RuntimeError, filter, 0, "foo")
#
# def testFilterInternalType(self):
# node = Node()
# node.internal_type = 'a'
# self.assertTrue(any(filter(node, "//a")))
# self.assertFalse(any(filter(node, "//b")))
#
# def testFilterToken(self):
# node = Node()
# node.token = 'a'
# self.assertTrue(any(filter(node, "//*[@token='a']")))
# self.assertFalse(any(filter(node, "//*[@token='b']")))
#
# def testFilterRoles(self):
# node = Node()
# node.roles.append(1)
# self.assertTrue(any(filter(node, "//*[@roleIdentifier]")))
# self.assertFalse(any(filter(node, "//*[@roleQualified]")))
#
# def testFilterProperties(self):
# node = Node()
# node.properties['k1'] = 'v2'
# node.properties['k2'] = 'v1'
# self.assertTrue(any(filter(node, "//*[@k2='v1']")))
# self.assertTrue(any(filter(node, "//*[@k1='v2']")))
# self.assertFalse(any(filter(node, "//*[@k1='v1']")))
#
# def testFilterStartOffset(self):
# node = Node()
# node.start_position.offset = 100
# self.assertTrue(any(filter(node, "//*[@startOffset=100]")))
# self.assertFalse(any(filter(node, "//*[@startOffset=10]")))
#
# def testFilterStartLine(self):
# node = Node()
# node.start_position.line = 10
# self.assertTrue(any(filter(node, "//*[@startLine=10]")))
# self.assertFalse(any(filter(node, "//*[@startLine=100]")))
#
# def testFilterStartCol(self):
# node = Node()
# node.start_position.col = 50
# self.assertTrue(any(filter(node, "//*[@startCol=50]")))
# self.assertFalse(any(filter(node, "//*[@startCol=5]")))
#
# def testFilterEndOffset(self):
# node = Node()
# node.end_position.offset = 100
# self.assertTrue(any(filter(node, "//*[@endOffset=100]")))
# self.assertFalse(any(filter(node, "//*[@endOffset=10]")))
#
# def testFilterEndLine(self):
# node = Node()
# node.end_position.line = 10
# self.assertTrue(any(filter(node, "//*[@endLine=10]")))
# self.assertFalse(any(filter(node, "//*[@endLine=100]")))
#
# def testFilterEndCol(self):
# node = Node()
# node.end_position.col = 50
# self.assertTrue(any(filter(node, "//*[@endCol=50]")))
# self.assertFalse(any(filter(node, "//*[@endCol=5]")))
#
# def testFilterBool(self):
# node = Node()
# self.assertTrue(filter_bool(node, "boolean(//*[@startOffset or @endOffset])"))
# self.assertFalse(filter_bool(node, "boolean(//*[@blah])"))
#
# def testFilterNumber(self):
# node = Node()
# node.children.extend([Node(), Node(), Node()])
# self.assertEqual(int(filter_number(node, "count(//*)")), 4)
#
# def testFilterString(self):
# node = Node()
# node.internal_type = "test"
# self.assertEqual(filter_string(node, "name(//*[1])"), "test")
#
# def testFilterBadQuery(self):
# node = Node()
# self.assertRaises(RuntimeError, filter, node, "//*roleModule")
#
# def testFilterBadType(self):
# node = Node()
# node.end_position.col = 50
# self.assertRaises(RuntimeError, filter, node, "boolean(//*[@startPosition or @endPosition])")
#
# def testRoleIdName(self):
# self.assertEqual(role_id(role_name(1)), 1)
# self.assertEqual(role_name(role_id("IDENTIFIER")), "IDENTIFIER")
#
# def _itTestTree(self):
# root = Node()
# root.internal_type = 'root'
# root.start_position.offset = 0
# root.start_position.line = 0
# root.start_position.col = 1
#
# son1 = Node()
# son1.internal_type = 'son1'
# son1.start_position.offset = 1
#
# son1_1 = Node()
# son1_1.internal_type = 'son1_1'
# son1_1.start_position.offset = 10
#
# son1_2 = Node()
# son1_2.internal_type = 'son1_2'
# son1_2.start_position.offset = 10
#
# son1.children.extend([son1_1, son1_2])
#
# son2 = Node()
# son2.internal_type = 'son2'
# son2.start_position.offset = 100
#
# son2_1 = Node()
# son2_1.internal_type = 'son2_1'
# son2_1.start_position.offset = 5
#
# son2_2 = Node()
# son2_2.internal_type = 'son2_2'
# son2_2.start_position.offset = 15
#
# son2.children.extend([son2_1, son2_2])
# root.children.extend([son1, son2])
#
# return root
#
# def testIteratorPreOrder(self):
# root = self._itTestTree()
# it = iterator(root, TreeOrder.PRE_ORDER)
# self.assertIsNotNone(it)
# expanded = [node.internal_type for node in it]
# self.assertListEqual(expanded, ['root', 'son1', 'son1_1', 'son1_2',
# 'son2', 'son2_1', 'son2_2'])
#
# def testIteratorPostOrder(self):
# root = self._itTestTree()
# it = iterator(root, TreeOrder.POST_ORDER)
# self.assertIsNotNone(it)
# expanded = [node.internal_type for node in it]
# self.assertListEqual(expanded, ['son1_1', 'son1_2', 'son1', 'son2_1',
# 'son2_2', 'son2', 'root'])
#
# def testIteratorLevelOrder(self):
# root = self._itTestTree()
# it = iterator(root, TreeOrder.LEVEL_ORDER)
# self.assertIsNotNone(it)
# expanded = [node.internal_type for node in it]
# self.assertListEqual(expanded, ['root', 'son1', 'son2', 'son1_1',
# 'son1_2', 'son2_1', 'son2_2'])
#
# def testIteratorPositionOrder(self):
# root = self._itTestTree()
# it = iterator(root, TreeOrder.POSITION_ORDER)
# self.assertIsNotNone(it)
# expanded = [node.internal_type for node in it]
# self.assertListEqual(expanded, ['root', 'son1', 'son2_1', 'son1_1',
# 'son1_2', 'son2_2', 'son2'])
#
def _validate_ctx(self, ctx):
import bblfsh
self.assertIsNotNone(ctx)
self.assertIsInstance(ctx, bblfsh.result_context.ResultContext)
self.assertIsInstance(ctx.uast, bytes)
# def testFilterInsideIter(self):
# root = self.client.parse(__file__).uast
# it = iterator(root, TreeOrder.PRE_ORDER)
# self.assertIsNotNone(it)
# for n in it:
# filter(n, "//*[@roleIdentifier]")
#
# def testItersMixingIterations(self):
# root = self.client.parse(__file__).uast
# it = iterator(root, TreeOrder.PRE_ORDER)
# next(it); next(it); next(it)
# n = next(it)
# it2 = iterator(n, TreeOrder.PRE_ORDER)
# next(it2)
# assert(next(it) == next(it2))
#
# def testManyFilters(self):
# root = self.client.parse(__file__).uast
# root.properties['k1'] = 'v2'
# root.properties['k2'] = 'v1'
#
# before = resource.getrusage(resource.RUSAGE_SELF)
# for _ in range(500):
# filter(root, "//*[@roleIdentifier]")
#
# after = resource.getrusage(resource.RUSAGE_SELF)
#
# # Check that memory usage has not doubled after running the filter
# self.assertLess(after[2] / before[2], 2.0)
#
# def testManyParses(self):
# before = resource.getrusage(resource.RUSAGE_SELF)
# for _ in range(100):
# root = self.client.parse(__file__).uast
# root.properties['k1'] = 'v2'
# root.properties['k2'] = 'v1'
#
# after = resource.getrusage(resource.RUSAGE_SELF)
#
# # Check that memory usage has not doubled after running the parse+filter
# self.assertLess(after[2] / before[2], 2.0)
#
# def testManyParsersAndFilters(self):
# before = resource.getrusage(resource.RUSAGE_SELF)
# for _ in range(100):
# root = self.client.parse(__file__).uast
# root.properties['k1'] = 'v2'
# root.properties['k2'] = 'v1'
#
# filter(root, "//*[@roleIdentifier]")
#
# after = resource.getrusage(resource.RUSAGE_SELF)
#
# # Check that memory usage has not doubled after running the parse+filter
# self.assertLess(after[2] / before[2], 2.0)
#
# def testSupportedLanguages(self):
# res = self.client.supported_languages()
# self.assertGreater(len(res), 0)
# for l in res:
# for key in ('language', 'version', 'status', 'features'):
# print(key)
# self.assertTrue(hasattr(l, key))
# self.assertIsNotNone(getattr(l, key))
def _validate_filter(self, ctx):
def assert_strnode(n: Node, expected: str) -> None:
self.assertEqual(n.get(), expected)
self.assertIsInstance(n.get_str(), str)
self.assertEqual(n.get_str(), expected)
# print(ctx)
it = ctx.filter(
"//uast:RuntimeImport/Path/uast:Alias/Name/uast:Identifier/Name")
self.assertIsInstance(it, NodeIterator)
# wtf = next(it)
# print(type(wtf))
# print(wtf)
assert_strnode(next(it), "os")
assert_strnode(next(it), "resource")
assert_strnode(next(it), "unittest")
assert_strnode(next(it), "docker")
assert_strnode(next(it), "bblfsh")
self.assertRaises(StopIteration, next(it))
