Ejemplo n.º 1
0
    def test_node_filter_dirname(self):

        with Tempdir() as tmp_install_dir:
            with Tempdir() as tmp_dir:

                build_dir = os.path.join(tmp_dir, 'output')

                num_sources = 3
                sources = self.generate_source_files(tmp_dir, num_sources, 200)

                # set_event_settings( EventSettings( brief = False,
                #                                    with_output = True ) )

                cfg = ProjectConfig(args=["build_dir=%s" % build_dir])
                cfg.debug_backtrace = True

                prj = Project(cfg)

                node = prj.tools.CopyFiles(sources[0], target=tmp_install_dir)

                prj.tools.CopyFiles(sources[1:], target=prj.node_dirname(node))

                self.build_prj(prj, 3)

                for src in sources:
                    tgt = os.path.join(tmp_install_dir, os.path.basename(src))
                    self.assertTrue(os.path.isfile(tgt))

                node = prj.tools.CopyFiles(sources[0], target=tmp_install_dir)
                prj.tools.CopyFiles(sources[1:], target=prj.node_dirname(node))

                self.build_prj(prj, 0)
Ejemplo n.º 2
0
    def test_temp_dir(self):
        with Tempdir() as tmp_dir:
            tmp_dir = Tempdir(root_dir=tmp_dir)

            for i in range(10):
                Tempfile(root_dir=tmp_dir, suffix='.tmp').close()

        self.assertFalse(os.path.exists(tmp_dir))
Ejemplo n.º 3
0
    def test_zip_files(self):

        with Tempdir() as tmp_install_dir:
            with Tempdir() as tmp_dir:
                # tmp_install_dir = Tempdir()
                # tmp_dir = Tempdir()

                sub_dir1 = Tempdir(root_dir=tmp_dir)
                sub_dir2 = Tempdir(root_dir=tmp_dir)

                build_dir = os.path.join(tmp_dir, 'output')

                num_sources = 3
                sources = []
                sources += self.generate_source_files(sub_dir1, num_sources, 2)
                sources += self.generate_source_files(sub_dir2, num_sources, 2)

                zip_file = tmp_install_dir + "/test.zip"

                cfg = ProjectConfig(args=["--bt", "build_dir=%s" % build_dir])

                prj = Project(cfg)

                value = prj.make_entity(name="test_content.txt",
                                        data="To add to a ZIP file")
                rename = [('test_file', sources[0])]

                prj.tools.CreateZip(sources,
                                    value,
                                    target=zip_file,
                                    basedir=tmp_dir,
                                    rename=rename)

                self.build_prj(prj, 1)

                prj.tools.CreateZip(sources,
                                    value,
                                    target=zip_file,
                                    basedir=tmp_dir,
                                    rename=rename)

                self.build_prj(prj, 0)

                self.regenerate_file(sources[-1], 200)

                prj.tools.CreateZip(sources,
                                    value,
                                    target=zip_file,
                                    basedir=tmp_dir,
                                    rename=rename)
                self.build_prj(prj, 1)
Ejemplo n.º 4
0
    def test_copy_files(self):

        with Tempdir() as tmp_install_dir:
            with Tempdir() as tmp_dir:
                # tmp_install_dir = Tempdir()
                # tmp_dir = Tempdir()

                sub_dir1 = Tempdir(root_dir=tmp_dir)
                sub_dir2 = Tempdir(root_dir=tmp_dir)

                num_sources = 3
                sources = []
                sources += self.generate_source_files(sub_dir1, num_sources, 2)
                sources += self.generate_source_files(sub_dir2, num_sources, 2)
                sources += self.generate_source_files(tmp_dir, num_sources, 2)

                build_dir = os.path.join(tmp_dir, 'output')

                cfg = ProjectConfig(args=["build_dir=%s" % build_dir])

                prj = Project(cfg)

                node = prj.tools.CopyFiles(sources,
                                           target=tmp_install_dir,
                                           basedir=tmp_dir)

                node.options.batch_groups = 1

                self.build_prj(prj, 1)

                found_dirs = set()
                files = find_files(tmp_install_dir, found_dirs=found_dirs)
                filenames = set(os.path.basename(path) for path in files)
                srcnames = set(os.path.basename(path) for path in sources)
                self.assertSetEqual(filenames, srcnames)

                found_dir_names = set(
                    os.path.basename(path) for path in found_dirs)

                sub_dir_names = set(
                    os.path.basename(path) for path in [sub_dir1, sub_dir2])

                self.assertSetEqual(found_dir_names, sub_dir_names)

                prj.tools.CopyFiles(sources,
                                    target=tmp_install_dir,
                                    basedir=tmp_dir)

                self.build_prj(prj, 0)
