def virtual_dependencies_test(self):
sphereh = 'dummy/geom/sphere.h'
sphereh_test = 'dummy/geom/test/sphere.h'
sphereh_dev = 'dummy/geom/develop/sphere.h'
block_holder = self._cells_setup(
'dummy/geom',
['main.cpp', 'test/sphere.h', 'main2.cpp', 'develop/sphere.h'],
CPP)
block_holder._resources['sphere.h'] = Resource(VirtualCell(sphereh),
None)
block_holder['test/sphere.h'].cell.container = BlockCellName(sphereh)
block_holder['develop/sphere.h'].cell.container = BlockCellName(
sphereh)
block_holder['main.cpp'].cell.dependencies.unresolved = {
CPPDeclaration(sphereh_test)
}
block_holder['main2.cpp'].cell.dependencies.unresolved = {
CPPDeclaration(sphereh_dev)
}
_, outputstream = process_holder(block_holder, DependenciesProcessor())
warn = 'Block dummy/geom has absolute paths, like: #include "dummy/geom/develop/sphere.h"'
self.assertIn(warn, str(outputstream))
# Checks
main_cell = block_holder['main.cpp'].cell
self.check_dependency_set(main_cell.dependencies,
resolved=[sphereh_test],
explicit=[sphereh])
main_cell = block_holder['main2.cpp'].cell
self.check_dependency_set(main_cell.dependencies,
resolved=[sphereh_dev],
explicit=[sphereh])
def test_normalize_declaration_package_and_index(self):
cut = NodeDeclaration("fran/noderedis")
block_cell_names = [
BlockCellName("fran/noderedis/index.js"),
BlockCellName("fran/noderedis/package.json")
]
self.assertEquals(cut, cut.normalize(block_cell_names))
def test_diamond_single_solution(self):
brl_a = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blocka'))
brl_b = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blockb'))
brl_c = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blockc'))
name_a = BlockCellName(self.user + "/blocka/a.h")
publisher = TestPublisher(self.user, self.store)
for _ in range(20):
publisher.publish(brl_a, {'a.h': ('a', [])})
name_b = BlockCellName(self.user + "/blockb/b.h")
name_c = BlockCellName(self.user + "/blockc/c.h")
for i in range(0, 20):
if i % 2 == 0:
publisher.publish(brl_b, {'b.h': ('b', [name_a])},
dep_versions=BlockVersion(brl_a, i))
if (i % 2 == 1 or i == 10):
publisher.publish(brl_c, {'c.h': ('c', [name_a])},
dep_versions=BlockVersion(brl_a, i))
request = self.build_unresolved_request([name_b, name_c])
result = self.service.find(request, BiiResponse())
self.check_result(result,
resolved=[(brl_b, 5, {name_b}),
(brl_c, 5, {name_c})])
def test_init_match(self):
sut = PythonDeclaration("import biicode.common.edition")
block_cell_names = set([
BlockCellName("biicode/common/__init__.py"),
BlockCellName("biicode/common/edition.py")
])
self.assertEquals(block_cell_names, sut.match(block_cell_names))
def test_simple_match(self):
sut = JavaDeclaration("biicode.common.Edition")
block_cell_names = set([
BlockCellName("biicode/common/Edition.java"),
BlockCellName("biicode/common/Jarl.java")
])
self.assertEquals(set([BlockCellName("biicode/common/Edition.java")]),
sut.match(block_cell_names))
def test_rw_multi_contents(self):
rid1 = BlockCellName("dummy/geom/sphere.cpp")
cell1 = mother.make_content(rid1)
rid2 = BlockCellName("dummy/geom/sphere.h")
cell2 = mother.make_content(rid2)
self.db.upsert_edition_contents([cell1, cell2])
retrieved1 = self.db.read_edition_contents()
self.assertEquals({rid1: cell1, rid2: cell2}, retrieved1)
def test_implementation_from_files(self, header, source):
'''basic check that header is implemented by source'''
sources = [header, source]
block_holder = self._process_from_files(sources)
header = BlockCellName(header)
source = BlockCellName(source)
header_cell = block_holder[header.cell_name].cell
self.assertEqual({source}, header_cell.dependencies.implicit)
def test_same_path_relative_index_require(self):
cut = NodeDeclaration("./")
origin_block_cell_name = BlockCellName("fran/noderedis/bench.js")
block_cell_names = [
BlockCellName("fran/noderedis/index.js"),
BlockCellName("fran/noderedis/client.js")
]
m = cut.match(block_cell_names, origin_block_cell_name)
self.assertItemsEqual(set(["fran/noderedis/index.js"]), m)
def test_match_with_implicit_require(self):
cut = NodeDeclaration("fran/noderedis")
block_cell_names = [
BlockCellName("fran/noderedis/index.js"),
BlockCellName("fran/noderedis/other.js")
]
self.assertItemsEqual(set([BlockCellName("fran/noderedis/index.js")]),
cut.match(block_cell_names))
def test_package_json_recognition(self):
cut = NodeDeclaration("fran/noderedis")
block_cell_names = [
BlockCellName("fran/noderedis/package.json"),
BlockCellName("fran/noderedis/other.js")
]
self.assertItemsEqual(
set([BlockCellName("fran/noderedis/package.json")]),
cut.match(block_cell_names))
def check_dependency_set(self,
dependencies,
explicit=None,
implicit=None,
data=None,
system=None,
resolved=None,
unresolved=None,
declaration=CPPDeclaration):
'''custom assertion to check DependencySet
system is a list of strings ['iostream', 'math.h']
resolved is a iterable of strings 'user/module/file.h, 'iostream.h'.
If None, will be computed from system+explicit
unresolved is similar to resolved, but names can be shorter, as are not resolved
unresolved {'sphere.h': Type:EXCPLICIT_CODE}'''
system = system or set()
explicit = explicit or set()
implicit = implicit or set()
data = data or set()
unresolved = unresolved or set()
if not resolved:
resolved = set(copy.copy(system))
resolved.update(explicit)
systemDeps = set([SystemCellName(s) for s in system])
self.assertEqual(systemDeps, dependencies.system,
'System dependencies do not match.\n\tExpected: %s\n\tObtained: %s' \
% (systemDeps, dependencies.system))
explicitDeps = set([BlockCellName(s) for s in explicit])
self.assertEqual(explicitDeps, dependencies.explicit,
'Explicit dependencies do not match.\n\tExpected: %s\n\tObtained: %s' \
% (explicitDeps, dependencies.explicit))
dataDeps = set([BlockCellName(s) for s in data])
self.assertEqual(dataDeps, dependencies.data,
'Data dependencies do not match.\n\tExpected: %s\n\tObtained: %s' \
% (dataDeps, dependencies.data))
implicitDeps = set([BlockCellName(s) for s in implicit])
self.assertEqual(implicitDeps, dependencies.implicit,
'Implicit dependencies do not match.\n\tExpected: %s\n\tObtained: %s' \
% (implicitDeps, dependencies.implicit))
unresolvedDeps = set([declaration(name) for name in unresolved])
self.assertEqual(unresolvedDeps, dependencies.unresolved,
'Unresolved dependencies do not match.\n\tExpected: %s\n\tObtained: %s' \
% (unresolvedDeps, dependencies.unresolved))
resolvedDeps = set([declaration(name) for name in resolved])
self.assertEqual(resolvedDeps, dependencies.resolved,
'Resolved dependencies do not match.\n\tExpected %s\n\tObtained: %s' \
% (resolvedDeps, dependencies.resolved))
def test_simple_match_relative_in_different_block(self):
sut = PythonDeclaration("from edition import *")
block_cell_names = set([
BlockCellName("biicode/parsing/edition.py"),
BlockCellName("biicode/parsing/jarl.py")
])
from_block_cell_name = BlockCellName("biicode/common/main.py")
self.assertEquals(set(),
sut.match(block_cell_names, from_block_cell_name))
def res_method(*args):
depsb = [BlockCellName('user/blockA/a.h')]
depsc = [BlockCellName('user/blockA/a.h')]
result = ReferencedResources()
for ref in args[0].explode():
result[ref.block_version][ref.ref] = \
{Reference(depA1, 'a.h'): ((0, 0), 0, []),
Reference(depA2, 'a.h'): ((0, 0), 0, []),
Reference(baseB, 'b.h'): ((1, 4), 1, depsb),
Reference(baseC, 'c.h'): ((2, 3), 2, depsc)}[ref]
return result
def test_dependency_set(self):
d1 = DependencySet()
d1.add_implicit(BlockCellName("user/block/path/file2.h"))
d1.add_implicit(BlockCellName("user/block/path/file3.h"))
d1.add_implicit(BlockCellName("user/block/path/file4.h"))
names = set()
names.add(CPPDeclaration("iostream.h"))
d1.update_declarations(names)
s = d1.serialize()
d2 = DependencySet.deserialize(s)
self.assert_bii_equal(d1, d2)
def test_no_matched_config_relpath(self):
cut = CMakeDeclaration("../config")
origin_block_cell_name = BlockCellName(
"fran/cmakeparsing/other/thing/start.cmake")
block_cell_names = [
BlockCellName("fran/cmakeparsing/CMakeLists.txt"),
BlockCellName("fran/cmakeparsing/other/thing/macro.cmake"),
BlockCellName("fran/cmakeparsing/config")
]
self.assertItemsEqual(
set(), cut.match(block_cell_names, origin_block_cell_name))
def test_relative_require_not_found(self):
cut = NodeDeclaration("../parser")
origin_block_cell_name = BlockCellName(
"fran/noderedis/other/thing/other.js")
block_cell_names = [
BlockCellName("fran/noderedis/index.js"),
BlockCellName("fran/noderedis/other/thing/other.js"),
BlockCellName("fran/noderedis/parser.js")
]
self.assertItemsEqual(
set(), cut.match(block_cell_names, origin_block_cell_name))
def test_one_level_relative_require_with_depth(self):
cut = NodeDeclaration("./lib/parser/queue")
origin_block_cell_name = BlockCellName("fran/noderedis/index.js")
block_cell_names = [
BlockCellName("fran/noderedis/index.js"),
BlockCellName("fran/noderedis/lib/queue.js"),
BlockCellName("fran/noderedis/lib/parser/queue.js")
]
self.assertItemsEqual(
set(["fran/noderedis/lib/parser/queue.js"]),
cut.match(block_cell_names, origin_block_cell_name))
def test_match_with_macro_cmake_abspath(self):
cut = CMakeDeclaration("fran/cmakeparsing/cmake/Macros_2.cmake")
origin_block_cell_name = BlockCellName(
"fran/cmakeparsing/CMakeLists.txt")
block_cell_names = [
BlockCellName("fran/cmakeparsing/CMakeLists.txt"),
BlockCellName("fran/cmakeparsing/cmake/Macros.cmake"),
BlockCellName("fran/cmakeparsing/cmake/Macros_2.cmake")
]
self.assertItemsEqual(
set(["fran/cmakeparsing/cmake/Macros_2.cmake"]),
cut.match(block_cell_names, origin_block_cell_name))
def test_simple_edition_cell_with_container(self):
virtual_cell = BlockCellName('user/block/path/file.h')
simpleresource = SimpleCell("user/block/path/to/file.h")
simpleresource.ID = BlockCellName("user/block/path/to/file.h")
simpleresource.root = ID()
simpleresource.dependencies.add_implicit(
BlockCellName("user/block/path/file.h"))
simpleresource.container = virtual_cell
s = simpleresource.serialize()
self.assertEqual(s[Deserializer.POLIMORPHIC_KEYWORD],
ClassTypedSerializer.getValue(SimpleCell))
ob = CellDeserializer(BlockCellName).deserialize(s)
self.assert_bii_equal(ob, simpleresource)
def res_method(*args):
c_virtual_leaves = [BlockCellName('user/blockC/win/c.h'),
BlockCellName('user/blockC/nix/c.h')]
c_win_deps = [BlockCellName('user/blockA/a.h')]
c_nix_deps = [BlockCellName('user/blockB/b.h')]
result = ReferencedResources()
for ref in args[0].explode():
result[ref.block_version][ref.ref] = \
{Reference(depA, 'a.h'): ((0, 0), 0, []),
Reference(depB, 'b.h'): ((1, 1), 1, []),
Reference(baseC, 'c.h'): ((2, 2), 2, c_virtual_leaves),
Reference(baseC, 'win/c.h'): ((3, 3), 3, c_win_deps),
Reference(baseC, 'nix/c.h'): ((4, 4), 4, c_nix_deps)}[ref]
return result
def test_relative_composed_block_match(self):
#Given
cut = CPPDeclaration("algs/astar.h")
from_block_cell_name = BlockCellName('fran/test/main.cpp')
block_cell_names = [
BlockCellName("fran/test/algs/astar.h"),
BlockCellName("fran/test/main.cpp")
]
#When
result = cut.match(block_cell_names, from_block_cell_name)
#Then
expected = set([BlockCellName('fran/test/algs/astar.h')])
self.assertEquals(result, expected)
def publish_pack_add(pack, block_cell_name, content_text):
name = BlockCellName(block_cell_name)
cell1 = SimpleCell(name)
pack.cells.add(cell1)
pack.contents[name.cell_name] = Content(
load=Blob(content_text)) # it MUST have a content to be deleted
return cell1
def test_find_two_files_at_a_time(self):
"""Starts with one include, finds it, then two more includes, finish when all are found.
Found items are taken into account in FindRequest.existing
"""
NUM_FILES = 10
brl_a = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blocka'))
names_a = [
BlockCellName(self.user + "/blocka/a%d.h" % i)
for i in range(NUM_FILES)
]
resources_info = {"a%d.h" % i: ("a", []) for i in range(NUM_FILES)}
publisher = TestPublisher(self.user, self.store)
publisher.publish(brl_a, resources_info)
# Use the same request object, to accumulate existing (already found) files
request = FinderRequest()
request.policy = Policy.default()
version = BlockVersion(brl_a, 0) # The version is always the same
for i in range(0, NUM_FILES, 2):
declaration1 = CPPDeclaration(names_a[i])
declaration2 = CPPDeclaration(names_a[i + 1])
request.unresolved = {declaration1, declaration2}
result = self.service.find(request, BiiResponse())
self.check_result(result,
resolved=[(brl_a, 0,
{names_a[i], names_a[i + 1]})])
# The found one is added to the existing, for next iteration
request.existing[version][declaration1] = {names_a[i]}
request.existing[version][declaration2] = {names_a[i + 1]}
self.assertEqual(len(request.existing[version]), i + 2)
def make_published_resource(block, block_cell_name):
if isinstance(block_cell_name, basestring):
moduleCellName = BlockCellName(block_cell_name)
sr = SimpleCell(block_cell_name)
sr.type = BiiType.from_extension(moduleCellName.extension)
sr.ID = UserID(1) + 1 + 2
return sr
def test_deps_block_match(self):
#Given
cut = CPPDeclaration("../../deps/akka/math/sphere.h")
from_block_cell_name = BlockCellName('fran/test/main.cpp')
block_cell_names = [
BlockCellName("akka/math/sphere.h"),
BlockCellName("fran/test/other/jarl.cpp"),
BlockCellName("fran/test/main.cpp")
]
#When
result = cut.match(block_cell_names, from_block_cell_name)
#Then
expected = set([BlockCellName('akka/math/sphere.h')])
self.assertEquals(result, expected)
def test_find_transitive(self):
'''Test including a block with other dependencies, without conflicts '''
brl_a = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blocka'))
name_a = BlockCellName(self.user + "/blocka/a.h")
publisher = TestPublisher(self.user, self.store)
publisher.publish(brl_a, {'a.h': ('a', [])})
brl_b = BRLBlock('%s/%s/%s/master' % (self.user, self.user, 'blockb'))
name_b = BlockCellName(self.user + "/blockb/b.h")
#self.publish(brl_b, name_b, deps={name_b: name_a}, dep_versions=BlockVersion(brl_a, 0))
publisher.publish(brl_b, {'b.h': ('b', [name_a])},
dep_versions=BlockVersion(brl_a, 0))
request = self.build_unresolved_request(name_b)
result = self.service.find(request, BiiResponse())
self.check_result(result, resolved=[(brl_b, 0, {name_b})])
def _getBlockCellNames(self, dim):
'''generates names from dim list'''
bcns = [
BlockCellName(self.testUser.ID + '/module%s/cell%s' % (i, i))
for i in range(len(dim))
]
return bcns
def order_paths(target):
include_paths = []
blocks = hive_holder.blocks
for key in sorted(target.include_paths.iterkeys()):
path = target.include_paths[key]
try:
current_block = BlockCellName("%s/dummy" % path).block_name
except: # Not able to build block_name, it should be only username
origins = [DEP_DIR, SRC_DIR]
current_block = "&*NoBlock%$"
else:
origins = [SRC_DIR if current_block in blocks else DEP_DIR]
for src in origins:
if src == SRC_DIR:
rel_path = bii_paths.blocks_relative
else:
rel_path = bii_paths.deps_relative
if root_block == current_block:
# remove the initial BlockName from path
cmake_path = '${BII_PROJECT_ROOT}/%s' % path[len(current_block):]
else:
cmake_path = '${BII_PROJECT_ROOT}/%s/%s' % (rel_path, path)
if cmake_path not in include_paths:
include_paths.append(cmake_path)
target.include_paths = include_paths
def test_cell(self):
brl = BlockCellName("drodri/pang/test.cpp")
r = SimpleCell(brl)
self.assertFalse(r.hasMain)
self.assertEquals(r.name, brl)
self.assertEquals(r.type, UNKNOWN)
def block(self):
python_import = self.python_import()
try:
return BlockCellName(normalized_name(
python_import.module)).block_name
except:
return None
def testDeserializeDict(self):
brl = BlockCellName("user/block/path/file.h")
brl2 = BlockCellName("user/block/path/file2.h")
h = {brl.serialize(): "asasdasdasd",
brl2.serialize(): "1123"
}
ret = DictDeserializer(BlockCellName, str).deserialize(h)
self.assertEqual(ret, {'user/block/path/file.h': 'asasdasdasd',
'user/block/path/file2.h': '1123'})
h = {brl.serialize(): brl.serialize(),
brl2.serialize(): brl.serialize()
}
ret = DictDeserializer(BlockCellName, BlockCellName).deserialize(h)
self.assertEqual(ret,
{'user/block/path/file.h': 'user/block/path/file.h',
'user/block/path/file2.h': 'user/block/path/file.h'}
)
def test_block_cell_name(self):
b = BlockCellName("user/block/path/file.h")
s = b.serialize()
b2 = BlockCellName.deserialize(s)
self.assertEqual(b, b2)
