def testShutdownRecordKeeping(self):
"""Test that one server's shutdown keeps the other records."""
# NOTE: Do NOT rename this method. It MUST come lexicographically
# AFTER testServerStartSecondary, because we shut down a server started
# by the aforementioned method.
# Kill the second started server.
EVENT_2.set()
# Give the server some grace period to react to the kill command.
time.sleep(5)
test_cfg = env.import_test_cfg(self._test_workspace)
codechecker_1 = test_cfg['codechecker_1']
codechecker_2 = test_cfg['codechecker_2']
instance_1 = [i for i in instance_manager.get_instances(self.home)
if i['port'] == codechecker_1['viewer_port'] and
i['workspace'] == self._test_workspace]
instance_2 = [i for i in instance_manager.get_instances(self.home)
if i['port'] == codechecker_2['viewer_port'] and
i['workspace'] == self._test_workspace]
self.assertNotEqual(instance_1, [],
"The stopped server deleted another server's "
"record from the instance list!")
self.assertEqual(instance_2, [],
"The stopped server did not disappear from the"
" instance list.")
def setUp(self):
"""
WARNING!!!
This is an example how to get the configurations needed by the tests.
WARNING!!!
"""
# TEST_WORKSPACE is automatically set by test package __init__.py .
test_workspace = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + test_workspace)
# Get the test configuration from the prepared int the test workspace.
test_cfg = env.import_test_cfg(test_workspace)
# Get the test project configuration from the prepared test workspace.
self._testproject_data = env.setup_test_proj_cfg(test_workspace)
self.assertIsNotNone(self._testproject_data)
# Setup a viewer client to test viewer API calls.
self._cc_client = env.setup_viewer_client(test_workspace)
self.assertIsNotNone(self._cc_client)
# Get the CodeChecker cmd if needed for the tests.
self._codechecker_cmd = env.codechecker_cmd()
# Get the run names which belong to this test.
run_names = env.get_run_names(test_workspace)
runs = self._cc_client.getRunData(None)
test_runs = [run for run in runs if run.name in run_names]
def test_suppress_import(self):
"""
Test the suppress file importing.
"""
generated_file = os.path.join(self._test_workspace,
"generated.suppress")
extract_cmd = ['CodeChecker', 'parse',
os.path.join(self._test_workspace, "reports"),
"--suppress", generated_file,
"--export-source-suppress"
]
ret = call_cmd(extract_cmd,
self._test_project_path,
env.test_env(self._test_workspace))
self.assertEqual(ret, 0, "Failed to generate suppress file.")
codechecker_cfg = env.import_test_cfg(
self._test_workspace)['codechecker_cfg']
product_url = env.parts_to_url(codechecker_cfg)
import_cmd = ['CodeChecker', 'cmd', 'suppress', '-i', generated_file,
'--url', product_url, self._run_name]
print(import_cmd)
ret = call_cmd(import_cmd,
self._test_project_path,
env.test_env(self._test_workspace))
self.assertEqual(ret, 0, "Failed to import suppress file.")
def testShutdownTerminateStopAll(self):
"""Tests that --stop-all kills all servers on the host."""
# NOTE: Yet again keep the lexicographical flow, no renames!
test_cfg = env.import_test_cfg(self._test_workspace)
codechecker_1 = test_cfg['codechecker_1']
codechecker_2 = test_cfg['codechecker_2']
EVENT_1.clear()
EVENT_2.clear()
start_server(codechecker_1, EVENT_1, ['--skip-db-cleanup'])
start_server(codechecker_2, EVENT_2, ['--skip-db-cleanup'])
self.assertEqual(len(instance_manager.get_instances(self.home)), 2,
"Two servers were started but they don't appear "
"in the instance list.")
# Kill the servers via cmdline.
self.assertEqual(0, self.run_cmd([env.codechecker_cmd(),
'server', '--stop-all']),
"The stop-all command didn't return exit code 0.")
self.assertEqual(len(instance_manager.get_instances(self.home)), 0,
"Both servers were allegedly stopped but they "
"did not disappear.")
def testServerStartSecondary(self):
"""Another started server appends itself to instance list."""
test_cfg = env.import_test_cfg(self._test_workspace)
codechecker_1 = test_cfg['codechecker_1']
codechecker_2 = test_cfg['codechecker_2']
EVENT_2.clear()
start_server(codechecker_2, EVENT_2, ['--skip-db-cleanup'])
# Workspaces must match, servers were started in the same workspace.
instance_workspaces = [
i['workspace'] for i in instance_manager.get_instances(self.home)
if i['workspace'] == self._test_workspace]
self.assertEqual(len(instance_workspaces), 2,
"Two servers in the same workspace but the workspace"
" was not found twice in the instance list.")
# Exactly one server should own each port generated
instance_ports = [
i['port'] for i in instance_manager.get_instances(self.home)
if i['port'] == codechecker_1['viewer_port'] or
i['port'] == codechecker_2['viewer_port']]
self.assertEqual(len(instance_ports), 2,
"The ports for the two started servers were not found"
" in the instance list.")
def setUp(self):
# Get the test workspace used to authentication tests.
self._test_workspace = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + self._test_workspace)
self._test_cfg = env.import_test_cfg(self._test_workspace)
def setUp(self):
# Get the test workspace used to tests.
self._test_workspace = os.environ['TEST_WORKSPACE']
test_cfg = env.import_test_cfg(self._test_workspace)
self._test_env = test_cfg['codechecker_1']['check_env']
self.home = self._test_env['HOME']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + self._test_workspace)
def teardown_package():
"""Clean up after the test."""
# TODO: If environment variable is set keep the workspace
# and print out the path.
global TEST_WORKSPACE
check_env = env.import_test_cfg(TEST_WORKSPACE)[
'codechecker_cfg']['check_env']
codechecker.remove_test_package_product(TEST_WORKSPACE, check_env)
print("Removing: " + TEST_WORKSPACE)
def setUp(self):
# TEST_WORKSPACE is automatically set by test package __init__.py .
test_workspace = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + test_workspace)
codechecker_cfg = env.import_test_cfg(test_workspace)[
'codechecker_cfg']
self.server_url = env.parts_to_url(codechecker_cfg)
# Get the test project configuration from the prepared test workspace.
self._testproject_data = env.setup_test_proj_cfg(test_workspace)
self.assertIsNotNone(self._testproject_data)
# Setup a viewer client to test viewer API calls.
self._cc_client = env.setup_viewer_client(test_workspace)
self.assertIsNotNone(self._cc_client)
# Get the CodeChecker cmd if needed for the tests.
self._codechecker_cmd = env.codechecker_cmd()
self._test_config = env.import_test_cfg(test_workspace)
def teardown_package():
"""Stop the CodeChecker server and clean up after the tests."""
# TODO If environment variable is set keep the workspace
# and print out the path.
global TEST_WORKSPACE
# Removing the product through this server requires credentials.
codechecker_cfg = env.import_test_cfg(TEST_WORKSPACE)['codechecker_cfg']
codechecker.remove_test_package_product(TEST_WORKSPACE,
codechecker_cfg['check_env'])
__STOP_SERVER.set()
print("Removing: " + TEST_WORKSPACE)
shutil.rmtree(TEST_WORKSPACE, ignore_errors=True)
def testServerStart(self):
"""Started server writes itself to instance list."""
test_cfg = env.import_test_cfg(self._test_workspace)
codechecker_1 = test_cfg['codechecker_1']
EVENT_1.clear()
start_server(codechecker_1, EVENT_1, ['--skip-db-cleanup'])
instance = [i for i in instance_manager.get_instances(self.home)
if i['port'] == codechecker_1['viewer_port'] and
i['workspace'] == self._test_workspace]
self.assertNotEqual(instance, [],
"The started server did not register itself to the"
" instance list.")
def teardown_package():
"""Stop the CodeChecker server and clean up after the tests."""
# TODO If environment variable is set keep the workspace
# and print out the path.
global TEST_WORKSPACE
check_env = env.import_test_cfg(TEST_WORKSPACE)[
'codechecker_cfg']['check_env']
codechecker.remove_test_package_product(TEST_WORKSPACE, check_env)
# Let the remaining CodeChecker servers die.
EVENT_1.set()
print("Removing: " + TEST_WORKSPACE)
shutil.rmtree(TEST_WORKSPACE, ignore_errors=True)
def setUp(self):
"""
"""
# TEST_WORKSPACE is automatically set by test package __init__.py .
self.test_workspace = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + self.test_workspace)
# Get the test configuration from the prepared int the test workspace.
self.test_cfg = env.import_test_cfg(self.test_workspace)
self.product_name = self.test_cfg['codechecker_cfg']['viewer_product']
# Setup a viewer client to test viewer API calls.
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
# Setup an authentication client for creating sessions.
self._auth_client = env.setup_auth_client(self.test_workspace,
session_token='_PROHIBIT')
# Create a SUPERUSER login.
root_token = self._auth_client.performLogin("Username:Password",
"root:root")
# Setup a product client to test product API calls.
self._pr_client = env.setup_product_client(self.test_workspace)
self.assertIsNotNone(self._pr_client)
# Setup a product client to test product API calls which requires root.
self._root_client = env.setup_product_client(self.test_workspace,
session_token=root_token)
self.assertIsNotNone(self._pr_client)
# Get the run names which belong to this test.
run_names = env.get_run_names(self.test_workspace)
runs = self._cc_client.getRunData(None)
test_runs = [run for run in runs if run.name in run_names]
self.assertEqual(len(test_runs), 1,
"There should be only one run for this test.")
self._runid = test_runs[0].runId
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 setUp(self):
test_workspace = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + test_workspace)
# Get the clang version which is tested.
self._clang_to_test = env.clang_to_test()
self._testproject_data = env.setup_test_proj_cfg(test_workspace)
self.assertIsNotNone(self._testproject_data)
self._cc_client = env.setup_viewer_client(test_workspace)
self.assertIsNotNone(self._cc_client)
# Get the run names which belong to this test.
run_names = env.get_run_names(test_workspace)
runs = self._cc_client.getRunData(None)
test_runs = [run for run in runs if run.name in run_names]
for r in test_runs:
print(r)
# There should be at least two runs for this test.
self.assertIsNotNone(runs)
self.assertNotEqual(len(runs), 0)
self.assertGreaterEqual(len(runs), 2)
# Name order matters from __init__ !
self._base_runid = test_runs[0].runId # base
self._new_runid = test_runs[1].runId # new
self._update_runid = test_runs[2].runId # updated
self._codechecker_cmd = env.codechecker_cmd()
self._report_dir = os.path.join(test_workspace, "reports")
self._report_dir_baseline = os.path.join(test_workspace,
"reports_baseline")
self._test_config = env.import_test_cfg(test_workspace)
self._run_names = env.get_run_names(test_workspace)
self._html_reports = os.path.join(test_workspace, "html_reports")
self._url = env.parts_to_url(self._test_config['codechecker_cfg'])
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(self):
"""
Set up the environment and the test module's configuration from the
package.
"""
# TEST_WORKSPACE is automatically set by test package __init__.py .
self.test_workspace_main = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' +
self.test_workspace_main)
# Set up a configuration for the main server.
# Get the test configuration from the prepared int the test workspace.
self.test_cfg = env.import_test_cfg(self.test_workspace_main)
self.product_name = self.test_cfg['codechecker_cfg']['viewer_product']
# Setup a viewer client to test viewer API calls.
self._cc_client = env.setup_viewer_client(self.test_workspace_main)
self.assertIsNotNone(self._cc_client)
# Setup an authentication client for creating sessions.
self._auth_client = env.setup_auth_client(self.test_workspace_main,
session_token='_PROHIBIT')
# Create a SUPERUSER login.
root_token = self._auth_client.performLogin("Username:Password",
"root:root")
ret = self._auth_client.addPermission(Permission.SUPERUSER, "root",
False, "")
self.assertTrue(ret)
# Setup a product client to test product API calls.
self._pr_client = env.setup_product_client(self.test_workspace_main)
self.assertIsNotNone(self._pr_client)
# Setup a product client to test product API calls which requires root.
self._root_client = env.setup_product_client(self.test_workspace_main,
session_token=root_token)
self.assertIsNotNone(self._pr_client)
# Get the run names which belong to this test.
run_names = env.get_run_names(self.test_workspace_main)
runs = self._cc_client.getRunData(None)
test_runs = [run for run in runs if run.name in run_names]
self.assertEqual(len(test_runs), 1,
"There should be only one run for this test.")
self._runid = test_runs[0].runId
# Start a second server with the same configuration database as the
# main one.
self.test_workspace_secondary = env.get_workspace('producttest_second')
self.codechecker_cfg_2 = {
'check_env': self.test_cfg['codechecker_cfg']['check_env'],
'workspace': self.test_workspace_secondary,
'checkers': [],
'viewer_host': 'localhost',
'viewer_port': env.get_free_port(),
'viewer_product': 'producttest_second'
}
self.codechecker_cfg_2['check_env']['HOME'] = \
self.test_workspace_secondary
env.export_test_cfg(self.test_workspace_secondary,
{'codechecker_cfg': self.codechecker_cfg_2})
start_server(self.codechecker_cfg_2, EVENT)
# Set up API clients for the secondary server.
self._auth_client_2 = env.setup_auth_client(
self.test_workspace_secondary, session_token='_PROHIBIT')
root_token_2 = self._auth_client_2.performLogin(
"Username:Password", "root:root")
self._pr_client_2 = env.setup_product_client(
self.test_workspace_secondary, session_token=root_token_2)
self.assertIsNotNone(self._pr_client_2)
def testShutdownTerminateByCmdline(self):
"""Tests that the command-line command actually kills the server,
and that it does not kill anything else."""
# NOTE: Yet again keep the lexicographical flow, no renames!
test_cfg = env.import_test_cfg(self._test_workspace)
codechecker_1 = test_cfg['codechecker_1']
codechecker_2 = test_cfg['codechecker_2']
EVENT_2.clear()
start_server(codechecker_2, EVENT_2, ['--skip-db-cleanup'])
# Kill the server, but yet again give a grace period.
self.assertEqual(0, self.run_cmd([env.codechecker_cmd(),
'server', '--stop',
'--view-port',
str(codechecker_2['viewer_port']),
'--workspace',
self._test_workspace]),
"The stop command didn't return exit code 0.")
# Check if the remaining server is still there,
# we need to make sure that --stop only kills the specified server!
instance_1 = [i for i in instance_manager.get_instances(self.home)
if i['port'] == codechecker_1['viewer_port'] and
i['workspace'] == self._test_workspace]
instance_2 = [i for i in instance_manager.get_instances(self.home)
if i['port'] == codechecker_2['viewer_port'] and
i['workspace'] == self._test_workspace]
self.assertNotEqual(instance_1, [],
"The stopped server deleted another server's "
"record from the instance list!")
self.assertEqual(instance_2, [],
"The stopped server did not disappear from the"
" instance list.")
# Kill the first server via cmdline too.
self.assertEqual(0, self.run_cmd([env.codechecker_cmd(),
'server', '--stop',
'--view-port',
str(codechecker_1['viewer_port']),
'--workspace',
self._test_workspace]),
"The stop command didn't return exit code 0.")
instance_1 = [i for i in instance_manager.get_instances(self.home)
if i['port'] == codechecker_1['viewer_port'] and
i['workspace'] == self._test_workspace]
instance_2 = [i for i in instance_manager.get_instances(self.home)
if i['port'] == codechecker_2['viewer_port'] and
i['workspace'] == self._test_workspace]
self.assertEqual(instance_1, [],
"The stopped server did not disappear from the"
" instance list.")
self.assertEqual(instance_2, [],
"The stopped server made another server's record "
"appear in the instance list.")
def setUp(self):
self._test_workspace = os.environ.get('TEST_WORKSPACE')
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + self._test_workspace)
self._clang_to_test = env.clang_to_test()
self._testproject_data = env.setup_test_proj_cfg(self._test_workspace)
self.assertIsNotNone(self._testproject_data)
# Get the test configuration from the prepared int the test workspace.
self.test_cfg = env.import_test_cfg(self._test_workspace)
self._product_name = self.test_cfg['codechecker_cfg']['viewer_product']
pr_client = env.setup_product_client(self._test_workspace,
product=self._product_name)
product_id = pr_client.getCurrentProduct().id
# Setup an authentication client for creating sessions.
self._auth_client = env.setup_auth_client(self._test_workspace,
session_token='_PROHIBIT')
# Create an PRODUCT_ADMIN login.
admin_token = self._auth_client.performLogin("Username:Password",
"admin:admin123")
extra_params = '{"productID":' + str(product_id) + '}'
ret = self._auth_client.addPermission(Permission.PRODUCT_ADMIN,
"admin", False, extra_params)
self.assertTrue(ret)
self._cc_client = env.setup_viewer_client(self._test_workspace,
session_token=admin_token)
self.assertIsNotNone(self._cc_client)
# Get the run names which belong to this test
run_names = env.get_run_names(self._test_workspace)
runs = self._cc_client.getRunData(None, None, 0, None)
test_runs = [run for run in runs if run.name in run_names]
self.assertEqual(len(test_runs), 1,
'There should be only one run for this test.')
self._runid = test_runs[0].runId
self._run_name = test_runs[0].name
self.components = [{
'name':
'test_component1',
'value':
'\n'.join(['+*/divide_zero.cpp', '-*/new_delete.cpp']),
'description':
'Description of my first component'
}, {
'name':
'component name with whitespaces',
'value':
'\n'.join(['+*/divide_zero.cpp', '-*/new_delete.cpp']),
'description':
'Description of my second component'
}, {
'name':
'test_component2',
'value':
'\n'.join([
'+*/divide_zero.cpp', '+*/null_dereference.cpp',
'-*/call_and_message.cpp', '-*/new_delete.*'
]),
'description':
'Description of my second component'
}, {
'name':
'complex1',
'value':
'\n'.join(['+*/divide_zero.cpp', '-*/call_and_message.cpp'])
}, {
'name':
'complex2',
'value':
'\n'.join(['+*/null_dereference.cpp', '-*/new_delete.cpp'])
}, {
'name': 'exclude_all',
'value': '-*'
}]
def setUp(self):
self._test_workspace = os.environ.get('TEST_WORKSPACE')
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + self._test_workspace)
self._clang_to_test = env.clang_to_test()
self._testproject_data = env.setup_test_proj_cfg(self._test_workspace)
self.assertIsNotNone(self._testproject_data)
# Get the test configuration from the prepared int the test workspace.
self.test_cfg = env.import_test_cfg(self._test_workspace)
self._product_name = self.test_cfg['codechecker_cfg']['viewer_product']
pr_client = env.setup_product_client(
self._test_workspace, product=self._product_name)
product_id = pr_client.getCurrentProduct().id
# Setup an authentication client for creating sessions.
self._auth_client = env.setup_auth_client(self._test_workspace,
session_token='_PROHIBIT')
# Create an PRODUCT_ADMIN login.
admin_token = self._auth_client.performLogin("Username:Password",
"admin:admin123")
extra_params = '{"productID":' + str(product_id) + '}'
ret = self._auth_client.addPermission(Permission.PRODUCT_ADMIN,
"admin",
False,
extra_params)
self.assertTrue(ret)
self._cc_client = env.setup_viewer_client(self._test_workspace,
session_token=admin_token)
self.assertIsNotNone(self._cc_client)
# Get the run names which belong to this test
run_names = env.get_run_names(self._test_workspace)
runs = self._cc_client.getRunData(None)
test_runs = [run for run in runs if run.name in run_names]
self.assertEqual(len(test_runs), 1,
'There should be only one run for this test.')
self._runid = test_runs[0].runId
self._run_name = test_runs[0].name
self.components = [
{
'name': 'test_component1',
'value': '\n'.join(['+*/divide_zero.cpp',
'-*/new_delete.cpp']),
'description': 'Description of my first component'
},
{
'name': 'component name with whitespaces',
'value': '\n'.join(['+*/divide_zero.cpp',
'-*/new_delete.cpp']),
'description': 'Description of my second component'
},
{
'name': 'test_component2',
'value': '\n'.join(['+*/divide_zero.cpp',
'+*/null_dereference.cpp',
'-*/call_and_message.cpp',
'-*/new_delete.*']),
'description': 'Description of my second component'
},
{
'name': 'complex1',
'value': '\n'.join(['+*/divide_zero.cpp',
'-*/call_and_message.cpp'])
},
{
'name': 'complex2',
'value': '\n'.join(['+*/null_dereference.cpp',
'-*/new_delete.cpp'])
},
{
'name': 'exclude_all',
'value': '-*'
}
]
def testShutdownTerminateByCmdline(self):
"""Tests that the command-line command actually kills the server,
and that it does not kill anything else."""
# NOTE: Yet again keep the lexicographical flow, no renames!
test_cfg = env.import_test_cfg(self._test_workspace)
codechecker_1 = test_cfg['codechecker_1']
codechecker_2 = test_cfg['codechecker_2']
EVENT_2.clear()
start_server(codechecker_2, EVENT_2, ['--skip-db-cleanup'])
# Kill the server, but yet again give a grace period.
self.assertEqual(
0,
self.run_cmd([
env.codechecker_cmd(), 'server', '--stop', '--view-port',
str(codechecker_2['viewer_port']), '--workspace',
self._test_workspace
]), "The stop command didn't return exit code 0.")
# Check if the remaining server is still there,
# we need to make sure that --stop only kills the specified server!
instance_1 = [
i for i in instance_manager.get_instances(self.home)
if i['port'] == codechecker_1['viewer_port']
and i['workspace'] == self._test_workspace
]
instance_2 = [
i for i in instance_manager.get_instances(self.home)
if i['port'] == codechecker_2['viewer_port']
and i['workspace'] == self._test_workspace
]
self.assertNotEqual(
instance_1, [], "The stopped server deleted another server's "
"record from the instance list!")
self.assertEqual(
instance_2, [], "The stopped server did not disappear from the"
" instance list.")
# Kill the first server via cmdline too.
self.assertEqual(
0,
self.run_cmd([
env.codechecker_cmd(), 'server', '--stop', '--view-port',
str(codechecker_1['viewer_port']), '--workspace',
self._test_workspace
]), "The stop command didn't return exit code 0.")
instance_1 = [
i for i in instance_manager.get_instances(self.home)
if i['port'] == codechecker_1['viewer_port']
and i['workspace'] == self._test_workspace
]
instance_2 = [
i for i in instance_manager.get_instances(self.home)
if i['port'] == codechecker_2['viewer_port']
and i['workspace'] == self._test_workspace
]
self.assertEqual(
instance_1, [], "The stopped server did not disappear from the"
" instance list.")
self.assertEqual(
instance_2, [], "The stopped server made another server's record "
"appear in the instance list.")
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_and_store(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'])
