def __get_files_in_report(self):
run_filter = RunFilter()
run_filter.names = ['db_cleanup_test']
run_filter.exactMatch = True
codechecker.check(self.codechecker_cfg, 'db_cleanup_test',
self.test_dir)
runs = self._cc_client.getRunData(run_filter)
run_id = runs[0].runId
reports \
= self._cc_client.getRunResults([run_id], 10, 0, [], None, None)
details = self._cc_client.getReportDetails(reports[0].reportId)
files = set()
files.update(map(lambda bp: bp.fileId, details.pathEvents))
files.update(map(lambda bp: bp.fileId, details.executionPath))
file_ids = set()
for file_id in files:
file_data = self._cc_client.getSourceFileData(file_id, False, None)
if file_data.fileId is not None:
file_ids.add(file_data.fileId)
return file_ids
def __get_files_in_report(self):
run_filter = RunFilter()
run_filter.names = ['db_cleanup_test']
run_filter.exactMatch = True
codechecker.check(self.codechecker_cfg,
'db_cleanup_test',
self.test_dir)
runs = self._cc_client.getRunData(run_filter)
run_id = runs[0].runId
reports \
= self._cc_client.getRunResults([run_id], 10, 0, [], None, None)
details = self._cc_client.getReportDetails(reports[0].reportId)
files = set()
files.update(map(lambda bp: bp.fileId, details.pathEvents))
files.update(map(lambda bp: bp.fileId, details.executionPath))
file_ids = set()
for file_id in files:
file_data = self._cc_client.getSourceFileData(file_id, False, None)
if file_data.fileId is not None:
file_ids.add(file_data.fileId)
return file_ids
def _create_source_file(self, version):
with open(os.path.join(self._test_dir, self._source_file), 'w') as f:
f.write(self.sources[version])
codechecker.check(self._codechecker_cfg,
'hello',
self._test_dir)
def test_store(self):
"""
Store should fail if the source files were modified since the
last analysis.
"""
test_proj = os.path.join(self.test_workspace, 'test_proj')
ret = codechecker.check(self._codechecker_cfg,
'test_proj',
test_proj)
self.assertEqual(ret, 0)
ret = codechecker.store(self._codechecker_cfg, 'test_proj')
self.assertEqual(ret, 0)
test_proj_path = self._testproject_data['project_path']
test_proj_files = os.listdir(test_proj_path)
print(test_proj_files)
null_deref_file = os.path.join(test_proj_path, 'null_dereference.cpp')
touch(null_deref_file)
ret = codechecker.store(self._codechecker_cfg, 'test_proj')
self.assertEqual(ret, 1)
def test_store(self):
"""
Store should fail if the source files were modified since the
last analysis.
"""
test_proj = os.path.join(self.test_workspace, 'test_proj')
ret = codechecker.check(self._codechecker_cfg, 'test_proj', test_proj)
self.assertEqual(ret, 0)
ret = codechecker.store(self._codechecker_cfg, 'test_proj')
self.assertEqual(ret, 0)
test_proj_path = self._testproject_data['project_path']
test_proj_files = os.listdir(test_proj_path)
print(test_proj_files)
null_deref_file = os.path.join(test_proj_path, 'null_dereference.cpp')
touch(null_deref_file)
ret = codechecker.store(self._codechecker_cfg, 'test_proj')
self.assertEqual(ret, 1)
def test_remove_run_results(self):
"""
Test for removing run results and run.
"""
# Run the anaysis again with different setup.
test_project_path = self._testproject_data['project_path']
ret = project.clean(test_project_path)
if ret:
sys.exit(ret)
codechecker.check(self._codechecker_cfg,
'remove_run_results',
test_project_path)
run_filter = RunFilter(names=['remove_run_results'], exactMatch=True)
runs = self._cc_client.getRunData(run_filter)
self.assertEqual(len(runs), 1)
run_id = runs[0].runId
orig_results_count = \
self._cc_client.getRunResultCount([run_id], None, None)
self.assertNotEqual(orig_results_count, 0)
checker_filter = ReportFilter(checkerName=["core.CallAndMessage"])
res_count = self._cc_client.getRunResultCount([run_id],
checker_filter,
None)
self.assertNotEqual(res_count, 0)
self._cc_client.removeRunReports([run_id],
checker_filter,
None)
res_count = self._cc_client.getRunResultCount([run_id],
checker_filter,
None)
self.assertEqual(res_count, 0)
# Remove the run.
self._cc_client.removeRun(run_id)
# Check that we removed all results from the run.
res = self._cc_client.getRunResultCount([run_id], None, None)
self.assertEqual(res, 0)
def setup_package():
"""Setup the environment for testing review_status."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('review_status')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'single_bug'
test_config = {}
project_info = project.get_info(test_project)
test_config['test_project'] = project_info
skip_list_file = None
test_env = env.test_env(TEST_WORKSPACE)
codechecker_cfg = {
'suppress_file': None,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'checkers': []
}
ret = project.clean(test_project, test_env)
if ret:
sys.exit(ret)
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'review_status'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg,
test_project_name,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for testing review_status."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('review_status')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'single_bug'
test_config = {}
project_info = project.get_info(test_project)
test_config['test_project'] = project_info
skip_list_file = None
test_env = env.test_env(TEST_WORKSPACE)
codechecker_cfg = {
'suppress_file': None,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'checkers': []
}
ret = project.clean(test_project, test_env)
if ret:
sys.exit(ret)
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'review_status'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
def test_suppress_comment_in_db(self):
"""
Exported source suppress comment stored as a review status in the db.
"""
runid = self._runid
logging.debug('Get all run results from the db for runid: ' +
str(runid))
run_results = get_all_run_results(self._cc_client, runid)
self.assertIsNotNone(run_results)
self.assertNotEqual(len(run_results), 0)
bug = run_results[0]
report = self._cc_client.getReport(bug.reportId)
# Check the stored suppress comment
status = ReviewStatus.FALSE_POSITIVE
self.assertEqual(report.reviewData.comment, 'deliberate segfault!')
self.assertEqual(report.reviewData.status, status)
# Change review status to confirmed bug.
review_comment = 'This is really a bug'
status = ReviewStatus.CONFIRMED
success = self._cc_client.changeReviewStatus(bug.reportId, status,
review_comment)
self.assertTrue(success)
logging.debug('Bug review status changed successfully')
# Check the same project again.
codechecker_cfg = env.import_test_cfg(
self._test_workspace)['codechecker_cfg']
initial_test_project_name = self._run_name
ret = codechecker.check(codechecker_cfg, initial_test_project_name,
self._test_project_path)
if ret:
sys.exit(1)
# Get the results to compare.
updated_results = get_all_run_results(self._cc_client, self._runid)
self.assertIsNotNone(updated_results)
self.assertNotEqual(len(updated_results), 0)
bug = updated_results[0]
report = self._cc_client.getReport(bug.reportId)
# The stored suppress comment for the same bughash is the same.
status = ReviewStatus.FALSE_POSITIVE
self.assertEqual(report.reviewData.comment, 'deliberate segfault!')
self.assertEqual(report.reviewData.status, status)
def test_disable_checker(self):
"""
The test depends on a run which was configured for update mode.
Compared to the original test analysis in this run
the deadcode.Deadstores checker was disabled.
"""
run_results = get_all_run_results(self._cc_client, self._runid)
print_run_results(run_results)
# Run the anaysis again with different setup.
test_project_path = self._testproject_data['project_path']
ret = project.clean(test_project_path)
if ret:
sys.exit(ret)
initial_codechecker_cfg = env.import_test_cfg(
self._test_workspace)['codechecker_cfg']
# Disable some checkers for the analysis.
deadcode = 'deadcode.DeadStores'
initial_codechecker_cfg['checkers'] = ['-d', deadcode]
initial_test_project_name = self._run_name
ret = codechecker.check(initial_codechecker_cfg,
initial_test_project_name,
test_project_path)
if ret:
sys.exit(1)
# Get the results to compare.
updated_results = get_all_run_results(self._cc_client, self._runid)
all_bugs = self._testproject_data[self._clang_to_test]['bugs']
deadcode_bugs = \
[bug['hash'] for bug in all_bugs if bug['checker'] == deadcode]
self.assertEquals(len(updated_results), len(all_bugs))
self.assertTrue(all(map(
lambda b: b.detectionStatus == 'unresolved',
filter(lambda x: x in deadcode_bugs, updated_results))))
def test_disable_checker(self):
"""
The test depends on a run which was configured for update mode.
Compared to the original test analysis in this run
the deadcode.Deadstores checker was disabled.
"""
run_results = get_all_run_results(self._cc_client, self._runid)
print_run_results(run_results)
# Run the anaysis again with different setup.
test_project_path = self._testproject_data['project_path']
ret = project.clean(test_project_path)
if ret:
sys.exit(ret)
initial_codechecker_cfg = env.import_test_cfg(
self._test_workspace)['codechecker_cfg']
# Disable some checkers for the analysis.
deadcode = 'deadcode.DeadStores'
initial_codechecker_cfg['checkers'] = ['-d', deadcode]
initial_test_project_name = self._run_name
ret = codechecker.check(initial_codechecker_cfg,
initial_test_project_name,
test_project_path)
if ret:
sys.exit(1)
# Get the results to compare.
updated_results = get_all_run_results(self._cc_client, self._runid)
all_bugs = self._testproject_data[self._clang_to_test]['bugs']
deadcode_bugs = \
[bug['hash'] for bug in all_bugs if bug['checker'] == deadcode]
self.assertEquals(len(updated_results), len(all_bugs))
self.assertTrue(all(map(
lambda b: b.detectionStatus == 'unresolved',
filter(lambda x: x in deadcode_bugs, updated_results))))
def _check_source_file(self, cfg):
codechecker.check(cfg, 'hello', self._test_dir)
def _create_source_file(self, version, run_name):
with open(os.path.join(self._test_dir, self._source_file), 'w') as f:
f.write(self.sources[version])
self._codechecker_cfg['tag'] = self.tags[version]
codechecker.check(self._codechecker_cfg, run_name, self._test_dir)
def setup_package():
"""
Setup the environment for the tests.
Check the test project twice.
"""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('diff')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
test_project_path = project.path(test_project)
test_project_path_altered = os.path.join(TEST_WORKSPACE, "cpp_copy")
# We create a copy of the test project which we will change
# to simulate code editing.
dir_util.copy_tree(test_project_path, test_project_path_altered)
test_config = {}
project_info = project.get_info(test_project)
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
test_env = env.test_env(TEST_WORKSPACE)
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'force': True,
'workspace': TEST_WORKSPACE,
'reportdir': os.path.join(TEST_WORKSPACE, 'reports'),
'checkers': ['-d', 'core.CallAndMessage',
'-e', 'core.StackAddressEscape']
}
test_config['codechecker_cfg'] = codechecker_cfg
ret = project.clean(test_project, test_env)
if ret:
sys.exit(ret)
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'diff'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
test_project_name_base = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg,
test_project_name_base,
test_project_path)
if ret:
sys.exit(1)
print("First analysis of the test project was successful.")
dir_util.copy_tree(codechecker_cfg['reportdir'],
os.path.join(TEST_WORKSPACE, 'reports_baseline'))
ret = project.clean(test_project, test_env)
if ret:
sys.exit(ret)
test_project_name_new = project_info['name'] + '_' + uuid.uuid4().hex
# Let's run the second analysis with different
# checkers to have some real difference.
codechecker_cfg['checkers'] = ['-e', 'core.CallAndMessage',
'-d', 'core.StackAddressEscape'
]
ret = codechecker.check(codechecker_cfg,
test_project_name_new,
test_project_path_altered)
if ret:
sys.exit(1)
print("Second analysis of the test project was successful.")
# Insert a real suppression into the code
altered_file = os.path.join(test_project_path_altered,
"call_and_message.cpp")
insert_suppression(altered_file)
test_project_name_update = project_info['name'] + '_' + uuid.uuid4().hex
codechecker_cfg['tag'] = 't1'
codechecker_cfg['checkers'] = ['-d', 'core.CallAndMessage',
'-e', 'core.StackAddressEscape'
]
codechecker_cfg['reportdir'] = os.path.join(TEST_WORKSPACE, 'reports2')
ret = codechecker.check(codechecker_cfg,
test_project_name_update,
test_project_path)
if ret:
sys.exit(1)
print("Third analysis of the test project was successful.")
codechecker_cfg['tag'] = 't2'
codechecker_cfg['checkers'] = ['-e', 'core.CallAndMessage',
'-d', 'core.StackAddressEscape'
]
ret = codechecker.check(codechecker_cfg,
test_project_name_update,
test_project_path)
if ret:
sys.exit(1)
print("Fourth analysis of the test project was successful.")
codechecker_cfg['tag'] = 't3'
ret = codechecker.check(codechecker_cfg,
test_project_name_update,
test_project_path)
if ret:
sys.exit(1)
print("Fifth analysis of the test project was successful.")
# Order of the test run names matter at comparison!
codechecker_cfg['run_names'] = [test_project_name_base,
test_project_name_new,
test_project_name_update]
test_config['codechecker_cfg'] = codechecker_cfg
# Export test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
def _check_source_file(self, cfg):
codechecker.check(cfg, 'hello', self._test_dir)
def setup_package():
"""Setup the environment for the tests. """
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('comment')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
test_project_path = project.path(test_project)
test_config = {}
project_info = project.get_info(test_project)
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
test_env = env.test_env(TEST_WORKSPACE)
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'reportdir': os.path.join(TEST_WORKSPACE, 'reports'),
'checkers': ['-d', 'core.CallAndMessage',
'-e', 'core.StackAddressEscape']
}
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'comment'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
# Check the test project for the first time.
test_project_names = []
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
test_project_names.append(test_project_name)
ret = codechecker.check(codechecker_cfg,
test_project_name,
test_project_path)
if ret:
sys.exit(1)
print("Analyzing test project was successful.")
# Check the test project again.
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
test_project_names.append(test_project_name)
ret = codechecker.check(codechecker_cfg,
test_project_name,
test_project_path)
if ret:
sys.exit(1)
print("Analyzing test project was succcessful.")
codechecker_cfg['run_names'] = test_project_names
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
def test_suppress_comment_in_db(self):
"""
Exported source suppress comment stored as a review status in the db.
"""
runid = self._runid
logging.debug("Get all run results from the db for runid: " +
str(runid))
hash_to_suppress_msgs = {}
with open(os.path.join(self._test_project_path, "suppress.expected"),
'r') as expected:
for line in expected:
src_code_info = line.strip().split('||')
status = None
if len(src_code_info) == 4:
# Newest source code comment format where status is given.
bug_hash, _, msg, status = src_code_info
elif len(src_code_info) == 3:
# Old format where review status is not given.
bug_hash, _, msg = src_code_info
else:
# Oldest source code comment format where status and file
# name are not given.
bug_hash, msg = src_code_info
rw_status = ReviewStatus.FALSE_POSITIVE
if status == 'confirmed':
rw_status = ReviewStatus.CONFIRMED
elif status == 'intentional':
rw_status = ReviewStatus.INTENTIONAL
hash_to_suppress_msgs[bug_hash] = {
'message': msg,
'status': rw_status
}
run_results = get_all_run_results(self._cc_client, runid)
self.assertIsNotNone(run_results)
self.assertNotEqual(len(run_results), 0)
for bug_hash in hash_to_suppress_msgs:
expected = hash_to_suppress_msgs[bug_hash]
report = [x for x in run_results if x.bugHash == bug_hash][0]
# Check the stored suppress comment
self.assertEqual(report.reviewData.comment, expected['message'])
self.assertEqual(report.reviewData.status, expected['status'])
# Change review status to confirmed bug.
review_comment = "This is really a bug"
status = ReviewStatus.CONFIRMED
success = self._cc_client.changeReviewStatus(
report.reportId, status, review_comment)
self.assertTrue(success)
logging.debug("Bug review status changed successfully")
# Check the same project again.
codechecker_cfg = env.import_test_cfg(
self._test_workspace)['codechecker_cfg']
initial_test_project_name = self._run_name
ret = codechecker.check(codechecker_cfg, initial_test_project_name,
self._test_project_path)
if ret:
sys.exit(1)
# Get the results to compare.
updated_results = get_all_run_results(self._cc_client, self._runid)
self.assertIsNotNone(updated_results)
self.assertNotEqual(len(updated_results), 0)
for bug_hash in hash_to_suppress_msgs:
report = [x for x in updated_results if x.bugHash == bug_hash][0]
# Check the stored suppress comment
self.assertEqual(report.reviewData.comment, "This is really a bug")
self.assertEqual(report.reviewData.status, ReviewStatus.CONFIRMED)
def setup_package():
"""Setup the environment for testing products."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('producttest')
# Set the TEST_WORKSPACE used by the tests.
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_config = {}
test_project = 'single_bug'
project_info = project.get_info(test_project)
# Copy the test project to the workspace. The tests should
# work only on this test project.
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_proj_path)
project_info['project_path'] = test_proj_path
# Generate a unique name for this test run.
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
test_config['test_project'] = project_info
# Get an environment which should be used by the tests.
test_env = env.test_env(TEST_WORKSPACE)
# Create a basic CodeChecker config for the tests, this should
# be imported by the tests and they should only depend on these
# configuration options.
codechecker_cfg = {
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'checkers': []
}
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'producttest'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
# Clean the test project, if needed by the tests.
ret = project.clean(test_project)
if ret:
sys.exit(ret)
# Check the test project, if needed by the tests.
ret = codechecker.check(codechecker_cfg,
test_project_name,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
# Save the run names in the configuration.
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
# Export the test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for testing components."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('component')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
test_config = {}
project_info = project.get_info(test_project)
test_project_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_project_path)
project_info['project_path'] = test_project_path
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
test_env = env.test_env(TEST_WORKSPACE)
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'checkers': []
}
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'component'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
# Clean the test project, if needed by the tests.
ret = project.clean(test_project)
if ret:
sys.exit(ret)
ret = codechecker.check(codechecker_cfg, test_project_name,
test_project_path)
if ret:
sys.exit(1)
print("Analyzing test project was succcessful.")
# Save the run names in the configuration.
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
# Export the test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for testing components."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('component')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
test_config = {}
project_info = project.get_info(test_project)
test_project_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_project_path)
project_info['project_path'] = test_project_path
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
test_env = env.test_env(TEST_WORKSPACE)
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'checkers': []
}
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'component'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
# Clean the test project, if needed by the tests.
ret = project.clean(test_project)
if ret:
sys.exit(ret)
ret = codechecker.check(codechecker_cfg,
test_project_name,
test_project_path)
if ret:
sys.exit(1)
print("Analyzing test project was succcessful.")
# Save the run names in the configuration.
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
# Export the test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for testing $TEST_NAME$."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('$TEST_NAME$')
# Set the TEST_WORKSPACE used by the tests.
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
# Get the clang version which is used for testing.
# Important because different clang releases might
# find different errors.
clang_version = env.clang_to_test()
# PostgreSQL configuration might be empty if tests are run
# with SQLite.
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(project.path())
# Copy the test project to the workspace. The tests should
# work only on this test project.
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(), test_proj_path)
project_info['project_path'] = test_proj_path
# Generate a unique name for this test run.
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
test_config['test_project'] = project_info
# Suppress file should be set here if needed by the tests.
suppress_file = None
# Skip list file should be set here if needed by the tests.
skip_list_file = None
# Get an environment which should be used by the tests.
test_env = env.test_env()
# Create a basic CodeChecker config for the tests, this should
# be imported by the tests and they should only depend on these
# configuration options.
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
# Get new unique port numbers for this test run.
host_port_cfg = env.get_host_port_cfg()
# Extend the checker configuration with the port numbers.
codechecker_cfg.update(host_port_cfg)
# Clean the test project, if needed by the tests.
ret = project.clean(project.path())
if ret:
sys.exit(ret)
# Check the test project, if needed by the tests.
ret = codechecker.check(codechecker_cfg,
test_project_name,
project.path())
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
if pg_db_config:
print("Waiting for PostgreSQL to stop.")
codechecker.wait_for_postgres_shutdown(TEST_WORKSPACE)
# Save the run names in the configuration.
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
# Export the test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
# Start the CodeChecker server.
print("Starting server to get results")
_start_server(codechecker_cfg, test_config, False)
def setup_package():
"""Setup the environment for the tests."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('cmdline')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
test_config = {}
project_info = project.get_info(test_project)
# Copy the test project to the workspace. The tests should
# work only on this test project.
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_proj_path)
project_info['project_path'] = test_proj_path
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
test_env = env.test_env(TEST_WORKSPACE)
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'checkers': []
}
ret = project.clean(test_project)
if ret:
sys.exit(ret)
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'cmdline'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
# Generate a unique name for this test run.
test_project_name_1 = project_info['name'] + '1_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg,
test_project_name_1,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
test_project_name_2 = project_info['name'] + '2_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg,
test_project_name_2,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
codechecker_cfg['run_names'] = [test_project_name_1, test_project_name_2]
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for testing $TEST_NAME$."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('$TEST_NAME$')
# Set the TEST_WORKSPACE used by the tests.
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
# Get the clang version which is used for testing.
# Important because different clang releases might
# find different errors.
clang_version = env.clang_to_test()
test_config = {}
test_project = 'cpp'
project_info = project.get_info(test_project)
# Copy the test project to the workspace. The tests should
# work only on this test project.
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_proj_path)
project_info['project_path'] = test_proj_path
# Generate a unique name for this test run.
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
test_config['test_project'] = project_info
# Suppress file should be set here if needed by the tests.
suppress_file = None
# Skip list file should be set here if needed by the tests.
skip_list_file = None
# Get an environment which should be used by the tests.
test_env = env.test_env(TEST_WORKSPACE)
# Create a basic CodeChecker config for the tests, this should
# be imported by the tests and they should only depend on these
# configuration options.
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'checkers': []
}
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = '$TEST_NAME$'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
# Clean the test project, if needed by the tests.
ret = project.clean(test_project)
if ret:
sys.exit(ret)
# Check the test project, if needed by the tests.
ret = codechecker.check(codechecker_cfg, test_project_name,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
# Save the run names in the configuration.
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
# Export the test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for testing delete_runs."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('delete_runs')
# Set the TEST_WORKSPACE used by the tests.
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_config = {}
test_project = 'simple'
project_info = project.get_info(test_project)
# Copy the test project to the workspace. The tests should
# work only on this test project.
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_proj_path)
project_info['project_path'] = test_proj_path
# Generate a unique name for this test run.
test_project_name = project_info['name']
test_config['test_project'] = project_info
# Suppress file should be set here if needed by the tests.
suppress_file = None
# Skip list file should be set here if needed by the tests.
skip_list_file = None
# Get an environment which should be used by the tests.
test_env = env.test_env(TEST_WORKSPACE)
# Create a basic CodeChecker config for the tests, this should
# be imported by the tests and they should only depend on these
# configuration options.
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'checkers': []
}
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'delete_runs'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
for i in range(0, 5):
# Clean the test project, if needed by the tests.
ret = project.clean(test_project)
if ret:
sys.exit(ret)
# Check the test project, if needed by the tests.
ret = codechecker.check(codechecker_cfg,
test_project_name + '_' + str(i),
test_proj_path)
if ret:
sys.exit(1)
print("Analyzing the test project was successful {}.".format(str(i)))
# If the check process is very fast, datetime of multiple runs can be
# almost the same different in microseconds. Test cases of delete runs
# can be failed for this reason because we didn't process microseconds
# in command line arguments.
time.sleep(1)
# Save the run names in the configuration.
codechecker_cfg['run_names'] \
= [test_project_name + '_' + str(i) for i in range(0, 5)]
test_config['codechecker_cfg'] = codechecker_cfg
# Export the test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""
Setup the environment for the tests.
Check the test project twice, then start the server.
"""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('diff')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project_path = project.path()
clang_version = env.clang_to_test()
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(project.path())
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
# Setup environment variabled for test cases.
host_port_cfg = env.get_host_port_cfg()
test_env = env.test_env()
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
codechecker_cfg.update(host_port_cfg)
test_config['codechecker_cfg'] = codechecker_cfg
ret = project.clean(test_project_path, test_env)
if ret:
sys.exit(ret)
test_project_name_base = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name_base,
test_project_path)
if ret:
sys.exit(1)
print("First analysis of the test project was successful.")
if pg_db_config:
print("Waiting for PotgreSQL to stop.")
codechecker.wait_for_postgres_shutdown(TEST_WORKSPACE)
ret = project.clean(test_project_path, test_env)
if ret:
sys.exit(ret)
test_project_name_new = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name_new,
test_project_path)
if ret:
sys.exit(1)
print("Second analysis of the test project was successful.")
if pg_db_config:
print("Waiting for PotgreSQL to stop.")
codechecker.wait_for_postgres_shutdown(TEST_WORKSPACE)
# Order of the test run names matter at comparison!
codechecker_cfg['run_names'] = [
test_project_name_base, test_project_name_new
]
test_config['codechecker_cfg'] = codechecker_cfg
# Export test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
# Start the CodeChecker server.
print("Starting server to get results")
_start_server(codechecker_cfg, test_config, False)
def setup_package():
"""Setup the environment for the tests. """
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('update')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project_path = project.path()
clang_version = env.clang_to_test()
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(project.path())
test_project_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(), test_project_path)
project_info['project_path'] = test_project_path
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
# Get port numbers for the tests.
host_port_cfg = env.get_host_port_cfg()
test_env = env.test_env()
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
codechecker_cfg.update(host_port_cfg)
ret = project.clean(test_project_path, test_env)
if ret:
sys.exit(ret)
ret = codechecker.check(codechecker_cfg, test_project_name,
test_project_path)
if ret:
sys.exit(1)
print("Analyzing test project was succcessful.")
if pg_db_config:
print("Waiting for PotgreSQL to stop.")
codechecker.wait_for_postgres_shutdown(TEST_WORKSPACE)
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
# Start the CodeChecker server.
print("Starting server to get results")
_start_server(codechecker_cfg, test_config, False)
def test_suppress_comment_in_db(self):
"""
Exported source suppress comment stored as a review status in the db.
"""
runid = self._runid
logging.debug("Get all run results from the db for runid: " +
str(runid))
hash_to_suppress_msgs = {}
with open(os.path.join(self._test_project_path,
"suppress.expected"), 'r') as expected:
for line in expected:
src_code_info = line.strip().split('||')
status = None
if len(src_code_info) == 4:
# Newest source code comment format where status is given.
bug_hash, _, msg, status = src_code_info
elif len(src_code_info) == 3:
# Old format where review status is not given.
bug_hash, _, msg = src_code_info
else:
# Oldest source code comment format where status and file
# name are not given.
bug_hash, msg = src_code_info
rw_status = ReviewStatus.FALSE_POSITIVE
if status == 'confirmed':
rw_status = ReviewStatus.CONFIRMED
elif status == 'intentional':
rw_status = ReviewStatus.INTENTIONAL
hash_to_suppress_msgs[bug_hash] = {'message': msg,
'status': rw_status}
run_results = get_all_run_results(self._cc_client, runid)
self.assertIsNotNone(run_results)
self.assertNotEqual(len(run_results), 0)
for bug_hash in hash_to_suppress_msgs:
expected = hash_to_suppress_msgs[bug_hash]
report = [x for x in run_results if x.bugHash == bug_hash][0]
# Check the stored suppress comment
self.assertEqual(report.reviewData.comment, expected['message'])
self.assertEqual(report.reviewData.status, expected['status'])
# Change review status to confirmed bug.
review_comment = "This is really a bug"
status = ReviewStatus.CONFIRMED
success = self._cc_client.changeReviewStatus(
report.reportId, status, review_comment)
self.assertTrue(success)
logging.debug("Bug review status changed successfully")
# Get the results to compare.
updated_results = get_all_run_results(self._cc_client, self._runid)
self.assertIsNotNone(updated_results)
self.assertNotEqual(len(updated_results), 0)
for bug_hash in hash_to_suppress_msgs:
report = [x for x in updated_results if x.bugHash == bug_hash][0]
# Check the stored suppress comment
self.assertEqual(report.reviewData.comment, "This is really a bug")
self.assertEqual(report.reviewData.status, ReviewStatus.CONFIRMED)
# Check the same project again.
codechecker_cfg = env.import_test_cfg(
self._test_workspace)['codechecker_cfg']
initial_test_project_name = self._run_name
ret = codechecker.check(codechecker_cfg,
initial_test_project_name,
self._test_project_path)
if ret:
sys.exit(1)
# Get the results to compare.
updated_results = get_all_run_results(self._cc_client, self._runid)
self.assertIsNotNone(updated_results)
self.assertNotEqual(len(updated_results), 0)
for bug_hash in hash_to_suppress_msgs:
expected = hash_to_suppress_msgs[bug_hash]
report = [x for x in updated_results if x.bugHash == bug_hash][0]
# Check that source code comments in the database are changed back
# after storage.
self.assertEqual(report.reviewData.comment, expected['message'])
self.assertEqual(report.reviewData.status, expected['status'])
def setup_package():
"""Setup the environment for the tests."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('report_viewer_api')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
test_config = {}
project_info = project.get_info(test_project)
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_proj_path)
project_info['project_path'] = test_proj_path
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
tag = 'v1.0'
test_env = env.test_env(TEST_WORKSPACE)
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'checkers': [],
'tag': tag
}
ret = project.clean(test_project)
if ret:
sys.exit(ret)
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'report_viewer_api'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex + '**'
ret = codechecker.check(codechecker_cfg, test_project_name,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
test_project_name_new = project_info['name'] + '*' + uuid.uuid4().hex + '%'
# Let's run the second analysis with different
# checkers to have some real difference.
codechecker_cfg['checkers'] = [
'-e', 'core.CallAndMessage', '-d', 'core.StackAddressEscape', '-d',
'unix.Malloc'
]
codechecker_cfg['tag'] = None
ret = codechecker.check(codechecker_cfg, test_project_name_new,
project.path(test_project))
if ret:
sys.exit(1)
print("Second analysis of the test project was successful.")
codechecker_cfg['run_names'] = [test_project_name, test_project_name_new]
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
def _create_source_file(self, version, run_name):
with open(os.path.join(self._test_dir, self._source_file), 'w') as f:
f.write(self.sources[version])
self._codechecker_cfg['tag'] = self.tags[version]
codechecker.check(self._codechecker_cfg, run_name, self._test_dir)
def setup_package():
"""
Setup the environment for the tests.
Check the test project twice.
"""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('diff')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
test_project_path = project.path(test_project)
test_project_path_altered = os.path.join(TEST_WORKSPACE, "cpp_copy")
# We create a copy of the test project which we will change
# to simulate code editing.
dir_util.copy_tree(test_project_path, test_project_path_altered)
test_config = {}
project_info = project.get_info(test_project)
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
test_env = env.test_env(TEST_WORKSPACE)
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'force': True,
'workspace': TEST_WORKSPACE,
'reportdir': os.path.join(TEST_WORKSPACE, 'reports'),
'checkers':
['-d', 'core.CallAndMessage', '-e', 'core.StackAddressEscape']
}
test_config['codechecker_cfg'] = codechecker_cfg
ret = project.clean(test_project, test_env)
if ret:
sys.exit(ret)
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'diff'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
test_project_name_base = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name_base,
test_project_path)
if ret:
sys.exit(1)
print("First analysis of the test project was successful.")
ret = project.clean(test_project, test_env)
if ret:
sys.exit(ret)
test_project_name_new = project_info['name'] + '_' + uuid.uuid4().hex
# Let's run the second analysis with different
# checkers to have some real difference.
codechecker_cfg['checkers'] = [
'-e', 'core.CallAndMessage', '-d', 'core.StackAddressEscape'
]
ret = codechecker.check(codechecker_cfg, test_project_name_new,
test_project_path_altered)
if ret:
sys.exit(1)
print("Second analysis of the test project was successful.")
# Insert a real suppression into the code
altered_file = os.path.join(test_project_path_altered,
"call_and_message.cpp")
insert_suppression(altered_file)
# Run the second analysis results
# into a report directory
ret = codechecker.analyze(codechecker_cfg, test_project_name_new,
test_project_path_altered)
if ret:
sys.exit(1)
print("CodeChecker analyze of test project was successful.")
test_project_name_update = project_info['name'] + '_' + uuid.uuid4().hex
codechecker_cfg['tag'] = 't1'
codechecker_cfg['checkers'] = [
'-d', 'core.CallAndMessage', '-e', 'core.StackAddressEscape'
]
codechecker_cfg['reportdir'] = os.path.join(TEST_WORKSPACE, 'reports2')
ret = codechecker.check(codechecker_cfg, test_project_name_update,
test_project_path)
if ret:
sys.exit(1)
print("Third analysis of the test project was successful.")
codechecker_cfg['tag'] = 't2'
codechecker_cfg['checkers'] = [
'-e', 'core.CallAndMessage', '-d', 'core.StackAddressEscape'
]
ret = codechecker.check(codechecker_cfg, test_project_name_update,
test_project_path)
if ret:
sys.exit(1)
print("Fourth analysis of the test project was successful.")
codechecker_cfg['tag'] = 't3'
ret = codechecker.check(codechecker_cfg, test_project_name_update,
test_project_path)
if ret:
sys.exit(1)
print("Fifth analysis of the test project was successful.")
# Order of the test run names matter at comparison!
codechecker_cfg['run_names'] = [
test_project_name_base, test_project_name_new, test_project_name_update
]
test_config['codechecker_cfg'] = codechecker_cfg
# Export test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for the tests. """
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('comment')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
test_project_path = project.path(test_project)
test_config = {}
project_info = project.get_info(test_project)
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
test_env = env.test_env(TEST_WORKSPACE)
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'reportdir': os.path.join(TEST_WORKSPACE, 'reports'),
'checkers':
['-d', 'core.CallAndMessage', '-e', 'core.StackAddressEscape']
}
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'comment'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
# Check the test project for the first time.
test_project_names = []
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
test_project_names.append(test_project_name)
ret = codechecker.check(codechecker_cfg, test_project_name,
test_project_path)
if ret:
sys.exit(1)
print("Analyzing test project was successful.")
# Check the test project again.
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
test_project_names.append(test_project_name)
ret = codechecker.check(codechecker_cfg, test_project_name,
test_project_path)
if ret:
sys.exit(1)
print("Analyzing test project was succcessful.")
codechecker_cfg['run_names'] = test_project_names
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""
Setup the environment for the tests.
Check the test project twice, then start the server.
"""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('diff')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
test_project_path = project.path(test_project)
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(test_project)
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
# Setup environment variabled for test cases.
host_port_cfg = env.get_host_port_cfg()
test_env = env.test_env()
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'reportdir': os.path.join(TEST_WORKSPACE, 'reports'),
'pg_db_config': pg_db_config,
'checkers':
['-d', 'core.CallAndMessage', '-e', 'core.StackAddressEscape']
}
codechecker_cfg.update(host_port_cfg)
test_config['codechecker_cfg'] = codechecker_cfg
ret = project.clean(test_project, test_env)
if ret:
sys.exit(ret)
# Start the CodeChecker server.
print("Starting server to get results")
_start_server(codechecker_cfg, test_config, False)
test_project_name_base = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name_base,
test_project_path)
if ret:
sys.exit(1)
print("First analysis of the test project was successful.")
ret = project.clean(test_project, test_env)
if ret:
sys.exit(ret)
test_project_name_new = project_info['name'] + '_' + uuid.uuid4().hex
# Let's run the second analysis with different
# checkers to have some real difference.
codechecker_cfg['checkers'] = [
'-e', 'core.CallAndMessage', '-d', 'core.StackAddressEscape'
]
ret = codechecker.check(codechecker_cfg, test_project_name_new,
test_project_path)
if ret:
sys.exit(1)
print("Second analysis of the test project was successful.")
# Run the second analysis results
# into a report directory
ret = codechecker.analyze(codechecker_cfg, test_project_name_new,
test_project_path)
if ret:
sys.exit(1)
print("CodeChecker analyze of test project was successful.")
if pg_db_config:
print("Waiting for PotgreSQL to stop.")
codechecker.wait_for_postgres_shutdown(TEST_WORKSPACE)
# Order of the test run names matter at comparison!
codechecker_cfg['run_names'] = [
test_project_name_base, test_project_name_new
]
test_config['codechecker_cfg'] = codechecker_cfg
# Export test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for the tests."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('cmdline')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
test_config = {}
project_info = project.get_info(test_project)
# Copy the test project to the workspace. The tests should
# work only on this test project.
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_proj_path)
project_info['project_path'] = test_proj_path
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
test_env = env.test_env(TEST_WORKSPACE)
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'checkers': []
}
ret = project.clean(test_project)
if ret:
sys.exit(ret)
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'cmdline'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
# Generate a unique name for this test run.
test_project_name_1 = project_info['name'] + '1_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name_1,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
test_project_name_2 = project_info['name'] + '2_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name_2,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
codechecker_cfg['run_names'] = [test_project_name_1, test_project_name_2]
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for the tests. Then start the server."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('report_viewer_api')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(test_project)
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_proj_path)
project_info['project_path'] = test_proj_path
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
# Get port numbers for the tests.
host_port_cfg = env.get_host_port_cfg()
test_env = env.test_env()
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
codechecker_cfg.update(host_port_cfg)
ret = project.clean(test_project)
if ret:
sys.exit(ret)
print("Starting server to get results.")
_start_server(codechecker_cfg, test_config, False)
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for the tests. Check the test project twice,
then start the server."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('skip')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(test_project)
test_config['test_project'] = project_info
suppress_file = None
# Generate skip list file for the tests.
skip_list_file = os.path.join(TEST_WORKSPACE, 'skip_file')
if os.path.isfile(skip_list_file):
os.remove(skip_list_file)
_generate_skip_list_file(skip_list_file)
# Get port numbers for the tests.
host_port_cfg = env.get_host_port_cfg()
test_env = env.test_env()
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
codechecker_cfg.update(host_port_cfg)
ret = project.clean(test_project, test_env)
if ret:
sys.exit(ret)
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
if pg_db_config:
print("Waiting for PostgreSQL to stop.")
codechecker.wait_for_postgres_shutdown(TEST_WORKSPACE)
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
# Start the CodeChecker server.
print("Starting server to get results.")
_start_server(codechecker_cfg, test_config, False)
def setup_package():
"""Setup the environment for testing delete_runs."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('delete_runs')
# Set the TEST_WORKSPACE used by the tests.
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
# PostgreSQL configuration might be empty if tests are run
# with SQLite.
pg_db_config = env.get_postgresql_cfg()
test_config = {}
test_project = 'simple'
project_info = project.get_info(test_project)
# Copy the test project to the workspace. The tests should
# work only on this test project.
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_proj_path)
project_info['project_path'] = test_proj_path
# Generate a unique name for this test run.
test_project_name = project_info['name']
test_config['test_project'] = project_info
# Suppress file should be set here if needed by the tests.
suppress_file = None
# Skip list file should be set here if needed by the tests.
skip_list_file = None
# Get an environment which should be used by the tests.
test_env = env.test_env()
# Create a basic CodeChecker config for the tests, this should
# be imported by the tests and they should only depend on these
# configuration options.
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
# Get new unique port numbers for this test run.
host_port_cfg = env.get_host_port_cfg()
# Extend the checker configuration with the port numbers.
codechecker_cfg.update(host_port_cfg)
# Start the CodeChecker server.
print("Starting server to get results")
_start_server(codechecker_cfg, test_config, False)
for i in range(0, 5):
# Clean the test project, if needed by the tests.
ret = project.clean(test_project)
if ret:
sys.exit(ret)
# Check the test project, if needed by the tests.
ret = codechecker.check(codechecker_cfg,
test_project_name + '_' + str(i),
test_proj_path)
if ret:
sys.exit(1)
print("Analyzing the test project was successful {}.".format(str(i)))
# If the check process is very fast, datetime of multiple runs can be
# almost the same different in microseconds. Test cases of delete runs
# can be failed for this reason because we didn't process microseconds
# in command line arguments.
time.sleep(1)
# Save the run names in the configuration.
codechecker_cfg['run_names'] \
= [test_project_name + '_' + str(i) for i in range(0, 5)]
test_config['codechecker_cfg'] = codechecker_cfg
# Export the test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for the tests."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('report_viewer_api')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
test_config = {}
project_info = project.get_info(test_project)
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_proj_path)
project_info['project_path'] = test_proj_path
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
tag = 'v1.0'
test_env = env.test_env(TEST_WORKSPACE)
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'checkers': [],
'tag': tag
}
ret = project.clean(test_project)
if ret:
sys.exit(ret)
# Start or connect to the running CodeChecker server and get connection
# details.
print("This test uses a CodeChecker server... connecting...")
server_access = codechecker.start_or_get_server()
server_access['viewer_product'] = 'report_viewer_api'
codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
# Extend the checker configuration with the server access.
codechecker_cfg.update(server_access)
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex + '**'
ret = codechecker.check(codechecker_cfg,
test_project_name,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
test_project_name_new = project_info['name'] + '*' + uuid.uuid4().hex + '%'
# Let's run the second analysis with different
# checkers to have some real difference.
codechecker_cfg['checkers'] = ['-e', 'core.CallAndMessage',
'-d', 'core.StackAddressEscape',
'-d', 'unix.Malloc'
]
codechecker_cfg['tag'] = None
ret = codechecker.check(codechecker_cfg,
test_project_name_new,
project.path(test_project))
if ret:
sys.exit(1)
print("Second analysis of the test project was successful.")
test_project_name_third = project_info['name'] + uuid.uuid4().hex
# Let's run the third analysis.
ret = codechecker.check(codechecker_cfg,
test_project_name_third,
project.path(test_project))
if ret:
sys.exit(1)
print("Third analysis of the test project was successful.")
codechecker_cfg['run_names'] = [test_project_name,
test_project_name_new]
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)