def test_make(configure_with_cmake_source_dir, capfd): tmp_dir = _tmpdir('test_make') with push_dir(str(tmp_dir)): src_dir = tmp_dir.ensure('SRC', dir=1) src_dir.join('CMakeLists.txt').write(textwrap.dedent( """ cmake_minimum_required(VERSION 3.5.0) project(foobar NONE) file(WRITE "${CMAKE_BINARY_DIR}/foo.txt" "# foo") install(FILES "${CMAKE_BINARY_DIR}/foo.txt" DESTINATION ".") install(CODE "message(STATUS \\"Project has been installed\\")") message(STATUS "CMAKE_SOURCE_DIR:${CMAKE_SOURCE_DIR}") message(STATUS "CMAKE_BINARY_DIR:${CMAKE_BINARY_DIR}") """ )) src_dir.ensure(CMAKE_BUILD_DIR(), dir=1) with push_dir(str(src_dir) if not configure_with_cmake_source_dir else str(tmp_dir.ensure('BUILD', dir=1))): cmkr = CMaker() config_kwargs = {} if configure_with_cmake_source_dir: config_kwargs['cmake_source_dir'] = str(src_dir) env = cmkr.configure(**config_kwargs) cmkr.make(env=env) messages = ["Project has been installed"] if configure_with_cmake_source_dir: messages += [ "/SRC", "/BUILD/{}".format(to_unix_path(CMAKE_BUILD_DIR())), "/BUILD/{}/./foo.txt".format(to_unix_path(CMAKE_INSTALL_DIR())) ] else: messages += [ "/SRC", "/SRC/{}".format(to_unix_path(CMAKE_BUILD_DIR())), "/SRC/{}/./foo.txt".format(to_unix_path(CMAKE_INSTALL_DIR())), ] out, _ = capfd.readouterr() for message in messages: assert message in out
def test_hello_cleans(capfd): with push_dir(): tmp_dir = _tmpdir("test_hello_cleans") _copy_dir(tmp_dir, os.path.join(SAMPLES_DIR, "hello-cpp")) @project_setup_py_test("hello-cpp", ["build"], tmp_dir=tmp_dir) def run_build(): pass @project_setup_py_test("hello-cpp", ["clean"], tmp_dir=tmp_dir) def run_clean(): pass # Check that a project can be cleaned twice in a row run_build() print("<<-->>") run_clean() print("<<-->>") run_clean() _, clean1_out, clean2_out = \ capfd.readouterr()[0].split('<<-->>') clean1_out = clean1_out.strip() clean2_out = clean2_out.strip() assert "running clean" == clean1_out.splitlines()[0] assert "removing '{}'".format( CMAKE_INSTALL_DIR()) == clean1_out.splitlines()[1] assert "removing '{}'".format( CMAKE_BUILD_DIR()) == clean1_out.splitlines()[2] assert "removing '{}'".format(SKBUILD_DIR()) == clean1_out.splitlines()[3] assert "running clean" == clean2_out
setup_requires = [] try: cmake_version = LegacyVersion(get_cmake_version()) if cmake_version < LegacyVersion("3.5") or cmake_version >= LegacyVersion( "3.15"): setup_requires.append('cmake<3.15') except SKBuildError: setup_requires.append('cmake<3.15') # If you want to re-build the cython cpp file (DracoPy.cpp), run: # cython --cplus -3 -I./_skbuild/linux-x86_64-3.7/cmake-install/include/draco/ ./src/TrakoDracoPy.pyx # Replace "linux-x86_64-3.6" with the directory under _skbuild in your system # Draco must already be built/setup.py already be run before running the above command src_dir = './src' lib_dir = os.path.abspath(os.path.join(CMAKE_INSTALL_DIR(), 'lib/')) cmake_args = [] if sys.platform == 'darwin': plat_name = skbuild_plat_name() sep = [pos for pos, char in enumerate(plat_name) if char == '-'] assert len(sep) == 2 cmake_args = [ '-DCMAKE_OSX_DEPLOYMENT_TARGET:STRING=' + plat_name[sep[0] + 1:sep[1]], '-DCMAKE_OSX_ARCHITECTURES:STRING=' + plat_name[sep[1] + 1:] ] library_link_args = [ '-l{0}'.format(lib) for lib in ('dracoenc', 'draco', 'dracodec') ] else: library_link_args = [ '-l:{0}'.format(lib)
class CleanUp(set_build_base_mixin, new_style(_clean)): """Custom implementation of ``clean`` setuptools command. Overriding clean in order to get rid if "dist" folder and etc """ skroot = dirname(SKBUILD_DIR()) CLEANFOLDERS = ( CMAKE_INSTALL_DIR(), CMAKE_BUILD_DIR(), SKBUILD_DIR(), skroot, "TMP", "__pycache__", "pip-wheel-metadata", ".eggs", "dist", "sdist", "wheel", ".pytest_cache", "docs/apiref", "docs/_build", "docs/_static", "docs/_templates", "htmlcov", ) CLEANFOLDERSRECURSIVE = ["__pycache__", "_tmp_*", "xtgeo.egg-info"] CLEANFILESRECURSIVE = ["*.pyc", "*.pyo", ".coverage", "coverage.xml"] CLEANFILES = glob("src/xtgeo/cxtgeo/cxtgeo*") CLEANFILES.extend(glob("src/xtgeo/cxtgeo/_cxtgeo*")) @staticmethod def ffind(pattern, path): result = [] for root, dirs, files in os.walk(path): for name in files: if fnmatch.fnmatch(name, pattern): result.append(os.path.join(root, name)) return result @staticmethod def dfind(pattern, path): result = [] for root, dirs, files in os.walk(path): for name in dirs: if fnmatch.fnmatch(name, pattern): result.append(os.path.join(root, name)) return result def run(self): """After calling the super class implementation, this function removes the directories specific to scikit-build ++.""" super(CleanUp, self).run() for dir_ in CleanUp.CLEANFOLDERS: if exists(dir_): print("Removing: {}".format(dir_)) if not self.dry_run and exists(dir_): rmtree(dir_) for dir_ in CleanUp.CLEANFOLDERSRECURSIVE: for pd in self.dfind(dir_, "."): print("Remove folder {}".format(pd)) rmtree(pd) for fil_ in CleanUp.CLEANFILESRECURSIVE: for pf in self.ffind(fil_, "."): print("Remove file {}".format(pf)) os.unlink(pf) for fil_ in CleanUp.CLEANFILES: if exists(fil_): print("Removing: {}".format(fil_)) if not self.dry_run and exists(fil_): os.remove(fil_)
# read the version number from the library pattern = r"[0-9]\.[0-9]\.[0-9]" version = None with open('./bindings/rascal/__init__.py', 'r') as fp: for line in fp.readlines(): if '__version__' in line: version = re.findall(pattern, line)[0] if version is None: raise ValueError("Version number not found.") with open('./requirements_pip.txt', 'r') as fp: requirements = list(filter(lambda x: '#' not in x, (line.strip() for line in fp))) setup( name="rascal", version=version, description="""A versatile and scalable computation of representations of atomic structures for machine learning.""", author='librascal developers', license="LGPL-3.0-or-later", cmake_args=[ '-DINSTALL_PATH:STRING='+join(os.getcwd(),CMAKE_INSTALL_DIR()), '-DBUILD_EXAMPLES:BOOL=OFF' ], package_dir={"": "bindings"}, packages=find_packages(where='bindings'), install_requires=requirements, # include_package_data=True, package_data={'': ['lib/librascal.*']}, zip_safe=False )
def test_cmake_install_into_pure_package(with_cmake_source_dir, capsys): # ------------------------------------------------------------------------- # "SOURCE" tree layout: # # (1) with_cmake_source_dir == 0 # # ROOT/ # # CMakeLists.txt # setup.py # # fruits/ # __init__.py # # # (2) with_cmake_source_dir == 1 # # ROOT/ # # setup.py # # fruits/ # __init__.py # # src/ # # CMakeLists.txt # # ------------------------------------------------------------------------- # "BINARY" distribution layout: # # ROOT/ # # fruits/ # # __init__.py # apple.py # banana.py # # data/ # # apple.dat # banana.dat # tmp_dir = _tmpdir('cmake_install_into_pure_package') cmake_source_dir = 'src' if with_cmake_source_dir else '' tmp_dir.join('setup.py').write( textwrap.dedent(""" from skbuild import setup setup( name="test_py_modules_keyword", version="1.2.3", description="a package testing use of py_modules keyword", author='The scikit-build team', license="MIT", packages=['fruits'], cmake_install_dir='fruits', cmake_source_dir='{cmake_source_dir}', ) """.format(cmake_source_dir=cmake_source_dir))) cmake_src_dir = tmp_dir.ensure(cmake_source_dir, dir=1) cmake_src_dir.join('CMakeLists.txt').write( textwrap.dedent(""" cmake_minimum_required(VERSION 3.5.0) project(test NONE) file(WRITE "${CMAKE_BINARY_DIR}/apple.py" "# apple.py") file(WRITE "${CMAKE_BINARY_DIR}/banana.py" "# banana.py") install( FILES "${CMAKE_BINARY_DIR}/apple.py" "${CMAKE_BINARY_DIR}/banana.py" DESTINATION "." ) file(WRITE "${CMAKE_BINARY_DIR}/apple.dat" "# apple.dat") file(WRITE "${CMAKE_BINARY_DIR}/banana.dat" "# banana.dat") install( FILES "${CMAKE_BINARY_DIR}/apple.dat" "${CMAKE_BINARY_DIR}/banana.dat" DESTINATION "data" ) """)) tmp_dir.ensure('fruits/__init__.py') with execute_setup_py(tmp_dir, ['build'], disable_languages_test=True): pass messages = [ "copying {}/{} -> " "{}/setuptools/lib".format(CMAKE_INSTALL_DIR(), module, SKBUILD_DIR()) for module in [ 'fruits/__init__.py', 'fruits/apple.py', 'fruits/banana.py', 'fruits/data/apple.dat', 'fruits/data/banana.dat', ] ] out, _ = capsys.readouterr() for message in messages: assert to_platform_path(message) in out
def test_setup_inputs(has_cmake_package, has_cmake_module, has_hybrid_package, has_pure_package, has_pure_module, with_package_base, mocker): """This test that a project can have a package with some modules installed using setup.py and some other modules installed using CMake. """ tmp_dir = _tmpdir('test_setup_inputs') package_base = 'to/the/base' if with_package_base else '' package_base_dir = package_base + '/' if package_base else '' cmake_source_dir = package_base if cmake_source_dir and (has_cmake_package or has_cmake_module): pytest.skip( "unsupported configuration: " "python package fully generated by CMake does *NOT* work. " "At least __init__.py should be in the project source tree") # ------------------------------------------------------------------------- # Here is the "SOURCE" tree layout: # # ROOT/ # # setup.py # # [<base>/] # # pureModule.py # # pure/ # __init__.py # pure.py # # data/ # pure.dat # # [<cmake_src_dir>/] # # hybrid/ # CMakeLists.txt # __init__.py # hybrid_pure.dat # hybrid_pure.py # # data/ # hybrid_data_pure.dat # # hybrid_2/ # __init__.py # hybrid_2_pure.py # # hybrid_2_pure/ # __init__.py # hybrid_2_pure_1.py # hybrid_2_pure_2.py # # # ------------------------------------------------------------------------- # and here is the "BINARY" distribution layout: # # The comment "CMake" or "Setuptools" indicates which tool is responsible # for placing the file in the tree used to create the binary distribution. # # ROOT/ # # cmakeModule.py # CMake # # cmake/ # __init__.py # CMake # cmake.py # CMake # # hybrid/ # hybrid_cmake.dat # CMake # hybrid_cmake.py # CMake # hybrid_pure.dat # Setuptools # hybrid_pure.py # Setuptools # # data/ # hybrid_data_pure.dat # CMake or Setuptools # hybrid_data_cmake.dat # CMake *NO TEST* # # hybrid_2/ # __init__.py # CMake or Setuptools # hybrid_2_pure.py # CMake or Setuptools # hybrid_2_cmake.py # CMake # # hybrid_2_pure/ # __init__.py # CMake or Setuptools # hybrid_2_pure_1.py # CMake or Setuptools # hybrid_2_pure_2.py # CMake or Setuptools # # pureModule.py # Setuptools # # pure/ # __init__.py # Setuptools # pure.py # Setuptools # # data/ # pure.dat # Setuptools tmp_dir.join('setup.py').write( textwrap.dedent(""" from skbuild import setup #from setuptools import setup setup( name="test_hybrid_project", version="1.2.3", description=("an hybrid package mixing files installed by both " "CMake and setuptools"), author='The scikit-build team', license="MIT", cmake_source_dir='{cmake_source_dir}', cmake_install_dir='{cmake_install_dir}', # Arbitrary order of packages packages=[ {p_off} 'pure', {h_off} 'hybrid.hybrid_2', {h_off} 'hybrid', {c_off} 'cmake', {p_off} 'hybrid.hybrid_2_pure', ], py_modules=[ {pm_off} '{package_base}pureModule', {cm_off} '{package_base}cmakeModule', ], package_data={{ {p_off} 'pure': ['data/pure.dat'], {h_off} 'hybrid': ['hybrid_pure.dat', 'data/hybrid_data_pure.dat'], }}, # Arbitrary order of package_dir package_dir = {{ {p_off} 'hybrid.hybrid_2_pure': '{package_base}hybrid/hybrid_2_pure', {p_off} 'pure': '{package_base}pure', {h_off} 'hybrid': '{package_base}hybrid', {h_off} 'hybrid.hybrid_2': '{package_base}hybrid/hybrid_2', {c_off} 'cmake': '{package_base}cmake', }} ) """.format(cmake_source_dir=cmake_source_dir, cmake_install_dir=package_base, package_base=package_base_dir, c_off='' if has_cmake_package else '#', cm_off='' if has_cmake_module else '#', h_off='' if has_hybrid_package else '#', p_off='' if has_pure_package else '#', pm_off='' if has_pure_module else '#'))) src_dir = tmp_dir.ensure(package_base, dir=1) src_dir.join('CMakeLists.txt').write( textwrap.dedent(""" cmake_minimum_required(VERSION 3.5.0) project(hybrid NONE) set(build_dir ${{CMAKE_BINARY_DIR}}) {c_off} file(WRITE ${{build_dir}}/__init__.py "") {c_off} file(WRITE ${{build_dir}}/cmake.py "") {c_off} install( {c_off} FILES {c_off} ${{build_dir}}/__init__.py {c_off} ${{build_dir}}/cmake.py {c_off} DESTINATION cmake {c_off} ) {cm_off} file(WRITE ${{build_dir}}/cmakeModule.py "") {cm_off} install( {cm_off} FILES ${{build_dir}}/cmakeModule.py {cm_off} DESTINATION .) {h_off} file(WRITE ${{build_dir}}/hybrid_cmake.dat "") {h_off} install( {h_off} FILES ${{build_dir}}/hybrid_cmake.dat {h_off} DESTINATION hybrid) {h_off} file(WRITE ${{build_dir}}/hybrid_cmake.py "") {h_off} install( {h_off} FILES ${{build_dir}}/hybrid_cmake.py {h_off} DESTINATION hybrid) {h_off} file(WRITE ${{build_dir}}/hybrid_data_cmake.dat "") {h_off} install( {h_off} FILES ${{build_dir}}/hybrid_data_cmake.dat {h_off} DESTINATION hybrid/data) {h_off} file(WRITE ${{build_dir}}/hybrid_2_cmake.py "") {h_off} install( {h_off} FILES ${{build_dir}}/hybrid_2_cmake.py {h_off} DESTINATION hybrid/hybrid_2) install(CODE "message(STATUS \\\"Installation complete\\\")") """.format(c_off='' if has_cmake_package else '#', cm_off='' if has_cmake_module else '#', h_off='' if has_hybrid_package else '#', p_off='' if has_pure_package else '#'))) # List path types: 'c', 'cm', 'h', 'p' or 'pm' try: path_types = list( zip(*filter(lambda i: i[1], [( 'c', has_cmake_package), ( 'cm', has_cmake_module), ( 'h', has_hybrid_package), ( 'p', has_pure_package), ('pm', has_pure_module)])))[0] except IndexError: path_types = [] def select_paths(annotated_paths): """Return a filtered list paths considering ``path_types``. `annotated_paths`` is list of tuple ``(type, path)`` where type is either `c`, 'cm', `h`, `p` or 'pm'. """ return filter(lambda i: i[0] in path_types, annotated_paths) # Commented paths are the one expected to be installed by CMake. For # this reason, corresponding files should NOT be created in the source # tree. for (_type, path) in select_paths([ # ('c', 'cmake/__init__.py'), # ('c', 'cmake/cmake.py'), # ('cm', 'cmakeModule.py'), ('h', 'hybrid/__init__.py'), # ('h', 'hybrid/hybrid_cmake.dat'), # ('h', 'hybrid/hybrid_cmake.py'), ('h', 'hybrid/hybrid_pure.dat'), ('h', 'hybrid/hybrid_pure.py'), # ('h', 'hybrid/data/hybrid_data_cmake.dat'), ('h', 'hybrid/data/hybrid_data_pure.dat'), ('h', 'hybrid/hybrid_2/__init__.py'), # ('h', 'hybrid/hybrid_2/hybrid_2_cmake.py'), ('h', 'hybrid/hybrid_2/hybrid_2_pure.py'), ('p', 'hybrid/hybrid_2_pure/__init__.py'), ('p', 'hybrid/hybrid_2_pure/hybrid_2_pure_1.py'), ('p', 'hybrid/hybrid_2_pure/hybrid_2_pure_2.py'), ('pm', 'pureModule.py'), ('p', 'pure/__init__.py'), ('p', 'pure/pure.py'), ('p', 'pure/data/pure.dat'), ]): assert _type in ['p', 'pm', 'h'] root = (package_base if (_type == 'p' or _type == 'pm') else cmake_source_dir) tmp_dir.ensure(os.path.join(root, path)) # Do not call the real setup function. Instead, replace it with # a MagicMock allowing to check with which arguments it was invoked. mock_setup = mocker.patch('skbuild.setuptools_wrap.upstream_setup') # Convenience print function def _pprint(desc, value=None): print("-----------------\n" "{}:\n" "\n" "{}\n".format( desc, pprint.pformat( setup_kw.get(desc, {}) if value is None else value, indent=2))) with execute_setup_py(tmp_dir, ['build'], disable_languages_test=True): assert mock_setup.call_count == 1 setup_kw = mock_setup.call_args[1] # packages expected_packages = [] if has_cmake_package: expected_packages += ['cmake'] if has_hybrid_package: expected_packages += ['hybrid', 'hybrid.hybrid_2'] if has_pure_package: expected_packages += ['hybrid.hybrid_2_pure', 'pure'] _pprint('expected_packages', expected_packages) _pprint('packages') # package dir expected_package_dir = { package: (os.path.join(CMAKE_INSTALL_DIR(), package_base, package.replace('.', '/'))) for package in expected_packages } _pprint('expected_package_dir', expected_package_dir) _pprint('package_dir') # package data expected_package_data = {} if has_cmake_package: expected_package_data['cmake'] = ['__init__.py', 'cmake.py'] if has_hybrid_package: expected_package_data['hybrid'] = [ '__init__.py', 'hybrid_cmake.dat', 'hybrid_cmake.py', 'hybrid_pure.dat', 'hybrid_pure.py', 'data/hybrid_data_cmake.dat', 'data/hybrid_data_pure.dat', ] expected_package_data['hybrid.hybrid_2'] = [ '__init__.py', 'hybrid_2_cmake.py', 'hybrid_2_pure.py' ] if has_pure_package: expected_package_data['hybrid.hybrid_2_pure'] = \ [ '__init__.py', 'hybrid_2_pure_1.py', 'hybrid_2_pure_2.py' ] expected_package_data['pure'] = [ '__init__.py', 'pure.py', 'data/pure.dat', ] if has_cmake_module or has_pure_module: expected_modules = [] if has_cmake_module: expected_modules.append(package_base_dir + 'cmakeModule.py') if has_pure_module: expected_modules.append(package_base_dir + 'pureModule.py') expected_package_data[''] = expected_modules _pprint('expected_package_data', expected_package_data) package_data = { p: sorted(files) for p, files in setup_kw['package_data'].items() } _pprint('package_data', package_data) # py_modules (corresponds to files associated with empty package) expected_py_modules = [] if '' in expected_package_data: expected_py_modules = [ os.path.splitext(module_file)[0] for module_file in expected_package_data[''] ] _pprint('expected_py_modules', expected_py_modules) _pprint('py_modules') # scripts expected_scripts = [] _pprint('expected_scripts', expected_scripts) _pprint('scripts') # data_files expected_data_files = [] _pprint('expected_data_files', expected_data_files) _pprint('data_files') assert sorted(setup_kw['packages']) == sorted(expected_packages) assert sorted(setup_kw['package_dir']) == sorted(expected_package_dir) assert package_data == { p: sorted(files) for p, files in expected_package_data.items() } assert sorted(setup_kw['py_modules']) == sorted(expected_py_modules) assert sorted(setup_kw['scripts']) == sorted([]) assert sorted(setup_kw['data_files']) == sorted([])
def test_py_modules_keyword(distribution_type, capsys): # ------------------------------------------------------------------------- # # "SOURCE" tree layout for "pure" distribution: # # ROOT/ # setup.py # foo.py # bar.py # # "SOURCE" tree layout for "skbuild" distribution: # # ROOT/ # setup.py # CMakeLists.txt # # ------------------------------------------------------------------------- # "BINARY" distribution layout is identical for both # # ROOT/ # foo.py # bar.py # tmp_dir = _tmpdir('py_modules_keyword') tmp_dir.join('setup.py').write( textwrap.dedent(""" from skbuild import setup setup( name="test_py_modules_keyword", version="1.2.3", description="a package testing use of py_modules keyword", author='The scikit-build team', license="MIT", py_modules=['foo', 'bar'] ) """)) if distribution_type == 'skbuild': tmp_dir.join('CMakeLists.txt').write( textwrap.dedent(""" cmake_minimum_required(VERSION 3.5.0) project(foobar NONE) file(WRITE "${CMAKE_BINARY_DIR}/foo.py" "# foo.py") file(WRITE "${CMAKE_BINARY_DIR}/bar.py" "# bar.py") install( FILES "${CMAKE_BINARY_DIR}/foo.py" "${CMAKE_BINARY_DIR}/bar.py" DESTINATION "." ) """)) messages = [ "copying {}/{}.py -> " "{}/setuptools/lib".format(CMAKE_INSTALL_DIR(), module, SKBUILD_DIR()) for module in ['foo', 'bar'] ] elif distribution_type == 'pure': tmp_dir.join('foo.py').write("# foo.py") tmp_dir.join('bar.py').write("# bar.py") messages = [ "copying {}.py -> " "{}/setuptools/lib".format(module, SKBUILD_DIR()) for module in ['foo', 'bar'] ] with execute_setup_py(tmp_dir, ['build'], disable_languages_test=True): pass out, _ = capsys.readouterr() for message in messages: assert to_platform_path(message) in out
def test_cmake_install_dir_keyword(cmake_install_dir, expected_failed, error_code_type, capsys): # ------------------------------------------------------------------------- # "SOURCE" tree layout: # # ROOT/ # # CMakeLists.txt # setup.py # # apple/ # __init__.py # # ------------------------------------------------------------------------- # "BINARY" distribution layout # # ROOT/ # # apple/ # __init__.py # tmp_dir = _tmpdir('cmake_install_dir_keyword') setup_kwarg = '' if cmake_install_dir is not None: setup_kwarg = 'cmake_install_dir=r\'{}\''.format(cmake_install_dir) tmp_dir.join('setup.py').write( textwrap.dedent(""" from skbuild import setup setup( name="test_cmake_install_dir", version="1.2.3", description="a package testing use of cmake_install_dir", author='The scikit-build team', license="MIT", packages=['apple', 'banana'], {setup_kwarg} ) """.format(setup_kwarg=setup_kwarg))) # Install location purposely set to "." so that we can test # usage of "cmake_install_dir" skbuild.setup keyword. tmp_dir.join('CMakeLists.txt').write( textwrap.dedent(""" cmake_minimum_required(VERSION 3.5.0) project(banana NONE) file(WRITE "${CMAKE_BINARY_DIR}/__init__.py" "") install(FILES "${CMAKE_BINARY_DIR}/__init__.py" DESTINATION ".") """)) tmp_dir.ensure('apple', '__init__.py') failed = False message = "" try: with execute_setup_py(tmp_dir, ['build'], disable_languages_test=True): pass except SystemExit as e: # Error is not of type SKBuildError, it is expected to be # raised by distutils.core.setup failed = isinstance(e.code, error_code_type) message = str(e) out, _ = capsys.readouterr() assert failed == expected_failed if failed: if error_code_type == str: assert message == "error: package directory " \ "'{}' does not exist".format( os.path.join(CMAKE_INSTALL_DIR(), 'banana')) else: assert message.strip().startswith( "setup parameter 'cmake_install_dir' " "is set to an absolute path.") else: init_py = to_platform_path("{}/banana/__init__.py".format( CMAKE_INSTALL_DIR())) assert "copying {}".format(init_py) in out