Ejemplo n.º 5
0
    def test_bm_no_conflicts(self):

        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir

            num_src_files = 3
            src_files = self.generate_source_files(tmp_dir, num_src_files, 201)

            bm = BuildManager()

            self.built_nodes = 0

            builder1 = ChecksumSingleBuilder(options, 0, 256)
            builder2 = ChecksumSingleBuilder(options, 0, 256)

            node1 = Node(builder1, src_files)
            node2 = Node(builder2, src_files)
            node1 = Node(builder1, node1)
            node2 = Node(builder2, node2)

            bm.add([node1, node2])
            _build(bm)

            self.assertEqual(self.built_nodes,
                             num_src_files + num_src_files * 2)
Ejemplo n.º 6
0
    def test_bm_batch(self):

        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir
            options.batch_build = True

            src_files = self.generate_source_files(tmp_dir, 3, 201)

            builder = ChecksumBuilder(options, 0, 256, replace_ext=True)

            self.building_nodes = self.built_nodes = 0
            _build_checksums(builder, src_files)
            self.assertEqual(self.building_nodes, 2)
            self.assertEqual(self.building_nodes, self.built_nodes)

            self.built_nodes = 0
            _build_checksums(builder, src_files)
            self.assertEqual(self.built_nodes, 0)

            bm = _add_nodes_to_bm(builder, src_files)
            try:
                bm.clear()
                bm.self_test()
            finally:
                bm.close()
Ejemplo n.º 7
0
    def test_bm_node_index(self):

        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir

            num_src_files = 2
            src_files = self.generate_source_files(tmp_dir, num_src_files, 201)

            bm = BuildManager()

            self.built_nodes = 0

            builder = ChecksumSingleBuilder(options, 0, 256)

            node = Node(builder, src_files)
            nodes = [
                Node(builder, node[i * 2]) for i in range(num_src_files + 1)
            ]
            node2 = Node(builder, node[1:2][:])
            #
            bm.add([node2])
            bm.add(nodes)
            _build(bm)

            self.assertEqual(self.built_nodes,
                             num_src_files + num_src_files + 1 + 1)
Ejemplo n.º 8
0
    def test_prj_list_options(self):

        with Tempdir() as tmp_dir:

            cfg = ProjectConfig(args=["build_dir=%s" % tmp_dir, "test", "run"])

            prj = Project(cfg)
            self.assertTrue(prj.list_options())
            self.assertTrue(prj.list_options(brief=True))
            self.assertFalse(prj.list_tools_options('c++'))
Ejemplo n.º 9
0
    def test_prj_implicit_value_args(self):

        with Tempdir() as tmp_dir:

            cfg = ProjectConfig(args=["build_dir=%s" % tmp_dir])

            prj = Project(cfg)

            tool = prj.tools.add_tool(_NullTool)

            tool.noop(v1="a", v2="b", v3="c")
            prj.build()

            self.assertEqual(self.built_nodes, 1)

            # -----------------------------------------------------------

            self.built_nodes = 0

            tool.noop(v1="aa", v2="bb", v3="cc")
            prj.build()
            self.assertEqual(self.built_nodes, 0)

            # -----------------------------------------------------------

            self.built_nodes = 0

            v1 = SimpleEntity("a", name="value1")

            tool.noop(v1=v1, v2="b", v3="c")
            prj.build()
            self.assertEqual(self.built_nodes, 1)

            # -----------------------------------------------------------

            self.built_nodes = 0

            v1 = SimpleEntity("ab", name="value1")

            tool.noop(v1=v1, v2="b", v3="c")
            prj.build()
            self.assertEqual(self.built_nodes, 1)

            # -----------------------------------------------------------

            self.built_nodes = 0

            v1 = SimpleEntity("ab", name="value1")

            tool.noop(v1=v1, v2="b", v3="c")
            prj.build()
            self.assertEqual(self.built_nodes, 0)
