diff --git a/analyzer/config/analyzer_version.json b/analyzer/config/analyzer_version.json
index f978e36055..e63ce28982 100644
--- a/analyzer/config/analyzer_version.json
+++ b/analyzer/config/analyzer_version.json
@@ -1,8 +1,8 @@
 {
     "version": {
         "major" : "6",
-        "minor" : "23",
-        "revision" : "0",
+        "minor" : "22",
+        "revision" : "2",
         "rc" : ""
     }
 }
diff --git a/analyzer/tools/build-logger/tests/unit/test_paths.py b/analyzer/tools/build-logger/tests/unit/test_paths.py
index c1ce67b3eb..5cfa9c5ae8 100644
--- a/analyzer/tools/build-logger/tests/unit/test_paths.py
+++ b/analyzer/tools/build-logger/tests/unit/test_paths.py
@@ -4,6 +4,7 @@
 import os
 import shutil
 import tempfile
+from typing import Mapping
 from . import BasicLoggerTest, empty_env, REPO_ROOT
 
 AVAILABLE_GNU_COMPILERS = [
@@ -13,6 +14,15 @@
 ]
 
 
+def append_host_LD_LIBRARY_PATH(env: Mapping[str, str]) -> Mapping[str, str]:
+    LD_LIBRARY_PATH = os.getenv("LD_LIBRARY_PATH")
+    if LD_LIBRARY_PATH:
+        if "LD_LIBRARY_PATH" not in env:
+            env["LD_LIBRARY_PATH"] = ""
+        env["LD_LIBRARY_PATH"] += ':' + LD_LIBRARY_PATH
+    return env
+
+
 class EscapingTests(BasicLoggerTest):
     def test_compiler_path1(self):
         """
@@ -242,6 +252,7 @@ def test_response_file(self):
         """Test clang-specific response files."""
         logger_env = self.get_envvars()
         # clang might need Z3
+        logger_env = append_host_LD_LIBRARY_PATH(logger_env)
         file = self.source_file
         binary = self.binary_file
         clang = shutil.which("clang")
@@ -277,6 +288,7 @@ def test_response_file_contain_source_file(self):
         """
         logger_env = self.get_envvars()
         # clang might need Z3
+        logger_env = append_host_LD_LIBRARY_PATH(logger_env)
         file = self.source_file
         binary = self.binary_file
         clang = shutil.which("clang")
