Пример #1
0
    def test_run(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        foo_c = os.path.join(pkg_dir, 'foo.c')
        self.write_file(foo_c, 'int main(void) { return 1;}\n')
        cmd.libraries = [('foo', {'sources': [foo_c]})]

        build_temp = os.path.join(pkg_dir, 'build')
        os.mkdir(build_temp)
        cmd.build_temp = build_temp
        cmd.build_clib = build_temp

        # before we run the command, we want to make sure
        # all commands are present on the system
        # by creating a compiler and checking its executables
        from distutils.ccompiler import new_compiler
        from distutils.sysconfig import customize_compiler

        compiler = new_compiler()
        customize_compiler(compiler)
        for ccmd in compiler.executables.values():
            if ccmd is None:
                continue
            if find_executable(ccmd[0]) is None:
                self.skipTest('The %r command is not found' % ccmd[0])

        # this should work
        cmd.run()

        # let's check the result
        self.assertIn('libfoo.a', os.listdir(build_temp))
Пример #2
0
    def test_check_library_dist(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        # 'libraries' option must be a list
        self.assertRaises(DistutilsSetupError, cmd.check_library_list, 'foo')

        # each element of 'libraries' must a 2-tuple
        self.assertRaises(DistutilsSetupError, cmd.check_library_list,
                          ['foo1', 'foo2'])

        # first element of each tuple in 'libraries'
        # must be a string (the library name)
        self.assertRaises(DistutilsSetupError, cmd.check_library_list,
                          [(1, 'foo1'), ('name', 'foo2')])

        # library name may not contain directory separators
        self.assertRaises(DistutilsSetupError, cmd.check_library_list,
                          [('name', 'foo1'),
                           ('another/name', 'foo2')])

        # second element of each tuple must be a dictionary (build info)
        self.assertRaises(DistutilsSetupError, cmd.check_library_list,
                          [('name', {}),
                           ('another', 'foo2')])

        # those work
        libs = [('name', {}), ('name', {'ok': 'good'})]
        cmd.check_library_list(libs)
Пример #3
0
    def test_check_library_dist(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        # 'libraries' option must be a list
        self.assertRaises(DistutilsSetupError, cmd.check_library_list, 'foo')

        # each element of 'libraries' must a 2-tuple
        self.assertRaises(DistutilsSetupError, cmd.check_library_list,
                          ['foo1', 'foo2'])

        # first element of each tuple in 'libraries'
        # must be a string (the library name)
        self.assertRaises(DistutilsSetupError, cmd.check_library_list,
                          [(1, 'foo1'), ('name', 'foo2')])

        # library name may not contain directory separators
        self.assertRaises(DistutilsSetupError, cmd.check_library_list,
                          [('name', 'foo1'), ('another/name', 'foo2')])

        # second element of each tuple must be a dictionary (build info)
        self.assertRaises(DistutilsSetupError, cmd.check_library_list,
                          [('name', {}), ('another', 'foo2')])

        # those work
        libs = [('name', {}), ('name', {'ok': 'good'})]
        cmd.check_library_list(libs)
Пример #4
0
    def test_run(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        foo_c = os.path.join(pkg_dir, 'foo.c')
        self.write_file(foo_c, 'int main(void) { return 1;}\n')
        cmd.libraries = [('foo', {'sources': [foo_c]})]

        build_temp = os.path.join(pkg_dir, 'build')
        os.mkdir(build_temp)
        cmd.build_temp = build_temp
        cmd.build_clib = build_temp

        # before we run the command, we want to make sure
        # all commands are present on the system
        # by creating a compiler and checking its executables
        from distutils.ccompiler import new_compiler
        from distutils.sysconfig import customize_compiler

        compiler = new_compiler()
        customize_compiler(compiler)
        for ccmd in compiler.executables.values():
            if ccmd is None:
                continue
            if find_executable(ccmd[0]) is None:
                self.skipTest('The %r command is not found' % ccmd[0])

        # this should work
        cmd.run()

        # let's check the result
        self.assertIn('libfoo.a', os.listdir(build_temp))
Пример #5
0
    def test_run(self):
        # can't test on windows
        if sys.platform == "win32":
            return

        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        foo_c = os.path.join(pkg_dir, "foo.c")
        self.write_file(foo_c, "int main(void) { return 1;}\n")
        cmd.libraries = [("foo", {"sources": [foo_c]})]

        build_temp = os.path.join(pkg_dir, "build")
        os.mkdir(build_temp)
        cmd.build_temp = build_temp
        cmd.build_clib = build_temp

        # before we run the command, we want to make sure
        # all commands are present on the system
        # by creating a compiler and checking its executables
        from distutils.ccompiler import new_compiler, customize_compiler

        compiler = new_compiler()
        customize_compiler(compiler)
        for ccmd in compiler.executables.values():
            if ccmd is None:
                continue
            if find_executable(ccmd[0]) is None:
                return  # can't test

        # this should work
        cmd.run()

        # let's check the result
        self.assertTrue("libfoo.a" in os.listdir(build_temp))
Пример #6
0
 def test_check_library_dist(self):
     pkg_dir, dist = self.create_dist()
     cmd = build_clib(dist)
     self.assertRaises(DistutilsSetupError, cmd.check_library_list, 'foo')
     self.assertRaises(DistutilsSetupError, cmd.check_library_list, ['foo1', 'foo2'])
     self.assertRaises(DistutilsSetupError, cmd.check_library_list, [(1, 'foo1'), ('name', 'foo2')])
     self.assertRaises(DistutilsSetupError, cmd.check_library_list, [('name', 'foo1'), ('another/name', 'foo2')])
     self.assertRaises(DistutilsSetupError, cmd.check_library_list, [('name', {}), ('another', 'foo2')])
     libs = [('name', {}), ('name', {'ok': 'good'})]
     cmd.check_library_list(libs)
Пример #7
0
 def test_check_library_dist(self):
     pkg_dir, dist = self.create_dist()
     cmd = build_clib(dist)
     self.assertRaises(DistutilsSetupError, cmd.check_library_list, 'foo')
     self.assertRaises(DistutilsSetupError, cmd.check_library_list, ['foo1', 'foo2'])
     self.assertRaises(DistutilsSetupError, cmd.check_library_list, [(1, 'foo1'), ('name', 'foo2')])
     self.assertRaises(DistutilsSetupError, cmd.check_library_list, [('name', 'foo1'), ('another/name', 'foo2')])
     self.assertRaises(DistutilsSetupError, cmd.check_library_list, [('name', {}), ('another', 'foo2')])
     libs = [('name', {}), ('name', {'ok': 'good'})]
     cmd.check_library_list(libs)
Пример #8
0
 def test_finalize_options(self):
     pkg_dir, dist = self.create_dist()
     cmd = build_clib(dist)
     cmd.include_dirs = 'one-dir'
     cmd.finalize_options()
     self.assertEqual(cmd.include_dirs, ['one-dir'])
     cmd.include_dirs = None
     cmd.finalize_options()
     self.assertEqual(cmd.include_dirs, [])
     cmd.distribution.libraries = 'WONTWORK'
     self.assertRaises(DistutilsSetupError, cmd.finalize_options)
Пример #9
0
 def test_finalize_options(self):
     pkg_dir, dist = self.create_dist()
     cmd = build_clib(dist)
     cmd.include_dirs = 'one-dir'
     cmd.finalize_options()
     self.assertEqual(cmd.include_dirs, ['one-dir'])
     cmd.include_dirs = None
     cmd.finalize_options()
     self.assertEqual(cmd.include_dirs, [])
     cmd.distribution.libraries = 'WONTWORK'
     self.assertRaises(DistutilsSetupError, cmd.finalize_options)
     return
Пример #10
0
 def test_get_source_files(self):
     pkg_dir, dist = self.create_dist()
     cmd = build_clib(dist)
     cmd.libraries = [('name', {})]
     self.assertRaises(DistutilsSetupError, cmd.get_source_files)
     cmd.libraries = [('name', {'sources': 1})]
     self.assertRaises(DistutilsSetupError, cmd.get_source_files)
     cmd.libraries = [('name', {'sources': ['a', 'b']})]
     self.assertEqual(cmd.get_source_files(), ['a', 'b'])
     cmd.libraries = [('name', {'sources': ('a', 'b')})]
     self.assertEqual(cmd.get_source_files(), ['a', 'b'])
     cmd.libraries = [('name', {'sources': ('a', 'b')}), ('name2', {
         'sources': ['c', 'd']})]
     self.assertEqual(cmd.get_source_files(), ['a', 'b', 'c', 'd'])
Пример #11
0
 def test_run(self):
     pkg_dir, dist = self.create_dist()
     cmd = build_clib(dist)
     foo_c = os.path.join(pkg_dir, 'foo.c')
     self.write_file(foo_c, 'int main(void) { return 1;}\n')
     cmd.libraries = [('foo', {'sources': [foo_c]})]
     build_temp = os.path.join(pkg_dir, 'build')
     os.mkdir(build_temp)
     cmd.build_temp = build_temp
     cmd.build_clib = build_temp
     ccmd = missing_compiler_executable()
     if ccmd is not None:
         self.skipTest('The %r command is not found' % ccmd)
     cmd.run()
     self.assertIn('libfoo.a', os.listdir(build_temp))
Пример #12
0
 def test_get_source_files(self):
     pkg_dir, dist = self.create_dist()
     cmd = build_clib(dist)
     cmd.libraries = [('name', {})]
     self.assertRaises(DistutilsSetupError, cmd.get_source_files)
     cmd.libraries = [('name', {'sources': 1})]
     self.assertRaises(DistutilsSetupError, cmd.get_source_files)
     cmd.libraries = [('name', {'sources': ['a', 'b']})]
     self.assertEqual(cmd.get_source_files(), ['a', 'b'])
     cmd.libraries = [('name', {'sources': ('a', 'b')})]
     self.assertEqual(cmd.get_source_files(), ['a', 'b'])
     cmd.libraries = [('name', {'sources': ('a', 'b')}), ('name2', {'sources': ['c', 'd']})]
     self.assertEqual(cmd.get_source_files(), ['a',
      'b',
      'c',
      'd'])
Пример #13
0
    def test_build_libraries(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)


        class FakeCompiler:

            def compile(*args, **kw):
                pass
            create_static_lib = compile
        cmd.compiler = FakeCompiler()
        lib = [('name', {'sources': 'notvalid'})]
        self.assertRaises(DistutilsSetupError, cmd.build_libraries, lib)
        lib = [('name', {'sources': list()})]
        cmd.build_libraries(lib)
        lib = [('name', {'sources': tuple()})]
        cmd.build_libraries(lib)
Пример #14
0
    def test_build_libraries(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        class FakeCompiler:

            def compile(*args, **kw):
                pass

            create_static_lib = compile

        cmd.compiler = FakeCompiler()
        lib = [('name', {'sources': 'notvalid'})]
        self.assertRaises(DistutilsSetupError, cmd.build_libraries, lib)
        lib = [('name', {'sources': list()})]
        cmd.build_libraries(lib)
        lib = [('name', {'sources': tuple()})]
        cmd.build_libraries(lib)
Пример #15
0
    def test_get_source_files(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        # "in 'libraries' option 'sources' must be present and must be
        # a list of source filenames
        cmd.libraries = [("name", {})]
        self.assertRaises(DistutilsSetupError, cmd.get_source_files)

        cmd.libraries = [("name", {"sources": 1})]
        self.assertRaises(DistutilsSetupError, cmd.get_source_files)

        cmd.libraries = [("name", {"sources": ["a", "b"]})]
        self.assertEqual(cmd.get_source_files(), ["a", "b"])

        cmd.libraries = [("name", {"sources": ("a", "b")})]
        self.assertEqual(cmd.get_source_files(), ["a", "b"])

        cmd.libraries = [("name", {"sources": ("a", "b")}), ("name2", {"sources": ["c", "d"]})]
        self.assertEqual(cmd.get_source_files(), ["a", "b", "c", "d"])
Пример #16
0
    def test_get_source_files(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        # "in 'libraries' option 'sources' must be present and must be
        # a list of source filenames
        cmd.libraries = [('name', {})]
        self.assertRaises(DistutilsSetupError, cmd.get_source_files)

        cmd.libraries = [('name', {'sources': 1})]
        self.assertRaises(DistutilsSetupError, cmd.get_source_files)

        cmd.libraries = [('name', {'sources': ['a', 'b']})]
        self.assertEqual(cmd.get_source_files(), ['a', 'b'])

        cmd.libraries = [('name', {'sources': ('a', 'b')})]
        self.assertEqual(cmd.get_source_files(), ['a', 'b'])

        cmd.libraries = [('name', {'sources': ('a', 'b')}),
                         ('name2', {'sources': ['c', 'd']})]
        self.assertEqual(cmd.get_source_files(), ['a', 'b', 'c', 'd'])
Пример #17
0
    def test_get_source_files(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        # "in 'libraries' option 'sources' must be present and must be
        # a list of source filenames
        cmd.libraries = [('name', {})]
        self.assertRaises(DistutilsSetupError, cmd.get_source_files)

        cmd.libraries = [('name', {'sources': 1})]
        self.assertRaises(DistutilsSetupError, cmd.get_source_files)

        cmd.libraries = [('name', {'sources': ['a', 'b']})]
        self.assertEqual(cmd.get_source_files(), ['a', 'b'])

        cmd.libraries = [('name', {'sources': ('a', 'b')})]
        self.assertEqual(cmd.get_source_files(), ['a', 'b'])

        cmd.libraries = [('name', {'sources': ('a', 'b')}),
                         ('name2', {'sources': ['c', 'd']})]
        self.assertEqual(cmd.get_source_files(), ['a', 'b', 'c', 'd'])
Пример #18
0
    def test_build_libraries(self):

        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        class FakeCompiler:
            def compile(*args, **kw):
                pass

            create_static_lib = compile

        cmd.compiler = FakeCompiler()

        # build_libraries is also doing a bit of typoe checking
        lib = [("name", {"sources": "notvalid"})]
        self.assertRaises(DistutilsSetupError, cmd.build_libraries, lib)

        lib = [("name", {"sources": list()})]
        cmd.build_libraries(lib)

        lib = [("name", {"sources": tuple()})]
        cmd.build_libraries(lib)
Пример #19
0
    def test_check_library_dist(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        # 'libraries' option must be a list
        self.assertRaises(DistutilsSetupError, cmd.check_library_list, "foo")

        # each element of 'libraries' must a 2-tuple
        self.assertRaises(DistutilsSetupError, cmd.check_library_list, ["foo1", "foo2"])

        # first element of each tuple in 'libraries'
        # must be a string (the library name)
        self.assertRaises(DistutilsSetupError, cmd.check_library_list, [(1, "foo1"), ("name", "foo2")])

        # library name may not contain directory separators
        self.assertRaises(DistutilsSetupError, cmd.check_library_list, [("name", "foo1"), ("another/name", "foo2")])

        # second element of each tuple must be a dictionary (build info)
        self.assertRaises(DistutilsSetupError, cmd.check_library_list, [("name", {}), ("another", "foo2")])

        # those work
        libs = [("name", {}), ("name", {"ok": "good"})]
        cmd.check_library_list(libs)
Пример #20
0
    def test_run(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)
        foo_c = os.path.join(pkg_dir, 'foo.c')
        self.write_file(foo_c, 'int main(void) { return 1;}\n')
        cmd.libraries = [('foo', {'sources': [foo_c]})]
        build_temp = os.path.join(pkg_dir, 'build')
        os.mkdir(build_temp)
        cmd.build_temp = build_temp
        cmd.build_clib = build_temp
        from distutils.ccompiler import new_compiler
        from distutils.sysconfig import customize_compiler
        compiler = new_compiler()
        customize_compiler(compiler)
        for ccmd in compiler.executables.values():
            if ccmd is None:
                continue
            if find_executable(ccmd[0]) is None:
                self.skipTest('The %r command is not found' % ccmd[0])

        cmd.run()
        self.assertIn('libfoo.a', os.listdir(build_temp))
        return
Пример #21
0
    def test_run(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)
        foo_c = os.path.join(pkg_dir, 'foo.c')
        self.write_file(foo_c, 'int main(void) { return 1;}\n')
        cmd.libraries = [('foo', {'sources': [foo_c]})]
        build_temp = os.path.join(pkg_dir, 'build')
        os.mkdir(build_temp)
        cmd.build_temp = build_temp
        cmd.build_clib = build_temp
        from distutils.ccompiler import new_compiler
        from distutils.sysconfig import customize_compiler
        compiler = new_compiler()
        customize_compiler(compiler)
        for ccmd in compiler.executables.values():
            if ccmd is None:
                continue
            if find_executable(ccmd[0]) is None:
                self.skipTest('The %r command is not found' % ccmd[0])

        cmd.run()
        self.assertIn('libfoo.a', os.listdir(build_temp))
        return
Пример #22
0
    def test_run(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        foo_c = os.path.join(pkg_dir, 'foo.c')
        self.write_file(foo_c, 'int main(void) { return 1;}\n')
        cmd.libraries = [('foo', {'sources': [foo_c]})]

        build_temp = os.path.join(pkg_dir, 'build')
        os.mkdir(build_temp)
        cmd.build_temp = build_temp
        cmd.build_clib = build_temp

        # Before we run the command, we want to make sure
        # all commands are present on the system.
        ccmd = missing_compiler_executable()
        if ccmd is not None:
            self.skipTest('The %r command is not found' % ccmd)

        # this should work
        cmd.run()

        # let's check the result
        self.assertIn('libfoo.a', os.listdir(build_temp))
Пример #23
0
    def test_run(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        foo_c = os.path.join(pkg_dir, 'foo.c')
        self.write_file(foo_c, 'int main(void) { return 1;}\n')
        cmd.libraries = [('foo', {'sources': [foo_c]})]

        build_temp = os.path.join(pkg_dir, 'build')
        os.mkdir(build_temp)
        cmd.build_temp = build_temp
        cmd.build_clib = build_temp

        # Before we run the command, we want to make sure
        # all commands are present on the system.
        ccmd = missing_compiler_executable()
        if ccmd is not None:
            self.skipTest('The %r command is not found' % ccmd)

        # this should work
        cmd.run()

        # let's check the result
        self.assertIn('libfoo.a', os.listdir(build_temp))