Ejemplo n.º 10
0
    def test_copy_file_as(self):

        with Tempdir() as tmp_install_dir:
            with Tempdir() as tmp_dir:
                # tmp_install_dir = Tempdir()
                # tmp_dir = Tempdir()

                build_dir = os.path.join(tmp_dir, 'output')

                source = self.generate_file(tmp_dir, 200)
                target = os.path.join(tmp_install_dir, 'copy_as_source.dat')

                cfg = ProjectConfig(args=["build_dir=%s" % build_dir])

                prj = Project(cfg)

                prj.tools.CopyFileAs(source, target=target)

                self.build_prj(prj, 1)

                prj.tools.CopyFileAs(source, target=target)

                self.build_prj(prj, 0)
Ejemplo n.º 11
0
    def test_write_file(self):

        with Tempdir() as tmp_install_dir:
            with Tempdir() as tmp_dir:
                # tmp_install_dir = Tempdir()
                # tmp_dir = Tempdir()

                build_dir = os.path.join(tmp_dir, 'output')

                cfg = ProjectConfig(args=["build_dir=%s" % build_dir])

                prj = Project(cfg)

                buf = "Test buffer content"

                target = os.path.join(tmp_install_dir, 'write_content.txt')
                prj.tools.WriteFile(buf, target=target)

                self.build_prj(prj, 1)

                prj.tools.WriteFile(buf, target=target)

                self.build_prj(prj, 0)
Ejemplo n.º 12
0
    def test_bm_skip_nodes_by_value(self):
        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir

            bm = BuildManager()

            self.built_nodes = 0

            node = Node(ValueBuilder(options), [1, 2, 3, 4])
            bm.add([node])

            bm.build_if(False, node)

            _build(bm, jobs=4)
            self.assertEqual(self.built_nodes, 0)
Ejemplo n.º 13
0
    def test_bm_dup_names(self):

        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir
            options.batch_build = True
            # options.batch_groups = 4
            options.batch_size = 3

            src_files = self.generate_source_files(tmp_dir, 10, 201)

            builder = ChecksumBadBuilder(options, 0, 256, replace_ext=True)

            self.building_nodes = self.built_nodes = 0

            with self.assertRaises(ErrorNodeDuplicateNames):
                _build_checksums(builder, src_files, jobs=4)
Ejemplo n.º 14
0
    def test_prj_expensive(self):
        with Tempdir() as tmp_dir:
            cfg = ProjectConfig(args=["build_dir=%s" % tmp_dir])

            prj = Project(cfg)

            cmd_heavy = prj.tools.ExecuteCommand(
                sys.executable, "-c", "print('test expensive')")

            prj.tools.ExecuteCommand(sys.executable, "-c",
                                     "print('test light')")

            prj.expensive(cmd_heavy)

            prj.build()

            self.assertEqual(self.built_nodes, 2)
Ejemplo n.º 15
0
    def test_bm_rebuild(self):

        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir

            num_src_files = 10
            src_files = self.generate_source_files(tmp_dir, num_src_files, 201)

            def _build_nodes(num_dups, uptodate):
                bm = BuildManager()

                self.building_nodes = self.built_nodes = 0

                builder = ChecksumSingleBuilder(options, 0, 256)

                src_entities = tuple(map(FileChecksumEntity, src_files))

                num_built_nodes = 0

                for i in range(num_dups):
                    num_built_nodes = 1
                    node = Node(builder, src_entities)

                    node = Node(builder, node)
                    num_built_nodes += 2

                    node = Node(builder, node)
                    num_built_nodes += 2**2

                    node = Node(builder, node)
                    num_built_nodes += 2**3

                    bm.add([node])

                _build(bm, jobs=10, explain=False)

                if uptodate:
                    num_built_nodes = 0
                else:
                    num_built_nodes *= num_src_files

                self.assertEqual(self.building_nodes, num_built_nodes)

            _build_nodes(3, False)
            _build_nodes(3, True)
Ejemplo n.º 16
0
    def test_bm_tags_batch(self):

        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir
            options.batch_build = True

            num_src_files = 3
            src_files = self.generate_source_files(tmp_dir, num_src_files, 201)

            builder = ChecksumBuilder(options, 0, 256)

            options.batch_build = False
            single_builder = ChecksumSingleBuilder(options, 0, 256)
            bm = BuildManager()

            self.built_nodes = 0

            node = Node(builder, src_files)

            node_md5 = Node(single_builder, node.at('md5'))

            bm.add([node_md5])

            _build(bm)

            self.assertEqual(self.built_nodes, num_src_files + 1)

            # -----------------------------------------------------------

            self.regenerate_file(src_files[0], 201)

            bm = BuildManager()

            self.built_nodes = 0

            node = Node(builder, src_files)

            node_md5 = Node(single_builder, node.at('md5'))

            bm.add([node_md5])

            _build(bm)

            self.assertEqual(self.built_nodes, 2)
