def test_create_dev_image(self) -> None: """Test VaRA install inside container.""" vara_cfg()["vara"]["llvm_source_dir"] = "tools_src/vara-llvm-project" vara_cfg()["vara"]["llvm_install_dir"] = "tools/VaRA" vara_cfg()["container"]["from_source"] = False bb_cfg()["container"]["from_source"] = False with TemporaryDirectory() as tmpdir: research_tool = get_research_tool("vara") image_context = BaseImageCreationContext(ImageBase.DEBIAN_10, Path(tmpdir)) _create_dev_image_layers(image_context, research_tool) layers = image_context.layers # check that varats will be installed properly varats_install_layer = self.check_layer_type(layers[10], RunLayer) self.assertEqual("pip3", varats_install_layer.command) self.assertTupleEqual( ("install", '--ignore-installed', "varats-core", "varats"), varats_install_layer.args) varats_copy_config_layer = self.check_layer_type(layers[12], CopyLayer) self.assertEqual("/varats_root/.varats.yaml", varats_copy_config_layer.destination) # check that research tool dependencies will be installed vara_deps_layer = self.check_layer_type(layers[11], RunLayer) self.assertEqual("apt", vara_deps_layer.command) # check that correct entry point will be set entrypoint_layer = self.check_layer_type(layers[16], EntryPoint) self.assertEqual(("vara-buildsetup", ), entrypoint_layer.command)
def test_prepare_slurm(self, mock_create, mock_export) -> None: runner = CliRunner() bb_root = str(vara_cfg()["benchbuild_root"]) node_dir = "/tmp/foo" export_dir = "/tmp/containers/export" vara_cfg()["container"]["research_tool"] = None result = runner.invoke(driver_container.main, [ "prepare-slurm", "-i", "DEBIAN_10", "-t", "vara", "--export-dir", export_dir, "--node-dir", node_dir ]) self.assertEqual(0, result.exit_code, result.exception) # check vara config self.assertEqual("vara", str(vara_cfg()["container"]["research_tool"])) # check slurm config self.assertEqual(f"{bb_root}/slurm_container.sh.inc", str(bb_cfg()["slurm"]["template"])) self.assertTrue(Path(f"{bb_root}/slurm_container.sh.inc").is_file()) # check bb container config self.assertEqual(f"{node_dir}/containers/lib", str(bb_cfg()["container"]["root"])) self.assertEqual(f"{node_dir}/containers/run", str(bb_cfg()["container"]["runroot"])) self.assertEqual(export_dir, str(bb_cfg()["container"]["export"])) self.assertEqual(export_dir, str(bb_cfg()["container"]["import"])) self.assertTrue(Path(export_dir).is_dir())
def test_vara_cs_gen_sample_start_end_timestamp(self): """Check if vara-cs gen select_sample with start and end timestamps selects the right revisiosn.""" runner = CliRunner() Path(vara_cfg()["paper_config"]["folder"].value + "/" + "test_gen").mkdir() vara_cfg()["paper_config"]["current_config"] = "test_gen" result = runner.invoke( driver_casestudy.main, [ 'gen', '-p', 'brotli', 'select_sample', '--num-rev', '6', '--start', '2021-08-17', '--end', '2021-09-09', 'UniformSamplingMethod' ] ) self.assertEqual(0, result.exit_code, result.exception) case_study_path = Path( vara_cfg()["paper_config"]["folder"].value + "/test_gen/brotli_0.case_study" ) self.assertTrue(case_study_path.exists()) case_study = load_case_study_from_file(case_study_path) self.assertEqual(len(case_study.revisions), 5) self.assertTrue( FullCommitHash('68f1b90ad0d204907beb58304d0bd06391001a4d') in case_study.revisions ) self.assertTrue( FullCommitHash('62662f87cdd96deda90ac817de94e3c4af75226a') in case_study.revisions )
def test_vara_cs_gen_sample_only_code(self): """Check if vara-cs gen select_sample with --only-code-commits only selects revisions that contain code.""" runner = CliRunner() Path(vara_cfg()["paper_config"]["folder"].value + "/" + "test_gen").mkdir() vara_cfg()["paper_config"]["current_config"] = "test_gen" result = runner.invoke( driver_casestudy.main, [ 'gen', '-p', 'brotli', 'select_sample', '--num-rev', '10', '--start', '68f1b90ad0d204907beb58304d0bd06391001a4d', '--end', 'f4153a09f87cbb9c826d8fc12c74642bb2d879ea', '--only-code-commits', 'UniformSamplingMethod' ] ) self.assertEqual(0, result.exit_code, result.exception) case_study_path = Path( vara_cfg()["paper_config"]["folder"].value + "/test_gen/brotli_0.case_study" ) self.assertTrue(case_study_path.exists()) case_study = load_case_study_from_file(case_study_path) self.assertEqual(len(case_study.revisions), 5)
def gen(self) -> None: """Generate the case study using the selected strategy, project and strategy specific arguments.""" cmap = create_lazy_commit_map_loader(self.selected_project, None, 'HEAD', None)() version = self.cs_version.value() case_study = CaseStudy(self.revision_list_project, version) paper_config = vara_cfg()["paper_config"]["current_config"].value path = Path(vara_cfg()["paper_config"]["folder"].value) / ( paper_config + f"/{self.revision_list_project}_{version}.case_study") if self.strategie_forms.currentIndex( ) == GenerationStrategie.SAMPLE.value: sampling_method = NormalSamplingMethod.get_sampling_method_type( self.sampling_method.currentText()) extend_with_distrib_sampling(case_study, cmap, sampling_method(), 0, self.num_revs.value(), True, self.code_commits.clicked) elif self.strategie_forms.currentIndex( ) == GenerationStrategie.SELECT_REVISION.value: selected_rows = self.revision_list.selectionModel().selectedRows(0) selected_commits = [row.data() for row in selected_rows] extend_with_extra_revs(case_study, cmap, selected_commits, 0) self.revision_list.clearSelection() self.revision_list.update() elif self.strategie_forms.currentIndex( ) == GenerationStrategie.REVS_PER_YEAR.value: extend_with_revs_per_year( case_study, cmap, 0, True, get_local_project_git_path(self.selected_project), self.revs_per_year.value(), self.seperate.checkState()) store_case_study(case_study, path)
def test_vara_cs_cleanup_error(self): """Test vara-cs cleanup error.""" runner = CliRunner() vara_cfg()["paper_config"]["current_config"] = "test_cleanup_error" save_config() load_paper_config() importlib.reload(driver_casestudy) result = runner.invoke( driver_casestudy.main, ['cleanup', 'all', '--error'] ) self.assertEqual(0, result.exit_code, result.stdout) self.assertFalse( Path( vara_cfg()["result_dir"].value + "/brotli/CRE-CR-brotli-all-6c47009892_5d26c7ff-6d27-478f-bcd1" "-99e8e8e97f16_cerror.txt" ).exists() ) self.assertFalse( Path( vara_cfg()["result_dir"].value + "/brotli/CRE-CR-brotli-all-aaa4424d9b_5d26c7ff-6d27-478f-bcd1-" "99e8e8e97f16_failed.txt" ).exists() ) self.assertTrue( Path( vara_cfg()["result_dir"].value + "/brotli/CRE-CR-brotli-brotli-21ac39f7c8_34d4d1b5-7212-4244-" "9adc-b19bff599cf1_success.yaml" ).exists() )
def test_create_base_image_from_source(self) -> None: """Test varats install from source.""" vara_cfg()["container"]["research_tool"] = None vara_cfg()["container"]["from_source"] = True vara_cfg()["container"]["varats_source"] = "varats_src" bb_cfg()["container"]["from_source"] = False bb_cfg()["jobs"] = 42 with TemporaryDirectory() as tmpdir: image_context = BaseImageCreationContext(ImageBase.DEBIAN_10, Path(tmpdir)) _create_base_image_layers(image_context) layers = image_context.layers varats_install_layer = self.check_layer_type(layers[12], RunLayer) self.assertEqual("pip3", varats_install_layer.command) self.assertTupleEqual(("install", "--ignore-installed", "/varats/varats-core", "/varats/varats"), varats_install_layer.args) mounting_parameters = "type=bind,src=varats_src,target=/varats" if buildah_version() >= (1, 24, 0): mounting_parameters += ",rm" self.assertIn(("mount", mounting_parameters), varats_install_layer.kwargs)
def test_vara_cs_gen_sample_start_before_initial_commit(self): """Check if vara-cs gen select_sample with start timestamp before the initial commit selects the right revisiosn.""" runner = CliRunner() Path(vara_cfg()["paper_config"]["folder"].value + "/" + "test_gen").mkdir() vara_cfg()["paper_config"]["current_config"] = "test_gen" result = runner.invoke( driver_casestudy.main, [ 'gen', '-p', 'brotli', '--allow-blocked', 'select_sample', '--num-rev', '6', '--start', '1991-01-01', '--end', '2013-10-20', 'UniformSamplingMethod' ] ) self.assertEqual(0, result.exit_code, result.exception) case_study_path = Path( vara_cfg()["paper_config"]["folder"].value + "/test_gen/brotli_0.case_study" ) self.assertTrue(case_study_path.exists()) case_study = load_case_study_from_file(case_study_path) self.assertEqual(len(case_study.revisions), 1) self.assertTrue( FullCommitHash('e0346c826249368f0f4a68a2b95f4ab5cf1e235b') in case_study.revisions )
def test_vara_cs_gen_specific(self): """Test for vara-cs gen select_specific.""" runner = CliRunner() Path(vara_cfg()["paper_config"]["folder"].value + "/" + "test_gen").mkdir() vara_cfg()["paper_config"]["current_config"] = "test_gen" result = runner.invoke( driver_casestudy.main, [ 'gen', '-p', 'gravity', 'select_specific', '8820d0e08d1b389fc1e4ac2a17ad9f5418b21dfc', 'f9e95a41c18ed995f2c7cee7498c1a2313427c08' ] ) self.assertEqual(0, result.exit_code, result.exception) case_study_path = Path( vara_cfg()["paper_config"]["folder"].value + "/test_gen/gravity_0.case_study" ) self.assertTrue(case_study_path.exists()) case_study = load_case_study_from_file(case_study_path) self.assertTrue( case_study.revisions.__contains__( FullCommitHash('8820d0e08d1b389fc1e4ac2a17ad9f5418b21dfc') ) ) self.assertTrue( case_study.revisions.__contains__( FullCommitHash('f9e95a41c18ed995f2c7cee7498c1a2313427c08') ) ) self.assertEqual(len(case_study.revisions), 2)
def load_paper_config(config_path: tp.Optional[Path] = None) -> None: """ Loads a paper config from a yaml file, initializes the paper config and sets it to the currently active paper config. If no config path is provided, the paper config set in the vara settings yaml is loaded. Note: Only one paper config can be active at a time Args: config_path: path to a paper config folder """ if config_path is None: if vara_cfg()["paper_config"]["folder"].value is None or \ vara_cfg()["paper_config"][ "current_config"].value is None: raise ConfigurationLookupError( f"No paper config was set in VaRA config file " f"{vara_cfg()['config_file']}") config_path = Path( str(vara_cfg()["paper_config"]["folder"]) + "/" + str(vara_cfg()["paper_config"]["current_config"])) global _G_PAPER_CONFIG # pylint: disable=global-statement _G_PAPER_CONFIG = PaperConfig(config_path)
def test_vara_install(self, mock_install_exists) -> None: """Test VaRA install inside container.""" mock_install_exists.return_value = True vara_cfg()["container"]["research_tool"] = "vara" vara_cfg()["vara"]["llvm_source_dir"] = "tools_src/vara-llvm-project" vara_cfg()["vara"]["llvm_install_dir"] = "tools/VaRA" vara_cfg()["container"]["from_source"] = False bb_cfg()["container"]["from_source"] = False with TemporaryDirectory() as tmpdir: image_context = BaseImageCreationContext(ImageBase.DEBIAN_10, Path(tmpdir)) _create_base_image_layers(image_context) layers = image_context.layers vara_deps_layer = self.check_layer_type(layers[11], RunLayer) self.assertEqual("apt", vara_deps_layer.command) vara_copy_layer = self.check_layer_type(layers[12], CopyLayer) self.assertEqual("/varats_root/tools/VaRA_DEBIAN_10", vara_copy_layer.destination) self.assertTupleEqual(("tools/VaRA_DEBIAN_10", ), vara_copy_layer.sources) bb_config_layer = self.check_layer_type(layers[15], UpdateEnv) self.assertTupleEqual( ("BB_ENV", "{PATH: [/varats_root/tools/VaRA_DEBIAN_10/bin]}"), bb_config_layer.env[3])
def test_vara_cs_gen_to_extend_new_stage(self): """Test the extend-functionality of vara-cs gen.""" runner = CliRunner() vara_cfg()["paper_config"]["current_config"] = "test_ext" save_config() load_paper_config() old_commit = 'ef364d3abc5647111c5424ea0d83a567e184a23b' new_commit = '6c6da57ae2aa962aabde6892442227063d87e88c' result = runner.invoke( driver_casestudy.main, [ 'gen', '-p', 'xz', '--new-stage', '--merge-stage', 'test', 'select_specific', new_commit ] ) self.assertEqual(0, result.exit_code, result.exception) case_study_path = Path( vara_cfg()["paper_config"]["folder"].value + "/test_ext/xz_0.case_study" ) self.assertTrue(case_study_path.exists()) case_study = load_case_study_from_file(case_study_path) self.assertTrue( case_study.revisions.__contains__(FullCommitHash(old_commit)) ) self.assertTrue( case_study.revisions.__contains__(FullCommitHash(new_commit)) ) self.assertEqual(2, case_study.num_stages) self.assertEqual('test', case_study.stages[1].name)
def test_get_newest_result_files_for_case_study_fail(self) -> None: """Check that when we have two files, the newes one get's selected.""" vara_cfg()['paper_config']['current_config'] = "test_revision_lookup" load_paper_config() bad_file = ReportFilename( 'CRE-CR-brotli-brotli-21ac39f7c8_' '34d4d1b5-7212-4244-9adc-b19bff599cf1_success.yaml') now = datetime.now().timestamp() file_path = Path(str( vara_cfg()['result_dir'])) / 'brotli' / bad_file.filename os.utime(file_path, (now, now)) newest_res_files = MCS.get_newest_result_files_for_case_study( get_paper_config().get_case_studies('brotli')[0], Path(vara_cfg()['result_dir'].value), CR) # remove unnecessary files filtered_newest_res_files = list( filter( lambda res_file: res_file.commit_hash == bad_file.commit_hash, map(lambda res_file: ReportFilename(res_file), newest_res_files))) self.assertFalse(filtered_newest_res_files[0].uuid.endswith('42'))
def test_bb_run_slurm_and_container(self, mock_sbatch, mock_build_images) -> None: runner = CliRunner() vara_cfg()['paper_config']['current_config'] = "test_revision_lookup" # needed so we see the paper config load_paper_config() # needed so benchbuild sees the paper config save_config() bb_cfg()["slurm"]["template"] = str( Path(str(vara_cfg()["benchbuild_root"])) / "slurm_container.sh.inc") save_bb_config() # Easiest way to configure slurm + container is 'vara-container' # As a side-effect, this command is now even more tested :) prepare_result = runner.invoke(driver_container.main, ["prepare-slurm"]) self.assertEqual(0, prepare_result.exit_code, prepare_result.exception) self.assertTrue(Path(str(bb_cfg()["slurm"]["template"])).exists()) result = runner.invoke(driver_run.main, ["--slurm", "--container", "-E", "JustCompile"]) self.assertEqual(0, result.exit_code, result.exception) self.assertTrue((Path(str(vara_cfg()["benchbuild_root"])) / "JustCompile-slurm.sh").exists())
def _pc_create(paper_config: str) -> None: """paper_config: Path to the new paper config. Relative paths are interpreted relative to the current `paper_config/folder`.""" pc_path: Path = Path(paper_config) if not pc_path.is_absolute(): current_folder = vara_cfg()["paper_config"]["folder"].value if current_folder is None: pc_path = Path(vara_cfg()["config_file"].value ).parent / "paper_configs" / pc_path else: pc_path = Path(current_folder) / pc_path if pc_path.exists(): LOG.error(f"Cannot create paper config at: {pc_path} " "(Path already exists).") return folder = pc_path.parent current_config = pc_path.name LOG.info( f"Creating new paper config {current_config} at location {folder}.") pc_path.mkdir(parents=True) vara_cfg()["paper_config"]["folder"] = str(folder) vara_cfg()["paper_config"]["current_config"] = str(current_config) save_config()
def sample(cls, prj_cls: tp.Type[Project]) -> tp.List[source.VariantContext]: """ Adapt version sampling process if needed, otherwise fallback to default implementation. Args: prj_cls: project class Returns: list of sampled versions """ variants = list(source.product(*prj_cls.SOURCE)) if bool(vara_cfg()["experiment"]["random_order"]): random.shuffle(variants) fs_blacklist = vara_cfg()["experiment"]["file_status_blacklist"].value fs_whitelist = vara_cfg()["experiment"]["file_status_whitelist"].value if fs_blacklist or fs_whitelist: fs_good = set(FileStatusExtension) if not fs_whitelist else set() fs_good -= { FileStatusExtension.get_file_status_from_str(x) for x in fs_blacklist } fs_good |= { FileStatusExtension.get_file_status_from_str(x) for x in fs_whitelist } report_specific_bad_revs = [] for report_type in cls.report_spec(): report_specific_bad_revs.append({ revision.hash for revision, file_status in get_tagged_experiment_specific_revisions( prj_cls, report_type, experiment_type=cls ) if file_status not in fs_good }) bad_revisions = report_specific_bad_revs[0].intersection( *report_specific_bad_revs[1:] ) variants = list( filter(lambda var: str(var[0]) not in bad_revisions, variants) ) if not variants: print("Could not find any unprocessed variants.") return [] variants = cls._sample_num_versions(variants) if bool(bb_cfg()["versions"]["full"]): return [source.context(*var) for var in variants] return [source.context(*variants[0])]
def test_vara_config_set(self): runner = CliRunner() vara_cfg()["artefacts"]["artefacts_dir"] = "test" save_config() runner.invoke(driver_config.main, ["set", "artefacts/artefacts_dir=artefacts"]) self.assertEqual("artefacts", vara_cfg()["artefacts"]["artefacts_dir"].value)
def test_gen_bbconfig(self): """basic tests for the `gen-bbconfig` command.""" runner = CliRunner() Path(vara_cfg()["benchbuild_root"].value + "/.benchbuild.yml").unlink() runner.invoke(driver_gen_benchbuild_config.main, []) self.assertTrue( Path(vara_cfg()["benchbuild_root"].value + "/.benchbuild.yml").exists())
def test_vara_pc_create(self): """Test the vara-pc create subcommand.""" runner = CliRunner() runner.invoke(driver_paper_config.main, ["create", "foo"]) paper_config = Path(vara_cfg()["paper_config"]["folder"].value + "/" + "foo") self.assertTrue(paper_config.exists()) self.assertEqual("foo", vara_cfg()["paper_config"]["current_config"].value)
def _pc_set(paper_config: tp.Optional[Path]) -> None: if not paper_config: pc_folder_path = Path( get_value_or_default(vara_cfg()["paper_config"], "folder", str(get_varats_base_folder()))) if not (pc_folder_path.exists() and pc_folder_path.is_dir()): LOG.error(f"Paper config folder not set: {pc_folder_path} " "(Path does not exist or is no directory).") return paper_configs = _get_paper_configs(pc_folder_path) if not paper_configs: LOG.error(f"Could not find paper configs in: {pc_folder_path}") return raw_pc_path = None def set_pc_path(choice: str) -> None: nonlocal raw_pc_path raw_pc_path = choice current_config = None try: current_config = get_paper_config().path.name except ConfigurationLookupError: # No paper config specified in the varats config file pass try: cli_list_choice( "Choose a number to select a paper config", paper_configs, lambda x: f"{x} *" if current_config and x == current_config else x, set_pc_path) except EOFError: return if raw_pc_path is None: raise AssertionError("Choice should always return a value") paper_config = Path(raw_pc_path) paper_config = Path(paper_config) if not paper_config.is_absolute(): paper_config = Path( vara_cfg()["paper_config"]["folder"].value) / paper_config if not (paper_config.exists() and paper_config.is_dir()): LOG.error(f"Not a paper config: {paper_config} " "(Path does not exist or is no directory).") return folder = paper_config.parent current_config = paper_config.name LOG.info( f"Current paper config is now {current_config} at location {folder}.") vara_cfg()["paper_config"]["folder"] = str(folder) vara_cfg()["paper_config"]["current_config"] = str(current_config) save_config()
def test_vara_cs_gen_release(self): """Test gen select_release.""" runner = CliRunner() Path(vara_cfg()["paper_config"]["folder"].value + "/" + "test_gen").mkdir() vara_cfg()["paper_config"]["current_config"] = "test_gen" result = runner.invoke( driver_casestudy.main, ['gen', '-p', 'gravity', 'select_release', 'major'] ) self.assertEqual(0, result.exit_code, result.exception)
def test_get_newest_result_files_for_case_study_with_empty_res_dir( self) -> None: """Check that we correctly handle the edge case where no result dir exists.""" vara_cfg()['paper_config']['current_config'] = "test_revision_lookup" load_paper_config() self.assertListEqual( MCS.get_newest_result_files_for_case_study( get_paper_config().get_case_studies('brotli')[0], Path(vara_cfg()['result_dir'].value), CR), [])
def test_research_tool_accessor_default(self, _): """Checks if the source_location of a ``ResearchTool`` is set to the correct default.""" with test_environment() as tmp_path: vara_cfg()["config_file"] = tmp_path / "dummy.yml" vara_cfg()["vara"]["llvm_source_dir"] = tmp_path / "tools_src" vara = get_research_tool("vara") self.assertTrue(vara.has_source_location()) self.assertEqual( vara.source_location().relative_to(Path(tmp_path)), Path("tools_src"))
def test_sample_limit(self): """Test if base_hash is loaded correctly.""" self.prepare_vara_config(vara_cfg()) self.assertEqual(vara_cfg()["experiment"]["sample_limit"].value, None) self.assertEqual( # pylint: disable=protected-access self.vers_expr._sample_num_versions(self.rev_list), self.rev_list) vara_cfg()["experiment"]["sample_limit"] = 3 self.assertEqual( len(self.vers_expr._sample_num_versions(self.rev_list)), 3)
def test_vara_pc_list(self): """Test the vara-pc list subcommand.""" runner = CliRunner() paper_configs = ["foo", "bar", "baz"] pc_path = Path(vara_cfg()["paper_config"]["folder"].value) for pc in paper_configs: (pc_path / pc).mkdir() vara_cfg()["paper_config"]["current_config"] = "foo" load_paper_config() result = runner.invoke(driver_paper_config.main, ["list"]) self.assertEqual( "Found the following paper_configs:\nbar\nbaz\nfoo *\n", result.output)
def main() -> None: """ Main function for working with paper configs. `vara-pc` """ initialize_cli_tool() if vara_cfg()["paper_config"]["folder"].value is None: # Setup default paper config path when none exists vara_cfg()["paper_config"]["folder"] = str( Path('paper_configs').absolute()) save_config()
def _create_benchbuild_config() -> None: if vara_cfg()["config_file"].value is None: LOG.warning("No VaRA config found, please initialize a " "VaRA config first.") return if vara_cfg()["benchbuild_root"].value is None: vara_cfg()["benchbuild_root"] = path.dirname( str(vara_cfg()["config_file"])) + "/benchbuild" create_missing_folders() bb_cfg = create_new_bb_config(vara_cfg()) save_bb_config(bb_cfg)
def _sample_num_versions( versions: tp.List[VersionType] ) -> tp.List[VersionType]: if vara_cfg()["experiment"]["sample_limit"].value is None: return versions sample_size = int(vara_cfg()["experiment"]["sample_limit"]) versions = [ versions[i] for i in sorted( random. sample(range(len(versions)), min(sample_size, len(versions))) ) ] return versions
def test_only_whitelisting_one(self, mock_get_tagged_revisions): """Test if we can whitelist file status.""" self.prepare_vara_config(vara_cfg()) bb_cfg()["versions"]["full"] = True # Revision not in set mock_get_tagged_revisions.return_value = \ self.generate_get_tagged_revisions_output() vara_cfg()["experiment"]["file_status_whitelist"] = ['success'] sample_gen = self.vers_expr.sample(BBTestProject) self.assertEqual(sample_gen[0]["test_source"].version, "rev1000000") self.assertEqual(len(sample_gen), 1) mock_get_tagged_revisions.assert_called()
def __quickfix_dev_branches(branch_name: str, sub_project: SubProject) -> str: """ Fix vara branches names for checking out master or dev branches. Test: >>> import re >>> fixed_branch_name = __quickfix_dev_branches(\ 'vara-dev', SubProject(None, "vara-llvm-project", "", "", "")) >>> re.match(r'vara-\\d+-dev', fixed_branch_name) is not None True >>> fixed_branch_name = __quickfix_dev_branches(\ 'vara', SubProject(None, "vara-llvm-project", "", "", "")) >>> re.match(r'vara-\\d+', fixed_branch_name) is not None True >>> __quickfix_dev_branches(\ "f-FooBar", SubProject(None, "vara-llvm-project", "", "", "")) 'f-FooBar' >>> __quickfix_dev_branches(\ "vara-dev", SubProject(None, "vara", "", "", "")) 'vara-dev' """ if sub_project.name == "vara-llvm-project": version = str(vara_cfg()['vara']['version']) if branch_name == 'vara-dev': return f"vara-{version}-dev" if branch_name == 'vara': return f"vara-{version}" return branch_name