diff --git a/setup.py b/setup.py
index ef7c27276c..aa3f25b99b 100644
--- a/setup.py
+++ b/setup.py
@@ -141,7 +141,7 @@ def run(self):
 
 setuptools.setup(
     name="codechecker",
-    version="6.23.0",
+    version="6.22.2",
     author='CodeChecker Team (Ericsson)',
     author_email='codechecker-tool@googlegroups.com',
     description="CodeChecker is an analyzer tooling, defect database and "
diff --git a/snap/snapcraft.yaml b/snap/snapcraft.yaml
index ab9d4c3706..61b11d8ea3 100644
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
@@ -1,6 +1,6 @@
 name: codechecker
 base: core18
-version: '6.23.0'
+version: '6.22.2'
 summary: CodeChecker is an analyzer tooling, defect database and viewer extension
 description: |
   CodeChecker is an analyzer tooling, defect database and viewer extension.
@@ -33,7 +33,7 @@ parts:
   codechecker:
     plugin: python
     python-version: python3
-    source: https://github.com/Ericsson/codechecker/archive/v6.23.0.tar.gz
+    source: https://github.com/Ericsson/codechecker/archive/v6.22.2.tar.gz
     build-packages:
       - curl
       - gcc-multilib
diff --git a/web/client/codechecker_client/blame_info.py b/web/client/codechecker_client/blame_info.py
index 9d02d7c70e..c6dd7f12c5 100644
--- a/web/client/codechecker_client/blame_info.py
+++ b/web/client/codechecker_client/blame_info.py
@@ -118,7 +118,7 @@ def assemble_blame_info(
     # being present in windows, so stuff like setting up
     # PYTHONPATH in parent CodeChecker before store is executed
     # are lost.
-    if sys.platform == "win32":
+    if sys.platform == "win32" or sys.platform == "darwin":
         file_blame_info = __collect_blame_info_for_files(file_paths)
     else:
         with ProcessPoolExecutor() as executor:
diff --git a/web/client/codechecker_client/cmd/store.py b/web/client/codechecker_client/cmd/store.py
index b0663bbb7d..1bcd67a9b8 100644
--- a/web/client/codechecker_client/cmd/store.py
+++ b/web/client/codechecker_client/cmd/store.py
@@ -370,8 +370,12 @@ def filter_source_files_with_comments(
     # being present in windows, so stuff like setting up
     # PYTHONPATH in parent CodeChecker before store is executed
     # are lost.
-    if sys.platform == "win32":
+    if sys.platform == "win32": #or sys.platform == "darwin":
         return get_source_file_with_comments(jobs)
+    elif sys.platform == "darwin":
+        import multiprocess
+        with multiprocess.Pool() as pool:
+            return get_source_file_with_comments(jobs, pool.map)
     else:
         with ProcessPoolExecutor() as executor:
             return get_source_file_with_comments(jobs, executor.map)
@@ -449,6 +453,13 @@ def assemble_zip(inputs, zip_file, client, checker_labels: CheckerLabels):
     if sys.platform == "win32":
         analyzer_result_file_reports = parse_analyzer_result_files(
             analyzer_result_file_paths, checker_labels)
+
+    elif sys.platform == "darwin":
+        import multiprocess
+        with multiprocess.Pool() as pool:
+            analyzer_result_file_reports = parse_analyzer_result_files(
+                 analyzer_result_file_paths, checker_labels, pool.map)
+            
     else:
         with ProcessPoolExecutor() as executor:
             analyzer_result_file_reports = parse_analyzer_result_files(
diff --git a/web/client/codechecker_client/cmd_line_client.py b/web/client/codechecker_client/cmd_line_client.py
index 9cede31eea..a14aeecb89 100644
--- a/web/client/codechecker_client/cmd_line_client.py
+++ b/web/client/codechecker_client/cmd_line_client.py
@@ -1025,13 +1025,16 @@ def get_diff_local_dirs(
     filtered_report_hashes = []
 
     context = webserver_context.get_context()
+    statuses_str = [ttypes.ReviewStatus._VALUES_TO_NAMES[x].lower()
+                    for x in report_filter.reviewStatus]
+
     base_results = get_report_dir_results(
         report_dirs, report_filter, context.checker_labels)
+    base_results = [res for res in base_results
+                    if res.check_source_code_comments(statuses_str)]
+
     new_results = get_report_dir_results(
         new_report_dirs, report_filter, context.checker_labels)
-
-    statuses_str = [ttypes.ReviewStatus._VALUES_TO_NAMES[x].lower()
-                    for x in report_filter.reviewStatus]
     new_results = [res for res in new_results
                    if res.check_source_code_comments(statuses_str)]
 
diff --git a/web/config/web_version.json b/web/config/web_version.json
index f978e36055..e63ce28982 100644
--- a/web/config/web_version.json
+++ b/web/config/web_version.json
@@ -1,8 +1,8 @@
 {
     "version": {
         "major" : "6",
-        "minor" : "23",
-        "revision" : "0",
+        "minor" : "22",
+        "revision" : "2",
         "rc" : ""
     }
 }
diff --git a/web/server/codechecker_server/api/mass_store_run.py b/web/server/codechecker_server/api/mass_store_run.py
index 0fd4bce90c..afeb63b81d 100644
--- a/web/server/codechecker_server/api/mass_store_run.py
+++ b/web/server/codechecker_server/api/mass_store_run.py
@@ -1323,10 +1323,15 @@ def store(self) -> int:
                         runtime = round(time.time() - start_time, 2)
                         zip_size_kb = round(zip_size / 1024)
 
+                        tag_desc = ""
+                        if self.__tag:
+                            tag_desc = f", under tag '{self.__tag}'"
+
                         LOG.info("'%s' stored results (%s KB "
-                                 "/decompressed/) to run '%s' (id: %d) in "
+                                 "/decompressed/) to run '%s' (id: %d) %s in "
                                  "%s seconds.", self.user_name,
-                                 zip_size_kb, self.__name, run_id, runtime)
+                                 zip_size_kb, self.__name, run_id, tag_desc,
+                                 runtime)
 
                         iso_start_time = datetime.fromtimestamp(
                             start_time).isoformat()
diff --git a/web/server/vue-cli/src/views/NewFeatures.vue b/web/server/vue-cli/src/views/NewFeatures.vue
index d9ae2606cc..0993720f61 100644
--- a/web/server/vue-cli/src/views/NewFeatures.vue
+++ b/web/server/vue-cli/src/views/NewFeatures.vue
@@ -2,6 +2,31 @@
   <!-- eslint-disable max-len -->
   <v-container fluid>
     <v-timeline align-top>
+      <v-timeline-item fill-dot icon="mdi-star">
+        <new-release-item>
+          <template v-slot:title>
+            <a
+              href="https://github.com/Ericsson/codechecker/releases/tag/v6.22.2"
+              target="_blank"
+              class="white--text"
+            >
+              Highlights of CodeChecker 6.22.2 release
+            </a>
+          </template>
+
+          <new-feature-item>
+            <template v-slot:title>
+              Support for Ubuntu 22.04
+            </template>
+            CodeChecker failed to build on Ubuntu 22.04 in its previous release
+            because of two issues: some of our dependencies broke with the
+            release of python3.9, and we didn't support GNU Make-s new way of
+            creating build jobs. These issues are all fixed now, so CodeChecker
+            should work with the latest version of python and GNU Make!
+          </new-feature-item>
+        </new-release-item>
+      </v-timeline-item>
+
       <v-timeline-item fill-dot icon="mdi-star" color="green lighten-1">
         <new-release-item color="green lighten-1">
           <template v-slot:title>
diff --git a/web/tests/functional/__init__.py b/web/tests/functional/__init__.py
index aecdd1cdee..0f4be0aa03 100644
--- a/web/tests/functional/__init__.py
+++ b/web/tests/functional/__init__.py
@@ -23,4 +23,7 @@
 REPO_ROOT = os.path.abspath(os.environ['REPO_ROOT'])
 PKG_ROOT = os.path.join(REPO_ROOT, 'build', 'CodeChecker')
 
+os.environ["CC_DATA_FILES_DIR"] = PKG_ROOT
+os.environ["CC_LIB_DIR"] = os.path.join(PKG_ROOT, "lib", "python3")
+
 sys.path.append(os.path.join(PKG_ROOT, 'lib', 'python3'))
diff --git a/web/tests/functional/diff_cmdline/__init__.py b/web/tests/functional/diff_cmdline/__init__.py
new file mode 100644
index 0000000000..f30c492687
--- /dev/null
+++ b/web/tests/functional/diff_cmdline/__init__.py
@@ -0,0 +1,8 @@
+# coding=utf-8
+# -------------------------------------------------------------------------
+#
+#  Part of the CodeChecker project, under the Apache License v2.0 with
+#  LLVM Exceptions. See LICENSE for license information.
+#  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#
+# -------------------------------------------------------------------------
diff --git a/web/tests/functional/diff_cmdline/test_diff_cmdline.py b/web/tests/functional/diff_cmdline/test_diff_cmdline.py
new file mode 100644
index 0000000000..2dd934e666
--- /dev/null
+++ b/web/tests/functional/diff_cmdline/test_diff_cmdline.py
@@ -0,0 +1,654 @@
+#
+# -------------------------------------------------------------------------
+#
+#  Part of the CodeChecker project, under the Apache License v2.0 with
+#  LLVM Exceptions. See LICENSE for license information.
+#  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#
+# -------------------------------------------------------------------------
+
+"""
+Test command line diffing (as opposed to natively using API calls).
+"""
+
+
+import os
+import shutil
+import unittest
+
+from codechecker_api.codeCheckerDBAccess_v6.ttypes import \
+        ReviewStatus, DiffType, ReportFilter
+
+from codechecker_client.cmd_line_client import \
+    get_diff_local_dirs, get_diff_remote_run_local_dir, \
+    get_diff_local_dir_remote_run, get_diff_remote_runs
+
+from libtest import codechecker, env
+from libtest.thrift_client_to_db import get_all_run_results
+
+
+class TestDiffFromCmdLine(unittest.TestCase):
+
+    def setup_class(self):
+        """Setup the environment for testing review_status."""
+
+        workspace_name = 'diff_cmdline'
+        global TEST_WORKSPACE
+        TEST_WORKSPACE = env.get_workspace(workspace_name)
+
+        os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
+
+        test_env = env.test_env(TEST_WORKSPACE)
+
+        codechecker_cfg = {
+            'suppress_file': None,
+            'skip_list_file': None,
+            'check_env': test_env,
+            'workspace': TEST_WORKSPACE,
+            'checkers': [],
+            'analyzers': ['clangsa']
+        }
+
+        # 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'] = workspace_name
+        codechecker.add_test_package_product(server_access, TEST_WORKSPACE)
+
+        # Extend the checker configuration with the server access.
+        codechecker_cfg.update(server_access)
+
+        test_config = {}
+        test_config['codechecker_cfg'] = codechecker_cfg
+
+        env.export_test_cfg(TEST_WORKSPACE, test_config)
+
+    def teardown_class(self):
+        """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)
+        shutil.rmtree(TEST_WORKSPACE, ignore_errors=True)
+
+    def setup_method(self, method):
+        self.test_workspace = os.environ['TEST_WORKSPACE']
+
+        test_class = self.__class__.__name__
+        print('Running ' + test_class + ' tests in ' + self.test_workspace)
+
+        self._cc_client = env.setup_viewer_client(self.test_workspace)
+        self.assertIsNotNone(self._cc_client)
+
+    def teardown_method(self, method):
+        """ Remove all review status rules after each test cases. """
+        self.__remove_all_runs()
+        self.__remove_all_rules()
+
+        dir1 = os.path.join(self.test_workspace, "dir1")
+        dir2 = os.path.join(self.test_workspace, "dir2")
+        shutil.rmtree(dir1, ignore_errors=True)
+        shutil.rmtree(dir2, ignore_errors=True)
+
+    # ===-----------------------------------------------------------------=== #
+
+    def __remove_all_runs(self):
+        for run_data in self._cc_client.getRunData(None, None, 0, None):
+            ret = self._cc_client.removeRun(run_data.runId, None)
+            self.assertTrue(ret)
+            print(f"Successfully removed run '{run_data.name}'.")
+
+    def __remove_all_rules(self):
+        """ Removes all review status rules from the database. """
+        self._cc_client.removeReviewStatusRules(None)
+
+        # Check that there is no review status rule in the database.
+        self.assertFalse(self._cc_client.getReviewStatusRulesCount(None))
+
+        rules = self._cc_client.getReviewStatusRules(None, None, None, 0)
+        self.assertFalse(rules)
+
+    def __analyze(self, file_dir, source_code):
+        build_json_path = os.path.join(file_dir, "build.json")
+
+        build_json = f"""
+[{{
+    "directory": "{file_dir}",
+    "file": "main.c",
+    "command": "gcc main.c -o /dev/null"
+}}]
+"""
+        os.makedirs(file_dir, exist_ok=True)
+
+        with open(os.path.join(file_dir, "main.c"), "w") as f:
+            f.write(source_code)
+
+        with open(build_json_path, "w") as f:
+            f.write(build_json)
+
+        codechecker_cfg = env.import_codechecker_cfg(self.test_workspace)
+        codechecker_cfg["workspace"] = file_dir
+        codechecker_cfg["reportdir"] = os.path.join(file_dir, "reports")
+        codechecker_cfg['analyzers'] = ['clangsa', 'clang-tidy']
+
+        codechecker.analyze(codechecker_cfg, file_dir)
+
+    def __store(self, file_dir, store_name, tag=None):
+        codechecker_cfg = env.import_codechecker_cfg(self.test_workspace)
+        codechecker_cfg["workspace"] = file_dir
+        codechecker_cfg["reportdir"] = \
+            os.path.join(file_dir, "reports")
+        codechecker_cfg["tag"] = tag
+        codechecker.store(codechecker_cfg, store_name)
+
+    def __analyze_and_store(self, file_dir, store_name, source_code, tag=None):
+        self.__analyze(file_dir, source_code)
+        self.__store(file_dir, store_name, tag)
+
+    def __get_run_id(self, run_name):
+        runs = self._cc_client.getRunData(None, None, 0, None)
+        self.assertEqual(len(runs), 1)
+        test_run = [run for run in runs if run.name == run_name]
+        self.assertEqual(len(test_run), 1)
+        return test_run[0].runid
+
+    # ===-----------------------------------------------------------------=== #
+    # Local-local tests.
+    # ===-----------------------------------------------------------------=== #
+
+    def test_local_local_different(self):
+        # Diff two different, local runs.
+        dir1 = os.path.join(self.test_workspace, "dir1")
+        dir2 = os.path.join(self.test_workspace, "dir2")
+
+        src_div_by_zero = """
+void a() {
+  int i = 0;
+  (void)(10 / i);
+}
+"""
+
+        src_nullptr_deref = """
+void b() {
+  int *i = 0;
+  *i = 5;
+}
+"""
+        self.__analyze(dir1, src_div_by_zero)
+        self.__analyze(dir2, src_nullptr_deref)
+
+        report_filter = ReportFilter()
+        report_filter.reviewStatus = []
+
+        def get_run_diff_count(diff_type: DiffType):
+            reports, _ = get_diff_local_dirs(
+                    report_filter, diff_type, [dir1], [], [dir2], [])
+            return len(reports)
+
+        # b() is a new report.
+        self.assertEqual(get_run_diff_count(DiffType.NEW), 1)
+
+        # a() is the old report.
+        self.assertEqual(get_run_diff_count(DiffType.RESOLVED), 1)
+
+        # There are no common reports.
+        self.assertEqual(get_run_diff_count(DiffType.UNRESOLVED), 0)
+
+        def get_run_diff_count_reverse(diff_type: DiffType):
+            reports, _ = get_diff_local_dirs(
+                    report_filter, diff_type, [dir2], [], [dir1], [])
+            return len(reports)
+
+        # b() is a new report.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.NEW), 1)
+
+        # a() is the old report.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.RESOLVED), 1)
+
+        # There are no common reports.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.UNRESOLVED), 0)
+
+    def test_local_local_identical(self):
+        # Diff two identical, local runs.
+        dir1 = os.path.join(self.test_workspace, "dir1")
+        dir2 = os.path.join(self.test_workspace, "dir2")
+
+        src_div_by_zero = """
+void a() {
+  int i = 0;
+  (void)(10 / i);
+}
+"""
+        self.__analyze(dir1, src_div_by_zero)
+        self.__analyze(dir2, src_div_by_zero)
+
+        report_filter = ReportFilter()
+        report_filter.reviewStatus = []
+
+        def get_run_diff_count(diff_type: DiffType):
+            reports, _ = get_diff_local_dirs(
+                    report_filter, diff_type, [dir1], [], [dir2], [])
+            return len(reports)
+
+        # No new reports appeared.
+        self.assertEqual(get_run_diff_count(DiffType.NEW), 0)
+
+        # No reports disappeared.
+        self.assertEqual(get_run_diff_count(DiffType.RESOLVED), 0)
+
+        # There is a single report that has remained.
+        self.assertEqual(get_run_diff_count(DiffType.UNRESOLVED), 1)
+
+    def test_localFPAnnotated_local_identical(self):
+        # Diff identical, local runs, where the baseline report is suppressed
+        # via //codechecker_suppress.
+        dir1 = os.path.join(self.test_workspace, "dir1")
+        dir2 = os.path.join(self.test_workspace, "dir2")
+
+        src_div_by_zero_FP = """
+void a() {
+  int i = 0;
+  // codechecker_false_positive [all] SUPPRESS ALL
+  (void)(10 / i);
+}
+"""
+        src_div_by_zero = """
+void a() {
+  int i = 0;
+  (void)(10 / i);
+}
+"""
+        self.__analyze(dir1, src_div_by_zero_FP)
+        self.__analyze(dir2, src_div_by_zero)
+
+        def get_run_diff_count(diff_type: DiffType):
+            report_filter = ReportFilter()
+            report_filter.reviewStatus = []
+
+            reports, _ = get_diff_local_dirs(
+                    report_filter, diff_type, [dir1], [], [dir2], [])
+            return len(reports)
+
+        self.assertEqual(get_run_diff_count(DiffType.NEW), 1)
+        self.assertEqual(get_run_diff_count(DiffType.RESOLVED), 0)
+        self.assertEqual(get_run_diff_count(DiffType.UNRESOLVED), 0)
+
+        def get_run_diff_count_reverse(diff_type: DiffType):
+            report_filter = ReportFilter()
+            report_filter.reviewStatus = []
+
+            reports, _ = get_diff_local_dirs(
+                    report_filter, diff_type, [dir2], [], [dir1], [])
+            return len(reports)
+
+        self.assertEqual(get_run_diff_count_reverse(DiffType.NEW), 0)
+        self.assertEqual(get_run_diff_count_reverse(DiffType.RESOLVED), 1)
+        self.assertEqual(get_run_diff_count_reverse(DiffType.UNRESOLVED), 0)
+
+    # ===-----------------------------------------------------------------=== #
+    # Local-Remote tests.
+    # ===-----------------------------------------------------------------=== #
+
+    def test_local_remote_different(self):
+        # Create two non-identical runs, store one on the server, leave one
+        # locally.
+        dir1 = os.path.join(self.test_workspace, "dir1")
+        dir2 = os.path.join(self.test_workspace, "dir2")
+
+        src_div_by_zero = """
+void a() {
+  int i = 0;
+  (void)(10 / i);
+}
+"""
+
+        src_nullptr_deref = """
+void b() {
+  int *i = 0;
+  *i = 5;
+}
+"""
+        self.__analyze_and_store(dir1, "run1", src_div_by_zero)
+        self.__analyze(dir2, src_nullptr_deref)
+
+        report_filter = ReportFilter()
+        report_filter.reviewStatus = []
+
+        def get_run_diff_count(diff_type: DiffType):
+            # Observe that the remote run is the baseline, and the local run
+            # is new.
+            reports, _, _ = get_diff_remote_run_local_dir(
+                    self._cc_client, report_filter, diff_type, [],
+                    ["run1"], [dir2], [])
+            return len(reports)
+
+        # b() is a new report.
+        self.assertEqual(get_run_diff_count(DiffType.NEW), 1)
+
+        # a() is the old report.
+        self.assertEqual(get_run_diff_count(DiffType.RESOLVED), 1)
+
+        # There are no common reports.
+        self.assertEqual(get_run_diff_count(DiffType.UNRESOLVED), 0)
+
+        def get_run_diff_count_reverse(diff_type: DiffType):
+            # Note how this isn't the same function!!
+            reports, _, _ = get_diff_local_dir_remote_run(
+                    self._cc_client, report_filter, diff_type, [],
+                    [dir2], [], ["run1"])
+            return len(reports)
+
+        # b() is a new report.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.NEW), 1)
+
+        # a() is the old report.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.RESOLVED), 1)
+
+        # There are no common reports.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.UNRESOLVED), 0)
+
+    def test_local_remote_identical(self):
+        # Create two identical runs, store one on the server, leave one
+        # locally.
+        dir1 = os.path.join(self.test_workspace, "dir1")
+        dir2 = os.path.join(self.test_workspace, "dir2")
+
+        src_div_by_zero = """
+void a() {
+  int i = 0;
+  (void)(10 / i);
+}
+"""
+        self.__analyze_and_store(dir1, "run1", src_div_by_zero)
+        self.__analyze(dir2, src_div_by_zero)
+
+        report_filter = ReportFilter()
+        report_filter.reviewStatus = []
+
+        def get_run_diff_count(diff_type: DiffType):
+            # Observe that the remote run is the baseline, and the local run
+            # is new.
+            reports, _, _ = get_diff_remote_run_local_dir(
+                    self._cc_client, report_filter, diff_type, [],
+                    ["run1"], [dir2], [])
+            return len(reports)
+
+        # b() is a new report.
+        self.assertEqual(get_run_diff_count(DiffType.NEW), 0)
+
+        # a() is the old report.
+        self.assertEqual(get_run_diff_count(DiffType.RESOLVED), 0)
+
+        # There are no common reports.
+        self.assertEqual(get_run_diff_count(DiffType.UNRESOLVED), 1)
+
+        def get_run_diff_count_reverse(diff_type: DiffType):
+            # Note how this isn't the same function!!
+            reports, _, _ = get_diff_local_dir_remote_run(
+                    self._cc_client, report_filter, diff_type, [],
+                    [dir2], [], ["run1"])
+            return len(reports)
+
+        # b() is a new report.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.NEW), 0)
+
+        # a() is the old report.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.RESOLVED), 0)
+
+        # There are no common reports.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.UNRESOLVED), 1)
+
+    def test_localFPAnnotated_remote_identical(self):
+        # Create two identical runs, store one on the server, leave one
+        # locally.
+        dir1 = os.path.join(self.test_workspace, "dir1")
+        dir2 = os.path.join(self.test_workspace, "dir2")
+
+        src_div_by_zero_FP = """
+void a() {
+  int i = 0;
+  // codechecker_false_positive [all] SUPPRESS ALL
+  (void)(10 / i);
+}
+"""
+        src_div_by_zero = """
+void a() {
+  int i = 0;
+  (void)(10 / i);
+}
+"""
+        self.__analyze(dir1, src_div_by_zero_FP)
+        self.__analyze_and_store(dir2, "run2", src_div_by_zero)
+
+        report_filter = ReportFilter()
+        report_filter.reviewStatus = []
+
+        def get_run_diff_count(diff_type: DiffType):
+            # Observe that the remote run is the baseline, and the local run
+            # is new.
+            reports, _, _ = get_diff_remote_run_local_dir(
+                    self._cc_client, report_filter, diff_type, [],
+                    ["run2"], [dir1], [])
+            return len(reports)
+
+        # b() is a new report.
+        self.assertEqual(get_run_diff_count(DiffType.NEW), 0)
+
+        # a() is the old report.
+        self.assertEqual(get_run_diff_count(DiffType.RESOLVED), 1)
+
+        # There are no common reports.
+        self.assertEqual(get_run_diff_count(DiffType.UNRESOLVED), 0)
+
+        def get_run_diff_count_reverse(diff_type: DiffType):
+            # Note how this isn't the same function!!
+            reports, _, _ = get_diff_local_dir_remote_run(
+                    self._cc_client, report_filter, diff_type, [],
+                    [dir1], [], ["run2"])
+            return len(reports)
+
+        # b() is a new report.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.NEW), 1)
+
+        # a() is the old report.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.RESOLVED), 0)
+
+        # There are no common reports.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.UNRESOLVED), 0)
+
+    def test_local_remoteFPAnnotated_identical(self):
+        # Create two identical runs, store one on the server with a FP source
+        # code suppression, leave one locally.
+        dir1 = os.path.join(self.test_workspace, "dir1")
+        dir2 = os.path.join(self.test_workspace, "dir2")
+
+        src_div_by_zero_FP = """
+void a() {
+  int i = 0;
+  // codechecker_false_positive [all] SUPPRESS ALL
+  (void)(10 / i);
+}
+"""
+        src_div_by_zero = """
+void a() {
+  int i = 0;
+  (void)(10 / i);
+}
+"""
+        self.__analyze(dir1, src_div_by_zero)
+        self.__analyze_and_store(dir2, "run2", src_div_by_zero_FP)
+
+        report_filter = ReportFilter()
+        report_filter.reviewStatus = []
+
+        def get_run_diff_count(diff_type: DiffType):
+            # Observe that the remote run is the baseline, and the local run
+            # is new.
+            reports, _, _ = get_diff_remote_run_local_dir(
+                    self._cc_client, report_filter, diff_type, [],
+                    ["run2"], [dir1], [])
+            return len(reports)
+
+        # b() is a new report.
+        self.assertEqual(get_run_diff_count(DiffType.NEW), 1)
+
+        # FIXME: This should be 0 -- the "before" set is suppressed, the
+        # "after" set is no longer, so it should only be in the NEW set.
+        # Not to mention that these sets must be disjointed.
+        self.assertEqual(get_run_diff_count(DiffType.RESOLVED), 1)
+
+        # There are no common reports.
+        self.assertEqual(get_run_diff_count(DiffType.UNRESOLVED), 0)
+
+        def get_run_diff_count_reverse(diff_type: DiffType):
+            # Note how this isn't the same function!!
+            reports, _, _ = get_diff_local_dir_remote_run(
+                    self._cc_client, report_filter, diff_type, [],
+                    [dir1], [], ["run2"])
+            return len(reports)
+
+        # FIXME: This should be 0 -- the "before" set is suppressed, the
+        # "after" set is no longer, so it should only be in the RESOLVED set.
+        # Not to mention that these sets must be disjointed.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.NEW), 1)
+
+        # a() is the old report.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.RESOLVED), 1)
+
+        # There are no common reports.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.UNRESOLVED), 0)
+
+    def test_local_remoteReviewStatusRule_identical(self):
+        """
+        Even though the local report is not marked as a false positive, we
+        expect the review status rule on the server to affect it.
+        Note that the remote run is the baseline, which suggests that the
+        review status rule is also a part of the baseline (it precedes the
+        local run), yet the rule still affects the local run.
+        This implies that review status rules are a timeless property -- once
+        a hash has a rule, all reports matching it before or after the rule
+        was made are affected. As a result, it should be in the UNRESOLVED set.
+        """
+        # Create two identical runs, store one on the server, leave one
+        # locally.
+        dir1 = os.path.join(self.test_workspace, "dir1")
+        dir2 = os.path.join(self.test_workspace, "dir2")
+        src_div_by_zero = """
+void a() {
+  int i = 0;
+  (void)(10 / i);
+}
+"""
+        self.__analyze_and_store(dir1, "run1", src_div_by_zero)
+
+        # Add a "false positive" review status rule on the stored report.
+        results = get_all_run_results(self._cc_client)
+        self.assertEqual(len(results), 1)
+        self._cc_client.addReviewStatusRule(
+                results[0].bugHash, ReviewStatus.FALSE_POSITIVE, "")
+
+        self.__analyze(dir2, src_div_by_zero)
+
+        def get_run_diff_count(diff_type: DiffType):
+            report_filter = ReportFilter()
+            # Observe that the remote run is the baseline, and the local run
+            # is new.
+            report_filter.reviewStatus = []
+            reports, _, _ = get_diff_remote_run_local_dir(
+                    self._cc_client, report_filter, diff_type, [],
+                    ["run1"], [dir2], [])
+            return len(reports)
+
+        self.assertEqual(get_run_diff_count(DiffType.NEW), 0)
+        # FIXME: This should be in the UNRESOLVED set.
+        self.assertEqual(get_run_diff_count(DiffType.RESOLVED), 1)
+        self.assertEqual(get_run_diff_count(DiffType.UNRESOLVED), 0)
+
+        def get_run_diff_count_reverse(diff_type: DiffType):
+            report_filter = ReportFilter()
+            report_filter.reviewStatus = []
+            # Note how this isn't the same function!!
+            reports, _, _ = get_diff_local_dir_remote_run(
+                    self._cc_client, report_filter, diff_type, [],
+                    [dir2], [], ["run1"])
+            return len(reports)
+
+        # FIXME: This should be in the UNRESOLVED set.
+        self.assertEqual(get_run_diff_count_reverse(DiffType.NEW), 1)
+        self.assertEqual(get_run_diff_count_reverse(DiffType.RESOLVED), 0)
+        self.assertEqual(get_run_diff_count_reverse(DiffType.UNRESOLVED), 0)
+
+    # TODO: source code suppression and review status rule conflict resolution
+    # TODO: diff against a tag on the server, not just a run
+
+    # ===-----------------------------------------------------------------=== #
+    # Remote-Remote tests.
+    # ===-----------------------------------------------------------------=== #
+
+    # TODO: remote-remote diffs not concerning tags
+
+    # ===--- Remote-Remote tests in between tags. ------------------------=== #
+
+    # TODO: remote-remote diffs concerning tags
+
+    def test_remote_remote_tag_FixedAtDate(self):
+        """
+        When a run disappears from one tag to the next, we regard it as fixed,
+        and set it fixed_at date. Test whether just because the fixed_at date
+        is set, we still regard it as an outstanding report if we diff it in
+        a context where the bug still isn't fixed yet.
+
+        You can read more about this bug here:
+        https://github.com/Ericsson/codechecker/pull/3853
+        """
+        # Diff two different, local runs.
+        dir1 = os.path.join(self.test_workspace, "dir1")
+        dir2 = os.path.join(self.test_workspace, "dir2")
+
+        src_div_by_zero = """
+void a() {
+  int i = 0;
+  (void)(10 / i);
+}
+"""
+
+        src_nullptr_deref = """
+void b() {
+  int *i = 0;
+  *i = 5;
+}
+"""
+        # Note that we're storing under the same run.
+        self.__analyze_and_store(dir1, "run1", src_div_by_zero, "tag1")
+        self.__analyze_and_store(dir2, "run1", src_nullptr_deref, "tag2")
+
+        report_filter = ReportFilter()
+        report_filter.reviewStatus = []
+        report_filter.detection_status = []
+
+        def get_run_diff_count(diff_type: DiffType):
+            reports, _, _ = get_diff_remote_runs(
+                    self._cc_client, report_filter, diff_type, [],
+                    ["run1:tag1"], ["run1:tag2"])
+            return len(reports)
+
+        self.assertEqual(get_run_diff_count(DiffType.NEW), 1)
+        self.assertEqual(get_run_diff_count(DiffType.RESOLVED), 0)
+        self.assertEqual(get_run_diff_count(DiffType.UNRESOLVED), 0)
+
+        # NOTE that we store the first report dir again. The report in tag2 is
+        # abscent, so its fixed_at date will be set. Still, the diff in between
+        # tag1 and tag2 shouldn't change.
+        self.__analyze_and_store(dir1, "run1", src_div_by_zero, "tag3")
+
+        # FIXME: This report should not have disappeared!
+        self.assertEqual(get_run_diff_count(DiffType.NEW), 0)
+        self.assertEqual(get_run_diff_count(DiffType.RESOLVED), 0)
+        self.assertEqual(get_run_diff_count(DiffType.UNRESOLVED), 1)