def autotools_configure_vars_test(self):
        from mock import patch

        runner = RunnerMock()
        settings = MockSettings({"build_type": "Debug",
                                 "arch": "x86_64",
                                 "compiler": "gcc",
                                 "compiler.libcxx": "libstdc++"})
        conanfile = MockConanfile(settings, None, runner)
        conanfile.settings = settings
        self._set_deps_info(conanfile)

        def custom_configure(obj, configure_dir=None, args=None, build=None, host=None, target=None,
                             pkg_config_paths=None, vars=None):  # @UnusedVariable
            self.assertNotEqual(obj.vars, vars)
            return vars or obj.vars

        with patch.object(AutoToolsBuildEnvironment, 'configure', new=custom_configure):
            be = AutoToolsBuildEnvironment(conanfile)

            # Get vars and modify them
            my_vars = be.vars
            my_vars["fake_var"] = "fake"
            my_vars["super_fake_var"] = "fakefake"

            # TEST with default vars
            mocked_result = be.configure()
            self.assertEqual(mocked_result, be.vars)

            # TEST with custom vars
            mocked_result = be.configure(vars=my_vars)
            self.assertEqual(mocked_result, my_vars)
Beispiel #2
0
    def test_autotools_configure_vars(self):
        from mock import patch

        runner = RunnerMock()
        settings = MockSettings({"build_type": "Debug",
                                 "arch": "x86_64",
                                 "compiler": "gcc",
                                 "compiler.libcxx": "libstdc++"})
        conanfile = MockConanfile(settings, None, runner)
        conanfile.settings = settings
        self._set_deps_info(conanfile)

        def custom_configure(obj, configure_dir=None, args=None, build=None, host=None, target=None,
                             pkg_config_paths=None, vars=None):  # @UnusedVariable
            self.assertNotEqual(obj.vars, vars)
            return vars or obj.vars

        with patch.object(AutoToolsBuildEnvironment, 'configure', new=custom_configure):
            be = AutoToolsBuildEnvironment(conanfile)

            # Get vars and modify them
            my_vars = be.vars
            my_vars["fake_var"] = "fake"
            my_vars["super_fake_var"] = "fakefake"

            # TEST with default vars
            mocked_result = be.configure()
            self.assertEqual(mocked_result, be.vars)

            # TEST with custom vars
            mocked_result = be.configure(vars=my_vars)
            self.assertEqual(mocked_result, my_vars)
    def autotools_install_dirs_test(self):

        runner = RunnerMockWithHelp(available_args=default_dirs_flags)
        conanfile = MockConanfileWithOutput(MockSettings({}), None, runner)
        # Package folder is not defined
        ab = AutoToolsBuildEnvironment(conanfile)
        ab.configure()
        self.assertNotIn("--prefix", runner.command_called)
        self.assertNotIn("--bindir", runner.command_called)
        self.assertNotIn("--libdir", runner.command_called)
        self.assertNotIn("--includedir", runner.command_called)
        self.assertNotIn("--dataroot", runner.command_called)
        # package folder defined
        conanfile.package_folder = "/package_folder"
        ab.configure()
        if platform.system() == "Windows":
            self.assertIn(
                "./configure --prefix=/package_folder --bindir=${prefix}/bin "
                "--sbin=${prefix}/bin --libexec=${prefix}/bin --libdir=${prefix}/lib "
                "--includedir=${prefix}/include --oldincludedir=${prefix}/include "
                "--datarootdir=${prefix}/res", runner.command_called)
        else:
            self.assertIn(
                "./configure '--prefix=/package_folder' '--bindir=${prefix}/bin' "
                "'--sbin=${prefix}/bin' '--libexec=${prefix}/bin' '--libdir=${prefix}/lib' "
                "'--includedir=${prefix}/include' '--oldincludedir=${prefix}/include' "
                "'--datarootdir=${prefix}/res'", runner.command_called)
        # --prefix already used in args
        ab.configure(args=["--prefix=/my_package_folder"])
        self.assertIn("--prefix=/my_package_folder", runner.command_called)
        self.assertNotIn("--prefix=/package_folder", runner.command_called)
        # --bindir, --libdir, --includedir already used in args
        ab.configure(args=[
            "--bindir=/pf/superbindir", "--libdir=/pf/superlibdir",
            "--includedir=/pf/superincludedir"
        ])
        self.assertNotIn("--bindir=${prefix}/bin", runner.command_called)
        self.assertNotIn("--libdir=${prefix}/lib", runner.command_called)
        self.assertNotIn("--includedir=${prefix}/lib", runner.command_called)
        if platform.system() == "Windows":
            self.assertIn(
                "./configure --bindir=/pf/superbindir --libdir=/pf/superlibdir "
                "--includedir=/pf/superincludedir --prefix=/package_folder "
                "--sbin=${prefix}/bin --libexec=${prefix}/bin "
                "--oldincludedir=${prefix}/include --datarootdir=${prefix}/res",
                runner.command_called)
        else:
            self.assertIn(
                "./configure '--bindir=/pf/superbindir' '--libdir=/pf/superlibdir' "
                "'--includedir=/pf/superincludedir' '--prefix=/package_folder' "
                "'--sbin=${prefix}/bin' '--libexec=${prefix}/bin' "
                "'--oldincludedir=${prefix}/include' '--datarootdir=${prefix}/res'",
                runner.command_called)
        # opt-out from default installation dirs
        ab.configure(use_default_install_dirs=False)
        self.assertIn("--prefix=/package_folder", runner.command_called)
        self.assertNotIn("--bindir=${prefix}/bin", runner.command_called)
        self.assertNotIn("--libdir=${prefix}/lib", runner.command_called)
        self.assertNotIn("--includedir=${prefix}/lib", runner.command_called)
 def test_make_targets(self):
     runner = RunnerMock()
     conanfile = MockConanfile(MockSettings({}),None,runner)
     
     ab = AutoToolsBuildEnvironment(conanfile)
     ab.configure()
     
     ab.make(target="install")
     self.assertEquals(runner.command_called,"make install -j%s" % cpu_count())        
 def autotools_install_dir_custom_configure_test(self):
     for flag_to_remove in default_dirs_flags:
         flags_available = set(default_dirs_flags) - set([flag_to_remove])
         runner = RunnerMockWithHelp(available_args=flags_available)
         conanfile = MockConanfileWithOutput(MockSettings({}), None, runner)
         conanfile.package_folder = "/package_folder"
         ab = AutoToolsBuildEnvironment(conanfile)
         ab.configure()
         self.assertNotIn(flag_to_remove, runner.command_called)
         for flag_applied in flags_available:
             self.assertIn(flag_applied, runner.command_called)
    def test_make_targets_install(self):
        runner = RunnerMock()
        conanfile = MockConanfile(MockSettings({}), None, runner)

        ab = AutoToolsBuildEnvironment(conanfile)
        ab.configure()

        ab.make(target="install")
        self.assertEquals(runner.command_called, "make install -j%s" % cpu_count())
        ab.install()
        self.assertEquals(runner.command_called, "make install -j%s" % cpu_count())