Ejemplo n.º 17
0
    def test_find_files(self):

        with Tempdir() as tmp_dir:
            # tmp_dir = Tempdir()
            # print("tmp_dir: %s" % tmp_dir)

            build_dir = os.path.join(tmp_dir, 'output')

            num_sources = 3
            sources = self.generate_source_files(tmp_dir, num_sources, 20)

            cfg = ProjectConfig(args=["build_dir=%s" % build_dir])

            prj = Project(cfg)

            prj.tools.FindFiles(tmp_dir)
            prj.tools.FindFiles(tmp_dir, mask="*.tmp")

            self.build_prj(prj, 2)

            prj.tools.FindFiles(tmp_dir)
            prj.tools.FindFiles(tmp_dir, mask="*.tmp")

            self.build_prj(prj, 0)

            prj.tools.FindFiles(tmp_dir, exclude_mask=".*db*")
            self.build_prj(prj, 1)

            prj.tools.FindFiles(tmp_dir, exclude_mask=".*db*")
            self.build_prj(prj, 0)

            sources += self.generate_source_files(tmp_dir, 1, 20)

            prj.tools.FindFiles(tmp_dir, exclude_mask=".*db*")
            prj.tools.FindFiles(tmp_dir, mask="*.tmp")
            self.build_prj(prj, 2)

            prj.tools.FindFiles(tmp_dir, exclude_mask=".db*")
            prj.tools.FindFiles(tmp_dir, mask="*.tmp")

            self.clear_prj(prj)

            self.assertTrue(all(os.path.isfile(source) for source in sources))
Ejemplo n.º 18
0
    def test_prj_default_targets(self):

        with Tempdir() as tmp_dir:

            cfg = ProjectConfig(args=["build_dir=%s" % tmp_dir])

            prj = Project(cfg)

            prj.tools.ExecuteCommand(
                sys.executable, "-c", "print('test builtin')")
            cmd_other = prj.tools.ExecuteCommand(
                sys.executable, "-c", "print('test other')")
            cmd_other2 = prj.tools.ExecuteCommand(
                sys.executable, "-c", "print('test other2')")

            prj.default_build([cmd_other, cmd_other2])
            prj.build()

            self.assertEqual(self.built_nodes, 2)
Ejemplo n.º 19
0
    def test_node_batch(self):

        with Tempdir() as tmp_dir:
            vfile_name = Tempfile(root_dir=tmp_dir)
            vfile_name.close()
            with EntitiesFile(vfile_name) as vfile:
                src_files = self.generate_source_files(tmp_dir, 5, 100)

                self._rebuild_batch_node(vfile, src_files, len(src_files))
                self._rebuild_batch_node(vfile, src_files, 0)
                self._rebuild_batch_node(vfile, src_files[:-2], 0)
                self._rebuild_batch_node(vfile, src_files[0:1], 0)

                # -----------------------------------------------------------

                write_bin_file(src_files[1], b"src_file1")
                write_bin_file(src_files[2], b"src_file1")

                self._rebuild_batch_node(vfile, src_files, 2)
Ejemplo n.º 20
0
    def test_bm_expensive(self):
        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir

            bm = BuildManager()
            self.built_nodes = 0

            event = threading.Event()

            heavy = ExpensiveValueBuilder(options, event, do_expensive=True)
            light = ExpensiveValueBuilder(options, event, do_expensive=False)

            node1 = Node(heavy, [1, 2, 3, 4, 5, 7])
            node2 = Node(light, list(range(10, 100, 10)))
            bm.add([node2, node1])
            bm.expensive(node1)

            _build(bm, jobs=16)
Ejemplo n.º 21
0
    def test_bm_node_build_fail(self):

        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir

            bm = BuildManager()

            self.built_nodes = 0

            builder = FailedBuilder(options)

            nodes = [
                Node(builder, SimpleEntity("123-%s" % (i, ))) for i in range(4)
            ]
            bm.add(nodes)

            self.assertRaises(Exception, _build, bm)
            self.assertEqual(self.built_nodes, 0)
