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)