Beispiel #7
0
 def test_partial_build(self):
     conan_file = ConanFileMock()
     conan_file.deps_cpp_info = self._creat_deps_cpp_info()
     conan_file.settings = Settings()
     be = AutoToolsBuildEnvironment(conan_file)
     conan_file.should_configure = False
     conan_file.should_build = False
     conan_file.should_install = False
     be.configure()
     self.assertIsNone(conan_file.command)
     be.make()
     self.assertIsNone(conan_file.command)
 def partial_build_test(self):
     conan_file = ConanFileMock()
     deps_cpp_info = namedtuple("Deps", "libs, include_paths, lib_paths, defines, cflags, "
                                "cppflags, sharedlinkflags, exelinkflags, sysroot")
     conan_file.deps_cpp_info = deps_cpp_info([], [], [], [], [], [], [], [], "")
     conan_file.settings = Settings()
     be = AutoToolsBuildEnvironment(conan_file)
     conan_file.should_configure = False
     conan_file.should_build = False
     conan_file.should_install = False
     be.configure()
     self.assertIsNone(conan_file.command)
     be.make()
     self.assertIsNone(conan_file.command)
 def partial_build_test(self):
     conan_file = ConanFileMock()
     deps_cpp_info = namedtuple("Deps", "libs, include_paths, lib_paths, defines, cflags, "
                                        "cxxflags, sharedlinkflags, exelinkflags, sysroot")
     conan_file.deps_cpp_info = deps_cpp_info([], [], [], [], [], [], [], [], "")
     conan_file.settings = Settings()
     be = AutoToolsBuildEnvironment(conan_file)
     conan_file.should_configure = False
     conan_file.should_build = False
     conan_file.should_install = False
     be.configure()
     self.assertIsNone(conan_file.command)
     be.make()
     self.assertIsNone(conan_file.command)
    def failing_configure_help_test(self):

        class RunnerMockWithHelpFailing(RunnerMockWithHelp):
            def __call__(self, command, output=None, win_bash=False, subsystem=None):  # @UnusedVariable
                if "configure --help" in command:
                    raise ConanException("Help not available")
                else:
                    return super(RunnerMockWithHelp, self).__call__(command, output, win_bash, subsystem)

        runner = RunnerMockWithHelpFailing(available_args=default_dirs_flags)
        conanfile = MockConanfileWithOutput(MockSettings({}), None, runner)
        conanfile.package_folder = "/package_folder"
        ab = AutoToolsBuildEnvironment(conanfile)
        ab.configure()
        for flag_applied in default_dirs_flags:
            self.assertNotIn(flag_applied, runner.command_called)
        self.assertIn("Error running `configure --help`: Help not available", conanfile.output)
 def autotools_prefix_test(self):
     runner = RunnerMock()
     conanfile = MockConanfile(MockSettings({}), None, runner)
     # Package folder is not defined
     ab = AutoToolsBuildEnvironment(conanfile)
     ab.configure()
     self.assertNotIn("--prefix", runner.command_called)
     # package folder defined
     conanfile.package_folder = "/package_folder"
     ab.configure()
     if platform.system() == "Windows":
         self.assertIn("./configure --prefix=/package_folder",
                       runner.command_called)
     else:
         self.assertIn("./configure '--prefix=/package_folder'",
                       runner.command_called)
     # --prefix already used in args
     ab.configure(args=["--prefix=/my_package_folder"])
     if platform.system() == "Windows":
         self.assertIn("./configure --prefix=/my_package_folder",
                       runner.command_called)
         self.assertNotIn("--prefix=/package_folder", runner.command_called)
     else:
         self.assertIn("./configure '--prefix=/my_package_folder'",
                       runner.command_called)
         self.assertNotIn("'--prefix=/package_folder'",
                          runner.command_called)
