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 test_increase_interaction_amount(self) -> None:
"""Checks if interactions where the amount increased between reports are
shown."""
diff = BlameReportDiff(self.reports[1], self.reports[0])
changed_func = diff.get_blame_result_function_entry('bool_exec')
# Check if deleted function is correctly added to diff
self.assertEqual(changed_func.name, 'bool_exec')
self.assertEqual(changed_func.demangled_name, 'bool_exec')
self.assertEqual(len(changed_func.interactions), 2)
# Check second interaction, that was increased
self.assertEqual(
changed_func.interactions[1].base_taint.commit.commit_hash,
FullCommitHash('48f8ed5347aeb9d54e7ea041b1f8d67ffe74db33'))
self.assertEqual(len(changed_func.interactions[1].interacting_taints),
2)
self.assertEqual(
changed_func.interactions[1].interacting_taints[0].commit.
commit_hash,
FullCommitHash('a387695a1a2e52dcb1c5b21e73d2fd5a6aadbaf9'))
self.assertEqual(
changed_func.interactions[1].interacting_taints[1].commit.
commit_hash,
FullCommitHash('e8999a84efbd9c3e739bff7af39500d14e61bfbc'))
self.assertEqual(changed_func.interactions[1].amount, 2)
def test_remove_function_between_reports(self) -> None:
"""Checks if the diff containts functions that where removed between
reports."""
diff = BlameReportDiff(self.reports[2], self.reports[0])
del_func = diff.get_blame_result_function_entry('bool_exec')
# Check if deleted function is correctly added to diff
self.assertEqual(del_func.name, 'bool_exec')
self.assertEqual(del_func.demangled_name, 'bool_exec')
self.assertEqual(len(del_func.interactions), 2)
# Check first interaction
self.assertEqual(
del_func.interactions[0].base_taint.commit.commit_hash,
FullCommitHash('48f8ed5347aeb9d54e7ea041b1f8d67ffe74db33'))
self.assertEqual(len(del_func.interactions[0].interacting_taints), 1)
self.assertEqual(
del_func.interactions[0].interacting_taints[0].commit.commit_hash,
FullCommitHash('a387695a1a2e52dcb1c5b21e73d2fd5a6aadbaf9'))
self.assertEqual(del_func.interactions[0].amount, 22)
# Check second interaction
self.assertEqual(
del_func.interactions[1].base_taint.commit.commit_hash,
FullCommitHash('48f8ed5347aeb9d54e7ea041b1f8d67ffe74db33'))
self.assertEqual(len(del_func.interactions[1].interacting_taints), 2)
self.assertEqual(
del_func.interactions[1].interacting_taints[0].commit.commit_hash,
FullCommitHash('a387695a1a2e52dcb1c5b21e73d2fd5a6aadbaf9'))
self.assertEqual(
del_func.interactions[1].interacting_taints[1].commit.commit_hash,
FullCommitHash('e8999a84efbd9c3e739bff7af39500d14e61bfbc'))
self.assertEqual(del_func.interactions[1].amount, 5)
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_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_interacting_commits_for_commit(self) -> None:
"""Test if retrieving of interacting commits works."""
report = self.reports[1] # YAML_DOC_BR_6
commit = CommitRepoPair(
FullCommitHash("e64923e69eab82332c1bed7fe1e80e14c2c5cb7f"),
"Elementalist")
expected_in = {
CommitRepoPair(
FullCommitHash("5e030723d70f4894c21881e32dba4decec815c7e"),
"Elementalist"),
CommitRepoPair(
FullCommitHash("bd693d7bc2e4ae5be93e300506ba1efea149e5b7"),
"Elementalist")
}
expected_out = {
CommitRepoPair(
FullCommitHash("5e030723d70f4894c21881e32dba4decec815c7e"),
"Elementalist"),
CommitRepoPair(
FullCommitHash("97c573ee98a1c2143b6876433697e363c9eca98b"),
"Elementalist")
}
actual_in, actual_out = get_interacting_commits_for_commit(
report, commit)
self.assertSetEqual(expected_in, actual_in)
self.assertSetEqual(expected_out, actual_out)
def as_raw_bug(pygit_bug: PygitBug) -> RawBug:
"""Converts a ``PygitBug`` to a ``RawBug``."""
introducing_commits: tp.Set[FullCommitHash] = set()
for intro_commit in pygit_bug.introducing_commits:
introducing_commits.add(FullCommitHash.from_pygit_commit(intro_commit))
return RawBug(FullCommitHash.from_pygit_commit(pygit_bug.fixing_commit),
introducing_commits, pygit_bug.issue_id,
pygit_bug.creation_date, pygit_bug.resolution_date)
def test_less_repo(self):
"""Tests that a smaller repo is less, if the commits are equal."""
cr_pair_1 = CommitRepoPair(
FullCommitHash("4200000000000000000000000000000000000000"),
"foo_repo")
cr_pair_2 = CommitRepoPair(
FullCommitHash("4200000000000000000000000000000000000000"),
"boo_repo")
self.assertFalse(cr_pair_1 < cr_pair_2)
def test_less_commit(self):
"""Tests that a smaller commit is less."""
cr_pair_1 = CommitRepoPair(
FullCommitHash("4100000000000000000000000000000000000000"),
"foo_repo")
cr_pair_2 = CommitRepoPair(
FullCommitHash("4200000000000000000000000000000000000000"),
"foo_repo")
self.assertTrue(cr_pair_1 < cr_pair_2)
def test_less_equal(self):
"""Tests that two equal pairs are not less."""
cr_pair_1 = CommitRepoPair(
FullCommitHash("4200000000000000000000000000000000000000"),
"foo_repo")
cr_pair_2 = CommitRepoPair(
FullCommitHash("4200000000000000000000000000000000000000"),
"foo_repo")
self.assertFalse(cr_pair_1 < cr_pair_2)
def test_equal_equal(self):
"""Tests that two equal pairs are equal."""
cr_pair_1 = CommitRepoPair(
FullCommitHash("4200000000000000000000000000000000000000"),
"foo_repo")
cr_pair_2 = CommitRepoPair(
FullCommitHash("4200000000000000000000000000000000000000"),
"foo_repo")
self.assertTrue(cr_pair_1 == cr_pair_2)
def test_equal_repo(self):
"""Tests that two different commits are not equal."""
cr_pair_1 = CommitRepoPair(
FullCommitHash("4200000000000000000000000000000000000000"),
"bar_repo")
cr_pair_2 = CommitRepoPair(
FullCommitHash("4200000000000000000000000000000000000000"),
"foo_repo")
self.assertFalse(cr_pair_1 == cr_pair_2)
def test_id_hash_mapping(self) -> None:
"""Test if id -> hash mappings are correct."""
self.assertEqual(
self.r_mappings["8ac1b3f73baceb4a16e99504807d23d38e5123b1"].hash,
FullCommitHash("8ac1b3f73baceb4a16e99504807d23d38e5123b1")
)
self.assertEqual(
self.r_mappings["38f87b03c2763bb2af05ae98905b0ac8ba55b3eb"].hash,
FullCommitHash("38f87b03c2763bb2af05ae98905b0ac8ba55b3eb")
)
def get_release_revisions(
cls, release_type: ReleaseType
) -> tp.List[tp.Tuple[FullCommitHash, str]]:
major_release_regex = "^v[0-9]+\\.[0-9]+$"
minor_release_regex = "^v[0-9]+\\.[0-9]+(\\.[0-9]+)?$"
tagged_commits = get_tagged_commits(cls.NAME)
if release_type == ReleaseType.MAJOR:
return [(FullCommitHash(h), tag) for h, tag in tagged_commits
if re.match(major_release_regex, tag)]
return [(FullCommitHash(h), tag) for h, tag in tagged_commits
if re.match(minor_release_regex, tag)]
def test_get_config_ids_for_rev_in_stage(self) -> None:
"""Checks if the correct config IDs are fetched for the different
revisions."""
self.assertEqual(
self.case_study.get_config_ids_for_revision_in_stage(
FullCommitHash('7620b817357d6f14356afd004ace2da426cf8c36'), 0
), [2]
)
self.assertEqual(
self.case_study.get_config_ids_for_revision_in_stage(
FullCommitHash('7620b817357d6f14356afd004ace2da426cf8c36'), 1
), [-1]
)
def test_get_config_ids_for_rev(self) -> None:
"""Checks if the correct config IDs are fetched for the different
revisions."""
self.assertEqual(
self.case_study.get_config_ids_for_revision(
FullCommitHash('b8b25e7f1593f6dcc20660ff9fb1ed59ede15b7a')
), [0, 1]
)
self.assertEqual(
self.case_study.get_config_ids_for_revision(
FullCommitHash('8798d5c4fd520dcf91f36ebfa60bc5f3dca550d9')
), [-1]
)
def test_gen_interactions_nodes(self) -> None:
"""Test generation of interaction node."""
nodes = generate_interactions(self.commit_report, self.cmap)[0]
self.assertEqual(
nodes.at[0, 'hash'],
FullCommitHash('38f87b03c2763bb2af05ae98905b0ac8ba55b3eb')
)
self.assertEqual(nodes.at[0, 'id'], 12)
self.assertEqual(
nodes.at[3, 'hash'],
FullCommitHash('95ace546d3f6c5909a636017f141784105f9dab2')
)
self.assertEqual(nodes.at[3, 'id'], 9)
def test_get_submodule_head(self):
"""Check if correct submodule commit is retrieved."""
repo_path = get_local_project_git_path("grep")
old_head = get_head_commit(repo_path)
repo_head = FullCommitHash("cb15dfa4b2d7fba0d50e87b49f979c7f996b8ebc")
checkout_branch_or_commit(repo_path, repo_head)
try:
submodule_head = get_submodule_head("grep", "gnulib", repo_head)
self.assertEqual(
submodule_head,
FullCommitHash("f44eb378f7239eadac38d02463019a8a6b935525"))
finally:
checkout_branch_or_commit(repo_path, old_head)
def test_commit_range(self):
"""Check if we get the correct code churn for commit range."""
repo_path = get_local_project_git_path("brotli")
files_changed, insertions, deletions = calc_code_churn(
repo_path,
FullCommitHash("36ac0feaf9654855ee090b1f042363ecfb256f31"),
FullCommitHash("924b2b2b9dc54005edbcd85a1b872330948cdd9e"),
ChurnConfig.create_c_style_languages_config())
self.assertEqual(files_changed, 3)
self.assertEqual(insertions, 49)
self.assertEqual(deletions, 11)
def test_found_interactions(self) -> None:
"""Test if all interactions were found."""
c_interaction_list = self.func_entry_c.interactions
self.assertEqual(len(c_interaction_list), 2)
self.assertEqual(
c_interaction_list[0].base_taint.commit.commit_hash,
FullCommitHash('48f8ed5347aeb9d54e7ea041b1f8d67ffe74db33'))
self.assertEqual(c_interaction_list[0].amount, 22)
self.assertEqual(
c_interaction_list[1].base_taint.commit.commit_hash,
FullCommitHash('48f8ed5347aeb9d54e7ea041b1f8d67ffe74db33'))
self.assertEqual(c_interaction_list[1].amount, 5)
cxx_interaction_list = self.func_entry_cxx.interactions
self.assertEqual(cxx_interaction_list, [])
def test_base_hash(self) -> None:
"""Test if base_hash is loaded correctly."""
self.assertEqual(
self.blame_interaction_1.base_taint.commit.commit_hash,
FullCommitHash('48f8ed5347aeb9d54e7ea041b1f8d67ffe74db33'))
self.assertEqual(
self.blame_interaction_1.base_taint.commit.repository_name,
'Unknown')
self.assertEqual(
self.blame_interaction_2.base_taint.commit.commit_hash,
FullCommitHash('48f8ed5347aeb9d54e7ea041b1f8d67ffe74db33'))
self.assertEqual(
self.blame_interaction_2.base_taint.commit.repository_name,
'Unknown')
def test_gen_filter(self) -> None:
"""Check if the project generates a revision filter."""
revision_filter = self.case_study.get_revision_filter()
self.assertTrue(
revision_filter(
FullCommitHash("b8b25e7f1593f6dcc20660ff9fb1ed59ede15b7a")
)
)
self.assertTrue(revision_filter(ShortCommitHash("b8b25e7f15")))
self.assertFalse(
revision_filter(
FullCommitHash("42b25e7f1593f6dcc20660ff9fb1ed59ede15b7a")
)
)
def test_get_all_revisions_between_full(self):
"""Check if the correct all revisions are correctly found."""
repo_path = get_local_project_git_path("brotli")
revs = get_all_revisions_between(
'5692e422da6af1e991f9182345d58df87866bc5e',
'2f9277ff2f2d0b4113b1ffd9753cc0f6973d354a', FullCommitHash,
repo_path)
self.assertSetEqual(
set(revs), {
FullCommitHash("5692e422da6af1e991f9182345d58df87866bc5e"),
FullCommitHash("2f9277ff2f2d0b4113b1ffd9753cc0f6973d354a"),
FullCommitHash("63be8a99401992075c23e99f7c84de1c653e39e2"),
FullCommitHash("2a51a85aa86abb4c294c65fab57f3d9c69f10080")
})
def test_start_with_initial_commit(self):
"""Check if the initial commit is handled correctly."""
repo_path = get_local_project_git_path("brotli")
churn = calc_code_churn_range(
repo_path, ChurnConfig.create_c_style_languages_config(),
FullCommitHash("8f30907d0f2ef354c2b31bdee340c2b11dda0fb0"),
FullCommitHash("8f30907d0f2ef354c2b31bdee340c2b11dda0fb0"))
files_changed, insertions, deletions = churn[FullCommitHash(
"8f30907d0f2ef354c2b31bdee340c2b11dda0fb0")]
self.assertEqual(files_changed, 11)
self.assertEqual(insertions, 1730)
self.assertEqual(deletions, 0)
def generate_interactions(
commit_report: CommitReport,
c_map: CommitMap) -> tp.Tuple[pd.DataFrame, pd.DataFrame]:
"""
Converts the commit analysis interaction data from a ``CommitReport`` into a
pandas data frame for plotting.
Args:
commit_report: the report
c_map: commit map for mapping commits to unique IDs
"""
node_rows = []
for item in commit_report.region_mappings.values():
node_rows.append([item.hash, c_map.time_id(item.hash)])
node_rows.sort(key=lambda row: int(tp.cast(int, row[1])), reverse=True)
nodes = pd.DataFrame(node_rows, columns=['hash', 'id'])
link_rows = []
for func_g_edge in commit_report.graph_info.values():
for cf_edge in func_g_edge.cf_edges:
link_rows.append([
cf_edge.edge_from, cf_edge.edge_to, 1,
c_map.time_id(FullCommitHash(cf_edge.edge_from))
])
links = pd.DataFrame(link_rows,
columns=['source', 'target', 'value', 'src_id'])
return (nodes, links)
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_get_initial_commit_with_specified_path(self) -> None:
"""Check if we can correctly retrieve the inital commit of a repo."""
inital_commit = get_initial_commit(
get_local_project_git_path("FeaturePerfCSCollection"))
self.assertEqual(
FullCommitHash("4d84c8f80ec2db3aaa880d323f7666752c4be51d"),
inital_commit)
def create_taint_data(
raw_taint_data: tp.Dict[str, tp.Any]) -> 'BlameTaintData':
"""Create a :class:`BlameTaintData` instance from from the corresponding
yaml document section."""
commit = CommitRepoPair(FullCommitHash(raw_taint_data["commit"]),
raw_taint_data["repository"])
return BlameTaintData(commit, raw_taint_data.get("region"),
raw_taint_data.get("function"))
def test_get_config_ids_for_multiple_revs(self) -> None:
"""Checks if the correct config IDs are fetched for the different
revisions if a revisions is part of more than one stage."""
self.assertEqual(
self.case_study.get_config_ids_for_revision(
FullCommitHash('7620b817357d6f14356afd004ace2da426cf8c36')
), [2]
)
def test_time_id(self) -> None:
"""Test time id look up."""
self.assertEqual(
self.cmap.time_id(
FullCommitHash("ae332f2a5d2f6f3e0a23443f8a9bcb068c8af74d")
), 1
)
self.assertEqual(
self.cmap.time_id(
FullCommitHash("ef58a957a6c1887930cc70d6199ae7e48aa8d716")
), 0
)
self.assertEqual(
self.cmap.time_id(
FullCommitHash("20540be6186c159880dda3a49a5827722c1a0ac9")
), 32
)