Ejemplo n.º 22
0
    def test_prj_targets(self):

        with Tempdir() as tmp_dir:

            cfg = ProjectConfig(args=["build_dir=%s" % tmp_dir, "test", "run"])

            prj = Project(cfg)

            cmd = prj.tools.ExecuteCommand(
                sys.executable, "-c", "print('test builtin')")

            prj.tools.ExecuteCommand(sys.executable, "-c",
                                     "print('test other')")

            self.assertSequenceEqual(prj.get_build_targets(), ['test', 'run'])

            prj.alias_nodes(prj.get_build_targets(), cmd)
            prj.build()

            self.assertEqual(self.built_nodes, 1)
Ejemplo n.º 23
0
    def test_bm_sync_nodes(self):

        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir

            bm = BuildManager()

            self.built_nodes = 0

            nodes = [
                Node(SyncValueBuilder(options, name="%s" % i, number=n),
                     SimpleEntity("123-%s" % i))
                for i, n in zip(range(4), [3, 5, 7, 11])
            ]

            bm.add(nodes)
            bm.sync(nodes)

            _build(bm, jobs=4)
Ejemplo n.º 24
0
    def test_bm_skip_nodes_by_option(self):
        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir

            bm = BuildManager()
            self.built_nodes = 0

            cond_node = Node(CondBuilder(options), False)

            options.has_openmp = BoolOptionType(default=True)
            options.has_openmp = cond_node

            node = Node(ValueBuilder(options), None)
            bm.add([node])

            bm.build_if(options.has_openmp, node)
            bm.depends(node, [cond_node])

            _build(bm, jobs=4)
            self.assertEqual(self.built_nodes, 1)
Ejemplo n.º 25
0
    def test_exec(self):

        with Tempdir() as tmp_dir:

            build_dir = os.path.join(tmp_dir, 'build')

            options = builtin_options()

            cmd = [sys.executable, '-c', 'print("TEST EXEC")']

            options.build_dir = build_dir

            exec_cmd = ExecuteCommandBuilder(options)

            bm = BuildManager()
            try:

                result = Node(exec_cmd, cmd)

                bm.add([result])

                self._build(bm, jobs=1, keep_going=False)

                self.assertEqual(self.building_started, 1)
                self.assertEqual(self.building_started, self.built_nodes)

                bm.close()

                result = Node(exec_cmd, cmd)

                bm = BuildManager()
                bm.add([result])

                self.building_started = 0
                self._build(bm, jobs=1, keep_going=False)

                self.assertEqual(self.building_started, 0)

            finally:
                bm.close()
Ejemplo n.º 26
0
    def test_bm_build(self):

        with Tempdir() as tmp_dir:

            options = builtin_options()
            options.build_dir = tmp_dir

            src_files = self.generate_source_files(tmp_dir, 5, 201)

            builder = ChecksumBuilder(options, 0, 256)

            self.building_nodes = self.built_nodes = 0
            _build_checksums(builder, src_files)
            self.assertEqual(self.building_nodes, 2)
            self.assertEqual(self.building_nodes, self.built_nodes)

            # -----------------------------------------------------------

            self.building_nodes = self.built_nodes = 0
            _build_checksums(builder, src_files)
            self.assertEqual(self.building_nodes, 0)
            self.assertEqual(self.building_nodes, self.built_nodes)

            # -----------------------------------------------------------

            builder = ChecksumBuilder(options, 32, 1024)

            self.building_nodes = self.built_nodes = 0
            _build_checksums(builder, src_files)
            self.assertEqual(self.building_nodes, 2)
            self.assertEqual(self.building_nodes, self.built_nodes)

            # -----------------------------------------------------------

            self.building_nodes = self.built_nodes = 0
            _build_checksums(builder, src_files)
            self.assertEqual(self.building_nodes, 0)
            self.assertEqual(self.building_nodes, self.building_nodes)
Ejemplo n.º 27
0
    def test_bm_conflicts(self):

        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir

            num_src_files = 3
            src_files = self.generate_source_files(tmp_dir, num_src_files, 201)

            bm = BuildManager()

            self.built_nodes = 0

            builder1 = ChecksumSingleBuilder(options, 0, 256)
            builder2 = ChecksumSingleBuilder(options, 0, 1024)

            node1 = Node(builder1, src_files)
            node2 = Node(builder2, src_files)
            # node1 = Node( builder1, node1 )
            # node2 = Node( builder2, node2 )

            bm.add([node1, node2])
            self.assertRaises(ErrorNodeSignatureDifferent, _build, bm)