Beispiel #12
0
    def cross_build_command_test(self):
        runner = RunnerMock()
        conanfile = MockConanfile(MockSettings({}), None, runner)
        ab = AutoToolsBuildEnvironment(conanfile)
        ab.configure()
        self.assertEquals(runner.command_called, "./configure  ")

        ab.configure(host="x86_64-apple-darwin")
        self.assertEquals(runner.command_called, "./configure  --host=x86_64-apple-darwin")

        ab.configure(build="arm-apple-darwin")
        self.assertEquals(runner.command_called, "./configure  --build=arm-apple-darwin")

        ab.configure(target="i686-apple-darwin")
        self.assertEquals(runner.command_called, "./configure  --target=i686-apple-darwin")
 def autotools_prefix_test(self):
     runner = RunnerMock()
     conanfile = MockConanfile(MockSettings({}), None, runner)
     # Package folder is not defined
     ab = AutoToolsBuildEnvironment(conanfile)
     ab.configure()
     self.assertNotIn("--prefix", runner.command_called)
     # package folder defined
     conanfile.package_folder = "/package_folder"
     ab.configure()
     if platform.system() == "Windows":
         self.assertIn("./configure --prefix=/package_folder", runner.command_called)
     else:
         self.assertIn("./configure '--prefix=/package_folder'", runner.command_called)
     # --prefix already used in args
     ab.configure(args=["--prefix=/my_package_folder"])
     if platform.system() == "Windows":
         self.assertIn("./configure --prefix=/my_package_folder", runner.command_called)
         self.assertNotIn("--prefix=/package_folder", runner.command_called)
     else:
         self.assertIn("./configure '--prefix=/my_package_folder'", runner.command_called)
         self.assertNotIn("'--prefix=/package_folder'", runner.command_called)
    def cross_build_command_test(self):
        runner = RunnerMock()
        conanfile = MockConanfile(MockSettings({}), None, runner)
        ab = AutoToolsBuildEnvironment(conanfile)
        self.assertFalse(ab.build)
        self.assertFalse(ab.host)
        self.assertFalse(ab.target)

        ab.configure()
        self.assertEquals(runner.command_called, "./configure  ")

        ab.configure(host="x86_64-apple-darwin")
        self.assertEquals(runner.command_called,
                          "./configure  --host=x86_64-apple-darwin")

        ab.configure(build="arm-apple-darwin")
        self.assertEquals(runner.command_called,
                          "./configure  --build=arm-apple-darwin")

        ab.configure(target="i686-apple-darwin")
        self.assertEquals(runner.command_called,
                          "./configure  --target=i686-apple-darwin")

        conanfile = MockConanfile(
            MockSettings({
                "build_type": "Debug",
                "arch": "x86_64",
                "os": "Windows",
                "compiler": "gcc",
                "compiler.libcxx": "libstdc++"
            }), None, runner)
        ab = AutoToolsBuildEnvironment(conanfile)
        ab.configure()
        if platform.system() == "Windows":
            # Not crossbuilding
            self.assertFalse(ab.host)
            self.assertFalse(ab.build)
            self.assertIn("./configure", runner.command_called)
            self.assertNotIn(
                "--build=x86_64-w64-mingw32 --host=x86_64-w64-mingw32",
                runner.command_called)
        elif platform.system() == "Linux":
            self.assertIn("x86_64-w64-mingw32", ab.host)
            self.assertIn("x86_64-linux-gnu", ab.build)
            self.assertIn(
                "./configure  --build=x86_64-linux-gnu --host=x86_64-w64-mingw32",
                runner.command_called)
        else:
            self.assertIn("x86_64-w64-mingw32", ab.host)
            self.assertIn("x86_64-apple-darwin", ab.build)
            self.assertIn(
                "./configure  --build=x86_64-apple-darwin --host=x86_64-w64-mingw32",
                runner.command_called)

        ab.configure(build="fake_build_triplet", host="fake_host_triplet")
        self.assertIn(
            "./configure  --build=fake_build_triplet --host=fake_host_triplet",
            runner.command_called)

        ab.build = "superfake_build_triplet"
        ab.host = "superfake_host_triplet"
        ab.configure()
        self.assertIn(
            "./configure  --build=superfake_build_triplet --host=superfake_host_triplet",
            runner.command_called)
    def cross_build_command_test(self):
        runner = RunnerMock()
        conanfile = MockConanfile(MockSettings({}), None, runner)
        ab = AutoToolsBuildEnvironment(conanfile)
        self.assertFalse(ab.build)
        self.assertFalse(ab.host)
        self.assertFalse(ab.target)

        ab.configure()
        self.assertEquals(runner.command_called, "./configure  ")

        ab.configure(host="x86_64-apple-darwin")
        self.assertEquals(runner.command_called, "./configure  --host=x86_64-apple-darwin")

        ab.configure(build="arm-apple-darwin")
        self.assertEquals(runner.command_called, "./configure  --build=arm-apple-darwin")

        ab.configure(target="i686-apple-darwin")
        self.assertEquals(runner.command_called, "./configure  --target=i686-apple-darwin")

        conanfile = MockConanfile(MockSettings({"build_type": "Debug",
                                                "arch": "x86_64",
                                                "os": "Windows",
                                                "compiler": "gcc",
                                                "compiler.libcxx": "libstdc++"}),
                                  None, runner)
        ab = AutoToolsBuildEnvironment(conanfile)
        ab.configure()
        if platform.system() == "Windows":
            # Not crossbuilding
            self.assertFalse(ab.host)
            self.assertFalse(ab.build)
            self.assertIn("./configure", runner.command_called)
            self.assertNotIn("--build=x86_64-w64-mingw32 --host=x86_64-w64-mingw32",
                             runner.command_called)
        elif platform.system() == "Linux":
            self.assertIn("x86_64-w64-mingw32", ab.host)
            self.assertIn("x86_64-linux-gnu", ab.build)
            self.assertIn("./configure  --build=x86_64-linux-gnu --host=x86_64-w64-mingw32",
                          runner.command_called)
        else:
            self.assertIn("x86_64-w64-mingw32", ab.host)
            self.assertIn("x86_64-apple-darwin", ab.build)
            self.assertIn("./configure  --build=x86_64-apple-darwin --host=x86_64-w64-mingw32",
                          runner.command_called)

        ab.configure(build="fake_build_triplet", host="fake_host_triplet")
        self.assertIn("./configure  --build=fake_build_triplet --host=fake_host_triplet",
                      runner.command_called)

        ab.build = "superfake_build_triplet"
        ab.host = "superfake_host_triplet"
        ab.configure()
        self.assertIn("./configure  --build=superfake_build_triplet --host=superfake_host_triplet",
                      runner.command_called)