Ejemplo n.º 28
0
    def test_bm_skip_nodes_by_node(self):
        with Tempdir() as tmp_dir:
            options = builtin_options()
            options.build_dir = tmp_dir

            bm = BuildManager()

            self.built_nodes = 0

            cond_node1 = Node(CondBuilder(options), False)
            node1 = Node(ValueBuilder(options), [1, 2])
            cond_node2 = Node(CondBuilder(options), True)
            node2 = Node(ValueBuilder(options), [3, 4])
            main = Node(ValueBuilder(options), [7, 8, node1, node2])

            bm.add([main])

            bm.build_if(cond_node1, node1)
            bm.build_if(cond_node2, node2)

            _build(bm, jobs=4)
            self.assertEqual(main.get(), "7-8-3-4")
            self.assertEqual(self.built_nodes, 4)
Ejemplo n.º 29
0
    def test_prj_builtin_tools(self):

        with Tempdir() as tmp_dir:

            cfg = ProjectConfig(args=["build_dir=%s" % tmp_dir])

            prj = Project(cfg)

            cmd = sys.executable, "-c", "print('test builtin')"

            prj.tools.ExecuteCommand(cmd)
            prj.build()

            self.assertEqual(self.building_started, 1)
            self.assertEqual(self.built_nodes, 1)

            self.building_started = 0

            prj = Project(cfg)
            prj.tools.ExecuteCommand(cmd)
            prj.build()

            self.assertEqual(self.building_started, 0)
Ejemplo n.º 30
0
    def test_exec_method(self):
        def copy_file_ext(builder, source_entities, targets, ext):
            src_file = source_entities[0].get()
            dst_file = os.path.splitext(src_file)[0] + ext
            shutil.copy(src_file, dst_file)
            targets.add_targets(dst_file)

        with Tempdir() as tmp_dir:

            set_event_settings(
                EventSettings(brief=True, with_output=True, trace_exec=False))

            build_dir = os.path.join(tmp_dir, 'build_output')

            num_sources = 2
            sources = self.generate_source_files(tmp_dir,
                                                 num_sources,
                                                 size=200,
                                                 suffix='.cpp')

            headers = self.generate_source_files(tmp_dir,
                                                 num_sources,
                                                 size=200,
                                                 suffix='.hpp')

            cfg = ProjectConfig(args=["build_dir=%s" % build_dir])

            prj = Project(cfg)

            prj.tools.ExecuteMethod(sources,
                                    method=copy_file_ext,
                                    args=('.cxx', ))
            prj.tools.ExecuteMethod(headers,
                                    method=copy_file_ext,
                                    args=('.hxx', ))

            self.build_prj(prj, len(sources) + len(headers))

            prj.tools.ExecuteMethod(sources,
                                    method=copy_file_ext,
                                    args=('.cxx', ))
            prj.tools.ExecuteMethod(headers,
                                    method=copy_file_ext,
                                    args=('.hxx', ))

            self.build_prj(prj, 0)

            prj.tools.ExecuteMethod(sources,
                                    method=copy_file_ext,
                                    args=('.cc', ))

            self.build_prj(prj, len(sources))

            prj.tools.ExecuteMethod(sources,
                                    method=copy_file_ext,
                                    args=('.cxx', ))
            self.build_prj(prj, len(sources))

            # -----------------------------------------------------------

            for src in sources:
                self.assertTrue(
                    os.path.isfile(os.path.splitext(src)[0] + '.cxx'))

            prj.tools.ExecuteMethod(sources,
                                    method=copy_file_ext,
                                    args=('.cxx', ))
            self.clear_prj(prj)

            for src in sources:
                self.assertFalse(
                    os.path.isfile(os.path.splitext(src)[0] + '.cxx'))

            # -----------------------------------------------------------

            prj.tools.ExecuteMethod(sources,
                                    method=copy_file_ext,
                                    args=('.cxx', ))
            self.build_prj(prj, len(sources))

            for src in sources:
                self.assertTrue(
                    os.path.isfile(os.path.splitext(src)[0] + '.cxx'))

            prj.tools.ExecuteMethod(sources,
                                    method=copy_file_ext,
                                    args=('.cxx', ),
                                    clear_targets=False)
            self.clear_prj(prj)

            for src in sources:
                self.assertTrue(
                    os.path.isfile(os.path.splitext(src)[0] + '.cxx'))