From 9a389a012fa78de851241490dbe5595f06ee56e2 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 19 Aug 2020 16:18:30 -0700
Subject: [PATCH 001/531] Add TestCase.load_archive()

---
 grizzly/common/storage.py      | 35 +++++++++++++++++++++++++++++++-
 grizzly/common/test_storage.py | 37 ++++++++++++++++++++++++++++++++++
 2 files changed, 71 insertions(+), 1 deletion(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 25e856f1..350a0f9e 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -8,7 +8,9 @@
 import json
 import os
 import shutil
-from tempfile import SpooledTemporaryFile
+from tempfile import mkdtemp, SpooledTemporaryFile
+from zipfile import BadZipfile, ZipFile
+from zlib import error as zlib_error
 
 from ..target import sanitizer_opts
 from .utils import grz_tmp
@@ -236,6 +238,37 @@ def dump(self, out_path, include_details=False):
             for meta_file in self._files.meta:
                 meta_file.dump(out_path)
 
+    @classmethod
+    def load_archive(cls, archive, working_path=None):
+        """Unpack and load TestCases from an archive.
+
+        Args:
+            archive (str): Path to archive file containing testcase data.
+            working_path (str): Location to unpack testcase data files.
+
+        Yields:
+            TestCase: A TestCase.
+        """
+        if archive.lower().endswith(".zip"):
+            unpacked = mkdtemp(prefix="test_unpack_", dir=working_path)
+            try:
+                with ZipFile(archive) as zip_fp:
+                    zip_fp.extractall(path=unpacked)
+            except (BadZipfile, zlib_error):
+                raise TestCaseLoadFailure("Testcase archive is corrupted")
+        else:
+            raise TestCaseLoadFailure("Unsupported archive type")
+        try:
+            for entry in os.listdir(unpacked):
+                tc_path = os.path.join(unpacked, entry)
+                if os.path.isdir(tc_path):
+                    try:
+                        yield cls.load_path(tc_path)
+                    except TestCaseLoadFailure:
+                        pass
+        finally:
+            shutil.rmtree(unpacked, ignore_errors=True)
+
     def load_environ(self, path, env_data):
         # sanity check environment variable data
         for name, value in env_data.items():
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 2bc35b35..f96883e8 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -7,6 +7,7 @@
 import json
 import re
 import os
+import zipfile
 
 import pytest
 
@@ -266,6 +267,42 @@ def test_testcase_11(tmp_path):
         with pytest.raises(TestFileExists, match="'file.bin' exists in test"):
             tcase.add_batch(str(include), [str(inc_1)])
 
+def test_testcase_12(tmp_path):
+    """test TestCase.load_archive()"""
+    # build archive containing multiple testcases
+    with TestCase("target.bin", None, "test-adapter") as src:
+        src.add_from_data("test", "target.bin")
+        src.dump(str(tmp_path / "src-0"), include_details=True)
+        src.dump(str(tmp_path / "src-1"), include_details=True)
+        src.dump(str(tmp_path / "src-2"), include_details=True)
+    (tmp_path / "log_dummy.txt").touch()
+    (tmp_path / "not_a_tc").mkdir()
+    (tmp_path / "not_a_tc" / "file.txt").touch()
+    archive = str(tmp_path / "testcase.zip")
+    with zipfile.ZipFile(archive, mode="w", compression=zipfile.ZIP_DEFLATED) as zfp:
+        for dir_name, _, dir_files in os.walk(str(tmp_path)):
+            arc_path = os.path.relpath(dir_name, str(tmp_path))
+            for file_name in dir_files:
+                zfp.write(
+                    os.path.join(dir_name, file_name),
+                    arcname=os.path.join(arc_path, file_name))
+    # load archive
+    tests = tuple(TestCase.load_archive(archive, working_path=str(tmp_path)))
+    try:
+        assert len(tests) == 3
+    finally:
+        for test in tests:
+            test.cleanup()
+    # load unsupported archive
+    with pytest.raises(TestCaseLoadFailure, match="Unsupported archive type"):
+        any(TestCase.load_archive("somefile.test"))
+    # load broken archive
+    archive = (tmp_path / "fake.zip")
+    archive.write_bytes(b"x")
+    with pytest.raises(TestCaseLoadFailure, match="Testcase archive is corrupted"):
+        any(TestCase.load_archive(str(archive)))
+
+
 def test_testfile_01():
     """test simple TestFile"""
     with TestFile("test_file.txt") as tfile:

From dda3f5ac061d6a867cbce9a9d72e25b8b8e168c7 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 19 Aug 2020 16:26:38 -0700
Subject: [PATCH 002/531] Add TestCase.timestamp

---
 grizzly/common/storage.py      | 15 ++++++++-------
 grizzly/common/test_storage.py |  3 +++
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 350a0f9e..da0aead0 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -9,6 +9,7 @@
 import os
 import shutil
 from tempfile import mkdtemp, SpooledTemporaryFile
+from time import time
 from zipfile import BadZipfile, ZipFile
 from zlib import error as zlib_error
 
@@ -35,15 +36,16 @@ class TestFileExists(Exception):
 class TestCase(object):
     __slots__ = (
         "adapter_name", "duration", "env_vars", "input_fname", "landing_page",
-        "redirect_page", "_existing_paths", "_files")
+        "redirect_page", "timestamp", "_existing_paths", "_files")
 
-    def __init__(self, landing_page, redirect_page, adapter_name, input_fname=None):
+    def __init__(self, landing_page, redirect_page, adapter_name, input_fname=None, timestamp=None):
         self.adapter_name = adapter_name
         self.duration = None
         self.env_vars = dict()  # environment variables
         self.input_fname = input_fname  # file that was used to create the test case
         self.landing_page = landing_page
         self.redirect_page = redirect_page
+        self.timestamp = time() if timestamp is None else timestamp
         self._existing_paths = list()  # file paths in use
         self._files = TestFileMap(
             meta=list(),  # environment files such as prefs.js, etc...
@@ -231,7 +233,8 @@ def dump(self, out_path, include_details=False):
                 "duration": self.duration,
                 "env": self.env_vars,
                 "input": os.path.basename(self.input_fname) if self.input_fname else None,
-                "target": self.landing_page}
+                "target": self.landing_page,
+                "timestamp": self.timestamp}
             with open(os.path.join(out_path, "test_info.json"), "w") as out_fp:
                 json.dump(info, out_fp, indent=2, sort_keys=True)
             # save meta files
@@ -316,16 +319,14 @@ def load_path(cls, path, full_scan=False, prefs=True):
             entry_point = os.path.basename(info["target"])
             if not os.path.isfile(os.path.join(path, entry_point)):
                 raise TestCaseLoadFailure("entry_point '%s' not found in '%s'" % (entry_point, path))
-            adapter = info.get("adapter", None)
             full_scan = True
         elif os.path.isfile(path):
-            adapter = None
+            info = dict()
             entry_point = os.path.basename(path)
             path = os.path.dirname(path)
-            info = None
         else:
             raise TestCaseLoadFailure("Cannot find %r" % (path,))
-        test = cls(None, None, adapter)
+        test = cls(None, None, info.get("adapter", None), timestamp=info.get("timestamp", 0))
         if full_scan:
             # load all files from directory as test
             for dpath, _, files in os.walk(path):
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index f96883e8..81315064 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -26,6 +26,7 @@ def test_testcase_01(tmp_path):
         assert tcase.duration is None
         assert tcase.data_size == 0
         assert tcase.input_fname is None
+        assert tcase.timestamp > 0
         assert not tcase.env_vars
         assert not tcase._existing_paths
         assert not tcase._files.meta
@@ -188,6 +189,7 @@ def test_testcase_08(tmp_path):
         assert "x.bin" in (x.file_name for x in dst._files.optional)
         assert os.path.join("nested", "x.bin") in (x.file_name for x in dst._files.optional)
         assert dst.env_vars["TEST_ENV_VAR"] == "100"
+        assert dst.timestamp > 0
 
 def test_testcase_09(tmp_path):
     """test TestCase.load_path() using a file"""
@@ -207,6 +209,7 @@ def test_testcase_09(tmp_path):
         assert "prefs.js" not in (x.file_name for x in tcase._files.meta)
         assert "target.bin" in (x.file_name for x in tcase._files.required)
         assert "optional.bin" not in (x.file_name for x in tcase._files.optional)
+        assert tcase.timestamp == 0
     # load full test case
     with TestCase.load_path(str(entry_point), full_scan=True, prefs=True) as tcase:
         assert tcase.landing_page == "target.bin"

From ac4d5f525b9557cfb201701e94e42c4a65d8a7fc Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 21 Aug 2020 16:01:55 -0400
Subject: [PATCH 003/531] Move argparse epilog to CommonArgs

---
 grizzly/args.py        | 6 +++---
 grizzly/reduce/args.py | 3 ---
 grizzly/replay/args.py | 3 ---
 3 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index d466e3e3..62c0d274 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -102,6 +102,9 @@ def __init__(self):
             "--tool",
             help="Override tool name used when reporting issues to FuzzManager")
 
+        self.parser.epilog = "For addition help check out the wiki:" \
+            " https://github.com/MozillaSecurity/grizzly/wiki"
+
     def parse_args(self, argv=None):
         args = self.parser.parse_args(argv)
         self.sanity_check(args)
@@ -193,9 +196,6 @@ def __init__(self):
             "--s3-fuzzmanager", action="store_true",
             help="Report large attachments (if any) to S3 and then the crash & S3 link to FuzzManager")
 
-        self.parser.epilog = "For addition help check out the wiki:" \
-            " https://github.com/MozillaSecurity/grizzly/wiki"
-
     def sanity_check(self, args):
         super(GrizzlyArgs, self).sanity_check(args)
 
diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 4f555cdb..2c25c3c8 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -64,9 +64,6 @@ def __init__(self):
             help="One or more strategies (space-separated). Available: %s (default: %s)"
             % (" ".join(sorted(strategies_by_name())), " ".join(ReductionJob.DEFAULT_STRATEGIES)))
 
-        self.parser.epilog = "For addition help check out the wiki:" \
-            " https://github.com/MozillaSecurity/grizzly/wiki"
-
     def sanity_check(self, args):
         super(ReducerArgs, self).sanity_check(args)
 
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index 36d8237d..a2a1f3e2 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -53,9 +53,6 @@ def __init__(self):
             "--include-test", action="store_true",
             help="Include the testcase when reporting results.")
 
-        self.parser.epilog = "For addition help check out the wiki:" \
-            " https://github.com/MozillaSecurity/grizzly/wiki"
-
     def sanity_check(self, args):
         super(ReplayArgs, self).sanity_check(args)
 

From df64c654603d7944b1acfc4b51bfda986aab926d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 20 Aug 2020 14:34:14 -0700
Subject: [PATCH 004/531] [replay] Add zip archive and multi-testcase support

---
 grizzly/common/storage.py      |  60 +++++--------
 grizzly/common/test_storage.py |  50 ++++-------
 grizzly/replay/args.py         |   5 +-
 grizzly/replay/replay.py       | 137 +++++++++++++++++++++-------
 grizzly/replay/test_main.py    |  23 +++++
 grizzly/replay/test_replay.py  | 159 ++++++++++++++++++++++++++++-----
 6 files changed, 306 insertions(+), 128 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index da0aead0..8bcc0998 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -8,10 +8,8 @@
 import json
 import os
 import shutil
-from tempfile import mkdtemp, SpooledTemporaryFile
+from tempfile import SpooledTemporaryFile
 from time import time
-from zipfile import BadZipfile, ZipFile
-from zlib import error as zlib_error
 
 from ..target import sanitizer_opts
 from .utils import grz_tmp
@@ -241,37 +239,6 @@ def dump(self, out_path, include_details=False):
             for meta_file in self._files.meta:
                 meta_file.dump(out_path)
 
-    @classmethod
-    def load_archive(cls, archive, working_path=None):
-        """Unpack and load TestCases from an archive.
-
-        Args:
-            archive (str): Path to archive file containing testcase data.
-            working_path (str): Location to unpack testcase data files.
-
-        Yields:
-            TestCase: A TestCase.
-        """
-        if archive.lower().endswith(".zip"):
-            unpacked = mkdtemp(prefix="test_unpack_", dir=working_path)
-            try:
-                with ZipFile(archive) as zip_fp:
-                    zip_fp.extractall(path=unpacked)
-            except (BadZipfile, zlib_error):
-                raise TestCaseLoadFailure("Testcase archive is corrupted")
-        else:
-            raise TestCaseLoadFailure("Unsupported archive type")
-        try:
-            for entry in os.listdir(unpacked):
-                tc_path = os.path.join(unpacked, entry)
-                if os.path.isdir(tc_path):
-                    try:
-                        yield cls.load_path(tc_path)
-                    except TestCaseLoadFailure:
-                        pass
-        finally:
-            shutil.rmtree(unpacked, ignore_errors=True)
-
     def load_environ(self, path, env_data):
         # sanity check environment variable data
         for name, value in env_data.items():
@@ -288,7 +255,7 @@ def load_environ(self, path, env_data):
                 self.env_vars[opt_key] = ":".join("=".join((k, v)) for k, v in opts.items())
 
     @classmethod
-    def load_path(cls, path, full_scan=False, prefs=True):
+    def load_path(cls, path, full_scan=False, load_prefs=True):
         """Load contents of a TestCase from disk. If `path` is a directory it must
         contain a valid test_info.json file.
 
@@ -299,7 +266,7 @@ def load_path(cls, path, full_scan=False, prefs=True):
                               subdirectories. This is always the case when
                               loading a directory.
                               WARNING: This should be used with caution!
-            prefs (bool): Include prefs.js file in the test case.
+            load_prefs (bool): Include prefs.js file in the test case.
 
         Returns:
             TestCase: A TestCase.
@@ -335,7 +302,7 @@ def load_path(cls, path, full_scan=False, prefs=True):
                         continue
                     if dpath == path:
                         if fname == "prefs.js":
-                            if prefs:
+                            if load_prefs:
                                 test.add_meta(TestFile.from_file(os.path.join(dpath, fname)))
                             continue
                         if fname == entry_point:
@@ -398,6 +365,25 @@ def purge_optional(self, keep):
         for idx in reversed(to_remove):
             self._files.optional.pop(idx).close()
 
+    @staticmethod
+    def scan_path(path):
+        """Check path and subdirectories for potential test cases.
+
+        Args:
+            path (str): Path to scan.
+
+        Yields:
+            str: Path to what appears to be a valid testcase.
+        """
+        contents = os.listdir(path)
+        if "test_info.json" in contents:
+            yield path
+        else:
+            for entry in contents:
+                tc_path = os.path.join(path, entry)
+                if os.path.isfile(os.path.join(tc_path, "test_info.json")):
+                    yield tc_path
+
 
 class TestFile(object):
     CACHE_LIMIT = 0x80000  # data cache limit per file: 512KB
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 81315064..e45913d5 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -7,7 +7,6 @@
 import json
 import re
 import os
-import zipfile
 
 import pytest
 
@@ -211,7 +210,7 @@ def test_testcase_09(tmp_path):
         assert "optional.bin" not in (x.file_name for x in tcase._files.optional)
         assert tcase.timestamp == 0
     # load full test case
-    with TestCase.load_path(str(entry_point), full_scan=True, prefs=True) as tcase:
+    with TestCase.load_path(str(entry_point), full_scan=True, load_prefs=True) as tcase:
         assert tcase.landing_page == "target.bin"
         assert "prefs.js" in (x.file_name for x in tcase._files.meta)
         assert "target.bin" in (x.file_name for x in tcase._files.required)
@@ -271,40 +270,21 @@ def test_testcase_11(tmp_path):
             tcase.add_batch(str(include), [str(inc_1)])
 
 def test_testcase_12(tmp_path):
-    """test TestCase.load_archive()"""
-    # build archive containing multiple testcases
+    """test TestCase.scan_path()"""
+    # empty path
+    (tmp_path / "not-test").mkdir()
+    assert not tuple(TestCase.scan_path(str(tmp_path)))
+    # multiple test case directories
+    paths = [str(tmp_path / ("test-%d" % i)) for i in range(3)]
     with TestCase("target.bin", None, "test-adapter") as src:
-        src.add_from_data("test", "target.bin")
-        src.dump(str(tmp_path / "src-0"), include_details=True)
-        src.dump(str(tmp_path / "src-1"), include_details=True)
-        src.dump(str(tmp_path / "src-2"), include_details=True)
-    (tmp_path / "log_dummy.txt").touch()
-    (tmp_path / "not_a_tc").mkdir()
-    (tmp_path / "not_a_tc" / "file.txt").touch()
-    archive = str(tmp_path / "testcase.zip")
-    with zipfile.ZipFile(archive, mode="w", compression=zipfile.ZIP_DEFLATED) as zfp:
-        for dir_name, _, dir_files in os.walk(str(tmp_path)):
-            arc_path = os.path.relpath(dir_name, str(tmp_path))
-            for file_name in dir_files:
-                zfp.write(
-                    os.path.join(dir_name, file_name),
-                    arcname=os.path.join(arc_path, file_name))
-    # load archive
-    tests = tuple(TestCase.load_archive(archive, working_path=str(tmp_path)))
-    try:
-        assert len(tests) == 3
-    finally:
-        for test in tests:
-            test.cleanup()
-    # load unsupported archive
-    with pytest.raises(TestCaseLoadFailure, match="Unsupported archive type"):
-        any(TestCase.load_archive("somefile.test"))
-    # load broken archive
-    archive = (tmp_path / "fake.zip")
-    archive.write_bytes(b"x")
-    with pytest.raises(TestCaseLoadFailure, match="Testcase archive is corrupted"):
-        any(TestCase.load_archive(str(archive)))
-
+        src.add_from_data("test", "test.htm")
+        for path in paths:
+            src.dump(path, include_details=True)
+    tc_paths = list(TestCase.scan_path(str(tmp_path)))
+    assert len(tc_paths) == 3
+    # single test case directory
+    tc_paths = list(TestCase.scan_path(str(paths[0])))
+    assert len(tc_paths) == 1
 
 def test_testfile_01():
     """test simple TestFile"""
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index a2a1f3e2..0cc88c6d 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -13,7 +13,10 @@ def __init__(self):
         super(ReplayArgs, self).__init__()
         self.parser.add_argument(
             "input",
-            help="Directory containing test case data or file to use as a test case." \
+            help="Accepted input includes: " \
+                "1) A directory containing testcase data. " \
+                "2) A file to use as a testcase. " \
+                "3) A zip archive containing testcases. " \
                 "When using a directory it must contain a 'test_info.json' file.")
 
         replay_args = self.parser.add_argument_group("Replay Arguments")
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 67cbefc1..e449a015 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -4,9 +4,12 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from logging import getLogger
-from os.path import dirname, join as pathjoin
+from os.path import dirname, isfile, join as pathjoin
+from shutil import copyfile, rmtree
 from tempfile import mkdtemp
 from time import sleep
+from zipfile import BadZipfile, ZipFile
+from zlib import error as zlib_error
 
 from FTB.Signatures.CrashInfo import CrashSignature
 from sapphire import Sapphire, ServerMap
@@ -28,21 +31,22 @@
 class ReplayManager(object):
     HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
 
-    __slots__ = ("ignore", "server", "status", "target", "testcase", "_any_crash",
+    __slots__ = ("ignore", "server", "status", "target", "testcases", "_any_crash",
                  "_harness", "_reports_expected", "_reports_other", "_runner",
                  "_signature")
 
-    def __init__(self, ignore, server, target, testcase, any_crash=False, signature=None, use_harness=True):
+    def __init__(self, ignore, server, target, testcases, any_crash=False, signature=None, use_harness=True):
         self.ignore = ignore
         self.server = server
         self.status = None
         self.target = target
-        self.testcase = testcase
+        self.testcases = testcases
         self._any_crash = any_crash
         self._harness = None
         self._reports_expected = dict()
         self._reports_other = dict()
         self._runner = Runner(self.server, self.target)
+        # TODO: make signature a property
         self._signature = signature
 
         if use_harness:
@@ -73,6 +77,55 @@ def cleanup(self):
         if self.status is not None:
             self.status.cleanup()
 
+    @staticmethod
+    def load_testcases(path, load_prefs):
+        """Load TestCases from disk.
+
+        Args:
+            path (str): Path to a file, directory or zip archive containing
+                        testcase data.
+            load_prefs (bool): Load prefs.js file if available.
+
+        Returns:
+            tuple: TestCases (list) and path to unpacked testcase data (str).
+        """
+        unpacked = None
+        try:
+            if path.lower().endswith(".zip"):
+                unpacked = mkdtemp(prefix="unpack_", dir=grz_tmp("replay"))
+                try:
+                    with ZipFile(path) as zip_fp:
+                        zip_fp.extractall(path=unpacked)
+                except (BadZipfile, zlib_error):
+                    raise TestCaseLoadFailure("Testcase archive is corrupted")
+                tc_paths = tuple(TestCase.scan_path(unpacked))
+                testcases = list()
+                for tc_path in tc_paths:
+                    try:
+                        testcases.append(TestCase.load_path(tc_path, load_prefs=load_prefs))
+                    except TestCaseLoadFailure:  # pragma: no cover
+                        pass
+                testcases.sort(key=lambda tc: tc.timestamp)
+                if load_prefs:
+                    # attempt to unpack prefs.js
+                    for tc_path in tc_paths:
+                        try:
+                            copyfile(
+                                pathjoin(tc_path, "prefs.js"),
+                                pathjoin(unpacked, "prefs.js"))
+                        except IOError:  # pragma: no cover
+                            continue
+                        break
+            else:
+                testcases = [TestCase.load_path(path, load_prefs=load_prefs)]
+            if not testcases:
+                raise TestCaseLoadFailure("Failed to load TestCases")
+        except TestCaseLoadFailure:
+            if unpacked is not None:
+                rmtree(unpacked, ignore_errors=True)
+            raise
+        return testcases, unpacked
+
     @property
     def other_reports(self):
         """Reports from results that do not match:
@@ -100,7 +153,7 @@ def reports(self):
         return self._reports_expected.values()
 
     @staticmethod
-    def report_to_filesystem(path, reports, other_reports=None, test=None):
+    def report_to_filesystem(path, reports, other_reports=None, tests=None):
         """Use FilesystemReporter to write reports and testcase to disk in a
         known location.
 
@@ -108,13 +161,11 @@ def report_to_filesystem(path, reports, other_reports=None, test=None):
             path (str): Location to write data.
             reports (iterable): Reports to output.
             other_reports (iterable): Reports to output.
-            test (TestCase): Testcase to output.
+            tests (iterable): Testcases to output.
 
         Returns:
             None
         """
-        assert test is None or isinstance(test, TestCase)
-        tests = [test] if test else tuple()
         if reports:
             reporter = FilesystemReporter(
                 report_path=pathjoin(path, "reports"),
@@ -154,10 +205,9 @@ def _dyn_close():  # pragma: no cover
                 return b"<h1>Close Browser</h1>"
             server_map.set_dynamic_response("grz_close_browser", _dyn_close, mime_type="text/html")
             server_map.set_dynamic_response("grz_harness", lambda: self._harness, mime_type="text/html")
-            server_map.set_redirect("grz_next_test", self.testcase.landing_page, required=True)
-        server_map.set_redirect("grz_current_test", self.testcase.landing_page, required=False)
 
         success = False
+        test_count = len(self.testcases)
         for _ in range(repeat):
             self.status.iteration += 1
             if self.target.closed:
@@ -170,10 +220,15 @@ def _dyn_close():  # pragma: no cover
                     location = self._runner.location(
                         "/grz_harness",
                         self.server.port,
-                        close_after=self.target.rl_reset,
+                        close_after=self.target.rl_reset * test_count,
                         forced_close=self.target.forced_close)
                 try:
-                    self._runner.launch(location, env_mod=self.testcase.env_vars)
+                    # The environment from the initial testcase is used because
+                    # a sequence of testcases is expected to be run without
+                    # relaunching the Target to match the functionality of
+                    # Grizzly. If this is not the case each TestCase should
+                    # be run individually.
+                    self._runner.launch(location, env_mod=self.testcases[0].env_vars)
                 except TargetLaunchError:
                     LOG.error("Target launch error. Check browser logs for details.")
                     log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
@@ -182,12 +237,20 @@ def _dyn_close():  # pragma: no cover
                     raise
             self.target.step()
             LOG.info("Performing replay (%d/%d)...", self.status.iteration, repeat)
-            # run test case
-            self._runner.run(
-                self.ignore,
-                server_map,
-                self.testcase,
-                wait_for_callback=self._harness is None)
+            # run test cases
+            for test_idx in range(test_count):
+                LOG.debug("running test: %d of %d", test_idx + 1, test_count)
+                if self._harness is not None:
+                    next_idx = (test_idx + 1) % test_count
+                    server_map.set_redirect("grz_next_test", self.testcases[next_idx].landing_page, required=True)
+                server_map.set_redirect("grz_current_test", self.testcases[test_idx].landing_page, required=False)
+                self._runner.run(
+                    self.ignore,
+                    server_map,
+                    self.testcases[test_idx],
+                    wait_for_callback=self._harness is None)
+                if self._runner.result != self._runner.COMPLETE:
+                    break
             # process results
             if self._runner.result == self._runner.FAILED:
                 log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
@@ -288,22 +351,26 @@ def main(cls, args):
         else:
             signature = None
 
+        LOG.debug("loading the TestCases")
         try:
-            LOG.debug("loading the TestCase")
-            testcase = TestCase.load_path(args.input, prefs=args.prefs is None)
-            # prioritize specified prefs.js file over included file
-            if args.prefs is not None:
-                prefs = args.prefs
-                testcase.add_meta(TestFile.from_file(args.prefs, "prefs.js"))
-                LOG.info("Using specified prefs.js")
-            elif testcase.contains("prefs.js"):
-                prefs = pathjoin(args.input, "prefs.js")
-                LOG.info("Using prefs.js from testcase")
-            else:
-                prefs = None
+            testcases, unpacked = cls.load_testcases(args.input, args.prefs is None)
         except TestCaseLoadFailure as exc:
             LOG.error("Error: %s", str(exc))
             return 1
+        # prioritize specified prefs.js file over included file
+        if args.prefs is not None:
+            prefs = args.prefs
+            for testcase in testcases:
+                testcase.add_meta(TestFile.from_file(args.prefs, "prefs.js"))
+            LOG.info("Using specified prefs.js")
+        elif unpacked and isfile(pathjoin(unpacked, "prefs.js")):
+            prefs = pathjoin(unpacked, "prefs.js")
+            LOG.info("Using prefs.js from testcase")
+        elif isfile(pathjoin(args.input, "prefs.js")):
+            prefs = pathjoin(args.input, "prefs.js")
+            LOG.info("Using prefs.js from testcase")
+        else:
+            prefs = None
 
         replay = None
         target = None
@@ -322,7 +389,7 @@ def main(cls, args):
                 xvfb=args.xvfb)
             if prefs is not None:
                 target.prefs = prefs
-            if testcase.env_vars.get("GRZ_FORCED_CLOSE") == "0":
+            if testcases[0].env_vars.get("GRZ_FORCED_CLOSE") == "0":
                 LOG.debug("setting target.forced_close=False")
                 target.forced_close = False
 
@@ -340,7 +407,7 @@ def main(cls, args):
                     args.ignore,
                     server,
                     target,
-                    testcase,
+                    testcases,
                     any_crash=args.any_crash,
                     signature=signature,
                     use_harness=not args.no_harness)
@@ -350,7 +417,7 @@ def main(cls, args):
                     args.logs,
                     replay.reports,
                     replay.other_reports,
-                    replay.testcase if args.include_test else None)
+                    replay.testcases if args.include_test else None)
             # TODO: add fuzzmanager reporting
             return 0 if success else 1
 
@@ -371,6 +438,8 @@ def main(cls, args):
                 replay.cleanup()
             if target is not None:
                 target.cleanup()
-            if testcase is not None:
+            for testcase in testcases:
                 testcase.cleanup()
+            if unpacked is not None:
+                rmtree(unpacked, ignore_errors=True)
             LOG.info("Done.")
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index cb764c12..32a79900 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -262,3 +262,26 @@ def _fake_save_logs(result_logs):
     assert log_path.is_dir()
     prefs = tuple(log_path.glob('**/prefs.js'))
     assert prefs[0].read_bytes() == b"specified"
+
+def test_main_05(mocker, tmp_path):
+    """test ReplayManager.main() - unpacked test case - prefs and cleanup """
+    unpacked = (tmp_path / "unpacked")
+    unpacked.mkdir()
+    # prefs.js from unpacked path
+    (unpacked / "prefs.js").touch()
+    fake_load_testcases = mocker.patch("grizzly.replay.replay.ReplayManager.load_testcases")
+    fake_load_testcases.return_value = ([mocker.Mock(env_vars=dict())], str(unpacked))
+    mocker.patch("grizzly.replay.replay.ReplayManager.run")
+    mocker.patch("grizzly.replay.replay.load_target")
+    mocker.patch("grizzly.replay.replay.Sapphire")
+    args = mocker.Mock(
+        fuzzmanager=False,
+        ignore=None,
+        min_crashes=1,
+        relaunch=1,
+        repeat=1,
+        prefs=None,
+        sig=None,
+        timeout=1)
+    assert ReplayManager.main(args) == 0
+    assert not unpacked.is_dir()
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 79a496f8..5abc8f78 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -6,12 +6,14 @@
 """
 unit tests for grizzly.replay
 """
-from os.path import join as pathjoin
+from os import walk
+from os.path import isfile, join as pathjoin, relpath
+from zipfile import ZIP_DEFLATED, ZipFile
 
 from pytest import raises
 
 from sapphire import Sapphire, SERVED_ALL, SERVED_REQUEST
-from .replay import ReplayManager
+from .replay import ReplayManager, TestCaseLoadFailure
 from ..common import Report, Status, TestCase
 from ..target import Target, TargetLaunchError
 
@@ -30,7 +32,7 @@ def _fake_save_logs_result(result_logs, meta=False):  # pylint: disable=unused-a
 
 def test_replay_01(mocker):
     """test ReplayManager.cleanup()"""
-    replay = ReplayManager([], mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target), mocker.Mock())
+    replay = ReplayManager([], mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target), [mocker.Mock()])
     replay._reports_expected = {"A":  mocker.Mock(spec=Report)}
     replay._reports_other = {"B":  mocker.Mock(spec=Report)}
     replay.status = mocker.Mock(spec=Status)
@@ -51,8 +53,8 @@ def test_replay_02(mocker):
     target.detect_failure.return_value = Target.RESULT_NONE
     target.forced_close = True
     target.rl_reset = 1
-    testcase = mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")
-    with ReplayManager([], server, target, testcase, use_harness=True) as replay:
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    with ReplayManager([], server, target, testcases, use_harness=True) as replay:
         assert not replay.run()
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
@@ -68,8 +70,8 @@ def test_replay_03(mocker):
     target.binary = "C:\\fake_bin"
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.save_logs = _fake_save_logs_result
-    testcase = mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")
-    with ReplayManager([], server, target, testcase, use_harness=False) as replay:
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    with ReplayManager([], server, target, testcases, use_harness=False) as replay:
         assert replay.run()
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
@@ -84,8 +86,8 @@ def test_replay_04(mocker):
     target = mocker.Mock(spec=Target)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
-    testcase = mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")
-    with ReplayManager([], server, target, testcase, use_harness=False) as replay:
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    with ReplayManager([], server, target, testcases, use_harness=False) as replay:
         assert not replay.run(repeat=2)
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
@@ -101,8 +103,8 @@ def test_replay_05(mocker):
     target = mocker.Mock(spec=Target)
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = Target.RESULT_IGNORED
-    testcase = mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")
-    with ReplayManager([], server, target, testcase, use_harness=False) as replay:
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    with ReplayManager([], server, target, testcases, use_harness=False) as replay:
         assert not replay.run()
         assert replay.status.ignored == 1
         assert replay.status.iteration == 1
@@ -120,10 +122,10 @@ def test_replay_06(mocker):
     target.RESULT_NONE = Target.RESULT_NONE
     target.binary = "path/fake_bin"
     target.save_logs = _fake_save_logs_result
-    testcase = mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
     # early failure
     target.detect_failure.side_effect = [Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_NONE]
-    with ReplayManager([], server, target, testcase, use_harness=False) as replay:
+    with ReplayManager([], server, target, testcases, use_harness=False) as replay:
         assert not replay.run(repeat=4, min_results=3)
         assert replay.status.iteration == 3
         assert replay.status.results == 1
@@ -131,7 +133,7 @@ def test_replay_06(mocker):
         assert len(replay.reports) == 1
     # early success
     target.detect_failure.side_effect = [Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_FAILURE]
-    with ReplayManager([], server, target, testcase, use_harness=False) as replay:
+    with ReplayManager([], server, target, testcases, use_harness=False) as replay:
         assert replay.run(repeat=4, min_results=2)
         assert replay.status.iteration == 3
         assert replay.status.results == 2
@@ -164,8 +166,8 @@ def test_replay_07(mocker, tmp_path):
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.binary = "fake_bin"
-    testcase = mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")
-    with ReplayManager([], server, target, testcase, signature=signature, use_harness=False) as replay:
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    with ReplayManager([], server, target, testcases, signature=signature, use_harness=False) as replay:
         assert not replay.run(repeat=3, min_results=2)
         assert replay._signature == signature
         assert report.from_path.call_count == 3
@@ -202,8 +204,8 @@ def test_replay_08(mocker, tmp_path):
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.binary = "fake_bin"
-    testcase = mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")
-    with ReplayManager([], server, target, testcase, any_crash=True, use_harness=False) as replay:
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    with ReplayManager([], server, target, testcases, any_crash=True, use_harness=False) as replay:
         assert replay.run(repeat=3, min_results=2)
         assert replay._signature is None
         assert report.from_path.call_count == 3
@@ -240,7 +242,7 @@ def test_replay_09(mocker, tmp_path):
     reports_other[-1].path = str(tmp_path / "report_other2")
     test = mocker.Mock(spec=TestCase)
     path = tmp_path / "dest"
-    ReplayManager.report_to_filesystem(str(path), reports_expected, reports_other, test=test)
+    ReplayManager.report_to_filesystem(str(path), reports_expected, reports_other, tests=[test])
     assert test.dump.call_count == 3  # called once per report
     assert not (tmp_path / "report_expected").is_dir()
     assert not (tmp_path / "report_other1").is_dir()
@@ -260,10 +262,125 @@ def test_replay_10(mocker, tmp_path):
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     target = mocker.Mock(spec=Target)
     target.launch.side_effect = TargetLaunchError
-    testcase = mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")
-    with ReplayManager([], server, target, testcase, use_harness=False) as replay:
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    with ReplayManager([], server, target, testcases, use_harness=False) as replay:
         with raises(TargetLaunchError):
             replay.run()
         assert not any(replay.reports)
         assert any(replay.other_reports)
         assert "STARTUP" in replay._reports_other
+
+def test_replay_11(mocker):
+    """test ReplayManager.run() - multiple TestCases - no repro"""
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server.serve_testcase.return_value = (SERVED_ALL, ["index.html"])
+    target = mocker.Mock(spec=Target)
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.closed = True
+    target.detect_failure.return_value = Target.RESULT_NONE
+    target.forced_close = True
+    target.rl_reset = 1
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html"),
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html"),
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    with ReplayManager([], server, target, testcases, use_harness=True) as replay:
+        assert not replay.run()
+        assert replay.status.ignored == 0
+        assert replay.status.iteration == 1
+        assert replay.status.results == 0
+        assert not replay.reports
+
+def test_replay_12(mocker):
+    """test ReplayManager.run() - multiple TestCases - successful repro"""
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server.serve_testcase.return_value = (SERVED_ALL, ["index.html"])
+    target = mocker.Mock(spec=Target, binary="fake_bin", rl_reset=1)
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.detect_failure.side_effect = (
+        Target.RESULT_NONE,
+        Target.RESULT_NONE,
+        Target.RESULT_FAILURE)
+    target.save_logs = _fake_save_logs_result
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html"),
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html"),
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    with ReplayManager([], server, target, testcases, use_harness=True) as replay:
+        assert replay.run()
+        assert replay.status.ignored == 0
+        assert replay.status.iteration == 1
+        assert replay.status.results == 1
+        assert len(replay.reports) == 1
+        assert not replay.other_reports
+
+def test_replay_13(tmp_path):
+    """test ReplayManager.load_testcases() - error cases"""
+    # test missing
+    with raises(TestCaseLoadFailure, match="Cannot find"):
+        ReplayManager.load_testcases("missing", False)
+    # test empty path
+    with raises(TestCaseLoadFailure, match="Missing 'test_info.json'"):
+        ReplayManager.load_testcases(str(tmp_path), False)
+    # test broken archive
+    archive = (tmp_path / "fake.zip")
+    archive.write_bytes(b"x")
+    with raises(TestCaseLoadFailure, match="Testcase archive is corrupted"):
+        ReplayManager.load_testcases(str(archive), False)
+
+def test_replay_14(tmp_path):
+    """test ReplayManager.load_testcases() - single file"""
+    tfile = (tmp_path / "testcase.html")
+    tfile.touch()
+    testcases, unpacked = ReplayManager.load_testcases(str(tfile), False)
+    try:
+        assert unpacked is None
+        assert len(tuple(testcases)) == 1
+    finally:
+        map(lambda x: x.cleanup, testcases)
+
+def test_replay_15(tmp_path):
+    """test ReplayManager.load_testcases() - single directory"""
+    with TestCase("target.bin", None, "test-adapter") as src:
+        src.add_from_data("test", "target.bin")
+        src.dump(str(tmp_path), include_details=True)
+    testcases, unpacked = ReplayManager.load_testcases(str(tmp_path), False)
+    try:
+        assert unpacked is None
+        assert len(tuple(testcases)) == 1
+    finally:
+        map(lambda x: x.cleanup, testcases)
+
+def test_replay_16(tmp_path):
+    """test ReplayManager.load_testcases() - archive"""
+    # build archive containing multiple testcases
+    with TestCase("target.bin", None, "test-adapter") as src:
+        src.add_from_data("test", "target.bin")
+        src.dump(str(tmp_path / "src-0"), include_details=True)
+        src.dump(str(tmp_path / "src-1"), include_details=True)
+        src.dump(str(tmp_path / "src-2"), include_details=True)
+    (tmp_path / "src-1" / "prefs.js").write_bytes(b"fake_prefs")
+    (tmp_path / "log_dummy.txt").touch()
+    (tmp_path / "not_a_tc").mkdir()
+    (tmp_path / "not_a_tc" / "file.txt").touch()
+    archive = str(tmp_path / "testcase.zip")
+    with ZipFile(archive, mode="w", compression=ZIP_DEFLATED) as zfp:
+        for dir_name, _, dir_files in walk(str(tmp_path)):
+            arc_path = relpath(dir_name, str(tmp_path))
+            for file_name in dir_files:
+                zfp.write(
+                    pathjoin(dir_name, file_name),
+                    arcname=pathjoin(arc_path, file_name))
+    testcases, unpacked = ReplayManager.load_testcases(str(archive), True)
+    try:
+        assert unpacked is not None
+        assert isfile(pathjoin(unpacked, "prefs.js"))
+        assert len(tuple(testcases)) == 3
+    finally:
+        map(lambda x: x.cleanup, testcases)
+    # empty archive
+    with ZipFile(archive, mode="w", compression=ZIP_DEFLATED) as zfp:
+        zfp.write(str(tmp_path / "not_a_tc"), arcname="not_a_tc")
+    with raises(TestCaseLoadFailure, match="Failed to load TestCases"):
+        ReplayManager.load_testcases(str(archive), True)

From e821fce280fe712026940d6f7deadd0f3ccac532 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 21 Aug 2020 19:50:00 -0700
Subject: [PATCH 005/531] Refactor TestCase loading

* Move zip archive handling to storage.py
* Add support for directories containing multiple testcases
---
 grizzly/common/storage.py      | 148 ++++++++++++++++++++++-----------
 grizzly/common/test_storage.py | 124 ++++++++++++++++++++++-----
 grizzly/replay/args.py         |  11 +--
 grizzly/replay/replay.py       |  96 +++++----------------
 grizzly/replay/test_main.py    |  82 ++++++------------
 grizzly/replay/test_replay.py  |  76 +----------------
 6 files changed, 256 insertions(+), 281 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 8bcc0998..239dec32 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -8,8 +8,10 @@
 import json
 import os
 import shutil
-from tempfile import SpooledTemporaryFile
+from tempfile import mkdtemp, SpooledTemporaryFile
 from time import time
+from zipfile import BadZipfile, ZipFile
+from zlib import error as zlib_error
 
 from ..target import sanitizer_opts
 from .utils import grz_tmp
@@ -239,6 +241,67 @@ def dump(self, out_path, include_details=False):
             for meta_file in self._files.meta:
                 meta_file.dump(out_path)
 
+    def get_file(self, file_name):
+        """Look up and return the TestFile with the specified file name.
+
+        Args:
+            file_name (str): Name of file to retrieve.
+
+        Returns:
+            TestFile: TestFile with matching file name otherwise None.
+        """
+        for tfile in chain(self._files.meta, self._files.optional, self._files.required):
+            if tfile.file_name == file_name:
+                return tfile
+        return None
+
+    @classmethod
+    def load(cls, path, load_prefs, adjacent=False):
+        """Load TestCases from disk.
+
+        Args:
+            path (str): Path can be:
+                        1) A directory containing `test_info.json` and data.
+                        2) A directory with one or more subdirectories of 1.
+                        3) A zip archive containing testcase data or
+                           subdirectories containing testcase data.
+                        4) A single file to be used as a test case.
+            load_prefs (bool): Load prefs.js file if available.
+            adjacent (str): Load adjacent files as part of the test case.
+                            This is always the case when loading a directory.
+                            WARNING: This should be used with caution!
+
+        Returns:
+            list: TestCases successfully loaded from path.
+        """
+        # unpack archive if needed
+        if path.lower().endswith(".zip"):
+            unpacked = mkdtemp(prefix="unpack_", dir=grz_tmp("storage"))
+            try:
+                with ZipFile(path) as zip_fp:
+                    zip_fp.extractall(path=unpacked)
+            except (BadZipfile, zlib_error):
+                shutil.rmtree(unpacked, ignore_errors=True)
+                raise TestCaseLoadFailure("Testcase archive is corrupted")
+            path = unpacked
+        else:
+            unpacked = None
+        # load testcase data from disk
+        try:
+            if os.path.isfile(path):
+                tests = [cls.load_single(path, load_prefs, adjacent=adjacent)]
+            elif os.path.isdir(path):
+                tests = list()
+                for tc_path in TestCase.scan_path(path):
+                    tests.append(cls.load_single(tc_path, load_prefs))
+                tests.sort(key=lambda tc: tc.timestamp)
+            else:
+                raise TestCaseLoadFailure("Invalid TestCase path")
+        finally:
+            if unpacked is not None:
+                shutil.rmtree(unpacked, ignore_errors=True)
+        return tests
+
     def load_environ(self, path, env_data):
         # sanity check environment variable data
         for name, value in env_data.items():
@@ -255,25 +318,23 @@ def load_environ(self, path, env_data):
                 self.env_vars[opt_key] = ":".join("=".join((k, v)) for k, v in opts.items())
 
     @classmethod
-    def load_path(cls, path, full_scan=False, load_prefs=True):
+    def load_single(cls, path, load_prefs, adjacent=False):
         """Load contents of a TestCase from disk. If `path` is a directory it must
-        contain a valid test_info.json file.
+        contain a valid 'test_info.json' file.
 
         Args:
             path (str): Path to the directory or file to load.
-            full_scan (bool): Include all files in the directory containing the
-                              test case entry point as well as the contents of
-                              subdirectories. This is always the case when
-                              loading a directory.
-                              WARNING: This should be used with caution!
-            load_prefs (bool): Include prefs.js file in the test case.
+            load_prefs (bool): Load prefs.js file if available.
+            adjacent (str): Load adjacent files as part of the test case.
+                            This is always the case when loading a directory.
+                            WARNING: This should be used with caution!
 
         Returns:
             TestCase: A TestCase.
         """
         path = os.path.abspath(path)
         if os.path.isdir(path):
-            # load a directory using test_info.json
+            # load using test_info.json
             try:
                 with open(os.path.join(path, "test_info.json"), "r") as in_fp:
                     info = json.load(in_fp)
@@ -281,51 +342,25 @@ def load_path(cls, path, full_scan=False, load_prefs=True):
                 raise TestCaseLoadFailure("Missing 'test_info.json'")
             except ValueError:
                 raise TestCaseLoadFailure("Invalid 'test_info.json'")
-            if "target" not in info:
-                raise TestCaseLoadFailure("'test_info.json' missing 'target' entry")
+            if not isinstance(info.get("target"), str):
+                raise TestCaseLoadFailure("'test_info.json' has invalid 'target' entry")
             entry_point = os.path.basename(info["target"])
             if not os.path.isfile(os.path.join(path, entry_point)):
-                raise TestCaseLoadFailure("entry_point '%s' not found in '%s'" % (entry_point, path))
-            full_scan = True
+                raise TestCaseLoadFailure("Entry point %r not found in '%s'" % (entry_point, path))
+            # always load all contents of a directory if a 'test_info.json' is loaded
+            adjacent = True
         elif os.path.isfile(path):
-            info = dict()
             entry_point = os.path.basename(path)
+            info = dict()
             path = os.path.dirname(path)
         else:
-            raise TestCaseLoadFailure("Cannot find %r" % (path,))
+            raise TestCaseLoadFailure("Missing or invalid TestCase %r" % (path,))
+        # create testcase and add data
         test = cls(None, None, info.get("adapter", None), timestamp=info.get("timestamp", 0))
-        if full_scan:
-            # load all files from directory as test
-            for dpath, _, files in os.walk(path):
-                for fname in files:
-                    if fname == "test_info.json":
-                        continue
-                    if dpath == path:
-                        if fname == "prefs.js":
-                            if load_prefs:
-                                test.add_meta(TestFile.from_file(os.path.join(dpath, fname)))
-                            continue
-                        if fname == entry_point:
-                            test.add_from_file(os.path.join(dpath, fname))
-                            # set entry point
-                            test.landing_page = fname
-                            continue
-                        location = None
-                    else:
-                        # handle nested directories
-                        location = "/".join((dpath.split(path, 1)[-1], fname))
-                    test.add_from_file(
-                        os.path.join(dpath, fname),
-                        file_name=location,
-                        required=False)
-        else:
-            # load single file as test
-            test.add_from_file(os.path.join(path, entry_point))
-            test.landing_page = entry_point
-        if test.landing_page is None:  # pragma: no cover
-            # this should not be possible
-            test.cleanup()
-            raise AssertionError("Scanning for test case 'entry point' failed")
+        if load_prefs and os.path.isfile(os.path.join(path, "prefs.js")):
+            test.add_meta(TestFile.from_file(os.path.join(path, "prefs.js")))
+        test.add_from_file(os.path.join(path, entry_point))
+        test.landing_page = entry_point
         # load environment variables
         if info:
             try:
@@ -333,6 +368,18 @@ def load_path(cls, path, full_scan=False, load_prefs=True):
             except TestCaseLoadFailure:
                 test.cleanup()
                 raise
+        # load all adjacent data from directory
+        if adjacent:
+            for dpath, _, files in os.walk(path):
+                for fname in files:
+                    # ignore files that have been previously loaded
+                    if fname in (entry_point, "prefs.js", "test_info.json"):
+                        continue
+                    location = "/".join((dpath.split(path, 1)[-1], fname))
+                    test.add_from_file(
+                        os.path.join(dpath, fname),
+                        file_name=location,
+                        required=False)
         return test
 
     @property
@@ -407,7 +454,10 @@ def __init__(self, file_name):
                 or file_name.startswith("../"):
             raise TypeError("file_name is invalid %r" % (file_name,))
         self._file_name = os.path.normpath(file_name)  # name including path relative to wwwroot
-        self._fp = SpooledTemporaryFile(max_size=self.CACHE_LIMIT, dir=grz_tmp(), prefix="grz_tf_")
+        self._fp = SpooledTemporaryFile(
+            dir=grz_tmp("storage"),
+            max_size=self.CACHE_LIMIT,
+            prefix="testfile_")
 
     def __enter__(self):
         return self
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index e45913d5..983673b0 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -7,6 +7,7 @@
 import json
 import re
 import os
+import zipfile
 
 import pytest
 
@@ -127,18 +128,18 @@ def test_testcase_06():
         assert tcase.data_size == 6
 
 def test_testcase_07(tmp_path):
-    """test TestCase.load_path() using a directory fail cases"""
+    """test TestCase.load_single() using a directory fail cases"""
     # missing test_info.json
     with pytest.raises(TestCaseLoadFailure, match="Missing 'test_info.json'"):
-        TestCase.load_path(str(tmp_path))
+        TestCase.load_single(str(tmp_path), True)
     # invalid test_info.json
     (tmp_path / "test_info.json").write_bytes(b"X")
     with pytest.raises(TestCaseLoadFailure, match="Invalid 'test_info.json'"):
-        TestCase.load_path(str(tmp_path))
+        TestCase.load_single(str(tmp_path), True)
     # test_info.json missing 'target' entry
     (tmp_path / "test_info.json").write_bytes(b"{}")
-    with pytest.raises(TestCaseLoadFailure, match="'test_info.json' missing 'target' entry"):
-        TestCase.load_path(str(tmp_path))
+    with pytest.raises(TestCaseLoadFailure, match="'test_info.json' has invalid 'target' entry"):
+        TestCase.load_single(str(tmp_path), True)
     # build a test case
     src_dir = (tmp_path / "src")
     src_dir.mkdir()
@@ -148,20 +149,20 @@ def test_testcase_07(tmp_path):
     with TestCase("target.bin", None, "test-adapter") as src:
         src.add_from_file(str(entry_point))
         src.dump(str(src_dir), include_details=True)
-    # bad test_info.json 'target' entry
+    # bad 'target' entry in test_info.json
     entry_point.unlink()
-    with pytest.raises(TestCaseLoadFailure, match="entry_point 'target.bin' not found in"):
-        TestCase.load_path(str(src_dir))
-    # bad test_info.json 'env' entry
+    with pytest.raises(TestCaseLoadFailure, match="Entry point 'target.bin' not found in"):
+        TestCase.load_single(str(src_dir), True)
+    # bad 'env' entry in test_info.json
     entry_point.touch()
     with TestCase("target.bin", None, "test-adapter") as src:
         src.add_environ_var("TEST_ENV_VAR", 100)
         src.dump(str(src_dir), include_details=True)
     with pytest.raises(TestCaseLoadFailure, match="'env_data' contains invalid 'env' entries"):
-        TestCase.load_path(str(src_dir))
+        TestCase.load_single(str(src_dir), True)
 
 def test_testcase_08(tmp_path):
-    """test TestCase.load_path() using a directory"""
+    """test TestCase.load_single() using a directory"""
     # build a valid test case
     src_dir = (tmp_path / "src")
     src_dir.mkdir()
@@ -180,7 +181,7 @@ def test_testcase_08(tmp_path):
         src.add_from_file(str(entry_point))
         src.dump(str(src_dir), include_details=True)
     # load test case from test_info.json
-    with TestCase.load_path(str(src_dir)) as dst:
+    with TestCase.load_single(str(src_dir), True) as dst:
         assert dst.landing_page == "target.bin"
         assert "prefs.js" in (x.file_name for x in dst._files.meta)
         assert "target.bin" in (x.file_name for x in dst._files.required)
@@ -191,10 +192,10 @@ def test_testcase_08(tmp_path):
         assert dst.timestamp > 0
 
 def test_testcase_09(tmp_path):
-    """test TestCase.load_path() using a file"""
+    """test TestCase.load_single() using a file"""
     # invalid entry_point specified
-    with pytest.raises(TestCaseLoadFailure, match="Cannot find"):
-        TestCase.load_path(str(tmp_path / "missing_file"))
+    with pytest.raises(TestCaseLoadFailure, match="Missing or invalid TestCase"):
+        TestCase.load_single(str(tmp_path / "missing_file"), False)
     # valid test case
     src_dir = (tmp_path / "src")
     src_dir.mkdir()
@@ -203,20 +204,96 @@ def test_testcase_09(tmp_path):
     entry_point.touch()
     (src_dir / "optional.bin").touch()
     # load single file test case
-    with TestCase.load_path(str(entry_point)) as tcase:
+    with TestCase.load_single(str(entry_point), False) as tcase:
         assert tcase.landing_page == "target.bin"
         assert "prefs.js" not in (x.file_name for x in tcase._files.meta)
         assert "target.bin" in (x.file_name for x in tcase._files.required)
         assert "optional.bin" not in (x.file_name for x in tcase._files.optional)
         assert tcase.timestamp == 0
     # load full test case
-    with TestCase.load_path(str(entry_point), full_scan=True, load_prefs=True) as tcase:
+    with TestCase.load_single(str(entry_point), True, adjacent=True) as tcase:
         assert tcase.landing_page == "target.bin"
         assert "prefs.js" in (x.file_name for x in tcase._files.meta)
         assert "target.bin" in (x.file_name for x in tcase._files.required)
         assert "optional.bin" in (x.file_name for x in tcase._files.optional)
 
 def test_testcase_10(tmp_path):
+    """test TestCase.load() - missing file and empty directory"""
+    # missing file
+    with pytest.raises(TestCaseLoadFailure, match="Invalid TestCase path"):
+        TestCase.load("missing", False)
+    # empty path
+    assert not TestCase.load(str(tmp_path), True)
+
+def test_testcase_11(tmp_path):
+    """test TestCase.load() - single file"""
+    tfile = (tmp_path / "testcase.html")
+    tfile.touch()
+    testcases = TestCase.load(str(tfile), False)
+    try:
+        assert len(testcases) == 1
+    finally:
+        map(lambda x: x.cleanup, testcases)
+
+def test_testcase_12(tmp_path):
+    """test TestCase.load() - single directory"""
+    with TestCase("target.bin", None, "test-adapter") as src:
+        src.add_from_data("test", "target.bin")
+        src.dump(str(tmp_path), include_details=True)
+    testcases = TestCase.load(str(tmp_path), False)
+    try:
+        assert len(testcases) == 1
+    finally:
+        map(lambda x: x.cleanup, testcases)
+
+def test_testcase_13(tmp_path):
+    """test TestCase.load() - multiple directories"""
+    nested = (tmp_path / "nested")
+    nested.mkdir()
+    with TestCase("target.bin", None, "test-adapter") as src:
+        src.add_from_data("test", "target.bin")
+        src.dump(str(nested / "test-1"), include_details=True)
+        src.dump(str(nested / "test-2"), include_details=True)
+        src.dump(str(nested / "test-3"), include_details=True)
+    testcases = TestCase.load(str(nested), False)
+    try:
+        assert len(testcases) == 3
+    finally:
+        map(lambda x: x.cleanup, testcases)
+    # try loading testcases that are nested too deep
+    assert not TestCase.load(str(tmp_path), False)
+
+def test_testcase_14(tmp_path):
+    """test TestCase.load() - archive"""
+    archive = tmp_path / "testcase.zip"
+    # bad archive
+    archive.write_bytes(b"x")
+    with pytest.raises(TestCaseLoadFailure, match="Testcase archive is corrupted"):
+        TestCase.load(str(archive), True)
+    # build archive containing multiple testcases
+    with TestCase("target.bin", None, "test-adapter") as src:
+        src.add_from_data("test", "target.bin")
+        src.dump(str(tmp_path / "test-0"), include_details=True)
+        src.dump(str(tmp_path / "test-1"), include_details=True)
+        src.dump(str(tmp_path / "test-2"), include_details=True)
+    (tmp_path / "test-1" / "prefs.js").write_bytes(b"fake_prefs")
+    (tmp_path / "log_dummy.txt").touch()
+    (tmp_path / "not_a_tc").mkdir()
+    (tmp_path / "not_a_tc" / "file.txt").touch()
+    with zipfile.ZipFile(str(archive), mode="w", compression=zipfile.ZIP_DEFLATED) as zfp:
+        for dir_name, _, dir_files in os.walk(str(tmp_path)):
+            arc_path = os.path.relpath(dir_name, str(tmp_path))
+            for file_name in dir_files:
+                zfp.write(
+                    os.path.join(dir_name, file_name),
+                    arcname=os.path.join(arc_path, file_name))
+    testcases = TestCase.load(str(archive), True)
+    try:
+        assert len(tuple(testcases)) == 3
+    finally:
+        map(lambda x: x.cleanup, testcases)
+
+def test_testcase_15(tmp_path):
     """test TestCase.load_environ()"""
     (tmp_path / "ubsan.supp").touch()
     (tmp_path / "other_file").touch()
@@ -233,7 +310,7 @@ def test_testcase_10(tmp_path):
         assert "b=2" in opts
         assert len(opts) == 3
 
-def test_testcase_11(tmp_path):
+def test_testcase_16(tmp_path):
     """test TestCase.add_batch()"""
     include = (tmp_path / "inc_path")
     include.mkdir()
@@ -269,14 +346,14 @@ def test_testcase_11(tmp_path):
         with pytest.raises(TestFileExists, match="'file.bin' exists in test"):
             tcase.add_batch(str(include), [str(inc_1)])
 
-def test_testcase_12(tmp_path):
+def test_testcase_17(tmp_path):
     """test TestCase.scan_path()"""
     # empty path
     (tmp_path / "not-test").mkdir()
     assert not tuple(TestCase.scan_path(str(tmp_path)))
     # multiple test case directories
     paths = [str(tmp_path / ("test-%d" % i)) for i in range(3)]
-    with TestCase("target.bin", None, "test-adapter") as src:
+    with TestCase("test.htm", None, "test-adapter") as src:
         src.add_from_data("test", "test.htm")
         for path in paths:
             src.dump(path, include_details=True)
@@ -286,6 +363,13 @@ def test_testcase_12(tmp_path):
     tc_paths = list(TestCase.scan_path(str(paths[0])))
     assert len(tc_paths) == 1
 
+def test_testcase_18():
+    """test TestCase.get_file()"""
+    with TestCase("test.htm", None, "test-adapter") as src:
+        src.add_from_data("test", "test.htm")
+        assert src.get_file("missing") is None
+        assert src.get_file("test.htm").data == b"test"
+
 def test_testfile_01():
     """test simple TestFile"""
     with TestFile("test_file.txt") as tfile:
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index 0cc88c6d..1983f127 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -2,7 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from os.path import isfile, isdir, join as pathjoin
+from os.path import isfile
 
 from ..args import CommonArgs
 
@@ -15,8 +15,9 @@ def __init__(self):
             "input",
             help="Accepted input includes: " \
                 "1) A directory containing testcase data. " \
-                "2) A file to use as a testcase. " \
-                "3) A zip archive containing testcases. " \
+                "2) A directory with one or more subdirectories containing testcase data. " \
+                "3) A zip archive containing testcase data or subdirectories containing testcase data. " \
+                "4) A single file to be used as a testcase. " \
                 "When using a directory it must contain a 'test_info.json' file.")
 
         replay_args = self.parser.add_argument_group("Replay Arguments")
@@ -59,10 +60,6 @@ def __init__(self):
     def sanity_check(self, args):
         super(ReplayArgs, self).sanity_check(args)
 
-        if "input" not in self._sanity_skip and isdir(args.input):
-            if not isfile(pathjoin(args.input, "test_info.json")):
-                self.parser.error("Test case folder must contain 'test_info.json'")
-
         if args.any_crash and args.sig is not None:
             self.parser.error("signature is ignored when running with '--any-crash'")
 
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index e449a015..d3fbc621 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -4,12 +4,10 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from logging import getLogger
-from os.path import dirname, isfile, join as pathjoin
-from shutil import copyfile, rmtree
+from os.path import dirname, join as pathjoin
 from tempfile import mkdtemp
 from time import sleep
-from zipfile import BadZipfile, ZipFile
-from zlib import error as zlib_error
+from shutil import rmtree
 
 from FTB.Signatures.CrashInfo import CrashSignature
 from sapphire import Sapphire, ServerMap
@@ -77,55 +75,6 @@ def cleanup(self):
         if self.status is not None:
             self.status.cleanup()
 
-    @staticmethod
-    def load_testcases(path, load_prefs):
-        """Load TestCases from disk.
-
-        Args:
-            path (str): Path to a file, directory or zip archive containing
-                        testcase data.
-            load_prefs (bool): Load prefs.js file if available.
-
-        Returns:
-            tuple: TestCases (list) and path to unpacked testcase data (str).
-        """
-        unpacked = None
-        try:
-            if path.lower().endswith(".zip"):
-                unpacked = mkdtemp(prefix="unpack_", dir=grz_tmp("replay"))
-                try:
-                    with ZipFile(path) as zip_fp:
-                        zip_fp.extractall(path=unpacked)
-                except (BadZipfile, zlib_error):
-                    raise TestCaseLoadFailure("Testcase archive is corrupted")
-                tc_paths = tuple(TestCase.scan_path(unpacked))
-                testcases = list()
-                for tc_path in tc_paths:
-                    try:
-                        testcases.append(TestCase.load_path(tc_path, load_prefs=load_prefs))
-                    except TestCaseLoadFailure:  # pragma: no cover
-                        pass
-                testcases.sort(key=lambda tc: tc.timestamp)
-                if load_prefs:
-                    # attempt to unpack prefs.js
-                    for tc_path in tc_paths:
-                        try:
-                            copyfile(
-                                pathjoin(tc_path, "prefs.js"),
-                                pathjoin(unpacked, "prefs.js"))
-                        except IOError:  # pragma: no cover
-                            continue
-                        break
-            else:
-                testcases = [TestCase.load_path(path, load_prefs=load_prefs)]
-            if not testcases:
-                raise TestCaseLoadFailure("Failed to load TestCases")
-        except TestCaseLoadFailure:
-            if unpacked is not None:
-                rmtree(unpacked, ignore_errors=True)
-            raise
-        return testcases, unpacked
-
     @property
     def other_reports(self):
         """Reports from results that do not match:
@@ -353,27 +302,16 @@ def main(cls, args):
 
         LOG.debug("loading the TestCases")
         try:
-            testcases, unpacked = cls.load_testcases(args.input, args.prefs is None)
+            testcases = TestCase.load(args.input, args.prefs is None)
+            if not testcases:
+                raise TestCaseLoadFailure("Failed to load TestCases")
         except TestCaseLoadFailure as exc:
             LOG.error("Error: %s", str(exc))
             return 1
-        # prioritize specified prefs.js file over included file
-        if args.prefs is not None:
-            prefs = args.prefs
-            for testcase in testcases:
-                testcase.add_meta(TestFile.from_file(args.prefs, "prefs.js"))
-            LOG.info("Using specified prefs.js")
-        elif unpacked and isfile(pathjoin(unpacked, "prefs.js")):
-            prefs = pathjoin(unpacked, "prefs.js")
-            LOG.info("Using prefs.js from testcase")
-        elif isfile(pathjoin(args.input, "prefs.js")):
-            prefs = pathjoin(args.input, "prefs.js")
-            LOG.info("Using prefs.js from testcase")
-        else:
-            prefs = None
 
         replay = None
         target = None
+        tmp_prefs = None
         try:
             relaunch = min(args.relaunch, args.repeat)
             LOG.debug("initializing the Target")
@@ -387,12 +325,24 @@ def main(cls, args):
                 rr=args.rr,
                 valgrind=args.valgrind,
                 xvfb=args.xvfb)
-            if prefs is not None:
-                target.prefs = prefs
+            # prioritize specified prefs.js file over included file
+            if args.prefs is not None:
+                for testcase in testcases:
+                    testcase.add_meta(TestFile.from_file(args.prefs, "prefs.js"))
+                LOG.info("Using specified prefs.js")
+                target.prefs = args.prefs
+            else:
+                for testcase in testcases:
+                    prefs_tf = testcase.get_file("prefs.js")
+                    if prefs_tf:
+                        tmp_prefs = mkdtemp(prefix="prefs_", dir=grz_tmp("replay"))
+                        prefs_tf.dump(tmp_prefs)
+                        LOG.info("Using prefs.js from testcase")
+                        target.prefs = pathjoin(tmp_prefs, "prefs.js")
+                        break
             if testcases[0].env_vars.get("GRZ_FORCED_CLOSE") == "0":
                 LOG.debug("setting target.forced_close=False")
                 target.forced_close = False
-
             LOG.debug("starting sapphire server")
             # launch HTTP server used to serve test cases
             with Sapphire(auto_close=1, timeout=args.timeout) as server:
@@ -440,6 +390,6 @@ def main(cls, args):
                 target.cleanup()
             for testcase in testcases:
                 testcase.cleanup()
-            if unpacked is not None:
-                rmtree(unpacked, ignore_errors=True)
+            if tmp_prefs is not None:
+                rmtree(tmp_prefs, ignore_errors=True)
             LOG.info("Done.")
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 32a79900..5f7c3d13 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -22,45 +22,33 @@ def test_args_01(capsys, tmp_path):
     # missing args tests
     with raises(SystemExit):
         ReplayArgs().parse_args([])
-
-    # test case directory missing test_info.json
+    # specified prefs.js missing
     exe = tmp_path / "binary"
     exe.touch()
     inp = tmp_path / "input"
     inp.mkdir()
     (inp / "somefile").touch()
-    with raises(SystemExit):
-        ReplayArgs().parse_args([str(exe), str(inp)])
-    assert "error: Test case folder must contain 'test_info.json'" in capsys.readouterr()[-1]
-
     (inp / "test_info.json").touch()
-    # specified prefs.js missing
     with raises(SystemExit):
         ReplayArgs().parse_args([str(exe), str(inp / "somefile"), "--prefs", "missing"])
     assert "error: -p/--prefs not found 'missing'" in capsys.readouterr()[-1]
-
     # test case directory
     (inp / "prefs.js").touch()
     ReplayArgs().parse_args([str(exe), str(inp)])
-
     # test case file
     ReplayArgs().parse_args([str(exe), str(inp / "somefile"), "--prefs", str(inp / "prefs.js")])
-
     # test negative min-crashes value
     with raises(SystemExit):
         ReplayArgs().parse_args([str(exe), str(inp), "--min-crashes", "-1"])
     assert "error: '--min-crashes' value must be positive" in capsys.readouterr()[-1]
-
     # test negative repeat value
     with raises(SystemExit):
         ReplayArgs().parse_args([str(exe), str(inp), "--repeat", "-1"])
     assert "error: '--repeat' value must be positive" in capsys.readouterr()[-1]
-
     # test missing signature file
     with raises(SystemExit):
         ReplayArgs().parse_args([str(exe), str(inp), "--sig", "missing"])
     assert "error: signature file not found" in capsys.readouterr()[-1]
-
     # test any crash and signature
     with raises(SystemExit):
         ReplayArgs().parse_args([str(exe), str(inp), "--any-crash", "--sig", "x"])
@@ -133,14 +121,14 @@ def test_main_02(mocker):
     mocker.patch("grizzly.replay.replay.Sapphire", autospec=True)
     mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
     # setup args
-    args = mocker.Mock()
-    args.ignore = None
-    args.input = "test"
-    args.min_crashes = 1
-    args.prefs = None
-    args.relaunch = 1
-    args.repeat = 1
-    args.sig = None
+    args = mocker.Mock(
+        ignore=None,
+        input="test",
+        min_crashes=1,
+        prefs=None,
+        relaunch=1,
+        repeat=1,
+        sig=None)
 
     mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchError)
     assert ReplayManager.main(args) == 1
@@ -151,7 +139,10 @@ def test_main_02(mocker):
     mocker.patch("grizzly.replay.replay.load_target", side_effect=KeyboardInterrupt)
     assert ReplayManager.main(args) == 1
 
-    mocker.patch("grizzly.replay.replay.TestCase.load_path", side_effect=TestCaseLoadFailure)
+    mocker.patch("grizzly.replay.replay.TestCase.load", side_effect=TestCaseLoadFailure)
+    assert ReplayManager.main(args) == 1
+
+    mocker.patch("grizzly.replay.replay.TestCase.load", return_value=list())
     assert ReplayManager.main(args) == 1
 
 def test_main_03(mocker):
@@ -164,20 +155,18 @@ def test_main_03(mocker):
         spec=TestCase,
         env_vars={"GRZ_FORCED_CLOSE": "0"},
         landing_page="x.html")
-    mocker.patch("grizzly.replay.replay.TestCase.load_path", return_value=testcase)
+    mocker.patch("grizzly.replay.replay.TestCase.load", return_value=[testcase])
     # setup args
-    args = mocker.Mock()
-    args.fuzzmanager = False
-    args.ignore = None
-    args.input = "test"
-    args.logs = None
-    args.min_crashes = 1
-    args.prefs = None
-    args.relaunch = 1
-    args.repeat = 1
-    args.sig = None
-    args.timeout = 1
-
+    args = mocker.Mock(
+        fuzzmanager=False,
+        ignore=None,
+        input="test",
+        min_crashes=1,
+        prefs=None,
+        relaunch=1,
+        repeat=1,
+        sig=None,
+        timeout=1)
     ReplayManager.main(args)
     assert testcase.cleanup.call_count == 1
     assert target.cleanup.call_count == 1
@@ -262,26 +251,3 @@ def _fake_save_logs(result_logs):
     assert log_path.is_dir()
     prefs = tuple(log_path.glob('**/prefs.js'))
     assert prefs[0].read_bytes() == b"specified"
-
-def test_main_05(mocker, tmp_path):
-    """test ReplayManager.main() - unpacked test case - prefs and cleanup """
-    unpacked = (tmp_path / "unpacked")
-    unpacked.mkdir()
-    # prefs.js from unpacked path
-    (unpacked / "prefs.js").touch()
-    fake_load_testcases = mocker.patch("grizzly.replay.replay.ReplayManager.load_testcases")
-    fake_load_testcases.return_value = ([mocker.Mock(env_vars=dict())], str(unpacked))
-    mocker.patch("grizzly.replay.replay.ReplayManager.run")
-    mocker.patch("grizzly.replay.replay.load_target")
-    mocker.patch("grizzly.replay.replay.Sapphire")
-    args = mocker.Mock(
-        fuzzmanager=False,
-        ignore=None,
-        min_crashes=1,
-        relaunch=1,
-        repeat=1,
-        prefs=None,
-        sig=None,
-        timeout=1)
-    assert ReplayManager.main(args) == 0
-    assert not unpacked.is_dir()
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 5abc8f78..47bb4e8f 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -6,14 +6,12 @@
 """
 unit tests for grizzly.replay
 """
-from os import walk
-from os.path import isfile, join as pathjoin, relpath
-from zipfile import ZIP_DEFLATED, ZipFile
+from os.path import join as pathjoin
 
 from pytest import raises
 
 from sapphire import Sapphire, SERVED_ALL, SERVED_REQUEST
-from .replay import ReplayManager, TestCaseLoadFailure
+from .replay import ReplayManager
 from ..common import Report, Status, TestCase
 from ..target import Target, TargetLaunchError
 
@@ -314,73 +312,3 @@ def test_replay_12(mocker):
         assert replay.status.results == 1
         assert len(replay.reports) == 1
         assert not replay.other_reports
-
-def test_replay_13(tmp_path):
-    """test ReplayManager.load_testcases() - error cases"""
-    # test missing
-    with raises(TestCaseLoadFailure, match="Cannot find"):
-        ReplayManager.load_testcases("missing", False)
-    # test empty path
-    with raises(TestCaseLoadFailure, match="Missing 'test_info.json'"):
-        ReplayManager.load_testcases(str(tmp_path), False)
-    # test broken archive
-    archive = (tmp_path / "fake.zip")
-    archive.write_bytes(b"x")
-    with raises(TestCaseLoadFailure, match="Testcase archive is corrupted"):
-        ReplayManager.load_testcases(str(archive), False)
-
-def test_replay_14(tmp_path):
-    """test ReplayManager.load_testcases() - single file"""
-    tfile = (tmp_path / "testcase.html")
-    tfile.touch()
-    testcases, unpacked = ReplayManager.load_testcases(str(tfile), False)
-    try:
-        assert unpacked is None
-        assert len(tuple(testcases)) == 1
-    finally:
-        map(lambda x: x.cleanup, testcases)
-
-def test_replay_15(tmp_path):
-    """test ReplayManager.load_testcases() - single directory"""
-    with TestCase("target.bin", None, "test-adapter") as src:
-        src.add_from_data("test", "target.bin")
-        src.dump(str(tmp_path), include_details=True)
-    testcases, unpacked = ReplayManager.load_testcases(str(tmp_path), False)
-    try:
-        assert unpacked is None
-        assert len(tuple(testcases)) == 1
-    finally:
-        map(lambda x: x.cleanup, testcases)
-
-def test_replay_16(tmp_path):
-    """test ReplayManager.load_testcases() - archive"""
-    # build archive containing multiple testcases
-    with TestCase("target.bin", None, "test-adapter") as src:
-        src.add_from_data("test", "target.bin")
-        src.dump(str(tmp_path / "src-0"), include_details=True)
-        src.dump(str(tmp_path / "src-1"), include_details=True)
-        src.dump(str(tmp_path / "src-2"), include_details=True)
-    (tmp_path / "src-1" / "prefs.js").write_bytes(b"fake_prefs")
-    (tmp_path / "log_dummy.txt").touch()
-    (tmp_path / "not_a_tc").mkdir()
-    (tmp_path / "not_a_tc" / "file.txt").touch()
-    archive = str(tmp_path / "testcase.zip")
-    with ZipFile(archive, mode="w", compression=ZIP_DEFLATED) as zfp:
-        for dir_name, _, dir_files in walk(str(tmp_path)):
-            arc_path = relpath(dir_name, str(tmp_path))
-            for file_name in dir_files:
-                zfp.write(
-                    pathjoin(dir_name, file_name),
-                    arcname=pathjoin(arc_path, file_name))
-    testcases, unpacked = ReplayManager.load_testcases(str(archive), True)
-    try:
-        assert unpacked is not None
-        assert isfile(pathjoin(unpacked, "prefs.js"))
-        assert len(tuple(testcases)) == 3
-    finally:
-        map(lambda x: x.cleanup, testcases)
-    # empty archive
-    with ZipFile(archive, mode="w", compression=ZIP_DEFLATED) as zfp:
-        zfp.write(str(tmp_path / "not_a_tc"), arcname="not_a_tc")
-    with raises(TestCaseLoadFailure, match="Failed to load TestCases"):
-        ReplayManager.load_testcases(str(archive), True)

From 4318e742d157eafa946a0142b8d28d8c08b60044 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 25 Aug 2020 11:47:34 -0700
Subject: [PATCH 006/531] Remove Sapphire.serve_testcase()

---
 grizzly/common/runner.py           | 33 ++++++++++++++++------
 grizzly/common/test_runner.py      | 42 +++++++++++++++++-----------
 grizzly/reduce/test_interesting.py |  3 +-
 grizzly/replay/test_main.py        | 27 +++++++++---------
 grizzly/replay/test_replay.py      | 44 +++++++++++++++---------------
 grizzly/test_session.py            | 20 ++++++--------
 sapphire/core.py                   | 30 --------------------
 sapphire/test_sapphire.py          | 33 ++++++++--------------
 8 files changed, 108 insertions(+), 124 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index b1c20381..46630f6c 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -3,6 +3,8 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
+from shutil import rmtree
+from tempfile import mkdtemp
 from time import sleep, time
 
 from sapphire import SERVED_TIMEOUT
@@ -149,13 +151,14 @@ def location(srv_path, srv_port, close_after=None, forced_close=True, timeout=No
             return "?".join([location, "&".join(args)])
         return location
 
-    def run(self, ignore, server_map, testcase, coverage=False, wait_for_callback=False):
+    def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait_for_callback=False):
         """Serve a testcase and monitor the target for results.
 
         Args:
             ignore (list): List of failure types to ignore.
             server_map (sapphire.ServerMap): A ServerMap.
             testcase (grizzly.TestCase): The test case that will be served.
+            test_path (str): Location of test case data on the filesystem.
             coverage (bool): Trigger coverage dump.
             wait_for_callback: (bool): Use `_keep_waiting()` to indicate when
                                        framework should move on.
@@ -169,13 +172,27 @@ def run(self, ignore, server_map, testcase, coverage=False, wait_for_callback=Fa
         self.timeout = False
         if self._idle is not None:
             self._idle.schedule_poll(initial=True)
-        # serve the test case
-        server_status, self.served = self._server.serve_testcase(
-            testcase,
-            continue_cb=self._keep_waiting,
-            forever=wait_for_callback,
-            server_map=server_map,
-            working_path=grz_tmp("serve"))
+        try:
+            # unpack test case
+            if test_path is None:
+                wwwdir = mkdtemp(prefix="test_", dir=grz_tmp("serve"))
+                testcase.dump(wwwdir)
+            else:
+                wwwdir = test_path
+            # serve the test case
+            serve_start = time()
+            server_status, self.served = self._server.serve_path(
+                wwwdir,
+                continue_cb=self._keep_waiting,
+                forever=wait_for_callback,
+                optional_files=tuple(testcase.optional),
+                server_map=server_map)
+            testcase.duration = time() - serve_start
+        finally:
+            # remove temporary files
+            if test_path is None:
+                rmtree(wwwdir)
+        # TODO: fix calling TestCase.add_batch() for multi-test replay
         # add all include files that were served
         for url, resource in server_map.include.items():
             testcase.add_batch(resource.target, self.served, prefix=url)
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 0a369a52..1d537054 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -13,7 +13,7 @@
 from .storage import TestCase
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 
-def test_runner_01(mocker):
+def test_runner_01(mocker, tmp_path):
     """test Runner()"""
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
@@ -24,33 +24,43 @@ def test_runner_01(mocker):
     assert runner.served is None
     assert not runner.timeout
     serv_files = ["a.bin", "/another/file.bin"]
-    testcase = mocker.Mock(spec=TestCase)
-    testcase.landing_page = serv_files[0]
+    testcase = mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[])
     # all files served
-    server.serve_testcase.return_value = (SERVED_ALL, serv_files)
+    server.serve_path.return_value = (SERVED_ALL, serv_files)
     runner.run([], ServerMap(), testcase)
     assert runner.result == runner.COMPLETE
     assert runner.served == serv_files
     assert not runner.timeout
     assert target.close.call_count == 0
     assert target.dump_coverage.call_count == 0
+    assert testcase.dump.call_count == 1
     # some files served
-    server.serve_testcase.return_value = (SERVED_REQUEST, serv_files)
+    server.serve_path.return_value = (SERVED_REQUEST, serv_files)
     runner.run([], ServerMap(), testcase, coverage=True)
     assert runner.result == runner.COMPLETE
     assert runner.served == serv_files
     assert not runner.timeout
     assert target.close.call_count == 0
     assert target.dump_coverage.call_count == 1
+    # existing test path
+    testcase.reset_mock()
+    tc_path = (tmp_path / "tc")
+    tc_path.mkdir()
+    server.serve_path.return_value = (SERVED_ALL, serv_files)
+    runner.run([], ServerMap(), testcase, test_path=str(tc_path))
+    assert runner.result == runner.COMPLETE
+    assert target.close.call_count == 0
+    assert testcase.dump.call_count == 0
+    tc_path.is_dir()
 
 def test_runner_02(mocker):
     """test Runner() errors"""
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
-    testcase = mocker.Mock(spec=TestCase, landing_page="x")
+    testcase = mocker.Mock(spec=TestCase, landing_page="x", optional=[])
     runner = Runner(server, target)
     # no files served
-    server.serve_testcase.return_value = (SERVED_NONE, [])
+    server.serve_path.return_value = (SERVED_NONE, [])
     target.detect_failure.return_value = target.RESULT_NONE
     runner.run([], ServerMap(), testcase)
     assert runner.result == runner.ERROR
@@ -59,7 +69,7 @@ def test_runner_02(mocker):
     assert target.close.call_count == 1
     target.reset_mock()
     # landing page not served
-    server.serve_testcase.return_value = (SERVED_REQUEST, ["harness"])
+    server.serve_path.return_value = (SERVED_REQUEST, ["harness"])
     runner.run([], ServerMap(), testcase)
     assert runner.result == runner.ERROR
     assert runner.served
@@ -70,10 +80,10 @@ def test_runner_03(mocker):
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
     serv_files = ["a.bin", "/another/file.bin"]
-    server.serve_testcase.return_value = (SERVED_TIMEOUT, serv_files)
+    server.serve_path.return_value = (SERVED_TIMEOUT, serv_files)
     runner = Runner(server, target)
     target.detect_failure.return_value = target.RESULT_FAILURE
-    runner.run([], ServerMap(), mocker.Mock(spec=TestCase, landing_page="x"))
+    runner.run([], ServerMap(), mocker.Mock(spec=TestCase, landing_page="x", optional=[]))
     assert runner.result == runner.FAILED
     assert runner.served == serv_files
     assert runner.timeout
@@ -83,8 +93,8 @@ def test_runner_04(mocker):
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
     serv_files = ["file.bin"]
-    server.serve_testcase.return_value = (SERVED_REQUEST, serv_files)
-    testcase = mocker.Mock(spec=TestCase, landing_page=serv_files[0])
+    server.serve_path.return_value = (SERVED_REQUEST, serv_files)
+    testcase = mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[])
     runner = Runner(server, target)
     # test FAILURE
     target.detect_failure.return_value = target.RESULT_FAILURE
@@ -99,7 +109,7 @@ def test_runner_04(mocker):
     assert runner.served == serv_files
     assert not runner.timeout
     # failure before serving landing page
-    server.serve_testcase.return_value = (SERVED_REQUEST, ["harness"])
+    server.serve_path.return_value = (SERVED_REQUEST, ["harness"])
     target.detect_failure.return_value = target.RESULT_FAILURE
     runner.run([], ServerMap(), testcase)
     assert runner.result == runner.FAILED
@@ -112,10 +122,10 @@ def test_runner_05(mocker):
     target = mocker.Mock(spec=Target)
     target.detect_failure.return_value = target.RESULT_NONE
     serv_files = ["/fake/file", "/another/file.bin"]
-    server.serve_testcase.return_value = (SERVED_REQUEST, serv_files)
+    server.serve_path.return_value = (SERVED_REQUEST, serv_files)
     runner = Runner(server, target, idle_threshold=0.01, idle_delay=0.01)
     assert runner._idle is not None
-    runner.run([], ServerMap(), mocker.Mock(spec=TestCase, landing_page=serv_files[0]))
+    runner.run([], ServerMap(), mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[]))
     assert runner.result == runner.COMPLETE
     assert target.close.call_count == 0
 
@@ -203,7 +213,7 @@ def test_runner_09(mocker, tmp_path):
     smap.set_include("/", str(inc_path1))
     smap.set_include("/test", str(inc_path2))
     serv_files = ["a.b", str(inc1), str(inc2), str(inc3)]
-    server.serve_testcase.return_value = (SERVED_ALL, serv_files)
+    server.serve_path.return_value = (SERVED_ALL, serv_files)
     with TestCase("a.b", "x", "x") as tcase:
         runner.run([], smap, tcase)
         assert runner.result == runner.COMPLETE
diff --git a/grizzly/reduce/test_interesting.py b/grizzly/reduce/test_interesting.py
index c9a6fc5e..859469aa 100644
--- a/grizzly/reduce/test_interesting.py
+++ b/grizzly/reduce/test_interesting.py
@@ -32,8 +32,7 @@ def add_dynamic_response(self, *args, **kwds):
     def set_redirect(self, *args, **kwds):
         pass
 
-    def serve_testcase(self, testcase, **kwds):  # pylint: disable=no-self-use,unused-argument
-        testcase.duration = 0.1
+    def serve_path(self, *args, **kwds):  # pylint: disable=no-self-use,unused-argument
         return sapphire.SERVED_ALL, ["test.html"]
 
     @property
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 5f7c3d13..cb8c99b2 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -59,9 +59,9 @@ def test_main_01(mocker, tmp_path):
     # This is a typical scenario - a test that reproduces results ~50% of the time.
     # Of the four attempts only the first and third will 'reproduce' the result
     # and the forth attempt should be skipped.
-    # mock Sapphire.serve_testcase only
-    serve_testcase = mocker.patch("grizzly.replay.replay.Sapphire.serve_testcase", autospec=True)
-    serve_testcase.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
+    # mock Sapphire.serve_path only
+    serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
+    serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_target")
     target = mocker.Mock(spec=Target, binary="bin", forced_close=True)
@@ -104,7 +104,7 @@ def _fake_save_logs(result_logs):
     assert target.launch.call_count == 3
     assert target.step.call_count == 3
     assert target.detect_failure.call_count == 3
-    assert serve_testcase.call_count == 3
+    assert serve_path.call_count == 3
     assert load_target.call_count == 1
     assert target.close.call_count == 1
     assert target.cleanup.call_count == 1
@@ -147,14 +147,15 @@ def test_main_02(mocker):
 
 def test_main_03(mocker):
     """test ReplayManager.main() loading GRZ_FORCED_CLOSE from test case"""
-    mocker.patch("grizzly.replay.replay.Sapphire.serve_testcase", return_value=(None, ["x.html"]))
+    mocker.patch("grizzly.replay.replay.Sapphire.serve_path", return_value=(None, ["x.html"]))
     target = mocker.Mock(spec=Target, forced_close=True)
     load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
     load_target.return_value.return_value = target
     testcase = mocker.Mock(
         spec=TestCase,
         env_vars={"GRZ_FORCED_CLOSE": "0"},
-        landing_page="x.html")
+        landing_page="x.html",
+        optional=[])
     mocker.patch("grizzly.replay.replay.TestCase.load", return_value=[testcase])
     # setup args
     args = mocker.Mock(
@@ -174,8 +175,8 @@ def test_main_03(mocker):
 
 def test_main_04(mocker, tmp_path):
     """test ReplayManager.main() loading/generating prefs.js"""
-    serve_testcase = mocker.patch("grizzly.replay.replay.Sapphire.serve_testcase", autospec=True)
-    serve_testcase.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
+    serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
+    serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
     target = mocker.Mock(spec=Target, binary="bin", forced_close=True)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
@@ -219,12 +220,12 @@ def _fake_save_logs(result_logs):
     assert ReplayManager.main(args) == 0
     assert target.launch.call_count == 1
     assert target.detect_failure.call_count == 1
-    assert serve_testcase.call_count == 1
+    assert serve_path.call_count == 1
     assert log_path.is_dir()
     assert not any(log_path.glob('**/prefs.js'))
 
     target.reset_mock()
-    serve_testcase.reset_mock()
+    serve_path.reset_mock()
     rmtree(str(log_path), ignore_errors=True)
 
     # test included prefs.js
@@ -232,13 +233,13 @@ def _fake_save_logs(result_logs):
     assert ReplayManager.main(args) == 0
     assert target.launch.call_count == 1
     assert target.detect_failure.call_count == 1
-    assert serve_testcase.call_count == 1
+    assert serve_path.call_count == 1
     assert log_path.is_dir()
     prefs = tuple(log_path.glob('**/prefs.js'))
     assert prefs[0].read_bytes() == b"included"
 
     target.reset_mock()
-    serve_testcase.reset_mock()
+    serve_path.reset_mock()
     rmtree(str(log_path), ignore_errors=True)
 
     # test specified prefs.js
@@ -247,7 +248,7 @@ def _fake_save_logs(result_logs):
     assert ReplayManager.main(args) == 0
     assert target.launch.call_count == 1
     assert target.detect_failure.call_count == 1
-    assert serve_testcase.call_count == 1
+    assert serve_path.call_count == 1
     assert log_path.is_dir()
     prefs = tuple(log_path.glob('**/prefs.js'))
     assert prefs[0].read_bytes() == b"specified"
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 47bb4e8f..efa85854 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -44,14 +44,14 @@ def test_replay_01(mocker):
 def test_replay_02(mocker):
     """test ReplayManager.run() - no repro"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    server.serve_testcase.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target)
     target.RESULT_NONE = Target.RESULT_NONE
     target.closed = True
     target.detect_failure.return_value = Target.RESULT_NONE
     target.forced_close = True
     target.rl_reset = 1
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, testcases, use_harness=True) as replay:
         assert not replay.run()
         assert replay.status.ignored == 0
@@ -62,13 +62,13 @@ def test_replay_02(mocker):
 def test_replay_03(mocker):
     """test ReplayManager.run() - successful repro"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    server.serve_testcase.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.binary = "C:\\fake_bin"
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.save_logs = _fake_save_logs_result
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, testcases, use_harness=False) as replay:
         assert replay.run()
         assert replay.status.ignored == 0
@@ -80,11 +80,11 @@ def test_replay_03(mocker):
 def test_replay_04(mocker):
     """test ReplayManager.run() - Error (landing page not requested/served)"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    server.serve_testcase.return_value = (SERVED_REQUEST, ["x"])
+    server.serve_path.return_value = (SERVED_REQUEST, ["x"])
     target = mocker.Mock(spec=Target)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, testcases, use_harness=False) as replay:
         assert not replay.run(repeat=2)
         assert replay.status.ignored == 0
@@ -97,11 +97,11 @@ def test_replay_04(mocker):
 def test_replay_05(mocker):
     """test ReplayManager.run() - ignored"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    server.serve_testcase.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target)
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = Target.RESULT_IGNORED
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, testcases, use_harness=False) as replay:
         assert not replay.run()
         assert replay.status.ignored == 1
@@ -113,14 +113,14 @@ def test_replay_05(mocker):
 def test_replay_06(mocker):
     """test ReplayManager.run() - early exit"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    server.serve_testcase.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
     target.binary = "path/fake_bin"
     target.save_logs = _fake_save_logs_result
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     # early failure
     target.detect_failure.side_effect = [Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_NONE]
     with ReplayManager([], server, target, testcases, use_harness=False) as replay:
@@ -157,14 +157,14 @@ def test_replay_07(mocker, tmp_path):
     report.from_path.side_effect = (report_0, report_1, report_2)
     server = mocker.Mock(spec=Sapphire)
     server.port = 0x1337
-    server.serve_testcase.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, False)
     target = mocker.Mock(spec=Target)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.binary = "fake_bin"
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, testcases, signature=signature, use_harness=False) as replay:
         assert not replay.run(repeat=3, min_results=2)
         assert replay._signature == signature
@@ -197,12 +197,12 @@ def test_replay_08(mocker, tmp_path):
     report_2.minor = "abcd9876"
     report.from_path.side_effect = (report_0, report_1, report_2)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    server.serve_testcase.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.binary = "fake_bin"
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, testcases, any_crash=True, use_harness=False) as replay:
         assert replay.run(repeat=3, min_results=2)
         assert replay._signature is None
@@ -271,7 +271,7 @@ def test_replay_10(mocker, tmp_path):
 def test_replay_11(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    server.serve_testcase.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target)
     target.RESULT_NONE = Target.RESULT_NONE
     target.closed = True
@@ -279,9 +279,9 @@ def test_replay_11(mocker):
     target.forced_close = True
     target.rl_reset = 1
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html"),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html"),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, testcases, use_harness=True) as replay:
         assert not replay.run()
         assert replay.status.ignored == 0
@@ -292,7 +292,7 @@ def test_replay_11(mocker):
 def test_replay_12(mocker):
     """test ReplayManager.run() - multiple TestCases - successful repro"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    server.serve_testcase.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target, binary="fake_bin", rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
@@ -302,9 +302,9 @@ def test_replay_12(mocker):
         Target.RESULT_FAILURE)
     target.save_logs = _fake_save_logs_result
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html"),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html"),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, testcases, use_harness=True) as replay:
         assert replay.run()
         assert replay.status.ignored == 0
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 8318fe71..0ee4b227 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -36,9 +36,7 @@ def generate(self, testcase, server_map):
     # set target.log_size to test warning code path
     fake_target.log_size.return_value = Session.TARGET_LOG_SIZE_WARN + 1
     with IOManager() as iomgr:
-        def fake_serve_tc(tcase, **_):
-            return (SERVED_ALL, [tcase.landing_page])
-        fake_serv.serve_testcase = fake_serve_tc
+        fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
         with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
             session.run([])
             assert session.status.iteration == 5
@@ -56,7 +54,6 @@ def generate(self, testcase, server_map):
     adapter = FuzzAdapter()
     adapter.setup(None, None)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_serv.serve_testcase.side_effect = lambda tc, **_: (SERVED_ALL, [tc.landing_page])
     prefs = tmp_path / "prefs.js"
     prefs.touch()
     fake_target = mocker.Mock(spec=Target, prefs=str(prefs), rl_reset=10)
@@ -64,6 +61,7 @@ def generate(self, testcase, server_map):
     fake_target.monitor.launches = 1
     with IOManager() as iomgr:
         iomgr.harness = adapter.get_harness()
+        fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
         with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
             session.run([], iteration_limit=10)
             assert session.status.iteration == 10
@@ -74,13 +72,13 @@ def test_session_03(tmp_path, mocker):
     Status.PATH = str(tmp_path)
     adapter = mocker.Mock(spec=Adapter, remaining=None)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_serv.serve_testcase.side_effect = lambda tc, **_: (SERVED_ALL, [tc.landing_page])
     fake_target = mocker.Mock(spec=Target, prefs=None, rl_reset=2)
     fake_target.log_size.return_value = 1000
     fake_target.monitor.launches = 1
     # target.launch() call will be skipped
     fake_target.closed = False
     with IOManager() as iomgr:
+        fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
         with Session(adapter, iomgr, None, fake_serv, fake_target, coverage=True) as session:
             session.run([], iteration_limit=2)
             assert session.status.iteration == 2
@@ -101,13 +99,13 @@ def generate(self, testcase, server_map):
     fake_target = mocker.Mock(spec=Target, prefs=None)
     fake_target.monitor.launches = 1
     with IOManager() as iomgr:
-        fake_serv.serve_testcase.return_value = (SERVED_NONE, [])
+        fake_serv.serve_path.return_value = (SERVED_NONE, [])
         # test error on first iteration
         with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
             with raises(SessionError, match="Please check Adapter and Target"):
                 session.run([], iteration_limit=10)
         # test that we continue if error happens later on
-        fake_serv.serve_testcase.return_value = (SERVED_REQUEST, ["x"])
+        fake_serv.serve_path.return_value = (SERVED_REQUEST, ["x"])
         with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
             session.status.iteration = 2
             session.run([], iteration_limit=3)
@@ -118,7 +116,7 @@ def test_session_05(tmp_path, mocker):
     fake_adapter = mocker.Mock(spec=Adapter)
     fake_adapter.TEST_DURATION = 10
     fake_adapter.remaining = None
-    fake_testcase = mocker.Mock(spec=TestCase, landing_page="page.htm")
+    fake_testcase = mocker.Mock(spec=TestCase, landing_page="page.htm", optional=[])
     fake_iomgr = mocker.Mock(spec=IOManager)
     fake_iomgr.server_map = ServerMap()
     fake_iomgr.create_testcase.return_value = fake_testcase
@@ -126,7 +124,7 @@ def test_session_05(tmp_path, mocker):
     fake_iomgr.tests = mocker.Mock(spec=deque)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     # return SERVED_TIMEOUT to test IGNORE_UNSERVED code path
-    fake_serv.serve_testcase.return_value = (SERVED_TIMEOUT, [fake_testcase.landing_page])
+    fake_serv.serve_path.return_value = (SERVED_TIMEOUT, [fake_testcase.landing_page])
     fake_target = mocker.Mock(spec=Target, prefs=None)
     fake_target.monitor.launches = 1
     with Session(fake_adapter, fake_iomgr, None, fake_serv, fake_target) as session:
@@ -139,7 +137,7 @@ def test_session_05(tmp_path, mocker):
     assert fake_iomgr.create_testcase.call_count == 1
     assert fake_iomgr.tests.pop.call_count == 0
     assert fake_testcase.purge_optional.call_count == 1
-    assert fake_serv.serve_testcase.call_count == 1
+    assert fake_serv.serve_path.call_count == 1
     assert fake_target.launch.call_count == 1
     assert fake_target.detect_failure.call_count == 1
     assert fake_target.step.call_count == 1
@@ -183,7 +181,6 @@ def test_session_07(tmp_path, mocker):
     fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
     fake_target.monitor.launches = 1
     with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
-        session.server.serve_testcase.return_value = SERVED_REQUEST
         fake_runner.return_value.result = fake_runner.return_value.FAILED
         fake_runner.return_value.served = ["/fake/file"]
         fake_runner.return_value.timeout = False
@@ -218,7 +215,6 @@ def test_session_08(tmp_path, mocker):
     # ignored results should not be reported so raise AssertionError if report_result is called
     mocker.patch.object(Session, 'report_result', side_effect=AssertionError)
     with Session(fake_adapter, fake_iomgr, None, fake_serv, fake_target) as session:
-        session.server.serve_testcase.return_value = SERVED_REQUEST
         fake_runner.return_value.result = fake_runner.return_value.IGNORED
         fake_runner.return_value.served = []
         fake_runner.return_value.timeout = False
diff --git a/sapphire/core.py b/sapphire/core.py
index df28e7a7..0efd5372 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -9,9 +9,7 @@
 import logging
 import os
 import random
-import shutil
 import socket
-import tempfile
 import time
 
 from .sapphire_job import SapphireJob
@@ -116,34 +114,6 @@ def serve_path(self, path, continue_cb=None, forever=False, optional_files=None,
         LOG.debug("status: %r, timeout: %r", job.status, was_timeout)
         return (SERVED_TIMEOUT if was_timeout else job.status, tuple(job.served))
 
-    def serve_testcase(self, testcase, continue_cb=None, forever=False, working_path=None, server_map=None):
-        """
-        serve_testcase() -> tuple
-        testcase is the Grizzly TestCase to serve. The callback continue_cb should
-        be a function that returns True or False. If continue_cb is specified and returns False
-        the server serve loop will exit. working_path is where the testcase will be unpacked
-        temporary.
-
-        returns a tuple (server status, files served)
-        see serve_path() for more info
-        """
-        LOG.debug("serve_testcase() called")
-        wwwdir = tempfile.mkdtemp(prefix="sphr_test_", dir=working_path)
-        try:
-            testcase.dump(wwwdir)
-            serve_start = time.time()
-            result = self.serve_path(
-                wwwdir,
-                continue_cb=continue_cb,
-                forever=forever,
-                optional_files=tuple(testcase.optional),
-                server_map=server_map)
-            testcase.duration = time.time() - serve_start
-        finally:
-            # remove test case working directory
-            shutil.rmtree(wwwdir, ignore_errors=True)
-        return result
-
     @property
     def timeout(self):
         return self._timeout
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 24719e97..0d82cd24 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -550,20 +550,7 @@ def test_sapphire_27(client, tmp_path):
     assert status == SERVED_TIMEOUT
     assert len(files_served) < len(files_to_serve)
 
-def test_sapphire_28(client, tmp_path):
-    """test Sapphire.serve_testcase()"""
-    with TestCase("test.html", "none.test", "foo") as test:
-        test.add_from_data(b"test", "test.html")
-        t_file = _create_test(test.landing_page, tmp_path)
-        with Sapphire(timeout=10) as serv:
-            client.launch("127.0.0.1", serv.port, [t_file])
-            assert test.duration is None
-            status, files_served = serv.serve_testcase(test)
-    assert status == SERVED_ALL
-    assert files_served
-    assert test.duration >= 0
-
-def test_sapphire_29(client_factory, tmp_path):
+def test_sapphire_28(client_factory, tmp_path):
     """test Sapphire.serve_path() with forever=True"""
     clients = list()
     with Sapphire(timeout=10) as serv:
@@ -584,7 +571,7 @@ def _test_callback():
     assert test.code == 200
     assert test.len_srv == test.len_org
 
-def test_sapphire_30(client, tmp_path):
+def test_sapphire_29(client, tmp_path):
     """test interesting file names"""
     to_serve = [
         # space in file name
@@ -595,10 +582,9 @@ def test_sapphire_30(client, tmp_path):
         client.launch("127.0.0.1", serv.port, to_serve)
         assert serv.serve_path(str(tmp_path))[0] == SERVED_ALL
     assert client.wait(timeout=10)
-    for t_file in to_serve:
-        assert t_file.code == 200
+    assert all(t_file.code == 200 for t_file in to_serve)
 
-def test_sapphire_31(client, tmp_path):
+def test_sapphire_30(client, tmp_path):
     """test interesting path string"""
     all_bytes = "".join(chr(i) for i in range(256))
     to_serve = [
@@ -610,10 +596,9 @@ def test_sapphire_31(client, tmp_path):
         client.launch("127.0.0.1", serv.port, to_serve, in_order=True)
         assert serv.serve_path(str(tmp_path), optional_files=[all_bytes])[0] == SERVED_ALL
     assert client.wait(timeout=10)
-    for t_file in to_serve:
-        assert t_file.code is not None
+    assert all(t_file.code is not None for t_file in to_serve)
 
-def test_sapphire_32(mocker):
+def test_sapphire_31(mocker):
     """test Sapphire._create_listening_socket()"""
     fake_sleep = mocker.patch("sapphire.core.time.sleep", autospec=True)
     fake_sock = mocker.patch("sapphire.core.socket.socket", autospec=True)
@@ -648,4 +633,10 @@ def test_main_01(mocker, tmp_path):
         port=4536,
         remote=False,
         timeout=None)
+    fake_srv = mocker.patch("sapphire.core.Sapphire.serve_path", autospec=True)
+    fake_srv.return_value = (SERVED_ALL, None)
+    Sapphire.main(args)
+    fake_srv.return_value = (SERVED_NONE, None)
+    Sapphire.main(args)
+    fake_srv.side_effect = KeyboardInterrupt
     Sapphire.main(args)

From 3fd861ab7502ab4223b49896d5a5a4037ef8272e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 25 Aug 2020 12:54:15 -0700
Subject: [PATCH 007/531] [replay] Unpack testcase data once

---
 grizzly/replay/replay.py      | 24 ++++++++++++++++++++++--
 grizzly/replay/test_replay.py | 15 +++++++++++++++
 2 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index d3fbc621..4cb24261 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -31,7 +31,7 @@ class ReplayManager(object):
 
     __slots__ = ("ignore", "server", "status", "target", "testcases", "_any_crash",
                  "_harness", "_reports_expected", "_reports_other", "_runner",
-                 "_signature")
+                 "_signature", "_unpacked")
 
     def __init__(self, ignore, server, target, testcases, any_crash=False, signature=None, use_harness=True):
         self.ignore = ignore
@@ -46,7 +46,7 @@ def __init__(self, ignore, server, target, testcases, any_crash=False, signature
         self._runner = Runner(self.server, self.target)
         # TODO: make signature a property
         self._signature = signature
-
+        self._unpacked = list()
         if use_harness:
             with open(self.HARNESS_FILE, "rb") as in_fp:
                 self._harness = in_fp.read()
@@ -57,6 +57,21 @@ def __enter__(self):
     def __exit__(self, *exc):
         self.cleanup()
 
+    def _unpack_tests(self):
+        """Unpack testcase data to known locations.
+
+        Args:
+            None
+
+        Returns:
+            None
+        """
+        assert not self._unpacked
+        for test in self.testcases:
+            dst_path = mkdtemp(prefix="tc_", dir=grz_tmp("serve"))
+            test.dump(dst_path)
+            self._unpacked.append(dst_path)
+
     def cleanup(self):
         """Remove temporary files from disk.
 
@@ -72,6 +87,8 @@ def cleanup(self):
         for report in self._reports_other.values():
             report.cleanup()
         self._reports_other.clear()
+        for tc_path in self._unpacked:
+            rmtree(tc_path)
         if self.status is not None:
             self.status.cleanup()
 
@@ -144,6 +161,8 @@ def run(self, repeat=1, min_results=1):
         assert min_results <= repeat
         self.status = Status.start()
 
+        self._unpack_tests()
+
         server_map = ServerMap()
         if self._harness is not None:
             def _dyn_close():  # pragma: no cover
@@ -197,6 +216,7 @@ def _dyn_close():  # pragma: no cover
                     self.ignore,
                     server_map,
                     self.testcases[test_idx],
+                    test_path=self._unpacked[test_idx],
                     wait_for_callback=self._harness is None)
                 if self._runner.result != self._runner.COMPLETE:
                     break
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index efa85854..a99015f4 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -33,6 +33,7 @@ def test_replay_01(mocker):
     replay = ReplayManager([], mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target), [mocker.Mock()])
     replay._reports_expected = {"A":  mocker.Mock(spec=Report)}
     replay._reports_other = {"B":  mocker.Mock(spec=Report)}
+    assert not replay._unpacked
     replay.status = mocker.Mock(spec=Status)
     ereport = tuple(replay.reports)[0]
     oreport = tuple(replay.other_reports)[0]
@@ -53,7 +54,9 @@ def test_replay_02(mocker):
     target.rl_reset = 1
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, testcases, use_harness=True) as replay:
+        assert not replay._unpacked
         assert not replay.run()
+        assert replay._unpacked
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 0
@@ -312,3 +315,15 @@ def test_replay_12(mocker):
         assert replay.status.results == 1
         assert len(replay.reports) == 1
         assert not replay.other_reports
+
+def test_replay_13(mocker, tmp_path):
+    """test ReplayManager._unpacked()"""
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    testcase = mocker.Mock(spec=TestCase, env_vars=[], optional=[])
+    mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
+    with ReplayManager([], server, mocker.Mock(spec=Target), [testcase]) as replay:
+        assert not replay._unpacked
+        replay._unpack_tests()
+        assert replay._unpacked
+        assert replay._unpacked[0] == str(tmp_path)
+    assert testcase.dump.call_count == 1

From e9ded587969285a4ae1c773501e102257f7b15cf Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 26 Aug 2020 16:46:19 -0700
Subject: [PATCH 008/531] [replay] Add more sanity checks

* Fix setting target.relaunch. Thanks @jschwartzentruber.
---
 grizzly/replay/args.py      |  5 ++++-
 grizzly/replay/replay.py    | 21 ++++++++++++---------
 grizzly/replay/test_main.py | 34 ++++++++++++++++++++++++----------
 3 files changed, 40 insertions(+), 20 deletions(-)

diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index 1983f127..78696a14 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -40,7 +40,7 @@ def __init__(self):
                 " Helpful for intermittent testcases (default: %(default)sx)")
         replay_args.add_argument(
             "--no-harness", action="store_true",
-            help="Don't use the harness for redirection")
+            help="Don't use the harness for redirection. Implies '--relaunch=1'.")
         replay_args.add_argument(
             "--repeat", type=int, default=1,
             help="Run the testcase n times." \
@@ -66,6 +66,9 @@ def sanity_check(self, args):
         if args.min_crashes < 1:
             self.parser.error("'--min-crashes' value must be positive")
 
+        if args.no_harness:
+            args.relaunch = 1
+
         if args.repeat < 1:
             self.parser.error("'--repeat' value must be positive")
 
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 4cb24261..8d74ef27 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -38,6 +38,7 @@ def __init__(self, ignore, server, target, testcases, any_crash=False, signature
         self.server = server
         self.status = None
         self.target = target
+        # TODO: make testcases getter and setter
         self.testcases = testcases
         self._any_crash = any_crash
         self._harness = None
@@ -161,6 +162,7 @@ def run(self, repeat=1, min_results=1):
         assert min_results <= repeat
         self.status = Status.start()
 
+        # TODO: should only be called if needed
         self._unpack_tests()
 
         server_map = ServerMap()
@@ -333,7 +335,14 @@ def main(cls, args):
         target = None
         tmp_prefs = None
         try:
-            relaunch = min(args.relaunch, args.repeat)
+            if args.no_harness and len(testcases) > 1:
+                LOG.error("'--no-harness' cannot be used with multiple testcases")
+                return 1
+            repeat = max(args.min_crashes, args.repeat)
+            relaunch = min(args.relaunch, repeat)
+            assert not args.no_harness or (args.no_harness and relaunch == 1)
+            LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
+                     repeat, args.min_crashes, relaunch)
             LOG.debug("initializing the Target")
             target = load_target(args.platform)(
                 args.binary,
@@ -367,12 +376,6 @@ def main(cls, args):
             # launch HTTP server used to serve test cases
             with Sapphire(auto_close=1, timeout=args.timeout) as server:
                 target.reverse(server.port, server.port)
-                if args.no_harness:
-                    LOG.debug("--no-harness specified relaunch set to 1")
-                    args.relaunch = 1
-                args.repeat = max(args.min_crashes, args.repeat)
-                LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
-                         args.repeat, args.min_crashes, relaunch)
                 replay = ReplayManager(
                     args.ignore,
                     server,
@@ -381,7 +384,7 @@ def main(cls, args):
                     any_crash=args.any_crash,
                     signature=signature,
                     use_harness=not args.no_harness)
-                success = replay.run(repeat=args.repeat, min_results=args.min_crashes)
+                success = replay.run(repeat=repeat, min_results=args.min_crashes)
             if args.logs:
                 replay.report_to_filesystem(
                     args.logs,
@@ -395,7 +398,7 @@ def main(cls, args):
             return 1
 
         except (TargetLaunchError, TargetLaunchTimeout):
-            if args.logs:
+            if args.logs and replay is not None:
                 replay.report_to_filesystem(
                     args.logs,
                     replay.reports,
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index cb8c99b2..b6b404c4 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -53,6 +53,10 @@ def test_args_01(capsys, tmp_path):
     with raises(SystemExit):
         ReplayArgs().parse_args([str(exe), str(inp), "--any-crash", "--sig", "x"])
     assert "error: signature is ignored when running with '--any-crash'" in capsys.readouterr()[-1]
+    # force relaunch == 1 with --no-harness
+    args = ReplayArgs().parse_args([str(exe), str(inp), "--no-harness"])
+    assert args.relaunch == 1
+
 
 def test_main_01(mocker, tmp_path):
     """test ReplayManager.main()"""
@@ -117,33 +121,43 @@ def _fake_save_logs(result_logs):
 def test_main_02(mocker):
     """test ReplayManager.main() failure cases"""
     mocker.patch("grizzly.replay.replay.FuzzManagerReporter", autospec=True)
-    mocker.patch("grizzly.replay.replay.load_target", autospec=True)
+    fake_load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
     mocker.patch("grizzly.replay.replay.Sapphire", autospec=True)
-    mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
+    fake_tc = mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
     # setup args
     args = mocker.Mock(
         ignore=None,
         input="test",
         min_crashes=1,
+        no_harenss=True,
         prefs=None,
         relaunch=1,
         repeat=1,
         sig=None)
-
+    # target launch error
     mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchError)
     assert ReplayManager.main(args) == 1
-
+    # target launch timeout
     mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchTimeout)
     assert ReplayManager.main(args) == 1
-
-    mocker.patch("grizzly.replay.replay.load_target", side_effect=KeyboardInterrupt)
+    # user abort
+    fake_load_target.side_effect = KeyboardInterrupt
     assert ReplayManager.main(args) == 1
-
-    mocker.patch("grizzly.replay.replay.TestCase.load", side_effect=TestCaseLoadFailure)
+    # invalid test case
+    fake_load_target.reset_mock()
+    fake_tc.load.side_effect = TestCaseLoadFailure
     assert ReplayManager.main(args) == 1
-
-    mocker.patch("grizzly.replay.replay.TestCase.load", return_value=list())
+    assert fake_load_target.call_count == 0
+    # no test cases
+    fake_tc.load.side_effect = None
+    fake_tc.load.return_value = list()
+    assert ReplayManager.main(args) == 1
+    assert fake_load_target.call_count == 0
+    # multiple test cases with --no-harness
+    fake_load_target.reset_mock()
+    fake_tc.load.return_value = [mocker.Mock(), mocker.Mock()]
     assert ReplayManager.main(args) == 1
+    assert fake_load_target.call_count == 0
 
 def test_main_03(mocker):
     """test ReplayManager.main() loading GRZ_FORCED_CLOSE from test case"""

From 43a3076348689e640b1c60f1f205bd153787e54c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 27 Aug 2020 12:18:59 -0700
Subject: [PATCH 009/531] [replay] Pass testcases directly to
 ReplayManager.run()

---
 grizzly/replay/replay.py      | 281 +++++++++++++++++-----------------
 grizzly/replay/test_replay.py | 119 ++++++--------
 2 files changed, 188 insertions(+), 212 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 8d74ef27..b906e204 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -29,17 +29,15 @@
 class ReplayManager(object):
     HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
 
-    __slots__ = ("ignore", "server", "status", "target", "testcases", "_any_crash",
+    __slots__ = ("ignore", "server", "status", "target", "_any_crash",
                  "_harness", "_reports_expected", "_reports_other", "_runner",
                  "_signature", "_unpacked")
 
-    def __init__(self, ignore, server, target, testcases, any_crash=False, signature=None, use_harness=True):
+    def __init__(self, ignore, server, target, any_crash=False, signature=None, use_harness=True):
         self.ignore = ignore
         self.server = server
         self.status = None
         self.target = target
-        # TODO: make testcases getter and setter
-        self.testcases = testcases
         self._any_crash = any_crash
         self._harness = None
         self._reports_expected = dict()
@@ -47,7 +45,6 @@ def __init__(self, ignore, server, target, testcases, any_crash=False, signature
         self._runner = Runner(self.server, self.target)
         # TODO: make signature a property
         self._signature = signature
-        self._unpacked = list()
         if use_harness:
             with open(self.HARNESS_FILE, "rb") as in_fp:
                 self._harness = in_fp.read()
@@ -58,21 +55,6 @@ def __enter__(self):
     def __exit__(self, *exc):
         self.cleanup()
 
-    def _unpack_tests(self):
-        """Unpack testcase data to known locations.
-
-        Args:
-            None
-
-        Returns:
-            None
-        """
-        assert not self._unpacked
-        for test in self.testcases:
-            dst_path = mkdtemp(prefix="tc_", dir=grz_tmp("serve"))
-            test.dump(dst_path)
-            self._unpacked.append(dst_path)
-
     def cleanup(self):
         """Remove temporary files from disk.
 
@@ -88,8 +70,6 @@ def cleanup(self):
         for report in self._reports_other.values():
             report.cleanup()
         self._reports_other.clear()
-        for tc_path in self._unpacked:
-            rmtree(tc_path)
         if self.status is not None:
             self.status.cleanup()
 
@@ -146,11 +126,12 @@ def report_to_filesystem(path, reports, other_reports=None, tests=None):
             for report in other_reports:
                 reporter.submit(tests, report=report)
 
-    def run(self, repeat=1, min_results=1):
+    def run(self, testcases, repeat=1, min_results=1):
         """Run testcase replay.
 
         Args:
-            repeat (int): Maximum number of times to run the test case.
+            testcases (list): One or more TestCases to run.
+            repeat (int): Maximum number of times to run the TestCase.
             min_results (int): Minimum number of results needed before run can
                                be considered successful.
 
@@ -160,10 +141,10 @@ def run(self, repeat=1, min_results=1):
         assert repeat > 0
         assert min_results > 0
         assert min_results <= repeat
-        self.status = Status.start()
 
-        # TODO: should only be called if needed
-        self._unpack_tests()
+        self.status = Status.start()
+        test_count = len(testcases)
+        assert test_count > 0
 
         server_map = ServerMap()
         if self._harness is not None:
@@ -177,122 +158,139 @@ def _dyn_close():  # pragma: no cover
             server_map.set_dynamic_response("grz_harness", lambda: self._harness, mime_type="text/html")
 
         success = False
-        test_count = len(self.testcases)
-        for _ in range(repeat):
-            self.status.iteration += 1
-            if self.target.closed:
-                LOG.info("Launching target...")
-                if self._harness is None:
-                    location = self._runner.location(
-                        "/grz_current_test",
-                        self.server.port)
-                else:
-                    location = self._runner.location(
-                        "/grz_harness",
-                        self.server.port,
-                        close_after=self.target.rl_reset * test_count,
-                        forced_close=self.target.forced_close)
-                try:
-                    # The environment from the initial testcase is used because
-                    # a sequence of testcases is expected to be run without
-                    # relaunching the Target to match the functionality of
-                    # Grizzly. If this is not the case each TestCase should
-                    # be run individually.
-                    self._runner.launch(location, env_mod=self.testcases[0].env_vars)
-                except TargetLaunchError:
-                    LOG.error("Target launch error. Check browser logs for details.")
+        unpacked = list()
+        try:
+            LOG.debug("unpacking testcases (%d)...", test_count)
+            for test in testcases:
+                dst_path = mkdtemp(prefix="tc_", dir=grz_tmp("serve"))
+                test.dump(dst_path)
+                unpacked.append(dst_path)
+            # perform iterations
+            for _ in range(repeat):
+                self.status.iteration += 1
+                if self.target.closed:
+                    LOG.info("Launching target...")
+                    if self._harness is None:
+                        location = self._runner.location(
+                            "/grz_current_test",
+                            self.server.port)
+                    else:
+                        location = self._runner.location(
+                            "/grz_harness",
+                            self.server.port,
+                            close_after=self.target.rl_reset * test_count,
+                            forced_close=self.target.forced_close)
+                    try:
+                        # The environment from the initial testcase is used because
+                        # a sequence of testcases is expected to be run without
+                        # relaunching the Target to match the functionality of
+                        # Grizzly. If this is not the case each TestCase should
+                        # be run individually.
+                        self._runner.launch(location, env_mod=testcases[0].env_vars)
+                    except TargetLaunchError:
+                        LOG.error("Target launch error. Check browser logs for details.")
+                        log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
+                        self.target.save_logs(log_path)
+                        self._reports_other["STARTUP"] = Report.from_path(log_path)
+                        raise
+                self.target.step()
+                LOG.info("Performing replay (%d/%d)...", self.status.iteration, repeat)
+                # run tests
+                for test_idx in range(test_count):
+                    LOG.debug("running test: %d of %d", test_idx + 1, test_count)
+                    # update redirects
+                    if self._harness is not None:
+                        next_idx = (test_idx + 1) % test_count
+                        server_map.set_redirect(
+                            "grz_next_test",
+                            testcases[next_idx].landing_page,
+                            required=True)
+                    server_map.set_redirect(
+                        "grz_current_test",
+                        testcases[test_idx].landing_page,
+                        required=False)
+                    # run testcase
+                    self._runner.run(
+                        self.ignore,
+                        server_map,
+                        testcases[test_idx],
+                        test_path=unpacked[test_idx],
+                        wait_for_callback=self._harness is None)
+                    if self._runner.result != self._runner.COMPLETE:
+                        break
+                # process results
+                if self._runner.result == self._runner.FAILED:
                     log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
                     self.target.save_logs(log_path)
-                    self._reports_other["STARTUP"] = Report.from_path(log_path)
-                    raise
-            self.target.step()
-            LOG.info("Performing replay (%d/%d)...", self.status.iteration, repeat)
-            # run test cases
-            for test_idx in range(test_count):
-                LOG.debug("running test: %d of %d", test_idx + 1, test_count)
-                if self._harness is not None:
-                    next_idx = (test_idx + 1) % test_count
-                    server_map.set_redirect("grz_next_test", self.testcases[next_idx].landing_page, required=True)
-                server_map.set_redirect("grz_current_test", self.testcases[test_idx].landing_page, required=False)
-                self._runner.run(
-                    self.ignore,
-                    server_map,
-                    self.testcases[test_idx],
-                    test_path=self._unpacked[test_idx],
-                    wait_for_callback=self._harness is None)
-                if self._runner.result != self._runner.COMPLETE:
-                    break
-            # process results
-            if self._runner.result == self._runner.FAILED:
-                log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
-                self.target.save_logs(log_path)
-                report = Report.from_path(log_path)
-                # check signatures
-                crash_info = report.crash_info(self.target.binary)
-                short_sig = crash_info.createShortSignature()
-                if not self._any_crash and self._signature is None and short_sig != "No crash detected":
-                    # signature has not been specified use the first one created
-                    self._signature = report.crash_signature(crash_info)
-                if short_sig == "No crash detected":
-                    # TODO: verify report.major == "NO_STACK" otherwise FM failed to parse the logs
-                    # TODO: change this to support hangs/timeouts, etc
-                    LOG.info("Result: No crash detected")
-                    crash_hash = None
-                elif self._any_crash or self._signature.matches(crash_info):
-                    self.status.count_result(short_sig)
-                    LOG.info("Result: %s (%s:%s)",
-                             short_sig, report.major[:8], report.minor[:8])
-                    crash_hash = report.crash_hash(crash_info)
-                    if crash_hash not in self._reports_expected:
-                        LOG.debug("now tracking %s", crash_hash)
-                        self._reports_expected[crash_hash] = report
-                        report = None  # don't remove report
-                    assert self._any_crash or len(self._reports_expected) == 1
-                else:
-                    LOG.info("Result: Different signature: %s (%s:%s)",
-                             short_sig, report.major[:8], report.minor[:8])
+                    report = Report.from_path(log_path)
+                    # check signatures
+                    crash_info = report.crash_info(self.target.binary)
+                    short_sig = crash_info.createShortSignature()
+                    if not self._any_crash and self._signature is None and short_sig != "No crash detected":
+                        # signature has not been specified use the first one created
+                        self._signature = report.crash_signature(crash_info)
+                    if short_sig == "No crash detected":
+                        # TODO: verify report.major == "NO_STACK" otherwise FM failed to parse the logs
+                        # TODO: change this to support hangs/timeouts, etc
+                        LOG.info("Result: No crash detected")
+                        crash_hash = None
+                    elif self._any_crash or self._signature.matches(crash_info):
+                        self.status.count_result(short_sig)
+                        LOG.info("Result: %s (%s:%s)",
+                                 short_sig, report.major[:8], report.minor[:8])
+                        crash_hash = report.crash_hash(crash_info)
+                        if crash_hash not in self._reports_expected:
+                            LOG.debug("now tracking %s", crash_hash)
+                            self._reports_expected[crash_hash] = report
+                            report = None  # don't remove report
+                        assert self._any_crash or len(self._reports_expected) == 1
+                    else:
+                        LOG.info("Result: Different signature: %s (%s:%s)",
+                                 short_sig, report.major[:8], report.minor[:8])
+                        self.status.ignored += 1
+                        crash_hash = report.crash_hash(crash_info)
+                        if crash_hash not in self._reports_other:
+                            LOG.debug("now tracking %s", crash_hash)
+                            self._reports_other[crash_hash] = report
+                            report = None  # don't remove report
+                    # purge untracked report
+                    if report is not None:
+                        if crash_hash is not None:
+                            LOG.debug("already tracking %s", crash_hash)
+                        report.cleanup()
+                        report = None
+                elif self._runner.result == self._runner.IGNORED:
                     self.status.ignored += 1
-                    crash_hash = report.crash_hash(crash_info)
-                    if crash_hash not in self._reports_other:
-                        LOG.debug("now tracking %s", crash_hash)
-                        self._reports_other[crash_hash] = report
-                        report = None  # don't remove report
-                # purge untracked report
-                if report is not None:
-                    if crash_hash is not None:
-                        LOG.debug("already tracking %s", crash_hash)
-                    report.cleanup()
-                    report = None
-            elif self._runner.result == self._runner.IGNORED:
-                self.status.ignored += 1
-                LOG.info("Result: Ignored (%d)", self.status.ignored)
-            elif self._runner.result == self._runner.ERROR:
-                LOG.error("ERROR: Replay malfunction, test case was not served")
-                break
-
-            # check status and exit early if possible
-            if repeat - self.status.iteration + self.status.results < min_results:
-                if self.status.iteration < repeat:
-                    LOG.debug("skipping remaining attempts")
-                # failed to reproduce issue
-                LOG.debug("results (%d) < expected (%s) after %d attempts",
-                          self.status.results, min_results, self.status.iteration)
-                break
-            if self.status.results >= min_results:
-                assert self.status.results == min_results
-                success = True
-                LOG.debug("results == expected (%s) after %d attempts",
-                          min_results, self.status.iteration)
-                break
-
-            # warn about large browser logs
-            #self.status.log_size = self.target.log_size()
-            #if self.status.log_size > self.TARGET_LOG_SIZE_WARN:
-            #    LOG.warning("Large browser logs: %dMBs", (self.status.log_size / 0x100000))
-
-            # trigger relaunch by closing the browser if needed
-            self.target.check_relaunch()
+                    LOG.info("Result: Ignored (%d)", self.status.ignored)
+                elif self._runner.result == self._runner.ERROR:
+                    LOG.error("ERROR: Replay malfunction, test case was not served")
+                    break
 
+                # check status and exit early if possible
+                if repeat - self.status.iteration + self.status.results < min_results:
+                    if self.status.iteration < repeat:
+                        LOG.debug("skipping remaining attempts")
+                    # failed to reproduce issue
+                    LOG.debug("results (%d) < expected (%s) after %d attempts",
+                              self.status.results, min_results, self.status.iteration)
+                    break
+                if self.status.results >= min_results:
+                    assert self.status.results == min_results
+                    success = True
+                    LOG.debug("results == expected (%s) after %d attempts",
+                              min_results, self.status.iteration)
+                    break
+
+                # warn about large browser logs
+                #self.status.log_size = self.target.log_size()
+                #if self.status.log_size > self.TARGET_LOG_SIZE_WARN:
+                #    LOG.warning("Large browser logs: %dMBs", (self.status.log_size / 0x100000))
+
+                # trigger relaunch by closing the browser if needed
+                self.target.check_relaunch()
+        finally:
+            for tc_path in unpacked:
+                rmtree(tc_path)
         if success:
             LOG.info("Result successfully reproduced")
         else:
@@ -380,17 +378,16 @@ def main(cls, args):
                     args.ignore,
                     server,
                     target,
-                    testcases,
                     any_crash=args.any_crash,
                     signature=signature,
                     use_harness=not args.no_harness)
-                success = replay.run(repeat=repeat, min_results=args.min_crashes)
+                success = replay.run(testcases, repeat=repeat, min_results=args.min_crashes)
             if args.logs:
                 replay.report_to_filesystem(
                     args.logs,
                     replay.reports,
                     replay.other_reports,
-                    replay.testcases if args.include_test else None)
+                    testcases if args.include_test else None)
             # TODO: add fuzzmanager reporting
             return 0 if success else 1
 
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index a99015f4..bd02dbbe 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -33,7 +33,6 @@ def test_replay_01(mocker):
     replay = ReplayManager([], mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target), [mocker.Mock()])
     replay._reports_expected = {"A":  mocker.Mock(spec=Report)}
     replay._reports_other = {"B":  mocker.Mock(spec=Report)}
-    assert not replay._unpacked
     replay.status = mocker.Mock(spec=Status)
     ereport = tuple(replay.reports)[0]
     oreport = tuple(replay.other_reports)[0]
@@ -42,8 +41,9 @@ def test_replay_01(mocker):
     assert oreport.cleanup.call_count == 1
     assert replay.status.cleanup.call_count == 1
 
-def test_replay_02(mocker):
+def test_replay_02(mocker, tmp_path):
     """test ReplayManager.run() - no repro"""
+    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target)
@@ -52,18 +52,18 @@ def test_replay_02(mocker):
     target.detect_failure.return_value = Target.RESULT_NONE
     target.forced_close = True
     target.rl_reset = 1
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, testcases, use_harness=True) as replay:
-        assert not replay._unpacked
-        assert not replay.run()
-        assert replay._unpacked
-        assert replay.status.ignored == 0
-        assert replay.status.iteration == 1
-        assert replay.status.results == 0
-        assert not replay.reports
+    with TestCase("land_page.html", "redirect.html", "test-adapter") as testcase:
+        with ReplayManager([], server, target, use_harness=True) as replay:
+            assert not replay.run([testcase])
+            assert replay.status.ignored == 0
+            assert replay.status.iteration == 1
+            assert replay.status.results == 0
+            assert not replay.reports
+        assert not any(tmp_path.glob("*"))
 
-def test_replay_03(mocker):
+def test_replay_03(mocker, tmp_path):
     """test ReplayManager.run() - successful repro"""
+    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target)
@@ -71,14 +71,15 @@ def test_replay_03(mocker):
     target.binary = "C:\\fake_bin"
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.save_logs = _fake_save_logs_result
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, testcases, use_harness=False) as replay:
-        assert replay.run()
-        assert replay.status.ignored == 0
-        assert replay.status.iteration == 1
-        assert replay.status.results == 1
-        assert len(replay.reports) == 1
-        assert not replay.other_reports
+    with TestCase("land_page.html", "redirect.html", "test-adapter") as testcase:
+        with ReplayManager([], server, target, use_harness=False) as replay:
+            assert replay.run([testcase])
+            assert replay.status.ignored == 0
+            assert replay.status.iteration == 1
+            assert replay.status.results == 1
+            assert len(replay.reports) == 1
+            assert not replay.other_reports
+        assert not any(tmp_path.glob("*"))
 
 def test_replay_04(mocker):
     """test ReplayManager.run() - Error (landing page not requested/served)"""
@@ -88,8 +89,8 @@ def test_replay_04(mocker):
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, testcases, use_harness=False) as replay:
-        assert not replay.run(repeat=2)
+    with ReplayManager([], server, target, use_harness=False) as replay:
+        assert not replay.run(testcases, repeat=2)
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 0
@@ -105,8 +106,8 @@ def test_replay_05(mocker):
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = Target.RESULT_IGNORED
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, testcases, use_harness=False) as replay:
-        assert not replay.run()
+    with ReplayManager([], server, target, use_harness=False) as replay:
+        assert not replay.run(testcases)
         assert replay.status.ignored == 1
         assert replay.status.iteration == 1
         assert replay.status.results == 0
@@ -117,25 +118,24 @@ def test_replay_06(mocker):
     """test ReplayManager.run() - early exit"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target)
+    target = mocker.Mock(spec=Target, binary="path/fake_bin")
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
-    target.binary = "path/fake_bin"
     target.save_logs = _fake_save_logs_result
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     # early failure
     target.detect_failure.side_effect = [Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_NONE]
-    with ReplayManager([], server, target, testcases, use_harness=False) as replay:
-        assert not replay.run(repeat=4, min_results=3)
+    with ReplayManager([], server, target, use_harness=False) as replay:
+        assert not replay.run(testcases, repeat=4, min_results=3)
         assert replay.status.iteration == 3
         assert replay.status.results == 1
         assert replay.status.ignored == 1
         assert len(replay.reports) == 1
     # early success
     target.detect_failure.side_effect = [Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_FAILURE]
-    with ReplayManager([], server, target, testcases, use_harness=False) as replay:
-        assert replay.run(repeat=4, min_results=2)
+    with ReplayManager([], server, target, use_harness=False) as replay:
+        assert replay.run(testcases, repeat=4, min_results=2)
         assert replay.status.iteration == 3
         assert replay.status.results == 2
         assert replay.status.ignored == 1
@@ -149,27 +149,21 @@ def test_replay_07(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report)
     report_0.crash_info.return_value.createShortSignature.return_value = "No crash detected"
-    report_1 = mocker.Mock(spec=Report)
+    report_1 = mocker.Mock(spec=Report, major="0123abcd", minor="01239999")
     report_1.crash_info.return_value.createShortSignature.return_value = "[@ test1]"
-    report_1.major = "0123abcd"
-    report_1.minor = "01239999"
-    report_2 = mocker.Mock(spec=Report)
+    report_2 = mocker.Mock(spec=Report, major="0123abcd", minor="abcd9876")
     report_2.crash_info.return_value.createShortSignature.return_value = "[@ test2]"
-    report_2.major = "0123abcd"
-    report_2.minor = "abcd9876"
     report.from_path.side_effect = (report_0, report_1, report_2)
-    server = mocker.Mock(spec=Sapphire)
-    server.port = 0x1337
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, False)
-    target = mocker.Mock(spec=Target)
+    target = mocker.Mock(spec=Target, binary="fake_bin")
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
-    target.binary = "fake_bin"
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, testcases, signature=signature, use_harness=False) as replay:
-        assert not replay.run(repeat=3, min_results=2)
+    with ReplayManager([], server, target, signature=signature, use_harness=False) as replay:
+        assert not replay.run(testcases, repeat=3, min_results=2)
         assert replay._signature == signature
         assert report.from_path.call_count == 3
         assert replay.status.iteration == 3
@@ -188,26 +182,21 @@ def test_replay_08(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report)
     report_0.crash_info.return_value.createShortSignature.return_value = "No crash detected"
-    report_1 = mocker.Mock(spec=Report)
+    report_1 = mocker.Mock(spec=Report, major="0123abcd", minor="01239999")
     report_1.crash_info.return_value.createShortSignature.return_value = "[@ test1]"
     report_1.crash_hash.return_value = "hash1"
-    report_1.major = "0123abcd"
-    report_1.minor = "01239999"
-    report_2 = mocker.Mock(spec=Report)
+    report_2 = mocker.Mock(spec=Report, major="0123abcd", minor="abcd9876")
     report_2.crash_info.return_value.createShortSignature.return_value = "[@ test2]"
     report_2.crash_hash.return_value = "hash2"
-    report_2.major = "0123abcd"
-    report_2.minor = "abcd9876"
     report.from_path.side_effect = (report_0, report_1, report_2)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target)
+    target = mocker.Mock(spec=Target, binary="fake_bin")
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
-    target.binary = "fake_bin"
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, testcases, any_crash=True, use_harness=False) as replay:
-        assert replay.run(repeat=3, min_results=2)
+    with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
+        assert replay.run(testcases, repeat=3, min_results=2)
         assert replay._signature is None
         assert report.from_path.call_count == 3
         assert replay.status.iteration == 3
@@ -264,9 +253,9 @@ def test_replay_10(mocker, tmp_path):
     target = mocker.Mock(spec=Target)
     target.launch.side_effect = TargetLaunchError
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
-    with ReplayManager([], server, target, testcases, use_harness=False) as replay:
+    with ReplayManager([], server, target, use_harness=False) as replay:
         with raises(TargetLaunchError):
-            replay.run()
+            replay.run(testcases)
         assert not any(replay.reports)
         assert any(replay.other_reports)
         assert "STARTUP" in replay._reports_other
@@ -285,12 +274,13 @@ def test_replay_11(mocker):
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, testcases, use_harness=True) as replay:
-        assert not replay.run()
+    with ReplayManager([], server, target, use_harness=True) as replay:
+        assert not replay.run(testcases)
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 0
         assert not replay.reports
+    assert all(x.dump.call_count == 1 for x in testcases)
 
 def test_replay_12(mocker):
     """test ReplayManager.run() - multiple TestCases - successful repro"""
@@ -308,22 +298,11 @@ def test_replay_12(mocker):
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, testcases, use_harness=True) as replay:
-        assert replay.run()
+    with ReplayManager([], server, target, use_harness=True) as replay:
+        assert replay.run(testcases)
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 1
         assert len(replay.reports) == 1
         assert not replay.other_reports
-
-def test_replay_13(mocker, tmp_path):
-    """test ReplayManager._unpacked()"""
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
-    testcase = mocker.Mock(spec=TestCase, env_vars=[], optional=[])
-    mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
-    with ReplayManager([], server, mocker.Mock(spec=Target), [testcase]) as replay:
-        assert not replay._unpacked
-        replay._unpack_tests()
-        assert replay._unpacked
-        assert replay._unpacked[0] == str(tmp_path)
-    assert testcase.dump.call_count == 1
+    assert all(x.dump.call_count == 1 for x in testcases)

From 7c407f9b157af0d1c0ad1fd4b7a143c37dee6976 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 1 Sep 2020 11:20:07 -0700
Subject: [PATCH 010/531] [replay] Pass empty list to Reporter.submit() instead
 of None

---
 grizzly/replay/replay.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index b906e204..8bb50973 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -118,13 +118,13 @@ def report_to_filesystem(path, reports, other_reports=None, tests=None):
                 report_path=pathjoin(path, "reports"),
                 major_bucket=False)
             for report in reports:
-                reporter.submit(tests, report=report)
+                reporter.submit(tests or [], report=report)
         if other_reports:
             reporter = FilesystemReporter(
                 report_path=pathjoin(path, "other_reports"),
                 major_bucket=False)
             for report in other_reports:
-                reporter.submit(tests, report=report)
+                reporter.submit(tests or [], report=report)
 
     def run(self, testcases, repeat=1, min_results=1):
         """Run testcase replay.

From 7536c632003c7472043736a62ba502b50b4edc3d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 1 Sep 2020 17:19:18 -0700
Subject: [PATCH 011/531] [tests] Add ReplayManager.report_to_filesystem() use
 case

---
 grizzly/replay/test_replay.py | 41 ++++++++++++++++++++++++-----------
 1 file changed, 28 insertions(+), 13 deletions(-)

diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index bd02dbbe..b08d64f1 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -215,24 +215,27 @@ def test_replay_09(mocker, tmp_path):
     # no reports
     ReplayManager.report_to_filesystem(str(tmp_path), [])
     assert not any(tmp_path.glob("*"))
-    # with reports
-    reports_expected = list()
-    reports_expected.append(mocker.Mock(spec=Report))
-    reports_expected[-1].prefix = "expected"
+    # with reports and tests
     (tmp_path / "report_expected").mkdir()
-    reports_expected[-1].path = str(tmp_path / "report_expected")
-    reports_other = list()
-    reports_other.append(mocker.Mock(spec=Report))
-    reports_other[-1].prefix = "other1"
+    expected = [
+        mocker.Mock(
+            spec=Report,
+            path=str(tmp_path / "report_expected"),
+            prefix="expected")]
     (tmp_path / "report_other1").mkdir()
-    reports_other[-1].path = str(tmp_path / "report_other1")
-    reports_other.append(mocker.Mock(spec=Report))
-    reports_other[-1].prefix = "other2"
     (tmp_path / "report_other2").mkdir()
-    reports_other[-1].path = str(tmp_path / "report_other2")
+    other = [
+        mocker.Mock(
+            spec=Report,
+            path=str(tmp_path / "report_other1"),
+            prefix="other1"),
+        mocker.Mock(
+            spec=Report,
+            path=str(tmp_path / "report_other2"),
+            prefix="other2")]
     test = mocker.Mock(spec=TestCase)
     path = tmp_path / "dest"
-    ReplayManager.report_to_filesystem(str(path), reports_expected, reports_other, tests=[test])
+    ReplayManager.report_to_filesystem(str(path), expected, other, tests=[test])
     assert test.dump.call_count == 3  # called once per report
     assert not (tmp_path / "report_expected").is_dir()
     assert not (tmp_path / "report_other1").is_dir()
@@ -243,6 +246,18 @@ def test_replay_09(mocker, tmp_path):
     assert (path / "other_reports").is_dir()
     assert (path / "other_reports" / "other1_logs").is_dir()
     assert (path / "other_reports" / "other2_logs").is_dir()
+    # with reports and not tests
+    (tmp_path / "report_expected").mkdir()
+    expected = [
+        mocker.Mock(
+            spec=Report,
+            path=str(tmp_path / "report_expected"),
+            prefix="expected")]
+    path = tmp_path / "dest2"
+    ReplayManager.report_to_filesystem(str(path), expected)
+    assert not (tmp_path / "report_expected").is_dir()
+    assert path.is_dir()
+    assert (path / "reports" / "expected_logs").is_dir()
 
 def test_replay_10(mocker, tmp_path):
     """test ReplayManager.run() - TargetLaunchError"""

From 850ee353c822aac4ae7be8813c604b116e98e393 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 1 Sep 2020 17:20:59 -0700
Subject: [PATCH 012/531] [replay] Avoid leaving temp directories on disk in
 failure case

---
 grizzly/replay/replay.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 8bb50973..0b40dcf6 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -163,8 +163,8 @@ def _dyn_close():  # pragma: no cover
             LOG.debug("unpacking testcases (%d)...", test_count)
             for test in testcases:
                 dst_path = mkdtemp(prefix="tc_", dir=grz_tmp("serve"))
-                test.dump(dst_path)
                 unpacked.append(dst_path)
+                test.dump(dst_path)
             # perform iterations
             for _ in range(repeat):
                 self.status.iteration += 1

From ce9034becfac15cd6cebd91c9e79fc116d50a5ad Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 2 Sep 2020 20:09:28 -0700
Subject: [PATCH 013/531] Add RunResult

---
 grizzly/common/__init__.py    |  6 +--
 grizzly/common/runner.py      | 55 ++++++++++++------------
 grizzly/common/test_runner.py | 79 +++++++++++++++++------------------
 grizzly/reduce/reduce.py      | 16 +++----
 grizzly/replay/replay.py      | 12 +++---
 grizzly/session.py            | 22 +++++-----
 grizzly/test_session.py       | 47 ++++++++-------------
 7 files changed, 113 insertions(+), 124 deletions(-)

diff --git a/grizzly/common/__init__.py b/grizzly/common/__init__.py
index 0fe3d642..c95dee8a 100644
--- a/grizzly/common/__init__.py
+++ b/grizzly/common/__init__.py
@@ -6,7 +6,7 @@
 from .adapter import Adapter, AdapterError
 from .iomanager import IOManager, ServerMap
 from .reporter import FilesystemReporter, FuzzManagerReporter, Report, Reporter, S3FuzzManagerReporter
-from .runner import Runner
+from .runner import Runner, RunResult
 from .status import ReducerStats, Status
 from .storage import TestCaseLoadFailure, TestCase, TestFile, TestFileExists
 from .utils import grz_tmp
@@ -14,7 +14,7 @@
 
 __all__ = (
     "Adapter", "AdapterError", "FilesystemReporter", "FuzzManagerReporter", "grz_tmp", "IOManager",
-    "ReducerStats", "Report", "Reporter", "Runner", "S3FuzzManagerReporter", "ServerMap", "Status",
-    "TestCase", "TestCaseLoadFailure", "TestFile", "TestFileExists")
+    "ReducerStats", "Report", "Reporter", "Runner", "RunResult", "S3FuzzManagerReporter",
+    "ServerMap", "Status", "TestCase", "TestCaseLoadFailure", "TestFile", "TestFileExists")
 __author__ = "Jesse Schwartzentruber"
 __credits__ = ["Jesse Schwartzentruber", "Tyson Smith"]
diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 46630f6c..2933df2b 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -11,7 +11,7 @@
 from ..target import TargetLaunchTimeout
 from .utils import grz_tmp
 
-__all__ = ("Runner",)
+__all__ = ("Runner", "RunResult")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
@@ -74,12 +74,7 @@ def schedule_poll(self, initial=False, now=None):
 
 
 class Runner(object):
-    COMPLETE = 1
-    ERROR = 2
-    FAILED = 3
-    IGNORED = 4
-
-    __slots__ = ("_idle", "_server", "_target", "result", "served", "timeout")
+    __slots__ = ("_idle", "_server", "_target")
 
     def __init__(self, server, target, idle_threshold=0, idle_delay=60):
         if idle_threshold > 0:
@@ -88,9 +83,6 @@ def __init__(self, server, target, idle_threshold=0, idle_delay=60):
             self._idle = None
         self._server = server  # a sapphire instance to serve the test case
         self._target = target  # target to run test case
-        self.result = None
-        self.served = None
-        self.timeout = False
 
     def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
         """Launch a target and open `location`.
@@ -164,12 +156,8 @@ def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait
                                        framework should move on.
 
         Returns:
-            None
+            RunResult: Files served, status and timeout flag from the run.
         """
-        # set initial state
-        self.served = None
-        self.result = None
-        self.timeout = False
         if self._idle is not None:
             self._idle.schedule_poll(initial=True)
         try:
@@ -181,7 +169,7 @@ def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait
                 wwwdir = test_path
             # serve the test case
             serve_start = time()
-            server_status, self.served = self._server.serve_path(
+            server_status, served = self._server.serve_path(
                 wwwdir,
                 continue_cb=self._keep_waiting,
                 forever=wait_for_callback,
@@ -192,31 +180,32 @@ def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait
             # remove temporary files
             if test_path is None:
                 rmtree(wwwdir)
+        result = RunResult(served, timeout=server_status == SERVED_TIMEOUT)
         # TODO: fix calling TestCase.add_batch() for multi-test replay
         # add all include files that were served
         for url, resource in server_map.include.items():
-            testcase.add_batch(resource.target, self.served, prefix=url)
-        self.timeout = server_status == SERVED_TIMEOUT
-        served_lpage = testcase.landing_page in self.served
+            testcase.add_batch(resource.target, result.served, prefix=url)
+        served_lpage = testcase.landing_page in result.served
         if not served_lpage:
             LOG.debug("%r not served!", testcase.landing_page)
-        elif coverage and not self.timeout:
+        elif coverage and not result.timeout:
             # dump_coverage() should be called before detect_failure()
             # to help catch any coverage related issues.
             self._target.dump_coverage()
         # detect failure
-        failure_detected = self._target.detect_failure(ignore, self.timeout)
+        failure_detected = self._target.detect_failure(ignore, result.timeout)
         if failure_detected == self._target.RESULT_FAILURE:
-            self.result = self.FAILED
+            result.status = RunResult.FAILED
         elif not served_lpage:
             # something is wrong so close the target
             # previous iteration put target in a bad state?
             self._target.close()
-            self.result = self.ERROR
+            result.status = RunResult.ERROR
         elif failure_detected == self._target.RESULT_IGNORED:
-            self.result = self.IGNORED
+            result.status = RunResult.IGNORED
         else:
-            self.result = self.COMPLETE
+            result.status = RunResult.COMPLETE
+        return result
 
     def _keep_waiting(self):
         """Callback used by the server to determine if should continue to wait
@@ -226,9 +215,23 @@ def _keep_waiting(self):
             None
 
         Returns:
-            bool: Continue to serve test test case
+            bool: Continue to serve the test case.
         """
         if self._idle is not None and self._idle.is_idle():
             LOG.debug("idle target detected")
             return False
         return self._target.monitor.is_healthy()
+
+
+class RunResult(object):
+    COMPLETE = 1
+    ERROR = 2
+    FAILED = 3
+    IGNORED = 4
+
+    __slots__ = ("served", "status", "timeout")
+
+    def __init__(self, served, status=None, timeout=False):
+        self.served = served
+        self.status = status
+        self.timeout = timeout
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 1d537054..da9be05f 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -9,7 +9,7 @@
 
 from sapphire import Sapphire, SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT, ServerMap
 
-from .runner import _IdleChecker, Runner
+from .runner import _IdleChecker, Runner, RunResult
 from .storage import TestCase
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 
@@ -20,26 +20,23 @@ def test_runner_01(mocker, tmp_path):
     target.detect_failure.return_value = target.RESULT_NONE
     runner = Runner(server, target)
     assert runner._idle is None
-    assert runner.result is None
-    assert runner.served is None
-    assert not runner.timeout
     serv_files = ["a.bin", "/another/file.bin"]
     testcase = mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[])
     # all files served
     server.serve_path.return_value = (SERVED_ALL, serv_files)
-    runner.run([], ServerMap(), testcase)
-    assert runner.result == runner.COMPLETE
-    assert runner.served == serv_files
-    assert not runner.timeout
+    result = runner.run([], ServerMap(), testcase)
+    assert result.status == RunResult.COMPLETE
+    assert result.served == serv_files
+    assert not result.timeout
     assert target.close.call_count == 0
     assert target.dump_coverage.call_count == 0
     assert testcase.dump.call_count == 1
     # some files served
     server.serve_path.return_value = (SERVED_REQUEST, serv_files)
-    runner.run([], ServerMap(), testcase, coverage=True)
-    assert runner.result == runner.COMPLETE
-    assert runner.served == serv_files
-    assert not runner.timeout
+    result = runner.run([], ServerMap(), testcase, coverage=True)
+    assert result.status == RunResult.COMPLETE
+    assert result.served == serv_files
+    assert not result.timeout
     assert target.close.call_count == 0
     assert target.dump_coverage.call_count == 1
     # existing test path
@@ -47,8 +44,8 @@ def test_runner_01(mocker, tmp_path):
     tc_path = (tmp_path / "tc")
     tc_path.mkdir()
     server.serve_path.return_value = (SERVED_ALL, serv_files)
-    runner.run([], ServerMap(), testcase, test_path=str(tc_path))
-    assert runner.result == runner.COMPLETE
+    result = runner.run([], ServerMap(), testcase, test_path=str(tc_path))
+    assert result.status == RunResult.COMPLETE
     assert target.close.call_count == 0
     assert testcase.dump.call_count == 0
     tc_path.is_dir()
@@ -62,17 +59,17 @@ def test_runner_02(mocker):
     # no files served
     server.serve_path.return_value = (SERVED_NONE, [])
     target.detect_failure.return_value = target.RESULT_NONE
-    runner.run([], ServerMap(), testcase)
-    assert runner.result == runner.ERROR
-    assert not runner.served
-    assert not runner.timeout
+    result = runner.run([], ServerMap(), testcase)
+    assert result.status == RunResult.ERROR
+    assert not result.served
+    assert not result.timeout
     assert target.close.call_count == 1
     target.reset_mock()
     # landing page not served
     server.serve_path.return_value = (SERVED_REQUEST, ["harness"])
-    runner.run([], ServerMap(), testcase)
-    assert runner.result == runner.ERROR
-    assert runner.served
+    result = runner.run([], ServerMap(), testcase)
+    assert result.status == RunResult.ERROR
+    assert result.served
     assert target.close.call_count == 1
 
 def test_runner_03(mocker):
@@ -83,10 +80,10 @@ def test_runner_03(mocker):
     server.serve_path.return_value = (SERVED_TIMEOUT, serv_files)
     runner = Runner(server, target)
     target.detect_failure.return_value = target.RESULT_FAILURE
-    runner.run([], ServerMap(), mocker.Mock(spec=TestCase, landing_page="x", optional=[]))
-    assert runner.result == runner.FAILED
-    assert runner.served == serv_files
-    assert runner.timeout
+    result = runner.run([], ServerMap(), mocker.Mock(spec=TestCase, landing_page="x", optional=[]))
+    assert result.status == RunResult.FAILED
+    assert result.served == serv_files
+    assert result.timeout
 
 def test_runner_04(mocker):
     """test reporting failures"""
@@ -98,23 +95,23 @@ def test_runner_04(mocker):
     runner = Runner(server, target)
     # test FAILURE
     target.detect_failure.return_value = target.RESULT_FAILURE
-    runner.run([], ServerMap(), testcase)
-    assert runner.result == runner.FAILED
-    assert runner.served == serv_files
-    assert not runner.timeout
+    result = runner.run([], ServerMap(), testcase)
+    assert result.status == RunResult.FAILED
+    assert result.served == serv_files
+    assert not result.timeout
     # test IGNORED
     target.detect_failure.return_value = target.RESULT_IGNORED
-    runner.run([], ServerMap(), testcase)
-    assert runner.result == runner.IGNORED
-    assert runner.served == serv_files
-    assert not runner.timeout
+    result = runner.run([], ServerMap(), testcase)
+    assert result.status == RunResult.IGNORED
+    assert result.served == serv_files
+    assert not result.timeout
     # failure before serving landing page
     server.serve_path.return_value = (SERVED_REQUEST, ["harness"])
     target.detect_failure.return_value = target.RESULT_FAILURE
-    runner.run([], ServerMap(), testcase)
-    assert runner.result == runner.FAILED
-    assert runner.served
-    assert not runner.timeout
+    result = runner.run([], ServerMap(), testcase)
+    assert result.status == RunResult.FAILED
+    assert result.served
+    assert not result.timeout
 
 def test_runner_05(mocker):
     """test Runner() with idle checking"""
@@ -125,8 +122,8 @@ def test_runner_05(mocker):
     server.serve_path.return_value = (SERVED_REQUEST, serv_files)
     runner = Runner(server, target, idle_threshold=0.01, idle_delay=0.01)
     assert runner._idle is not None
-    runner.run([], ServerMap(), mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[]))
-    assert runner.result == runner.COMPLETE
+    result = runner.run([], ServerMap(), mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[]))
+    assert result.status == RunResult.COMPLETE
     assert target.close.call_count == 0
 
 def test_runner_06(mocker):
@@ -215,8 +212,8 @@ def test_runner_09(mocker, tmp_path):
     serv_files = ["a.b", str(inc1), str(inc2), str(inc3)]
     server.serve_path.return_value = (SERVED_ALL, serv_files)
     with TestCase("a.b", "x", "x") as tcase:
-        runner.run([], smap, tcase)
-        assert runner.result == runner.COMPLETE
+        result = runner.run([], smap, tcase)
+        assert result.status == RunResult.COMPLETE
         assert "inc_file.bin" in tcase._existing_paths
         assert pathjoin("nested", "nested_inc.bin") in tcase._existing_paths
         assert pathjoin("test", "inc_file3.txt") in tcase._existing_paths
diff --git a/grizzly/reduce/reduce.py b/grizzly/reduce/reduce.py
index 9d57de92..9edc21ba 100644
--- a/grizzly/reduce/reduce.py
+++ b/grizzly/reduce/reduce.py
@@ -26,7 +26,7 @@
 from . import strategies as strategies_module, testcase_contents
 from .exceptions import CorruptTestcaseError, NoTestcaseError, ReducerError
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter, Report
-from ..common.runner import Runner
+from ..common.runner import Runner, RunResult
 from ..common.status import ReducerStats, Status
 from ..common.storage import TestCase, TestFile
 from ..common.utils import grz_tmp
@@ -599,7 +599,7 @@ def _run(self, testcase, temp_prefix):
         Returns:
             bool: True if reduced testcase is still interesting.
         """
-        result = False
+        interesting = False
 
         # if target is closed and server is alive, we should restart it or else the first request
         #   against /first_test will 404
@@ -656,12 +656,12 @@ def _dyn_resp_close():  # pragma: no cover
             self._server_map.set_redirect("grz_next_test", str(self.landing_page), required=True)
 
         # run test case
-        runner.run(self._ignore, self._server_map, testcase, wait_for_callback=self._no_harness)
+        result = runner.run(self._ignore, self._server_map, testcase, wait_for_callback=self._no_harness)
 
         # handle failure if detected
-        if runner.result == Runner.FAILED:
+        if result.status == RunResult.FAILED:
             self._target.close()
-            testcase.purge_optional(runner.served)
+            testcase.purge_optional(result.served)
 
             # save logs
             result_logs = temp_prefix + "_logs"
@@ -679,7 +679,7 @@ def _dyn_resp_close():  # pragma: no cover
                 # XXX: need to change this to support reducing timeouts?
                 LOG.info("Uninteresting: no crash detected")
             elif self._orig_sig is None or self._orig_sig.matches(crash):
-                result = True
+                interesting = True
                 LOG.info("Interesting: %s", short_sig)
                 if self._orig_sig is None and not self._any_crash:
                     self._orig_sig = Report.crash_signature(crash)
@@ -687,7 +687,7 @@ def _dyn_resp_close():  # pragma: no cover
                 LOG.info("Uninteresting: different signature: %s", short_sig)
                 self.on_other_crash_found(testcase, temp_prefix)
 
-        elif runner.result == Runner.IGNORED:
+        elif result.status == RunResult.IGNORED:
             LOG.info("Uninteresting: ignored")
             self._target.close()
 
@@ -697,7 +697,7 @@ def _dyn_resp_close():  # pragma: no cover
         # trigger relaunch by closing the browser if needed
         self._target.check_relaunch()
 
-        return result
+        return interesting
 
     def _stop_log_capture(self):
         """Stop handling reduce logs.
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 0b40dcf6..01c09d44 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -13,7 +13,7 @@
 from sapphire import Sapphire, ServerMap
 
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter, Report
-from ..common.runner import Runner
+from ..common.runner import Runner, RunResult
 from ..common.status import Status
 from ..common.storage import TestCase, TestCaseLoadFailure, TestFile
 from ..common.utils import grz_tmp
@@ -210,16 +210,16 @@ def _dyn_close():  # pragma: no cover
                         testcases[test_idx].landing_page,
                         required=False)
                     # run testcase
-                    self._runner.run(
+                    result = self._runner.run(
                         self.ignore,
                         server_map,
                         testcases[test_idx],
                         test_path=unpacked[test_idx],
                         wait_for_callback=self._harness is None)
-                    if self._runner.result != self._runner.COMPLETE:
+                    if result.status != RunResult.COMPLETE:
                         break
                 # process results
-                if self._runner.result == self._runner.FAILED:
+                if result.status == RunResult.FAILED:
                     log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
                     self.target.save_logs(log_path)
                     report = Report.from_path(log_path)
@@ -259,10 +259,10 @@ def _dyn_close():  # pragma: no cover
                             LOG.debug("already tracking %s", crash_hash)
                         report.cleanup()
                         report = None
-                elif self._runner.result == self._runner.IGNORED:
+                elif result.status == RunResult.IGNORED:
                     self.status.ignored += 1
                     LOG.info("Result: Ignored (%d)", self.status.ignored)
-                elif self._runner.result == self._runner.ERROR:
+                elif result.status == RunResult.ERROR:
                     LOG.error("ERROR: Replay malfunction, test case was not served")
                     break
 
diff --git a/grizzly/session.py b/grizzly/session.py
index 1087a9b8..362a4f10 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -9,7 +9,7 @@
 from tempfile import mkdtemp
 from time import sleep, time
 
-from .common import grz_tmp, Report, Runner, Status, TestFile
+from .common import grz_tmp, Report, Runner, RunResult, Status, TestFile
 from .target import TargetLaunchError
 
 
@@ -172,31 +172,31 @@ def _dyn_close():  # pragma: no cover
             self.display_status(log_limiter=log_limiter)
 
             # run test case
-            runner.run(ignore, self.iomanager.server_map, current_test, coverage=self.coverage)
+            result = runner.run(ignore, self.iomanager.server_map, current_test, coverage=self.coverage)
             # adapter callbacks
-            if runner.timeout:
+            if result.timeout:
                 log.debug("calling self.adapter.on_timeout()")
-                self.adapter.on_timeout(current_test, runner.served)
+                self.adapter.on_timeout(current_test, result.served)
             else:
                 log.debug("calling self.adapter.on_served()")
-                self.adapter.on_served(current_test, runner.served)
+                self.adapter.on_served(current_test, result.served)
             # update test case
-            if runner.result != runner.ERROR:
-                if not runner.served:
+            if result.status != RunResult.ERROR:
+                if not result.served:
                     # this can happen if the target crashes between serving test cases
                     log.info("Ignoring test case since nothing was served")
                     self.iomanager.tests.pop().cleanup()
                 elif self.adapter.IGNORE_UNSERVED:
                     log.debug("removing unserved files from the test case")
-                    current_test.purge_optional(runner.served)
+                    current_test.purge_optional(result.served)
             # process results
-            if runner.result == runner.FAILED:
+            if result.status == RunResult.FAILED:
                 log.debug("result detected")
                 self.report_result()
-            elif runner.result == runner.IGNORED:
+            elif result.status == RunResult.IGNORED:
                 self.status.ignored += 1
                 log.info("Ignored (%d)", self.status.ignored)
-            elif runner.result == runner.ERROR:
+            elif result.status == RunResult.ERROR:
                 log.error("Test case was not served")
                 if not current_test.contains(current_test.landing_page):
                     log.warning("Test case is missing landing page")
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 0ee4b227..8533895c 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -11,7 +11,7 @@
 from pytest import raises
 
 from sapphire import Sapphire, ServerMap, SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
-from .common import Adapter, IOManager, Reporter, Status, TestCase
+from .common import Adapter, IOManager, Reporter, RunResult, Status, TestCase
 from .session import LogOutputLimiter, Session, SessionError
 from .target import Target, TargetLaunchError
 
@@ -113,14 +113,12 @@ def generate(self, testcase, server_map):
 def test_session_05(tmp_path, mocker):
     """test basic Session functions"""
     Status.PATH = str(tmp_path)
-    fake_adapter = mocker.Mock(spec=Adapter)
+    fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
     fake_adapter.TEST_DURATION = 10
-    fake_adapter.remaining = None
     fake_testcase = mocker.Mock(spec=TestCase, landing_page="page.htm", optional=[])
     fake_iomgr = mocker.Mock(spec=IOManager)
-    fake_iomgr.server_map = ServerMap()
+    fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
     fake_iomgr.create_testcase.return_value = fake_testcase
-    fake_iomgr.harness = None
     fake_iomgr.tests = mocker.Mock(spec=deque)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     # return SERVED_TIMEOUT to test IGNORE_UNSERVED code path
@@ -148,8 +146,7 @@ def test_session_06(tmp_path, mocker):
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter)
     fake_adapter.NAME = "fake_adapter"
-    fake_iomgr = mocker.Mock(spec=IOManager)
-    fake_iomgr.server_map = ServerMap()
+    fake_iomgr = mocker.Mock(spec=IOManager, server_map=ServerMap())
     fake_iomgr.create_testcase.return_value = mocker.Mock(spec=TestCase)
     fake_target = mocker.Mock(spec=Target, prefs="fake")
     with Session(fake_adapter, fake_iomgr, None, None, fake_target) as session:
@@ -166,25 +163,20 @@ def test_session_07(tmp_path, mocker):
     Status.PATH = str(tmp_path)
     mocker.patch("grizzly.session.Report", autospec=True)
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
+    fake_runner.return_value.run.return_value = RunResult(["/fake/file"], status=RunResult.FAILED)
     mocker.patch("grizzly.session.TestFile", autospec=True)
-    fake_adapter = mocker.Mock(spec=Adapter)
+    fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
     fake_adapter.IGNORE_UNSERVED = True
     fake_adapter.TEST_DURATION = 10
-    fake_adapter.remaining = None
-    fake_iomgr = mocker.Mock(spec=IOManager)
+    fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap(), tests=deque())
     fake_iomgr.create_testcase.return_value = mocker.Mock(spec=TestCase)
-    fake_iomgr.harness = None
-    fake_iomgr.server_map = ServerMap()
-    fake_iomgr.tests = deque()
     fake_reporter = mocker.Mock(spec=Reporter)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
     fake_target.monitor.launches = 1
     with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
-        fake_runner.return_value.result = fake_runner.return_value.FAILED
-        fake_runner.return_value.served = ["/fake/file"]
-        fake_runner.return_value.timeout = False
         session.run([], iteration_limit=1)
+        assert fake_runner.return_value.run.call_count == 1
         assert fake_adapter.on_served.call_count == 1
         assert fake_adapter.on_timeout.call_count == 0
         assert fake_iomgr.purge_tests.call_count == 1
@@ -198,15 +190,13 @@ def test_session_08(tmp_path, mocker):
     """test Session.run() ignoring failures"""
     Status.PATH = str(tmp_path)
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
+    fake_runner.return_value.run.return_value = RunResult([], status=RunResult.IGNORED)
     mocker.patch("grizzly.session.TestFile", autospec=True)
-    fake_adapter = mocker.Mock(spec=Adapter)
+    fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
     fake_adapter.IGNORE_UNSERVED = True
     fake_adapter.TEST_DURATION = 10
-    fake_adapter.remaining = None
-    fake_iomgr = mocker.Mock(spec=IOManager)
+    fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
     fake_iomgr.create_testcase.return_value = mocker.Mock(spec=TestCase)
-    fake_iomgr.harness = None
-    fake_iomgr.server_map = ServerMap()
     fake_iomgr.tests = mocker.Mock(spec=deque)
     fake_iomgr.tests.pop.return_value = mocker.Mock(spec=TestCase)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
@@ -215,10 +205,8 @@ def test_session_08(tmp_path, mocker):
     # ignored results should not be reported so raise AssertionError if report_result is called
     mocker.patch.object(Session, 'report_result', side_effect=AssertionError)
     with Session(fake_adapter, fake_iomgr, None, fake_serv, fake_target) as session:
-        fake_runner.return_value.result = fake_runner.return_value.IGNORED
-        fake_runner.return_value.served = []
-        fake_runner.return_value.timeout = False
         session.run([], iteration_limit=1)
+        assert fake_runner.return_value.run.call_count == 1
         assert fake_adapter.on_served.call_count == 1
         assert fake_adapter.on_timeout.call_count == 0
         assert fake_iomgr.purge_tests.call_count == 1
@@ -236,11 +224,12 @@ def test_session_09(tmp_path, mocker):
     fake_runner.return_value.launch.side_effect = TargetLaunchError
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter)
-    fake_iomgr = mocker.Mock(spec=IOManager)
-    fake_iomgr.harness = None
-    fake_iomgr.input_files = []
-    fake_iomgr.server_map = ServerMap()
-    fake_iomgr.tests = deque()
+    fake_iomgr = mocker.Mock(
+        spec=IOManager,
+        harness=None,
+        input_files=[],
+        server_map=ServerMap(),
+        tests=deque())
     fake_reporter = mocker.Mock(spec=Reporter)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_target = mocker.Mock(spec=Target)

From 4842b5737e05baea0f1bd86a7c45fde8b049fa05 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 17 Sep 2020 13:22:10 -0700
Subject: [PATCH 014/531] Cleanup Report and Reporter

---
 grizzly/common/reporter.py      | 344 ++++++++++++++++++--------------
 grizzly/common/test_reporter.py | 307 +++++++++++++++-------------
 grizzly/main.py                 |   4 +-
 grizzly/reduce/reduce.py        |  70 +++----
 grizzly/reduce/test_common.py   |  45 ++++-
 grizzly/replay/replay.py        |  33 ++-
 grizzly/replay/test_replay.py   |  34 ++--
 grizzly/session.py              |   7 +-
 grizzly/test_session.py         |  39 ++--
 9 files changed, 484 insertions(+), 399 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 14060dc6..48d2892c 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -4,6 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from abc import ABCMeta, abstractmethod
+from collections import namedtuple
 from hashlib import sha1
 from json import dump
 from logging import getLogger, WARNING
@@ -43,7 +44,10 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-log = getLogger("grizzly")  # pylint: disable=invalid-name
+LOG = getLogger("grizzly")
+
+# NOTE: order matters, aux -> stderr -> stdout
+LogMap = namedtuple("LogMap", "aux stderr stdout")
 
 
 class Report(object):
@@ -51,89 +55,95 @@ class Report(object):
     DEFAULT_MINOR = "0"
     MAX_LOG_SIZE = 1048576  # 1MB
 
-    __slots__ = ("_crash_info", "log_aux", "log_err", "log_out", "path", "prefix", "stack")
+    __slots__ = ("_crash_info", "_logs", "_signature", "_target_binary", "path", "prefix", "stack")
 
-    def __init__(self, log_path, log_map, size_limit=MAX_LOG_SIZE):
+    def __init__(self, log_path, target_binary, size_limit=MAX_LOG_SIZE):
+        assert isinstance(log_path, str) and isdir(log_path)
+        assert isinstance(target_binary, str)
         self._crash_info = None
-        self.log_aux = log_map.get("aux") if log_map is not None else None
-        self.log_err = log_map.get("stderr") if log_map is not None else None
-        self.log_out = log_map.get("stdout") if log_map is not None else None
+        self._logs = self.select_logs(log_path)
+        assert self._logs is not None
+        self._signature = None
+        self._target_binary = target_binary
         self.path = log_path
-
-        # tail logs if needed
+        # tail files in log_path if needed
         if size_limit < 1:
-            log.warning("No limit set on report log size!")
-        elif isdir(log_path):
+            LOG.warning("No limit set on report log size!")
+        else:
             for fname in listdir(log_path):
                 log_file_path = pathjoin(log_path, fname)
                 if isfile(log_file_path):
                     Report.tail(log_file_path, size_limit)
-
         # look through logs one by one until we find a stack
-        # NOTE: order matters aux->stderr->stdout
-        for scan_log in (self.log_aux, self.log_err, self.log_out):
-            if scan_log is None:
-                continue
-            with open(pathjoin(log_path, scan_log), "rb") as log_fp:
+        for log_file in (x for x in self._logs if x is not None):
+            with open(log_file, "rb") as log_fp:
                 stack = Stack.from_text(log_fp.read().decode("utf-8", errors="ignore"))
             if stack.frames:
                 self.prefix = "%s_%s" % (stack.minor[:8], strftime("%Y-%m-%d_%H-%M-%S"))
                 self.stack = stack
                 break
         else:
-            self.stack = None
             self.prefix = "%s_%s" % (self.DEFAULT_MINOR, strftime("%Y-%m-%d_%H-%M-%S"))
+            self.stack = None
 
     def cleanup(self):
-        if isdir(self.path):
+        """Remove Report data from filesystem.
+
+        Args:
+            None
+
+        Returns:
+            None
+        """
+        if self.path and isdir(self.path):
             rmtree(self.path)
+        self.path = None
 
-    @staticmethod
-    def crash_hash(crash_info):
-        """Create CrashInfo object from logs.
+    @property
+    def crash_hash(self):
+        """Create SHA1 hash from signature.
 
         Args:
-            crash_info (CrashInfo): Binary file being tested.
+            None
 
         Returns:
             str: Hash of the raw signature of the crash.
         """
-        max_frames = Report.crash_signature_max_frames(crash_info, 5)
-        sig = Report.crash_signature(crash_info, max_frames)
-        return sha1(sig.rawSignature.encode("utf-8")).hexdigest()[:16]
+        return sha1(self.crash_signature.rawSignature.encode("utf-8")).hexdigest()[:16]
 
-    def crash_info(self, target_binary):
+    @property
+    def crash_info(self):
         """Create CrashInfo object from logs.
 
         Args:
-            target_binary (str): Binary file being tested.
+            None
 
         Returns:
-            CrashInfo: CrashInfo based on Result log data.
+            CrashInfo: CrashInfo based on log data.
         """
         if self._crash_info is None:
+            assert self.path is not None
             # read in the log files and create a CrashInfo object
-            aux_data = None
-            if self.log_aux is not None:
-                with open(pathjoin(self.path, self.log_aux), "rb") as log_fp:
+            if self._logs.aux is not None:
+                with open(self._logs.aux, "rb") as log_fp:
                     aux_data = log_fp.read().decode("utf-8", errors="ignore").splitlines()
-            stderr_file = pathjoin(self.path, self.log_err)
-            stdout_file = pathjoin(self.path, self.log_out)
+            else:
+                aux_data = None
             # create ProgramConfiguration that can be reported to a FM server
-            if isfile("%s.fuzzmanagerconf" % (target_binary,)):
+            if isfile("%s.fuzzmanagerconf" % (self._target_binary,)):
                 # attempt to use "<target_binary>.fuzzmanagerconf"
-                fm_cfg = ProgramConfiguration.fromBinary(target_binary)
+                fm_cfg = ProgramConfiguration.fromBinary(self._target_binary)
             else:
-                log.debug("'%s.fuzzmanagerconf' does not exist", target_binary)
+                LOG.debug("'%s.fuzzmanagerconf' does not exist", self._target_binary)
                 fm_cfg = None
             if fm_cfg is None:
-                log.debug("creating ProgramConfiguration")
+                LOG.debug("creating ProgramConfiguration")
                 cpu = machine().lower()
                 fm_cfg = ProgramConfiguration(
-                    basename(target_binary),
+                    basename(self._target_binary),
                     "x86_64" if cpu == "amd64" else cpu,
                     system())
-            with open(stderr_file, "rb") as err_fp, open(stdout_file, "rb") as out_fp:
+            with open(self._logs.stderr, "rb") as err_fp, open(self._logs.stdout, "rb") as out_fp:
                 self._crash_info = CrashInfo.fromRawCrashData(
                     out_fp.read().decode("utf-8", errors="ignore").splitlines(),
                     err_fp.read().decode("utf-8", errors="ignore").splitlines(),
@@ -141,10 +151,20 @@ def crash_info(self, target_binary):
                     auxCrashData=aux_data)
         return self._crash_info
 
-    @staticmethod
-    def crash_signature(crash_info, max_frames=5):
-        return crash_info.createCrashSignature(
-            maxFrames=Report.crash_signature_max_frames(crash_info, max_frames))
+    @property
+    def crash_signature(self):
+        """Create CrashSignature object from CrashInfo.
+
+        Args:
+            None
+
+        Returns:
+            CrashSignature: CrashSignature based on log data.
+        """
+        if self._signature is None:
+            self._signature = self.crash_info.createCrashSignature(
+                maxFrames=self.crash_signature_max_frames(self.crash_info))
+        return self._signature
 
     @staticmethod
     def crash_signature_max_frames(crash_info, suggested_frames=8):
@@ -156,48 +176,74 @@ def crash_signature_max_frames(crash_info, suggested_frames=8):
             suggested_frames += 6
         return suggested_frames
 
-    @classmethod
-    def from_path(cls, path, size_limit=MAX_LOG_SIZE):
-        """Create Report from a directory containing logs.
+    @property
+    def major(self):
+        """The inclusive bucketing hash based on the stack trace
+        data found in logs.
 
         Args:
-            path (str): Directory containing log files.
-            size_limit (int): Maximum size in bytes of a log file.
+            None
 
         Returns:
-            Report: Result object based on log data.
+            str: major hash string.
         """
-        return cls(path, Report.select_logs(path), size_limit=size_limit)
-
-    @property
-    def major(self):
         if self.stack and self.stack.major is not None:
             return self.stack.major
         return self.DEFAULT_MAJOR
 
     @property
     def minor(self):
+        """The specific bucketing hash based on the stack trace
+        data found in logs.
+
+        Args:
+            None
+
+        Returns:
+            str: minor hash string.
+        """
         if self.stack and self.stack.minor is not None:
             return self.stack.minor
         return self.DEFAULT_MINOR
 
     @property
     def preferred(self):
-        return self.log_aux if self.log_aux is not None else self.log_err
+        """Log file containing most relevant data.
+
+        Args:
+            None
+
+        Returns:
+            str: Name of log.
+        """
+        return self._logs.aux or self._logs.stderr
 
     @staticmethod
     def select_logs(log_path):
-        if not isdir(log_path):
-            raise IOError("log_path does not exist %r" % log_path)
-        log_files = listdir(log_path)
-        if not log_files:
-            raise IOError("No logs found in %r" % log_path)
-        logs = {"aux": None, "stderr": None, "stdout": None}
+        """Scan log_path for file containing stderr, stdout and other (aux)
+        data and build a LogMap.
+
+        Args:
+            log_path (str): Path to scan for log files.
+
+        Returns:
+            LogMap: A LogMap pointing to files or None if log_path is empty.
+        """
+        # scan path for files
+        to_scan = list()
+        for entry in listdir(log_path):
+            full_path = pathjoin(log_path, entry)
+            if isfile(full_path):
+                to_scan.append(full_path)
+        if not to_scan:
+            LOG.warning("No files found in %r", log_path)
+            return None
 
         # order by creation date because the oldest log is likely the cause of the issue
-        log_files.sort(key=lambda x: stat(pathjoin(log_path, x)).st_mtime)
+        to_scan.sort(key=lambda x: stat(x).st_mtime)
 
         # pattern to identify the ASan crash triggered when the parent process goes away
+        # TODO: this may no longer be required
         re_e10s_forced = re_compile(r"""
             ==\d+==ERROR:.+?SEGV\son.+?0x[0]+\s\(.+?T2\).+?
             #0\s+0x[0-9a-f]+\sin\s+mozilla::ipc::MessageChannel::OnChannelErrorFromLink
@@ -210,12 +256,12 @@ def select_logs(log_path):
             "use-after-", "-buffer-overflow on", ": SEGV on ", "access-violation on ",
             "negative-size-param", "attempting free on ", "-param-overlap")
 
+        log_aux = None
         # look for sanitizer (ASan, UBSan, etc...) logs
-        for fname in (log_file for log_file in log_files if "asan" in log_file):
+        for fname in (x for x in to_scan if "asan" in x):
             # grab first chunk of log to help triage
-            with open(pathjoin(log_path, fname), "r") as log_fp:
-                log_data = log_fp.read(4096)
-
+            with open(fname, "r") as log_fp:
+                log_data = log_fp.read(65536)
             # look for interesting crash info in the log
             if "==ERROR:" in log_data:
                 # check for e10s forced crash
@@ -223,58 +269,72 @@ def select_logs(log_path):
                     continue
                 # make sure there is something that looks like a stack frame in the log
                 if "#0 " in log_data:
-                    logs["aux"] = fname
+                    log_aux = fname
                     if any(x in log_data for x in interesting_sanitizer_tokens):
                         break  # this is the likely cause of the crash
                     continue  # probably the most interesting but lets keep looking
-
-            # UBSan error (non-ASan builds)
-            if ": runtime error: " in log_data:
-                logs["aux"] = fname
-
-            # catch all (choose the one with info for now)
-            if logs["aux"] is None and stat(pathjoin(log_path, fname)).st_size:
-                logs["aux"] = fname
+            if log_aux is None:
+                # UBSan error (non-ASan builds)
+                if ": runtime error: " in log_data:
+                    log_aux = fname
+                # catch all (choose the one with info for now)
+                elif log_data:
+                    log_aux = fname
 
         # look for Valgrind logs
-        if logs["aux"] is None:
-            for fname in (log_file for log_file in log_files if "valgrind" in log_file):
-                if stat(pathjoin(log_path, fname)).st_size:
-                    logs["aux"] = fname
+        if log_aux is None:
+            for fname in (x for x in to_scan if "valgrind" in x):
+                if stat(fname).st_size:
+                    log_aux = fname
                     break
 
         # prefer ASan logs over minidump logs
-        if logs["aux"] is None:
+        if log_aux is None:
             re_dump_req = re_compile(r"\d+\|0\|.+?\|google_breakpad::ExceptionHandler::WriteMinidump")
-            for fname in (log_file for log_file in log_files if "minidump" in log_file):
-                with open(pathjoin(log_path, fname), "r") as log_fp:
-                    log_data = log_fp.read(4096)
+            for fname in (x for x in to_scan if "minidump" in x):
+                with open(fname, "r") as log_fp:
+                    log_data = log_fp.read(65536)
                     # this will select log that contains "Crash|SIGSEGV|" or
                     # the desired "DUMP_REQUESTED" log
                     # TODO: review this it may be too strict
                     # see https://searchfox.org/mozilla-central/source/accessible/ipc/DocAccessibleParent.cpp#452
                     if "Crash|DUMP_REQUESTED|" not in log_data or re_dump_req.search(log_data):
-                        logs["aux"] = fname
+                        log_aux = fname
                         break
 
         # look for ffpuppet worker logs, worker logs should be used if nothing else is available
-        if logs["aux"] is None:
-            for fname in (log_file for log_file in log_files if "ffp_worker" in log_file):
-                if logs["aux"] is not None:
+        if log_aux is None:
+            for fname in (x for x in to_scan if "ffp_worker" in x):
+                if log_aux is not None:
                     # we only expect one log here...
-                    log.warning("aux log previously selected: %s, overwriting!", logs["aux"])
-                logs["aux"] = fname
+                    LOG.warning("aux log previously selected: %s, overwriting!", log_aux)
+                log_aux = fname
 
-        for fname in log_files:
+        # look for stderr and stdout log files
+        log_err = None
+        log_out = None
+        for fname in to_scan:
             if "stderr" in fname:
-                logs["stderr"] = fname
+                log_err = fname
             elif "stdout" in fname:
-                logs["stdout"] = fname
+                log_out = fname
 
-        return logs
+        result = LogMap(log_aux, log_err, log_out)
+        if not any(result):
+            LOG.warning("No logs found in %r", log_path)
+        return result
 
     @staticmethod
     def tail(in_file, size_limit):
+        """Tail the given file. This is destructive.
+
+        Args:
+            in_file (str): Path to file to work with.
+            size_limit (int): Maximum size of file after tail operation.
+
+        Returns:
+            None
+        """
         assert size_limit > 0
         if stat(in_file).st_size <= size_limit:
             return
@@ -292,46 +352,36 @@ def tail(in_file, size_limit):
 
 class Reporter(metaclass=ABCMeta):
     @abstractmethod
-    def _process_report(self, report):
+    def _post_submit(self):
         pass
 
     @abstractmethod
-    def _reset(self):
+    def _pre_submit(self, report):
         pass
 
     @abstractmethod
     def _submit_report(self, report, test_cases):
         pass
 
-    def submit(self, test_cases, log_path=None, report=None):
-        """Submit report containing results. Either `log_path` or `report` must
-        be specified.
+    def submit(self, test_cases, report):
+        """Submit report containing results.
 
         Args:
             test_cases (iterable): A collection of testcases, ordered newest to oldest,
                                    the newest being the mostly likely to trigger
                                    the result (crash, assert... etc).
-            log_path (str): Path to logs from the Target. A Report will
-                            be created from this.
             report (Report): Report to submit.
 
         Returns:
             None
         """
-        if log_path is not None:
-            assert report is None, "Only 'log_path' or 'report' can be specified!"
-            if not isdir(log_path):
-                raise IOError("No such directory %r" % log_path)
-            report = Report.from_path(log_path)
-        elif report is not None:
-            assert isinstance(report, Report)
-        else:
-            raise AssertionError("Either 'log_path' or 'report' must be specified!")
-        self._process_report(report)
+        assert isinstance(report, Report)
+        assert report.path is not None
+        self._pre_submit(report)
         self._submit_report(report, test_cases)
         if report is not None:
             report.cleanup()
-        self._reset()
+        self._post_submit()
 
 
 class FilesystemReporter(Reporter):
@@ -339,12 +389,12 @@ class FilesystemReporter(Reporter):
 
     def __init__(self, report_path=None, major_bucket=True):
         self.major_bucket = major_bucket
-        self.report_path = pathjoin(getcwd(), "results") if report_path is None else report_path
+        self.report_path = report_path or pathjoin(getcwd(), "results")
 
-    def _process_report(self, report):
+    def _pre_submit(self, report):
         pass
 
-    def _reset(self):
+    def _post_submit(self):
         pass
 
     def _submit_report(self, report, test_cases):
@@ -364,7 +414,7 @@ def _submit_report(self, report, test_cases):
         # move logs into bucket directory
         log_path = pathjoin(dest_path, "%s_%s" % (report.prefix, "logs"))
         if isdir(log_path):
-            log.warning("Report log path exists %r", log_path)
+            LOG.warning("Report log path exists %r", log_path)
         move(report.path, log_path)
         # avoid filling the disk
         free_space = disk_usage(log_path).free
@@ -388,19 +438,13 @@ class FuzzManagerReporter(Reporter):
     QUAL_REDUCER_ERROR = 9  # reducer error
     QUAL_NOT_REPRODUCIBLE = 10  # could not reproduce the testcase
 
-    def __init__(self, target_binary, tool=None):
+    def __init__(self, tool=None):
         self._extra_metadata = {}
         self.force_report = False
         self.quality = self.QUAL_UNREDUCED
-        self.target_binary = target_binary
         self.tool = tool  # optional tool name
 
-    @staticmethod
-    def create_crash_info(report, target_binary):
-        # TODO: this is here to preserve the old way of operation (used by reducer)
-        return report.crash_info(target_binary)
-
-    def _reset(self):
+    def _post_submit(self):
         self._extra_metadata = {}
 
     @staticmethod
@@ -414,7 +458,7 @@ def sanity_check(bin_file):
             None
         """
         if not isfile(FuzzManagerReporter.FM_CONFIG):
-            raise IOError("Missing: %s" % FuzzManagerReporter.FM_CONFIG)
+            raise IOError("Missing: %s" % (FuzzManagerReporter.FM_CONFIG,))
         if not isfile("".join([bin_file, ".fuzzmanagerconf"])):
             raise IOError("Missing: %s.fuzzmanagerconf" % (bin_file,))
         ProgramConfiguration.fromBinary(bin_file)
@@ -426,14 +470,14 @@ def quality_name(cls, value):
                 return name
         return "unknown quality (%r)" % (value,)
 
-    def _process_report(self, report):
+    def _pre_submit(self, report):
         self._process_rr_trace(report)
 
     def _process_rr_trace(self, report):
         # don't report large files to FuzzManager
         trace_path = pathjoin(report.path, "rr-traces")
         if isdir(trace_path):
-            log.info("Ignored rr trace")
+            LOG.info("Ignored rr trace")
             self._extra_metadata["rr-trace"] = "ignored"
             # remove traces so they are not uploaded to FM (because they are huge)
             # use S3FuzzManagerReporter instead
@@ -443,38 +487,34 @@ def _process_rr_trace(self, report):
     def _ignored(report):
         # This is here to prevent reporting stack-less crashes
         # that were caused by system OOM or bogus other crashes
-        log_file = pathjoin(report.path, report.preferred)
-        with open(log_file, "rb") as log_fp:
+        with open(report.preferred, "rb") as log_fp:
             log_data = log_fp.read().decode("utf-8", errors="ignore")
         mem_errs = (
             "ERROR: Failed to mmap",
             ": AddressSanitizer failed to allocate")
+        # ignore sanitizer OOMs missing stack
         for msg in mem_errs:
             if msg in log_data and "#0 " not in log_data:
                 return True
+        # ignore Valgrind crashes
         if log_data.startswith("VEX temporary storage exhausted."):
-            # ignore Valgrind crashes
             return True
         return False
 
     def _submit_report(self, report, test_cases):
-        # prepare data for submission as CrashInfo
-        crash_info = report.crash_info(self.target_binary)
-        assert crash_info is not None
-
         # search for a cached signature match and if the signature
         # is already in the cache and marked as frequent, don't bother submitting
         with InterProcessLock(pathjoin(grz_tmp(), "fm_sigcache.lock")):
             collector = Collector()
-            cache_sig_file, cache_metadata = collector.search(crash_info)
+            cache_sig_file, cache_metadata = collector.search(report.crash_info)
             if cache_metadata is not None:
                 if cache_metadata["frequent"]:
-                    log.info("Frequent crash matched existing signature: %s",
+                    LOG.info("Frequent crash matched existing signature: %s",
                              cache_metadata["shortDescription"])
                     if not self.force_report:
                         return
                 elif "bug__id" in cache_metadata:
-                    log.info("Crash matched existing signature (bug %s): %s",
+                    LOG.info("Crash matched existing signature (bug %s): %s",
                              cache_metadata["bug__id"],
                              cache_metadata["shortDescription"])
                     # we will still report this one, but no more
@@ -484,17 +524,17 @@ def _submit_report(self, report, test_cases):
             else:
                 # there is no signature, create one locally so we can count
                 # the number of times we've seen it
-                max_frames = Report.crash_signature_max_frames(crash_info)
-                cache_sig_file = collector.generate(crash_info, numFrames=max_frames)
+                max_frames = report.crash_signature_max_frames(report.crash_info)
+                cache_sig_file = collector.generate(report.crash_info, numFrames=max_frames)
                 cache_metadata = {
                     "_grizzly_seen_count": 0,
                     "frequent": False,
-                    "shortDescription": crash_info.createShortSignature()}
+                    "shortDescription": report.crash_info.createShortSignature()}
             if cache_sig_file is None:
                 if self._ignored(report):
-                    log.info("Report is unsupported and is in ignore list")
+                    LOG.info("Report is unsupported and is in ignore list")
                     return
-                log.warning("Report is unsupported by FM, saved to %r", report.path)
+                LOG.warning("Report is unsupported by FM, saved to %r", report.path)
                 # TODO: we should check if stackhasher failed too
                 raise RuntimeError("Failed to create FM signature")
             # limit the number of times we report per cycle
@@ -514,17 +554,17 @@ def _submit_report(self, report, test_cases):
             if not isdir(dump_path):
                 mkdir(dump_path)
             test_case.dump(dump_path, include_details=True)
-        crash_info.configuration.addMetadata({"grizzly_input": repr(test_case_meta)})
+        report.crash_info.configuration.addMetadata({"grizzly_input": repr(test_case_meta)})
         if test_cases:
             environ_string = " ".join("=".join(kv) for kv in test_cases[0].env_vars.items())
-            crash_info.configuration.addMetadata({"recorded_envvars": environ_string})
+            report.crash_info.configuration.addMetadata({"recorded_envvars": environ_string})
         else:
             self.quality = self.QUAL_NO_TESTCASE
-        crash_info.configuration.addMetadata(self._extra_metadata)
+        report.crash_info.configuration.addMetadata(self._extra_metadata)
 
-        # grab screen log
+        # grab screen log (used in automation)
         if getenv("WINDOW") is not None:
-            screen_log = ".".join(["screenlog", getenv("WINDOW")])
+            screen_log = pathjoin(getcwd(), ".".join(["screenlog", getenv("WINDOW")]))
             if isfile(screen_log):
                 target_log = pathjoin(report.path, "screenlog.txt")
                 copyfile(screen_log, target_log)
@@ -547,10 +587,10 @@ def _submit_report(self, report, test_cases):
 
         # announce shortDescription if crash is not in a bucket
         if cache_metadata["_grizzly_seen_count"] == 1 and not cache_metadata["frequent"]:
-            log.info("Submitting new crash %r", cache_metadata["shortDescription"])
+            LOG.info("Submitting new crash %r", cache_metadata["shortDescription"])
         # submit results to the FuzzManager server
-        new_entry = collector.submit(crash_info, testCase=zip_name, testCaseQuality=self.quality)
-        log.info("Logged %d with quality %d", new_entry["id"], self.quality)
+        new_entry = collector.submit(report.crash_info, testCase=zip_name, testCaseQuality=self.quality)
+        LOG.info("Logged %d with quality %d", new_entry["id"], self.quality)
 
         # remove zipfile
         if isfile(zip_name):
@@ -564,14 +604,14 @@ def compress_rr_trace(src, dest):
         latest_trace = realpath(pathjoin(src, "latest-trace"))
         assert isdir(latest_trace), "missing latest-trace directory"
         rr_arc = pathjoin(dest, "rr.tar.bz2")
-        log.debug("creating %r from %r", rr_arc, latest_trace)
+        LOG.debug("creating %r from %r", rr_arc, latest_trace)
         with tar_open(rr_arc, "w:bz2") as arc_fp:
             arc_fp.add(latest_trace, arcname=basename(latest_trace))
         # remove path containing uncompressed traces
         rmtree(src)
         return rr_arc
 
-    def _process_report(self, report):
+    def _pre_submit(self, report):
         self._process_rr_trace(report)
 
     def _process_rr_trace(self, report):
@@ -590,12 +630,12 @@ def _process_rr_trace(self, report):
             if exc.response["Error"]["Code"] == "404":
                 # The object does not exist.
                 pass
-            else:
+            else:  # pragma: no cover
                 # Something else has gone wrong.
                 raise
         else:
             # The object already exists.
-            log.info("RR trace exists at %s", s3_url)
+            LOG.info("rr trace exists at %r", s3_url)
             self._extra_metadata["rr-trace"] = s3_url
             # remove traces so they are not reported to FM
             rmtree(trace_path)
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index ce844702..843a0694 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -18,27 +18,18 @@
 from .storage import TestCase
 
 
-def test_report_01():
-    """test creating a simple Report"""
-    report = Report("no_dir", dict())
-    assert report.path == "no_dir"
-    assert report.log_aux is None
-    assert report.log_err is None
-    assert report.log_out is None
-    assert report.stack is None
-    assert report.preferred is None
-    report.cleanup()
-
-def test_report_02(tmp_path):
-    """test from_path() with boring logs (no stack)"""
+def test_report_01(tmp_path):
+    """test Report() with boring logs (no stack)"""
+    (tmp_path / "not_a_log.txt").touch()
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    report = Report.from_path(str(tmp_path))
+    report = Report(str(tmp_path), "a.bin", size_limit=0)
+    assert report._target_binary == "a.bin"
     assert report.path == str(tmp_path)
-    assert report.log_err.endswith("log_stderr.txt")
-    assert report.log_out.endswith("log_stdout.txt")
+    assert report._logs.aux is None
+    assert report._logs.stderr.endswith("log_stderr.txt")
+    assert report._logs.stdout.endswith("log_stdout.txt")
     assert report.preferred.endswith("log_stderr.txt")
-    assert report.log_aux is None
     assert report.stack is None
     assert Report.DEFAULT_MAJOR == report.major
     assert Report.DEFAULT_MINOR == report.minor
@@ -46,18 +37,18 @@ def test_report_02(tmp_path):
     report.cleanup()
     assert not tmp_path.exists()
 
-def test_report_03(tmp_path):
-    """test from_path()"""
+def test_report_02(tmp_path):
+    """test Report() with crash logs"""
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     with (tmp_path / "log_asan_blah.txt").open("wb") as log_fp:
         log_fp.write(b"    #0 0xbad000 in foo /file1.c:123:234\n")
         log_fp.write(b"    #1 0x1337dd in bar /file2.c:1806:19")
-    report = Report.from_path(str(tmp_path))
+    report = Report(str(tmp_path), "bin")
     assert report.path == str(tmp_path)
-    assert report.log_aux.endswith("log_asan_blah.txt")
-    assert report.log_err.endswith("log_stderr.txt")
-    assert report.log_out.endswith("log_stdout.txt")
+    assert report._logs.aux.endswith("log_asan_blah.txt")
+    assert report._logs.stderr.endswith("log_stderr.txt")
+    assert report._logs.stdout.endswith("log_stdout.txt")
     assert report.preferred.endswith("log_asan_blah.txt")
     assert report.stack is not None
     assert Report.DEFAULT_MAJOR != report.major
@@ -65,7 +56,7 @@ def test_report_03(tmp_path):
     assert report.prefix is not None
     report.cleanup()
 
-def test_report_04(tmp_path):
+def test_report_03(tmp_path):
     """test Report.tail()"""
     tmp_file = tmp_path / "file.txt"
     tmp_file.write_bytes(b"blah\ntest\n123\xEF\x00FOO")
@@ -79,10 +70,15 @@ def test_report_04(tmp_path):
     assert log_data.startswith(b"[LOG TAILED]\n")
     assert log_data[13:] == b"FOO"
 
+def test_report_04(tmp_path):
+    """test Report.select_logs() uninteresting data"""
+    # test with empty path
+    assert Report.select_logs(str(tmp_path)) is None
+    (tmp_path / "not_a_log.txt").touch()
+    assert not any(Report.select_logs(str(tmp_path)))
+
 def test_report_05(tmp_path):
     """test Report.select_logs()"""
-    with pytest.raises(IOError, match="log_path does not exist"):
-        Report.select_logs("missing_path")
     # small log with nothing interesting
     with (tmp_path / "log_asan.txt.1").open("wb") as log_fp:
         log_fp.write(b"SHORT LOG\n")
@@ -109,9 +105,9 @@ def test_report_05(tmp_path):
     # should be ignored in favor of "GOOD LOG"
     (tmp_path / "log_ffp_worker_blah.txt").write_bytes(b"worker log")
     log_map = Report.select_logs(str(tmp_path))
-    assert "GOOD LOG" in (tmp_path / log_map["aux"]).read_text()
-    assert "STDERR" in (tmp_path / log_map["stderr"]).read_text()
-    assert "STDOUT" in (tmp_path / log_map["stdout"]).read_text()
+    assert "GOOD LOG" in (tmp_path / log_map.aux).read_text()
+    assert "STDERR" in (tmp_path / log_map.stderr).read_text()
+    assert "STDOUT" in (tmp_path / log_map.stdout).read_text()
 
 def test_report_06(tmp_path):
     """test minidump with Report.select_logs()"""
@@ -123,9 +119,9 @@ def test_report_06(tmp_path):
         log_fp.write(b"minidump log\n")
     (tmp_path / "log_ffp_worker_blah.txt").write_bytes(b"worker log")
     log_map = Report.select_logs(str(tmp_path))
-    assert (tmp_path / log_map["stderr"]).is_file()
-    assert (tmp_path / log_map["stdout"]).is_file()
-    assert "minidump log" in (tmp_path / log_map["aux"]).read_text()
+    assert (tmp_path / log_map.stderr).is_file()
+    assert (tmp_path / log_map.stdout).is_file()
+    assert "minidump log" in (tmp_path / log_map.aux).read_text()
 
 def test_report_07(tmp_path):
     """test selecting preferred DUMP_REQUESTED minidump with Report.select_logs()"""
@@ -147,19 +143,21 @@ def test_report_07(tmp_path):
         log_fp.write(b"0|0|bar.so|sadf|a.cc:1234|3066|0x0\n")
         log_fp.write(b"0|1|gar.so|fdsa|b.cc:4323|1644|0x12\n")
     log_map = Report.select_logs(str(tmp_path))
-    assert (tmp_path / log_map["stderr"]).is_file()
-    assert (tmp_path / log_map["stdout"]).is_file()
-    assert "google_breakpad::ExceptionHandler::WriteMinidump" in (tmp_path / log_map["aux"]).read_text()
+    assert (tmp_path / log_map.stderr).is_file()
+    assert (tmp_path / log_map.stdout).is_file()
+    assert "google_breakpad::ExceptionHandler::WriteMinidump" in (tmp_path / log_map.aux).read_text()
 
 def test_report_08(tmp_path):
     """test selecting worker logs with Report.select_logs()"""
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    (tmp_path / "log_ffp_worker_blah.txt").write_bytes(b"worker log")
+    (tmp_path / "log_ffp_worker_1.txt").write_bytes(b"worker log")
+    # we should only ever see one but if we see multiple we warn, so test that.
+    (tmp_path / "log_ffp_worker_2.txt").write_bytes(b"worker log")
     log_map = Report.select_logs(str(tmp_path))
-    assert (tmp_path / log_map["stderr"]).is_file()
-    assert (tmp_path / log_map["stdout"]).is_file()
-    assert "worker log" in (tmp_path / log_map["aux"]).read_text()
+    assert (tmp_path / log_map.stderr).is_file()
+    assert (tmp_path / log_map.stdout).is_file()
+    assert "worker log" in (tmp_path / log_map.aux).read_text()
 
 def test_report_09(tmp_path):
     """test prioritizing *San logs with Report.select_logs()"""
@@ -192,25 +190,25 @@ def test_report_09(tmp_path):
         log_fp.write(b"BAD LOG\n")
         log_fp.write(b"ERROR: Failed to mmap\n")  # must be 2nd line
     log_map = Report.select_logs(str(tmp_path))
-    assert "GOOD LOG" in (tmp_path / log_map["aux"]).read_text()
+    assert "GOOD LOG" in (tmp_path / log_map.aux).read_text()
 
 def test_report_10(tmp_path):
-    """test Report size_limit"""
+    """test Report() size_limit"""
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log\n" * 200)
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log\n" * 200)
     (tmp_path / "unrelated.txt").write_bytes(b"nothing burger\n" * 200)
     (tmp_path / "rr-trace").mkdir()
     size_limit = len("STDERR log\n")
-    report = Report.from_path(str(tmp_path), size_limit=size_limit)
+    report = Report(str(tmp_path), "bin", size_limit=size_limit)
     assert report.path == str(tmp_path)
-    assert report.log_err.endswith("log_stderr.txt")
-    assert report.log_out.endswith("log_stdout.txt")
+    assert report._logs.aux is None
+    assert report._logs.stderr.endswith("log_stderr.txt")
+    assert report._logs.stdout.endswith("log_stdout.txt")
     assert report.preferred.endswith("log_stderr.txt")
-    assert report.log_aux is None
     assert report.stack is None
     size_limit += len("[LOG TAILED]\n")
-    assert os.stat(os.path.join(report.path, report.log_err)).st_size == size_limit
-    assert os.stat(os.path.join(report.path, report.log_out)).st_size == size_limit
+    assert os.stat(os.path.join(report.path, report._logs.stderr)).st_size == size_limit
+    assert os.stat(os.path.join(report.path, report._logs.stdout)).st_size == size_limit
     assert os.stat(os.path.join(report.path, "unrelated.txt")).st_size == size_limit
     report.cleanup()
     assert not tmp_path.is_dir()
@@ -221,21 +219,21 @@ def test_report_11(tmp_path):
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     (tmp_path / "log_valgrind.txt").write_bytes(b"valgrind log")
     log_map = Report.select_logs(str(tmp_path))
-    assert (tmp_path / log_map["stderr"]).is_file()
-    assert (tmp_path / log_map["stdout"]).is_file()
-    assert "valgrind log" in (tmp_path / log_map["aux"]).read_text()
+    assert (tmp_path / log_map.stderr).is_file()
+    assert (tmp_path / log_map.stdout).is_file()
+    assert "valgrind log" in (tmp_path / log_map.aux).read_text()
 
 def test_report_12(tmp_path):
-    """test Report.crash_info()"""
+    """test Report.crash_info"""
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     with (tmp_path / "log_asan_blah.txt").open("wb") as log_fp:
         log_fp.write(b"    #0 0xbad000 in foo /file1.c:123:234\n")
         log_fp.write(b"    #1 0x1337dd in bar /file2.c:1806:19")
     # no binary.fuzzmanagerconf
-    report = Report.from_path(str(tmp_path))
+    report = Report(str(tmp_path), target_binary="fake_bin")
     assert report._crash_info is None
-    assert report.crash_info("fake_bin") is not None
+    assert report.crash_info is not None
     assert report._crash_info is not None
     # with binary.fuzzmanagerconf
     with (tmp_path / "fake_bin.fuzzmanagerconf").open("wb") as conf:
@@ -243,13 +241,13 @@ def test_report_12(tmp_path):
         conf.write(b"platform = x86-64\n")
         conf.write(b"product = mozilla-central\n")
         conf.write(b"os = linux\n")
-    report = Report.from_path(str(tmp_path))
+    report = Report(str(tmp_path), target_binary=str(tmp_path / "fake_bin"))
     assert report._crash_info is None
-    assert report.crash_info(str(tmp_path / "fake_bin")) is not None
+    assert report.crash_info is not None
     assert report._crash_info is not None
 
 def test_report_13(mocker, tmp_path):
-    """test Report.crash_signature() and Report.crash_hash()"""
+    """test Report.crash_signature and Report.crash_hash"""
     mocker.patch("grizzly.common.reporter.ProgramConfiguration", autospec=True)
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
@@ -257,14 +255,11 @@ def test_report_13(mocker, tmp_path):
         log_fp.write(b"==1==ERROR: AddressSanitizer: SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n")
         log_fp.write(b"    #0 0xbad000 in foo /file1.c:123:234\n")
         log_fp.write(b"    #1 0x1337dd in bar /file2.c:1806:19")
-    report = Report.from_path(str(tmp_path))
-    assert report._crash_info is None
-    info = report.crash_info("fake_bin")
-    sig = Report.crash_signature(info)
-    assert sig.symptoms
-    short_sig = info.createShortSignature()
-    assert short_sig == "[@ foo]"
-    assert Report.crash_hash(info)
+    report = Report(str(tmp_path), "bin")
+    assert report._signature is None
+    assert report.crash_signature
+    assert report.crash_info.createShortSignature() == "[@ foo]"
+    assert report.crash_hash
 
 def test_report_14(mocker):
     """test Report.crash_signature_max_frames()"""
@@ -274,25 +269,16 @@ def test_report_14(mocker):
     info.backtrace = ("std::panicking::rust_panic", "std::panicking::rust_panic_with_hook")
     assert Report.crash_signature_max_frames(info) == 14
 
-def test_reporter_01(mocker, tmp_path):
+def test_reporter_01(mocker):
     """test creating a simple Reporter"""
     class SimpleReporter(Reporter):
-        def _process_report(self, report):
+        def _pre_submit(self, report):
             pass
-        def _reset(self):
+        def _post_submit(self):
             pass
         def _submit_report(self, report, test_cases):
             pass
     reporter = SimpleReporter()
-    with pytest.raises(AssertionError, match="Either 'log_path' or 'report' must be specified!"):
-        reporter.submit([])
-    with pytest.raises(IOError, match="No such directory 'fake_dir'"):
-        reporter.submit([], log_path="fake_dir")
-    with pytest.raises(IOError, match="No logs found in"):
-        reporter.submit([], log_path=str(tmp_path))
-    with pytest.raises(AssertionError, match="Only 'log_path' or 'report' can be specified!"):
-        reporter.submit([], log_path=str(tmp_path), report=mocker.Mock())
-    # submit a report
     reporter.submit([], report=mocker.Mock(spec=Report))
 
 def test_filesystem_reporter_01(tmp_path):
@@ -307,13 +293,13 @@ def test_filesystem_reporter_01(tmp_path):
     report_path = tmp_path / "reports"
     report_path.mkdir()
     reporter = FilesystemReporter(report_path=str(report_path))
-    reporter.submit([], log_path=str(log_path))
-    buckets = [x for x in report_path.iterdir()]
+    reporter.submit([], Report(str(log_path), "fake_bin"))
+    buckets = tuple(report_path.iterdir())
     # check major bucket
     assert len(buckets) == 1
     assert buckets[0].is_dir()
     # check log path exists
-    log_dirs = [x for x in buckets[0].iterdir()]
+    log_dirs = tuple(buckets[0].iterdir())
     assert len(log_dirs) == 1
     assert log_dirs[0].is_dir()
     assert "_logs" in str(log_dirs[0])
@@ -333,7 +319,7 @@ def test_filesystem_reporter_02(tmp_path, mocker):
     report_path = tmp_path / "reports"
     assert not report_path.exists()
     reporter = FilesystemReporter(report_path=str(report_path))
-    reporter.submit(testcases, log_path=str(log_path))
+    reporter.submit(testcases, Report(str(log_path), "fake_bin"))
     assert not log_path.exists()
     assert report_path.exists()
     assert len(tuple(report_path.glob("*"))) == 1
@@ -346,7 +332,7 @@ def test_filesystem_reporter_02(tmp_path, mocker):
     testcases = list()
     for _ in range(2):
         testcases.append(mocker.Mock(spec=TestCase))
-    reporter.submit(testcases, log_path=str(log_path))
+    reporter.submit(testcases, Report(str(log_path), "fake_bin"))
     for tstc in testcases:
         assert tstc.dump.call_count == 1
     assert len(tuple(report_path.glob("*"))) == 2
@@ -363,22 +349,23 @@ def test_filesystem_reporter_03(tmp_path):
     reporter = FilesystemReporter(report_path=str(report_path))
     reporter.DISK_SPACE_ABORT = 2 ** 50
     with pytest.raises(RuntimeError) as exc:
-        reporter.submit([], log_path=str(log_path))
+        reporter.submit([], Report(str(log_path), "fake_bin"))
     assert "Running low on disk space" in str(exc.value)
 
 def test_filesystem_reporter_04(mocker, tmp_path):
     """test FilesystemReporter w/o major bucket"""
-    report = mocker.Mock(spec=Report)
     report_path = (tmp_path / "report")
     report_path.mkdir()
-    report.path = str(report_path)
-    report.prefix = "0000_2020_01_01"
+    report = mocker.Mock(
+        spec=Report,
+        path=str(report_path),
+        prefix="0000_2020_01_01")
     reporter = FilesystemReporter(report_path=str(tmp_path), major_bucket=False)
-    reporter.submit([], report=report)
+    reporter.submit([], report)
     assert not report_path.is_dir()
     assert not report.major.call_count
 
-def test_fuzzmanager_reporter_01(tmp_path, mocker):
+def test_fuzzmanager_reporter_01(mocker, tmp_path):
     """test FuzzManagerReporter.sanity_check()"""
     fake_reporter = mocker.patch("grizzly.common.reporter.ProgramConfiguration")
     fake_reporter.fromBinary.return_value = mocker.Mock(spec=ProgramConfiguration)
@@ -399,111 +386,161 @@ def test_fuzzmanager_reporter_01(tmp_path, mocker):
     FuzzManagerReporter.sanity_check(str(fake_bin))
     assert fake_reporter.fromBinary.call_count == 1
 
-def test_fuzzmanager_reporter_02(tmp_path):
-    """test FuzzManagerReporter.submit() empty path"""
-    reporter = FuzzManagerReporter("fake_bin")
-    report_path = tmp_path / "report"
-    report_path.mkdir()
-    with pytest.raises(IOError) as exc:
-        reporter.submit([], log_path=str(report_path))
-    assert "No logs found in" in str(exc.value)
-
-def test_fuzzmanager_reporter_03(tmp_path, mocker):
+def test_fuzzmanager_reporter_02(mocker, tmp_path):
     """test FuzzManagerReporter.submit()"""
+    mocker.patch("grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path))
+    mocker.patch("grizzly.common.reporter.getenv", autospec=True, return_value="0")
     fake_crashinfo = mocker.patch("grizzly.common.reporter.CrashInfo", autospec=True)
     fake_crashinfo.fromRawCrashData.return_value.createShortSignature.return_value = "test [@ test]"
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     fake_collector.return_value.search.return_value = (None, None)
-    fake_collector.return_value.generate.return_value = str(tmp_path / "fake_sig_file")
+    fake_collector.return_value.generate.return_value = str(tmp_path / "fm_file.signature")
     log_path = tmp_path / "log_path"
     log_path.mkdir()
     (log_path / "log_ffp_worker_blah.txt").touch()
     (log_path / "log_stderr.txt").touch()
     (log_path / "log_stdout.txt").touch()
-    report = Report.from_path(str(log_path))
-    fake_test = mocker.Mock(spec=TestCase)
-    fake_test.adapter_name = "adapter"
-    fake_test.input_fname = "input"
-    fake_test.env_vars = {"TEST": "1"}
-    reporter = FuzzManagerReporter(str("fake_bin"))
-    reporter.submit([fake_test], report=report)
+    (log_path / "rr-traces").mkdir()
+    (tmp_path / "screenlog.0").touch()
+    fake_test = mocker.Mock(
+        spec=TestCase,
+        adapter_name="adapter",
+        env_vars={"TEST": "1"},
+        input_fname="input")
+    reporter = FuzzManagerReporter("fake_bin")
+    reporter.submit([fake_test], Report(str(log_path), "fake_bin"))
     assert not log_path.is_dir()
     assert fake_test.dump.call_count == 1
     assert fake_collector.return_value.submit.call_count == 1
+    meta_data = (tmp_path / "fm_file.metadata").read_text()
+    assert "\"frequent\": false" in meta_data
+    assert "\"_grizzly_seen_count\": 1" in meta_data
+    assert "\"shortDescription\": \"test [@ test]\"" in meta_data
+
+def test_fuzzmanager_reporter_03(mocker, tmp_path):
+    """test FuzzManagerReporter.submit() - no test / mark as frequent"""
+    mocker.patch("grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path))
+    fake_crashinfo = mocker.patch("grizzly.common.reporter.CrashInfo", autospec=True)
+    fake_crashinfo.fromRawCrashData.return_value.createShortSignature.return_value = "test [@ test]"
+    fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
+    fake_collector.return_value.search.return_value = (None, None)
+    fake_collector.return_value.generate.return_value = str(tmp_path / "fm_file.signature")
+    log_path = tmp_path / "log_path"
+    log_path.mkdir()
+    (log_path / "log_stderr.txt").touch()
+    (log_path / "log_stdout.txt").touch()
+    reporter = FuzzManagerReporter("fake_bin")
+    reporter.MAX_REPORTS = 1
+    reporter.submit([], Report(str(log_path), "fake_bin"))
+    assert fake_collector.return_value.submit.call_count == 1
+    meta_data = (tmp_path / "fm_file.metadata").read_text()
+    assert "\"frequent\": true" in meta_data
+    assert "\"_grizzly_seen_count\": 1" in meta_data
+    assert "\"shortDescription\": \"test [@ test]\"" in meta_data
 
-def test_fuzzmanager_reporter_04(tmp_path, mocker):
+def test_fuzzmanager_reporter_04(mocker, tmp_path):
     """test FuzzManagerReporter.submit() hit frequent crash"""
     mocker.patch("grizzly.common.reporter.CrashInfo", autospec=True)
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
-    fake_collector.return_value.search.return_value = (None, {"frequent": True, "shortDescription": "[@ test]"})
-    reporter = FuzzManagerReporter("fake_bin")
+    fake_collector.return_value.search.return_value = (
+        None,
+        {"frequent": True, "shortDescription": "[@ test]"})
     log_path = tmp_path / "log_path"
     log_path.mkdir()
     (log_path / "log_stderr.txt").touch()
     (log_path / "log_stdout.txt").touch()
-    reporter.submit([], log_path=str(log_path))
+    reporter = FuzzManagerReporter("fake_bin")
+    reporter.submit([], Report(str(log_path), "fake_bin"))
     fake_collector.return_value.submit.assert_not_called()
 
-def test_fuzzmanager_reporter_05(tmp_path, mocker):
+def test_fuzzmanager_reporter_05(mocker, tmp_path):
     """test FuzzManagerReporter.submit() hit existing crash"""
     mocker.patch("grizzly.common.reporter.CrashInfo", autospec=True)
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     fake_collector.return_value.search.return_value = (
-        None, {"bug__id":1, "frequent": False, "shortDescription": "[@ test]"})
-    reporter = FuzzManagerReporter("fake_bin")
+        None,
+        {"bug__id":1, "frequent": False, "shortDescription": "[@ test]"})
     log_path = tmp_path / "log_path"
     log_path.mkdir()
     (log_path / "log_stderr.txt").touch()
     (log_path / "log_stdout.txt").touch()
+    reporter = FuzzManagerReporter("fake_bin")
     reporter._ignored = lambda x: True
-    reporter.submit([], log_path=str(log_path))
+    reporter.submit([], Report(str(log_path), "fake_bin"))
     fake_collector.return_value.submit.assert_not_called()
 
-def test_fuzzmanager_reporter_06(tmp_path, mocker):
+def test_fuzzmanager_reporter_06(mocker, tmp_path):
     """test FuzzManagerReporter.submit() no signature"""
-    mocker.patch("grizzly.common.reporter.CrashInfo", autospec=True)
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     fake_collector.return_value.search.return_value = (None, None)
     fake_collector.return_value.generate.return_value = None
-    reporter = FuzzManagerReporter("fake_bin")
     log_path = tmp_path / "log_path"
     log_path.mkdir()
     (log_path / "log_stderr.txt").touch()
     (log_path / "log_stdout.txt").touch()
+    reporter = FuzzManagerReporter("fake_bin")
     with pytest.raises(RuntimeError) as exc:
-        reporter.submit([], log_path=str(log_path))
+        reporter.submit([], Report(str(log_path), "fake_bin"))
     assert "Failed to create FM signature" in str(exc.value)
-    fake_collector.return_value.submit.assert_not_called()
-    # test ignore unsymbolized crash
+
+def test_fuzzmanager_reporter_07(mocker, tmp_path):
+    """test FuzzManagerReporter.submit() unsymbolized crash"""
+    fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
+    fake_collector.return_value.search.return_value = (None, None)
+    fake_collector.return_value.generate.return_value = None
+    log_path = tmp_path / "log_path"
+    log_path.mkdir()
+    (log_path / "log_stderr.txt").touch()
+    (log_path / "log_stdout.txt").touch()
+    reporter = FuzzManagerReporter("fake_bin")
     reporter._ignored = lambda x: True
-    reporter.submit([], log_path=str(log_path))
+    reporter.submit([], Report(str(log_path), "fake_bin"))
     fake_collector.return_value.submit.assert_not_called()
 
-def test_s3fuzzmanager_reporter_01(tmp_path, mocker):
+def test_fuzzmanager_reporter_08():
+    """test FuzzManagerReporter.quality_name()"""
+    assert FuzzManagerReporter.quality_name(0) == "QUAL_REDUCED_RESULT"
+    assert FuzzManagerReporter.quality_name(-1) == "unknown quality (-1)"
+
+def test_fuzzmanager_reporter_09(mocker, tmp_path):
+    """test FuzzManagerReporter._ignored()"""
+    log_file = (tmp_path / "test.log")
+    log_file.touch()
+    report = mocker.Mock(spec=Report, path=str(tmp_path), preferred=str(log_file))
+    # not ignored
+    assert not FuzzManagerReporter._ignored(report)
+    # ignored - sanitizer OOM missing stack
+    log_file.write_bytes(b"ERROR: Failed to mmap")
+    assert FuzzManagerReporter._ignored(report)
+    # ignored - Valgrind OOM
+    log_file.write_bytes(b"VEX temporary storage exhausted.")
+    assert FuzzManagerReporter._ignored(report)
+
+def test_s3fuzzmanager_reporter_01(mocker, tmp_path):
     """test S3FuzzManagerReporter.sanity_check()"""
     mocker.patch("grizzly.common.reporter.FuzzManagerReporter", autospec=True)
     fake_bin = tmp_path / "bin"
+    # test GRZ_S3_BUCKET missing
     with pytest.raises(EnvironmentError) as exc:
         S3FuzzManagerReporter.sanity_check(str(fake_bin))
     assert "'GRZ_S3_BUCKET' is not set in environment" in str(exc.value)
+    # test GRZ_S3_BUCKET set
     pytest.importorskip("boto3")
-    os.environ["GRZ_S3_BUCKET"] = "test"
-    try:
-        S3FuzzManagerReporter.sanity_check(str(fake_bin))
-    finally:
-        os.environ.pop("GRZ_S3_BUCKET", None)
+    mocker.patch("grizzly.common.reporter.getenv", autospec=True, return_value="test")
+    S3FuzzManagerReporter.sanity_check(str(fake_bin))
 
-def test_s3fuzzmanager_reporter_02(tmp_path, mocker):
-    """test S3FuzzManagerReporter._process_report()"""
+def test_s3fuzzmanager_reporter_02(mocker, tmp_path):
+    """test S3FuzzManagerReporter._pre_submit()"""
     pytest.importorskip("boto3")
     pytest.importorskip("botocore")
+    mocker.patch("grizzly.common.reporter.getenv", autospec=True, return_value="test")
     fake_resource = mocker.patch("grizzly.common.reporter.resource", autospec=True)
 
     fake_report = mocker.Mock(spec=Report)
     fake_report.path = "no-path"
     reporter = S3FuzzManagerReporter("fake_bin")
     # test will missing rr-trace
-    assert reporter._process_report(fake_report) is None
+    assert reporter._pre_submit(fake_report) is None
     assert not reporter._extra_metadata
 
     # test will exiting rr-trace
@@ -511,11 +548,7 @@ def test_s3fuzzmanager_reporter_02(tmp_path, mocker):
     trace_dir.mkdir(parents=True)
     fake_report.minor = "1234abcd"
     fake_report.path = str(tmp_path)
-    os.environ["GRZ_S3_BUCKET"] = "test"
-    try:
-        reporter._process_report(fake_report)
-    finally:
-        os.environ.pop("GRZ_S3_BUCKET", None)
+    reporter._pre_submit(fake_report)
     assert not tuple(tmp_path.glob("*"))
     assert "rr-trace" in reporter._extra_metadata
     assert fake_report.minor in reporter._extra_metadata["rr-trace"]
@@ -531,11 +564,7 @@ def __init__(self, message, response):
             self.response = response
     mocker.patch("grizzly.common.reporter.ClientError", new=FakeClientError)
     fake_resource.return_value.Object.side_effect = FakeClientError("test", {"Error": {"Code": "404"}})
-    os.environ["GRZ_S3_BUCKET"] = "test"
-    try:
-        reporter._process_report(fake_report)
-    finally:
-        os.environ.pop("GRZ_S3_BUCKET", None)
+    reporter._pre_submit(fake_report)
     assert not tuple(tmp_path.glob("*"))
     assert "rr-trace" in reporter._extra_metadata
     assert fake_report.minor in reporter._extra_metadata["rr-trace"]
diff --git a/grizzly/main.py b/grizzly/main.py
index dc418ec6..08047aa4 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -94,10 +94,10 @@ def main(args):
         log.debug("initializing the Reporter")
         if args.fuzzmanager:
             log.info("Results will be reported via FuzzManager")
-            reporter = FuzzManagerReporter(args.binary, tool=args.tool)
+            reporter = FuzzManagerReporter(tool=args.tool)
         elif args.s3_fuzzmanager:
             log.info("Results will be reported via FuzzManager w/ large attachments in S3")
-            reporter = S3FuzzManagerReporter(args.binary, tool=args.tool)
+            reporter = S3FuzzManagerReporter(tool=args.tool)
         else:
             reporter = FilesystemReporter()
             log.info("Results will be stored in %r", reporter.report_path)
diff --git a/grizzly/reduce/reduce.py b/grizzly/reduce/reduce.py
index 9edc21ba..d187df41 100644
--- a/grizzly/reduce/reduce.py
+++ b/grizzly/reduce/reduce.py
@@ -6,7 +6,6 @@
 Given a build and testcase, try to reproduce it using a set of strategies.
 """
 from __future__ import absolute_import
-import glob
 import hashlib
 import io
 import json
@@ -249,7 +248,7 @@ class ReductionJob(object):
     __slots__ = [
         '_any_crash', '_best_testcase', '_cache_iter_harness_created', '_env_mod',
         '_fixed_timeout', '_force_no_harness', '_idle_threshold', '_idle_timeout', '_ignore',
-        '_input_fname', '_interesting_prefix', '_iter_timeout', '_landing_page', '_log_handler',
+        '_input_fname', '_interesting_report', '_iter_timeout', '_landing_page', '_log_handler',
         '_min_crashes', '_no_harness', '_orig_sig', '_original_relaunch', '_other_crashes',
         '_reduce_file', '_repeat', '_reporter', '_result_cache', '_result_code', '_server', '_server_map',
         '_signature', '_skip', '_skip_analysis', '_skipped', '_status', '_target', '_tcroot', '_testcase',
@@ -273,7 +272,7 @@ def __init__(self, ignore, target, iter_timeout, no_harness, any_crash, skip, mi
         self._idle_timeout = idle_timeout
         self._ignore = ignore  # things to ignore
         self._input_fname = None
-        self._interesting_prefix = None
+        self._interesting_report = None
         self._iter_timeout = iter_timeout
         self._landing_page = None  # the file to point the target at
         self._min_crashes = min_crashes
@@ -448,16 +447,6 @@ def lithium_interesting(self, temp_prefix):
                 result = self._result_cache[cache_key]['result']
                 if result:
                     LOG.info("Interesting (cached)")
-                    cached_prefix = self._result_cache[cache_key]['prefix']
-                    for filename in glob.glob(r"%s_*" % cached_prefix):
-                        suffix = os.path.basename(filename).split("_", 1)
-                        if os.path.isfile(filename):
-                            shutil.copy(filename, "%s_%s" % (temp_prefix, suffix[1]))
-                        elif os.path.isdir(filename):
-                            shutil.copytree(filename, "%s_%s" % (temp_prefix, suffix[1]))
-                        else:
-                            raise RuntimeError("Cannot copy non-file/non-directory: %s"
-                                               % (filename,))
                 else:
                     LOG.info("Uninteresting (cached)")
                 return result
@@ -487,16 +476,17 @@ def lithium_interesting(self, temp_prefix):
             self._status.report()
             self._status.iteration += 1
             run_prefix = "%s(%d)" % (temp_prefix, try_num)
-            if self._run(testcase, run_prefix):
+            interesting_report = self._run(testcase, run_prefix)
+            if interesting_report:
                 # track the maximum duration of the successful reduction attempts
                 if testcase.duration > max_duration:
                     max_duration = testcase.duration
                 n_crashes += 1
                 if n_crashes >= self._min_crashes:
-                    self.on_interesting_crash(run_prefix)
+                    self.on_interesting_crash(interesting_report)
                     if self._use_result_cache:
                         self._result_cache[cache_key] = {
-                            'result': True,
+                            'result': interesting_report,
                             'prefix': run_prefix
                         }
                     self._best_testcase = testcase
@@ -509,7 +499,7 @@ def lithium_interesting(self, temp_prefix):
             # No need to save the temp_prefix on uninteresting testcases
             # But let's do it anyway to stay consistent
             self._result_cache[cache_key] = {
-                'result': False,
+                'result': None,
                 'prefix': run_prefix
             }
         return False
@@ -597,9 +587,9 @@ def _run(self, testcase, temp_prefix):
             temp_prefix (str): A unique prefix for any files written during this iteration.
 
         Returns:
-            bool: True if reduced testcase is still interesting.
+            Report: Report from reduced testcase if still interesting else None.
         """
-        interesting = False
+        interesting = None
 
         # if target is closed and server is alive, we should restart it or else the first request
         #   against /first_test will 404
@@ -669,23 +659,21 @@ def _dyn_resp_close():  # pragma: no cover
                 os.mkdir(result_logs)
             self._target.save_logs(result_logs)
 
-            # create a CrashInfo
-            crash = FuzzManagerReporter.create_crash_info(
-                Report.from_path(result_logs),
-                self._target.binary)
+            # create report
+            report = Report(result_logs, self._target.binary)
 
-            short_sig = crash.createShortSignature()
+            short_sig = report.crash_info.createShortSignature()
             if short_sig == "No crash detected":
                 # XXX: need to change this to support reducing timeouts?
                 LOG.info("Uninteresting: no crash detected")
-            elif self._orig_sig is None or self._orig_sig.matches(crash):
-                interesting = True
+            elif self._orig_sig is None or self._orig_sig.matches(report.crash_info):
+                interesting = report
                 LOG.info("Interesting: %s", short_sig)
                 if self._orig_sig is None and not self._any_crash:
-                    self._orig_sig = Report.crash_signature(crash)
+                    self._orig_sig = report.crash_signature
             else:
                 LOG.info("Uninteresting: different signature: %s", short_sig)
-                self.on_other_crash_found(testcase, temp_prefix)
+                self.on_other_crash_found(testcase, report)
 
         elif result.status == RunResult.IGNORED:
             LOG.info("Uninteresting: ignored")
@@ -956,43 +944,39 @@ def close(self, keep_temp=False):
             self._target.cleanup()
         self._status.cleanup()
 
-    def _report_result(self, testcase, temp_prefix, quality_value, force=False):
+    def _report_result(self, testcase, report, quality_value, force=False):
         self._reporter.quality = quality_value
         self._reporter.force_report = force
-        self._reporter.submit([testcase], log_path=temp_prefix + "_logs")
+        self._reporter.submit([testcase], report)
 
-    def on_interesting_crash(self, temp_prefix):
+    def on_interesting_crash(self, report):
         # called for any interesting crash
-        self._interesting_prefix = temp_prefix
+        self._interesting_report = report
 
     def on_result(self, result_code):
         pass
 
-    def on_other_crash_found(self, testcase, temp_prefix):
+    def on_other_crash_found(self, testcase, report):
         """
         If we hit an alternate crash, store the testcase in a tmp folder.
         If the same crash is encountered again, only keep the newest one.
         """
-        crash_info = FuzzManagerReporter.create_crash_info(
-            Report.from_path(temp_prefix + "_logs"),
-            self._target.binary)
-        crash_hash = Report.crash_hash(crash_info)
-        short_sig = crash_info.createShortSignature()
-        if crash_hash in self._other_crashes:
+        short_sig = report.crash_info.createShortSignature()
+        if report.crash_hash in self._other_crashes:
             LOG.info("Found alternate crash (newer): %s", short_sig)
             # already counted when initially found
             self._status.ignored += 1
         else:
             LOG.info("Found alternate crash: %s", short_sig)
             self._status.count_result(short_sig)
-        self._other_crashes[crash_hash] = {"tc": testcase, "prefix": temp_prefix}
+        self._other_crashes[report.crash_hash] = {"tc": testcase, "report": report}
 
     def _report_other_crashes(self):
         """
         After reduce is finished, report any alternate results (if they don't match the collector cache).
         """
         for entry in self._other_crashes.values():
-            self._report_result(entry["tc"], entry["prefix"], FuzzManagerReporter.QUAL_UNREDUCED)
+            self._report_result(entry["tc"], entry["report"], FuzzManagerReporter.QUAL_UNREDUCED)
 
     def run(self, strategies=None):
         """Run reduction.
@@ -1090,7 +1074,7 @@ def run(self, strategies=None):
                 raise ReducerError("Reducer succeeded but nothing was reduced!")
 
             self._report_result(self._best_testcase,
-                                self._interesting_prefix,
+                                self._interesting_report,
                                 FuzzManagerReporter.QUAL_REDUCED_RESULT,
                                 force=True)
 
@@ -1147,7 +1131,7 @@ def from_args(cls, args, target):
         LOG.debug("initializing the Reporter")
         if args.fuzzmanager:
             LOG.info("Reporting issues via FuzzManager")
-            job.set_reporter(FuzzManagerReporter(args.binary, tool=args.tool))
+            job.set_reporter(FuzzManagerReporter(tool=args.tool))
         else:
             reporter = FilesystemReporter()
             job.set_reporter(reporter)
diff --git a/grizzly/reduce/test_common.py b/grizzly/reduce/test_common.py
index 87459144..7a24a239 100644
--- a/grizzly/reduce/test_common.py
+++ b/grizzly/reduce/test_common.py
@@ -2,18 +2,19 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# pylint: disable=protected-access
 from __future__ import unicode_literals
 import os
 from grizzly.target.target import Target
-from grizzly.common import Reporter
+from grizzly.common import Report, Reporter
 from grizzly.reduce import crash
 from grizzly.reduce.reduce import ReductionJob
 
 class BaseFakeReporter(Reporter):
-    def _process_report(self, _):
+    def _post_submit(self):
         pass
 
-    def _reset(self):
+    def _pre_submit(self, _):
         pass
 
     def _submit_report(self, *_args, **_kwds):
@@ -98,6 +99,11 @@ def create_target_binary(target, tmp_path):
     )
     target.binary = str(tmp_path / "firefox")
 
+def write_fail_log(path):
+    with open(os.path.join(path, "log_stderr.txt"), "wb") as log_fp:
+        log_fp.write(b"==1==ERROR: AddressSanitizer: SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n")
+        log_fp.write(b"    #0 0xbad000 in foo /file1.c:123:234\n")
+        log_fp.write(b"    #1 0x1337dd in bar /file2.c:1806:19")
 
 class TestReductionJob(ReductionJob):
     """Stub to fake parts of grizzly.reduce.ReductionJob needed for testing the reduce loop"""
@@ -122,7 +128,13 @@ def _run(self, testcase, temp_prefix):
         self.target.save_logs(result_logs)
         testcase.duration = 0.1
         with open(self.reduce_file) as fp:
-            return "required" in fp.read()
+            if "required" in fp.read():
+                write_fail_log(result_logs)
+                report = Report(result_logs, self.target.binary)
+            else:
+                report = None
+        return report
+
 
     def lithium_cleanup(self):
         pass
@@ -155,11 +167,14 @@ def _run(self, testcase, temp_prefix):
         testcase.duration = 0.1
         with open(self.reduce_file) as fp:
             if "required" in fp.read():
-                self.on_other_crash_found(testcase, temp_prefix)
+                write_fail_log(result_logs)
+                report = Report(result_logs, self.target.binary)
+                self.on_other_crash_found(testcase, report)
+            else:
+                report = None
         if self.__first_run:
             self.__first_run = False
-            return True
-        return False
+        return report
 
 
 class TestReductionJobKeepHarness(TestReductionJob):
@@ -179,10 +194,15 @@ def _run(self, testcase, temp_prefix):
         testcase.duration = 0.1
         if self.__init_data is not None:
             with open(self.reduce_file) as fp:
-                return self.__init_data == fp.read()
+                if self.__init_data == fp.read():
+                    write_fail_log(result_logs)
+                    return Report(result_logs, self.target.binary)
         else:
             with open(self.reduce_file) as fp:
-                return "required" in fp.read()
+                if "required" in fp.read():
+                    write_fail_log(result_logs)
+                    return Report(result_logs, self.target.binary)
+        return None
 
 
 class TestReductionJobSemiReliable(TestReductionJob):
@@ -206,6 +226,9 @@ def _run(self, testcase, temp_prefix):
         self.target.save_logs(result_logs)
         testcase.duration = 0.1
         if self.__require_no_harness and not self._no_harness:
-            return False
+            return None
         self.__interesting_count += 1
-        return self.__interesting_count <= self.__interesting_times
+        if self.__interesting_count <= self.__interesting_times:
+            write_fail_log(result_logs)
+            return Report(result_logs, self.target.binary)
+        return None
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 01c09d44..6d7bc3b9 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -141,6 +141,7 @@ def run(self, testcases, repeat=1, min_results=1):
         assert repeat > 0
         assert min_results > 0
         assert min_results <= repeat
+        assert self.status is None
 
         self.status = Status.start()
         test_count = len(testcases)
@@ -191,7 +192,7 @@ def _dyn_close():  # pragma: no cover
                         LOG.error("Target launch error. Check browser logs for details.")
                         log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
                         self.target.save_logs(log_path)
-                        self._reports_other["STARTUP"] = Report.from_path(log_path)
+                        self._reports_other["STARTUP"] = Report(log_path, self.target.binary)
                         raise
                 self.target.step()
                 LOG.info("Performing replay (%d/%d)...", self.status.iteration, repeat)
@@ -222,41 +223,39 @@ def _dyn_close():  # pragma: no cover
                 if result.status == RunResult.FAILED:
                     log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
                     self.target.save_logs(log_path)
-                    report = Report.from_path(log_path)
+                    report = Report(log_path, self.target.binary)
                     # check signatures
-                    crash_info = report.crash_info(self.target.binary)
-                    short_sig = crash_info.createShortSignature()
+                    short_sig = report.crash_info.createShortSignature()
                     if not self._any_crash and self._signature is None and short_sig != "No crash detected":
                         # signature has not been specified use the first one created
-                        self._signature = report.crash_signature(crash_info)
+                        self._signature = report.crash_signature
                     if short_sig == "No crash detected":
                         # TODO: verify report.major == "NO_STACK" otherwise FM failed to parse the logs
                         # TODO: change this to support hangs/timeouts, etc
                         LOG.info("Result: No crash detected")
-                        crash_hash = None
-                    elif self._any_crash or self._signature.matches(crash_info):
+                    elif self._any_crash or self._signature.matches(report.crash_info):
                         self.status.count_result(short_sig)
                         LOG.info("Result: %s (%s:%s)",
                                  short_sig, report.major[:8], report.minor[:8])
-                        crash_hash = report.crash_hash(crash_info)
-                        if crash_hash not in self._reports_expected:
-                            LOG.debug("now tracking %s", crash_hash)
-                            self._reports_expected[crash_hash] = report
+                        if report.crash_hash not in self._reports_expected:
+                            LOG.debug("now tracking %s", report.crash_hash)
+                            self._reports_expected[report.crash_hash] = report
                             report = None  # don't remove report
+                        else:
+                            LOG.debug("already tracking %s", report.crash_hash)
                         assert self._any_crash or len(self._reports_expected) == 1
                     else:
                         LOG.info("Result: Different signature: %s (%s:%s)",
                                  short_sig, report.major[:8], report.minor[:8])
                         self.status.ignored += 1
-                        crash_hash = report.crash_hash(crash_info)
-                        if crash_hash not in self._reports_other:
-                            LOG.debug("now tracking %s", crash_hash)
-                            self._reports_other[crash_hash] = report
+                        if report.crash_hash not in self._reports_other:
+                            LOG.debug("now tracking %s", report.crash_hash)
+                            self._reports_other[report.crash_hash] = report
                             report = None  # don't remove report
+                        else:
+                            LOG.debug("already tracking %s", report.crash_hash)
                     # purge untracked report
                     if report is not None:
-                        if crash_hash is not None:
-                            LOG.debug("already tracking %s", crash_hash)
                         report.cleanup()
                         report = None
                 elif result.status == RunResult.IGNORED:
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index b08d64f1..6b9d90ce 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -145,15 +145,15 @@ def test_replay_06(mocker):
 
 def test_replay_07(mocker, tmp_path):
     """test ReplayManager.run() - test signatures"""
-    report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report)
-    report_0.crash_info.return_value.createShortSignature.return_value = "No crash detected"
+    report_0.crash_info.createShortSignature.return_value = "No crash detected"
     report_1 = mocker.Mock(spec=Report, major="0123abcd", minor="01239999")
-    report_1.crash_info.return_value.createShortSignature.return_value = "[@ test1]"
+    report_1.crash_info.createShortSignature.return_value = "[@ test1]"
     report_2 = mocker.Mock(spec=Report, major="0123abcd", minor="abcd9876")
-    report_2.crash_info.return_value.createShortSignature.return_value = "[@ test2]"
-    report.from_path.side_effect = (report_0, report_1, report_2)
+    report_2.crash_info.createShortSignature.return_value = "[@ test2]"
+    fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
+    fake_report.side_effect = (report_0, report_1, report_2)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     signature = mocker.Mock()
@@ -165,7 +165,7 @@ def test_replay_07(mocker, tmp_path):
     with ReplayManager([], server, target, signature=signature, use_harness=False) as replay:
         assert not replay.run(testcases, repeat=3, min_results=2)
         assert replay._signature == signature
-        assert report.from_path.call_count == 3
+        assert fake_report.call_count == 3
         assert replay.status.iteration == 3
         assert replay.status.results == 1
         assert replay.status.ignored == 1
@@ -178,17 +178,17 @@ def test_replay_07(mocker, tmp_path):
 
 def test_replay_08(mocker, tmp_path):
     """test ReplayManager.run() - any crash"""
-    report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report)
-    report_0.crash_info.return_value.createShortSignature.return_value = "No crash detected"
+    report_0.crash_info.createShortSignature.return_value = "No crash detected"
     report_1 = mocker.Mock(spec=Report, major="0123abcd", minor="01239999")
-    report_1.crash_info.return_value.createShortSignature.return_value = "[@ test1]"
-    report_1.crash_hash.return_value = "hash1"
+    report_1.crash_info.createShortSignature.return_value = "[@ test1]"
+    report_1.crash_hash = "hash1"
     report_2 = mocker.Mock(spec=Report, major="0123abcd", minor="abcd9876")
-    report_2.crash_info.return_value.createShortSignature.return_value = "[@ test2]"
-    report_2.crash_hash.return_value = "hash2"
-    report.from_path.side_effect = (report_0, report_1, report_2)
+    report_2.crash_info.createShortSignature.return_value = "[@ test2]"
+    report_2.crash_hash = "hash2"
+    fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
+    fake_report.side_effect = (report_0, report_1, report_2)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target, binary="fake_bin")
@@ -198,12 +198,10 @@ def test_replay_08(mocker, tmp_path):
     with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
         assert replay.run(testcases, repeat=3, min_results=2)
         assert replay._signature is None
-        assert report.from_path.call_count == 3
+        assert fake_report.call_count == 3
         assert replay.status.iteration == 3
         assert replay.status.results == 2
         assert replay.status.ignored == 0
-        assert report_1.crash_hash.call_count == 1
-        assert report_2.crash_hash.call_count == 1
         assert len(replay.reports) == 2
         assert not replay.other_reports
         assert report_0.cleanup.call_count == 1
@@ -261,9 +259,9 @@ def test_replay_09(mocker, tmp_path):
 
 def test_replay_10(mocker, tmp_path):
     """test ReplayManager.run() - TargetLaunchError"""
-    report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
-    report.from_path.side_effect = (mocker.Mock(spec=Report),)
+    fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
+    fake_report.side_effect = (mocker.Mock(spec=Report),)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     target = mocker.Mock(spec=Target)
     target.launch.side_effect = TargetLaunchError
diff --git a/grizzly/session.py b/grizzly/session.py
index 362a4f10..aac7027d 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -109,13 +109,12 @@ def report_result(self):
         # create working directory for target logs
         result_logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
         self.target.save_logs(result_logs)
-        report = Report.from_path(result_logs)
-        crash_info = report.crash_info(self.target.binary)
-        short_sig = crash_info.createShortSignature()
+        report = Report(result_logs, self.target.binary)
+        short_sig = report.crash_info.createShortSignature()
         log.info("Result: %s (%s:%s)", short_sig, report.major[:8], report.minor[:8])
         # order test cases newest to oldest
         self.iomanager.tests.reverse()
-        self.reporter.submit(self.iomanager.tests, report=report)
+        self.reporter.submit(self.iomanager.tests, report)
         if isdir(result_logs):
             rmtree(result_logs)
         self.status.count_result(short_sig)
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 8533895c..fb07082e 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -11,11 +11,27 @@
 from pytest import raises
 
 from sapphire import Sapphire, ServerMap, SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
-from .common import Adapter, IOManager, Reporter, RunResult, Status, TestCase
+from .common import Adapter, IOManager, Report, Reporter, RunResult, Status, TestCase
 from .session import LogOutputLimiter, Session, SessionError
 from .target import Target, TargetLaunchError
 
 
+class NullReporter(Reporter):
+    def __init__(self):
+        self.submit_calls = 0
+
+    def _post_submit(self):
+        pass
+
+    def _pre_submit(self, report):
+        pass
+
+    def _submit_report(self, report, test_cases):
+        assert isinstance(report, Report)
+        for test in test_cases:
+            assert isinstance(test, TestCase)
+        self.submit_calls += 1
+
 def test_session_01(tmp_path, mocker):
     """test Session with playback Adapter"""
     class PlaybackAdapter(Adapter):
@@ -170,11 +186,11 @@ def test_session_07(tmp_path, mocker):
     fake_adapter.TEST_DURATION = 10
     fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap(), tests=deque())
     fake_iomgr.create_testcase.return_value = mocker.Mock(spec=TestCase)
-    fake_reporter = mocker.Mock(spec=Reporter)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
     fake_target.monitor.launches = 1
-    with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
+    reporter = NullReporter()
+    with Session(fake_adapter, fake_iomgr, reporter, fake_serv, fake_target) as session:
         session.run([], iteration_limit=1)
         assert fake_runner.return_value.run.call_count == 1
         assert fake_adapter.on_served.call_count == 1
@@ -184,7 +200,7 @@ def test_session_07(tmp_path, mocker):
         assert session.status.iteration == 1
         assert session.status.results == 1
         assert session.status.ignored == 0
-        assert fake_reporter.submit.call_count == 1
+        assert reporter.submit_calls == 1
 
 def test_session_08(tmp_path, mocker):
     """test Session.run() ignoring failures"""
@@ -230,17 +246,17 @@ def test_session_09(tmp_path, mocker):
         input_files=[],
         server_map=ServerMap(),
         tests=deque())
-    fake_reporter = mocker.Mock(spec=Reporter)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_target = mocker.Mock(spec=Target)
     fake_target.monitor.launches = 1
-    with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
+    reporter = NullReporter()
+    with Session(fake_adapter, fake_iomgr, reporter, fake_serv, fake_target) as session:
         with raises(TargetLaunchError, match=""):
             session.run([], iteration_limit=1)
         assert session.status.iteration == 1
         assert session.status.results == 1
         assert session.status.ignored == 0
-    assert fake_reporter.submit.call_count == 1
+    assert reporter.submit_calls == 1
 
 def test_session_10(tmp_path, mocker):
     """test Session.report_result()"""
@@ -253,19 +269,16 @@ def test_session_10(tmp_path, mocker):
         log_fp.write(b"SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n")
         log_fp.write(b"    #0 0xbad000 in foo /file1.c:123:234\n")
         log_fp.write(b"    #1 0x1337dd in bar /file2.c:1806:19\n")
-    fake_report = mocker.patch("grizzly.session.Report", autospec=True)
     mocker.patch("grizzly.session.mkdtemp", autospec=True, return_value=str(tmpd))
     Status.PATH = str(tmp_path)
     fake_iomgr = mocker.Mock(spec=IOManager, tests=deque())
-    fake_reporter = mocker.Mock(spec=Reporter)
     fake_target = mocker.Mock(spec=Target, binary="bin")
-    with Session(None, fake_iomgr, fake_reporter, None, fake_target) as session:
+    reporter = NullReporter()
+    with Session(None, fake_iomgr, reporter, None, fake_target) as session:
         session.report_result()
     assert fake_target.save_logs.call_count == 1
     fake_target.save_logs.assert_called_with(str(tmpd))
-    assert fake_report.from_path.return_value.crash_info.call_count == 1
-    fake_report.from_path.return_value.crash_info.assert_called_with("bin")
-    assert fake_reporter.submit.call_count == 1
+    assert reporter.submit_calls == 1
     assert not tmpd.is_dir()
 
 def test_log_output_limiter_01(mocker):

From e630f60044c23ec30b223a2358457b916f8138f8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 22 Sep 2020 11:34:41 -0700
Subject: [PATCH 015/531] Add ReplayResult

* Update Replay report handling
* TargetLaunchError now include a Report
* TargetLaunchError handling updates
* Removed GRZ_BROWSER_LOGS
* FilesystemReporter now requires report path
* Added tests, fixes and nits
---
 grizzly/common/reporter.py           |  23 +-
 grizzly/common/storage.py            |   1 +
 grizzly/common/test_reporter.py      |  80 +++--
 grizzly/common/test_runner.py        |   5 +-
 grizzly/common/test_storage.py       |   2 +-
 grizzly/main.py                      |  16 +-
 grizzly/reduce/reduce.py             |   2 +-
 grizzly/reduce/test_interesting.py   |   7 +-
 grizzly/reduce/test_main.py          |   4 +-
 grizzly/replay/replay.py             | 219 +++++++-------
 grizzly/replay/test_main.py          |  65 ++--
 grizzly/replay/test_replay.py        | 429 ++++++++++++++++++---------
 grizzly/session.py                   |   9 +-
 grizzly/target/puppet_target.py      |  32 +-
 grizzly/target/target.py             |   5 +
 grizzly/target/test_puppet_target.py |  39 +--
 grizzly/test_main.py                 |  15 +-
 grizzly/test_session.py              |  10 +-
 18 files changed, 578 insertions(+), 385 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 48d2892c..aafce0f9 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -86,6 +86,18 @@ def __init__(self, log_path, target_binary, size_limit=MAX_LOG_SIZE):
             self.prefix = "%s_%s" % (self.DEFAULT_MINOR, strftime("%Y-%m-%d_%H-%M-%S"))
             self.stack = None
 
+    @staticmethod
+    def calc_hash(signature):
+        """Create unique hash from a signature.
+
+        Args:
+            None
+
+        Returns:
+            str: Hash of the raw signature.
+        """
+        return sha1(signature.rawSignature.encode("utf-8")).hexdigest()[:16]
+
     def cleanup(self):
         """Remove Report data from filesystem.
 
@@ -101,7 +113,7 @@ def cleanup(self):
 
     @property
     def crash_hash(self):
-        """Create SHA1 hash from signature.
+        """Create unique hash from a signature.
 
         Args:
             None
@@ -109,7 +121,7 @@ def crash_hash(self):
         Returns:
             str: Hash of the raw signature of the crash.
         """
-        return sha1(self.crash_signature.rawSignature.encode("utf-8")).hexdigest()[:16]
+        return self.calc_hash(self.crash_signature)
 
     @property
     def crash_info(self):
@@ -387,9 +399,12 @@ def submit(self, test_cases, report):
 class FilesystemReporter(Reporter):
     DISK_SPACE_ABORT = 512 * 1024 * 1024  # 512 MB
 
-    def __init__(self, report_path=None, major_bucket=True):
+    __slots__ = ("major_bucket", "report_path")
+
+    def __init__(self, report_path, major_bucket=True):
         self.major_bucket = major_bucket
-        self.report_path = report_path or pathjoin(getcwd(), "results")
+        assert report_path
+        self.report_path = report_path
 
     def _pre_submit(self, report):
         pass
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 239dec32..352c3650 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -404,6 +404,7 @@ def purge_optional(self, keep):
         Returns:
             None
         """
+        # TODO: should we limit or warn on multiple calls to prevent issues?
         keep = set(keep)
         to_remove = []
         for idx, tfile in enumerate(self._files.optional):
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 843a0694..5804dafd 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -17,6 +17,12 @@
 from .reporter import FilesystemReporter, FuzzManagerReporter, Report, Reporter, S3FuzzManagerReporter
 from .storage import TestCase
 
+def _create_crash_log(log_path):
+    with log_path.open("w") as log_fp:
+        log_fp.write("==1==ERROR: AddressSanitizer: SEGV on unknown address 0x0")
+        log_fp.write(" (pc 0x0 bp 0x0 sp 0x0 T0)\n")
+        log_fp.write("    #0 0xbad000 in foo /file1.c:123:234\n")
+        log_fp.write("    #1 0x1337dd in bar /file2.c:1806:19")
 
 def test_report_01(tmp_path):
     """test Report() with boring logs (no stack)"""
@@ -41,9 +47,7 @@ def test_report_02(tmp_path):
     """test Report() with crash logs"""
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    with (tmp_path / "log_asan_blah.txt").open("wb") as log_fp:
-        log_fp.write(b"    #0 0xbad000 in foo /file1.c:123:234\n")
-        log_fp.write(b"    #1 0x1337dd in bar /file2.c:1806:19")
+    _create_crash_log(tmp_path / "log_asan_blah.txt")
     report = Report(str(tmp_path), "bin")
     assert report.path == str(tmp_path)
     assert report._logs.aux.endswith("log_asan_blah.txt")
@@ -74,6 +78,7 @@ def test_report_04(tmp_path):
     """test Report.select_logs() uninteresting data"""
     # test with empty path
     assert Report.select_logs(str(tmp_path)) is None
+    # empty file
     (tmp_path / "not_a_log.txt").touch()
     assert not any(Report.select_logs(str(tmp_path)))
 
@@ -227,9 +232,7 @@ def test_report_12(tmp_path):
     """test Report.crash_info"""
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    with (tmp_path / "log_asan_blah.txt").open("wb") as log_fp:
-        log_fp.write(b"    #0 0xbad000 in foo /file1.c:123:234\n")
-        log_fp.write(b"    #1 0x1337dd in bar /file2.c:1806:19")
+    _create_crash_log(tmp_path / "log_asan_blah.txt")
     # no binary.fuzzmanagerconf
     report = Report(str(tmp_path), target_binary="fake_bin")
     assert report._crash_info is None
@@ -251,10 +254,7 @@ def test_report_13(mocker, tmp_path):
     mocker.patch("grizzly.common.reporter.ProgramConfiguration", autospec=True)
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    with (tmp_path / "log_asan_blah.txt").open("wb") as log_fp:
-        log_fp.write(b"==1==ERROR: AddressSanitizer: SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n")
-        log_fp.write(b"    #0 0xbad000 in foo /file1.c:123:234\n")
-        log_fp.write(b"    #1 0x1337dd in bar /file2.c:1806:19")
+    _create_crash_log(tmp_path / "log_asan_blah.txt")
     report = Report(str(tmp_path), "bin")
     assert report._signature is None
     assert report.crash_signature
@@ -287,12 +287,10 @@ def test_filesystem_reporter_01(tmp_path):
     log_path.mkdir()
     (log_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (log_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    with (log_path / "log_asan_blah.txt").open("wb") as log_fp:
-        log_fp.write(b"    #0 0xbad000 in foo /file1.c:123:234\n")
-        log_fp.write(b"    #1 0x1337dd in bar /file2.c:1806:19")
+    _create_crash_log(tmp_path / "log_asan_blah.txt")
     report_path = tmp_path / "reports"
     report_path.mkdir()
-    reporter = FilesystemReporter(report_path=str(report_path))
+    reporter = FilesystemReporter(str(report_path))
     reporter.submit([], Report(str(log_path), "fake_bin"))
     buckets = tuple(report_path.iterdir())
     # check major bucket
@@ -310,31 +308,23 @@ def test_filesystem_reporter_02(tmp_path, mocker):
     log_path.mkdir()
     (log_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (log_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    with (log_path / "log_asan_blah.txt").open("wb") as log_fp:
-        log_fp.write(b"    #0 0xbad000 in foo /file1.c:123:234\n")
-        log_fp.write(b"    #1 0x1337dd in bar /file2.c:1806:19")
-    testcases = list()
-    for _ in range(10):
-        testcases.append(mocker.Mock(spec=TestCase))
+    _create_crash_log(log_path / "log_asan_blah.txt")
+    tests = list(mocker.Mock(spec=TestCase) for _ in range(10))
     report_path = tmp_path / "reports"
     assert not report_path.exists()
-    reporter = FilesystemReporter(report_path=str(report_path))
-    reporter.submit(testcases, Report(str(log_path), "fake_bin"))
+    reporter = FilesystemReporter(str(report_path))
+    reporter.submit(tests, Report(str(log_path), "fake_bin"))
     assert not log_path.exists()
     assert report_path.exists()
     assert len(tuple(report_path.glob("*"))) == 1
-    for tstc in testcases:
-        assert tstc.dump.call_count == 1
+    assert all(x.dump.call_count == 1 for x in tests)
     # call report a 2nd time
     log_path.mkdir()
     (log_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (log_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    testcases = list()
-    for _ in range(2):
-        testcases.append(mocker.Mock(spec=TestCase))
-    reporter.submit(testcases, Report(str(log_path), "fake_bin"))
-    for tstc in testcases:
-        assert tstc.dump.call_count == 1
+    tests = list(mocker.Mock(spec=TestCase) for _ in range(2))
+    reporter.submit(tests, Report(str(log_path), "fake_bin"))
+    assert all(x.dump.call_count == 1 for x in tests)
     assert len(tuple(report_path.glob("*"))) == 2
     assert len(tuple(report_path.glob("NO_STACK"))) == 1
 
@@ -344,26 +334,24 @@ def test_filesystem_reporter_03(tmp_path):
     log_path.mkdir()
     (log_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (log_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    report_path = tmp_path / "reports"
-    report_path.mkdir()
-    reporter = FilesystemReporter(report_path=str(report_path))
+    reporter = FilesystemReporter(str(tmp_path / "reports"))
     reporter.DISK_SPACE_ABORT = 2 ** 50
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(RuntimeError, match="Running low on disk space"):
         reporter.submit([], Report(str(log_path), "fake_bin"))
-    assert "Running low on disk space" in str(exc.value)
 
 def test_filesystem_reporter_04(mocker, tmp_path):
     """test FilesystemReporter w/o major bucket"""
-    report_path = (tmp_path / "report")
-    report_path.mkdir()
+    fake_report = (tmp_path / "fake_report")
+    fake_report.mkdir()
     report = mocker.Mock(
         spec=Report,
-        path=str(report_path),
-        prefix="0000_2020_01_01")
-    reporter = FilesystemReporter(report_path=str(tmp_path), major_bucket=False)
+        path=str(fake_report),
+        prefix="test_prefix")
+    reporter = FilesystemReporter(str(tmp_path / "dst"), major_bucket=False)
     reporter.submit([], report)
-    assert not report_path.is_dir()
+    assert not fake_report.is_dir()
     assert not report.major.call_count
+    assert any((tmp_path / "dst").glob("test_prefix_logs"))
 
 def test_fuzzmanager_reporter_01(mocker, tmp_path):
     """test FuzzManagerReporter.sanity_check()"""
@@ -479,9 +467,8 @@ def test_fuzzmanager_reporter_06(mocker, tmp_path):
     (log_path / "log_stderr.txt").touch()
     (log_path / "log_stdout.txt").touch()
     reporter = FuzzManagerReporter("fake_bin")
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(RuntimeError, match="Failed to create FM signature"):
         reporter.submit([], Report(str(log_path), "fake_bin"))
-    assert "Failed to create FM signature" in str(exc.value)
 
 def test_fuzzmanager_reporter_07(mocker, tmp_path):
     """test FuzzManagerReporter.submit() unsymbolized crash"""
@@ -521,9 +508,8 @@ def test_s3fuzzmanager_reporter_01(mocker, tmp_path):
     mocker.patch("grizzly.common.reporter.FuzzManagerReporter", autospec=True)
     fake_bin = tmp_path / "bin"
     # test GRZ_S3_BUCKET missing
-    with pytest.raises(EnvironmentError) as exc:
+    with pytest.raises(EnvironmentError, match="'GRZ_S3_BUCKET' is not set in environment"):
         S3FuzzManagerReporter.sanity_check(str(fake_bin))
-    assert "'GRZ_S3_BUCKET' is not set in environment" in str(exc.value)
     # test GRZ_S3_BUCKET set
     pytest.importorskip("boto3")
     mocker.patch("grizzly.common.reporter.getenv", autospec=True, return_value="test")
@@ -549,7 +535,7 @@ def test_s3fuzzmanager_reporter_02(mocker, tmp_path):
     fake_report.minor = "1234abcd"
     fake_report.path = str(tmp_path)
     reporter._pre_submit(fake_report)
-    assert not tuple(tmp_path.glob("*"))
+    assert not any(tmp_path.glob("*"))
     assert "rr-trace" in reporter._extra_metadata
     assert fake_report.minor in reporter._extra_metadata["rr-trace"]
     fake_resource.return_value.meta.client.upload_file.assert_not_called()
@@ -565,7 +551,7 @@ def __init__(self, message, response):
     mocker.patch("grizzly.common.reporter.ClientError", new=FakeClientError)
     fake_resource.return_value.Object.side_effect = FakeClientError("test", {"Error": {"Code": "404"}})
     reporter._pre_submit(fake_report)
-    assert not tuple(tmp_path.glob("*"))
+    assert not any(tmp_path.glob("*"))
     assert "rr-trace" in reporter._extra_metadata
     assert fake_report.minor in reporter._extra_metadata["rr-trace"]
     assert fake_resource.return_value.meta.client.upload_file.call_count == 1
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index da9be05f..b8d89935 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -9,6 +9,7 @@
 
 from sapphire import Sapphire, SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT, ServerMap
 
+from .reporter import Report
 from .runner import _IdleChecker, Runner, RunResult
 from .storage import TestCase
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
@@ -176,8 +177,8 @@ def test_runner_08(mocker):
     assert target.launch.call_count == 1
     target.reset_mock()
 
-    target.launch.side_effect = TargetLaunchError
-    with raises(TargetLaunchError):
+    target.launch.side_effect = TargetLaunchError("test", mocker.Mock(spec=Report))
+    with raises(TargetLaunchError, match="test"):
         runner.launch("http://a/")
     assert target.launch.call_count == 1
     target.reset_mock()
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 983673b0..c090e48c 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -89,7 +89,7 @@ def test_testcase_04(tmp_path):
     """test TestCase.add_environ_var() and TestCase.env_vars"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
         tcase.add_environ_var("TEST_ENV_VAR", "1")
-        assert len(list(tcase.env_vars)) == 1
+        assert len(tcase.env_vars) == 1
         tcase.add_environ_var("TEST_NONE", None)
         assert len(tcase.env_vars) == 2
         dmp_path = tmp_path / "dmp_test"
diff --git a/grizzly/main.py b/grizzly/main.py
index 08047aa4..b52c9f9a 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -3,11 +3,15 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import basicConfig, DEBUG, getLogger
+from os.path import join as pathjoin
+from os import getcwd
 
 from sapphire import Sapphire
 
 from .adapters import get as get_adapter
-from .common import FilesystemReporter, FuzzManagerReporter, IOManager, S3FuzzManagerReporter
+from .common.iomanager import IOManager
+from .common.reporter import FilesystemReporter, FuzzManagerReporter, S3FuzzManagerReporter
+from .common.utils import grz_tmp
 from .session import Session
 from .target import load as load_target, TargetLaunchError, TargetLaunchTimeout
 
@@ -99,7 +103,7 @@ def main(args):
             log.info("Results will be reported via FuzzManager w/ large attachments in S3")
             reporter = S3FuzzManagerReporter(tool=args.tool)
         else:
-            reporter = FilesystemReporter()
+            reporter = FilesystemReporter(pathjoin(getcwd(), "results"))
             log.info("Results will be stored in %r", reporter.report_path)
 
         # set 'auto_close=1' so the client error pages (code 4XX) will
@@ -126,7 +130,13 @@ def main(args):
         log.info("Ctrl+C detected.")
         return Session.EXIT_ABORT
 
-    except (TargetLaunchError, TargetLaunchTimeout):
+    except (TargetLaunchError, TargetLaunchTimeout) as exc:
+        log.error(str(exc))
+        if isinstance(exc, TargetLaunchError) and exc.report:
+            path = grz_tmp("launch_failures")
+            log.error("Logs can be found here %r", path)
+            reporter = FilesystemReporter(path, major_bucket=False)
+            reporter.submit([], exc.report)
         return Session.EXIT_LAUNCH_FAILURE
 
     finally:
diff --git a/grizzly/reduce/reduce.py b/grizzly/reduce/reduce.py
index d187df41..008f8f5a 100644
--- a/grizzly/reduce/reduce.py
+++ b/grizzly/reduce/reduce.py
@@ -1133,7 +1133,7 @@ def from_args(cls, args, target):
             LOG.info("Reporting issues via FuzzManager")
             job.set_reporter(FuzzManagerReporter(tool=args.tool))
         else:
-            reporter = FilesystemReporter()
+            reporter = FilesystemReporter(os.path.join(os.getcwd(), "results"))
             job.set_reporter(reporter)
             LOG.info("Results will be stored in %r", reporter.report_path)
 
diff --git a/grizzly/reduce/test_interesting.py b/grizzly/reduce/test_interesting.py
index 859469aa..8622eada 100644
--- a/grizzly/reduce/test_interesting.py
+++ b/grizzly/reduce/test_interesting.py
@@ -8,6 +8,7 @@
 import time
 import pytest
 import sapphire
+from ..common import Report
 from ..reduce.reduce import ReductionJob
 from ..target.target import Target, TargetLaunchError, TargetLaunchTimeout
 from .test_common import FakeTarget, create_target_binary
@@ -120,14 +121,14 @@ def detect_failure(self, ignored, *args, **kwds):
         assert obj.target._calls["detect_failure"] == 1
 
 
-def test_target_relaunch_error(tmp_path):
+def test_target_relaunch_error(mocker, tmp_path):
     "target should be launched only once on TargetLaunchError"
 
     class MyTarget(FakeTarget):
 
         def launch(self, *args, **kwds):
             FakeTarget.launch(self, *args, **kwds)
-            raise TargetLaunchError()
+            raise TargetLaunchError("test", mocker.Mock(spec=Report))
 
     with ReductionJob([], MyTarget(), 30, False, False, 0, 1, 1, 0, 0) as obj:
         create_target_binary(obj.target, tmp_path)
@@ -136,7 +137,7 @@ def launch(self, *args, **kwds):
         (tmp_path / "test.html").touch()
         obj.reduce_file = str(tmp_path / "test.html")
         obj.lithium_init()
-        with pytest.raises(TargetLaunchError):
+        with pytest.raises(TargetLaunchError, match="test"):
             obj.lithium_interesting(str(prefix))
         assert obj.server is not None
         assert obj.target._calls["launch"] == 1
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index d4928128..bfd4c5b1 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -152,8 +152,8 @@ def test_main_strategies(mocker, monkeypatch, tmp_path):  # noqa pylint: disable
 
     class FakeReporter(BaseFakeReporter):
 
-        def __init__(self, *args, **kwds):
-            super(FakeReporter, self).__init__(*args, **kwds)
+        def __init__(self, _):
+            super(FakeReporter, self).__init__()
             self.report_path = "foo"
 
         def _submit_report(self, _report, test_cases):
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 6d7bc3b9..fd0e5ffa 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -26,12 +26,21 @@
 LOG = getLogger("replay")
 
 
+class ReplayResult(object):
+    __slots__ = ("count", "expected", "report", "served")
+
+    def __init__(self, report, served, expected):
+        self.count = 1
+        self.expected = expected
+        self.report = report
+        self.served = served
+
+
 class ReplayManager(object):
     HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
 
     __slots__ = ("ignore", "server", "status", "target", "_any_crash",
-                 "_harness", "_reports_expected", "_reports_other", "_runner",
-                 "_signature", "_unpacked")
+                 "_harness", "_runner", "_signature", "_unpacked")
 
     def __init__(self, ignore, server, target, any_crash=False, signature=None, use_harness=True):
         self.ignore = ignore
@@ -40,8 +49,6 @@ def __init__(self, ignore, server, target, any_crash=False, signature=None, use_
         self.target = target
         self._any_crash = any_crash
         self._harness = None
-        self._reports_expected = dict()
-        self._reports_other = dict()
         self._runner = Runner(self.server, self.target)
         # TODO: make signature a property
         self._signature = signature
@@ -64,67 +71,38 @@ def cleanup(self):
         Returns:
             None
         """
-        for report in self._reports_expected.values():
-            report.cleanup()
-        self._reports_expected.clear()
-        for report in self._reports_other.values():
-            report.cleanup()
-        self._reports_other.clear()
         if self.status is not None:
             self.status.cleanup()
 
-    @property
-    def other_reports(self):
-        """Reports from results that do not match:
-            - the given signature
-            - the initial result (if any-crash is not specified)
-
-        Args:
-            None
-
-        Returns:
-            iterable: Reports.
-        """
-        return self._reports_other.values()
-
-    @property
-    def reports(self):
-        """Reports from results.
-
-        Args:
-            None
-
-        Returns:
-            iterable: Reports.
-        """
-        return self._reports_expected.values()
-
     @staticmethod
-    def report_to_filesystem(path, reports, other_reports=None, tests=None):
+    def report_to_filesystem(path, results, tests=None):
         """Use FilesystemReporter to write reports and testcase to disk in a
         known location.
 
         Args:
             path (str): Location to write data.
-            reports (iterable): Reports to output.
-            other_reports (iterable): Reports to output.
+            results (iterable): ReplayResult to output.
             tests (iterable): Testcases to output.
 
         Returns:
             None
         """
-        if reports:
-            reporter = FilesystemReporter(
-                report_path=pathjoin(path, "reports"),
-                major_bucket=False)
-            for report in reports:
-                reporter.submit(tests or [], report=report)
-        if other_reports:
-            reporter = FilesystemReporter(
-                report_path=pathjoin(path, "other_reports"),
-                major_bucket=False)
-            for report in other_reports:
+        others = list(x.report for x in results if not x.expected)
+        if others:
+            reporter = FilesystemReporter(pathjoin(path, "other_reports"), major_bucket=False)
+            for report in others:
                 reporter.submit(tests or [], report=report)
+        expected = list(x for x in results if x.expected)
+        if expected:
+            if tests and len(expected) == 1:
+                # only purge optional is reporting a single testcase
+                assert len(tests) >= len(expected[0].served)
+                for test, served in zip(tests, expected[0].served):
+                    LOG.debug("calling test.purge_optional() with %r", served)
+                    test.purge_optional(served)
+            reporter = FilesystemReporter(pathjoin(path, "reports"), major_bucket=False)
+            for result in expected:
+                reporter.submit(tests or [], report=result.report)
 
     def run(self, testcases, repeat=1, min_results=1):
         """Run testcase replay.
@@ -136,16 +114,15 @@ def run(self, testcases, repeat=1, min_results=1):
                                be considered successful.
 
         Returns:
-            bool: True if results were reproduced otherwise False.
+            list: List of ReplayResults that were found running testcases.
         """
         assert repeat > 0
         assert min_results > 0
         assert min_results <= repeat
+        assert testcases
         assert self.status is None
 
         self.status = Status.start()
-        test_count = len(testcases)
-        assert test_count > 0
 
         server_map = ServerMap()
         if self._harness is not None:
@@ -158,9 +135,13 @@ def _dyn_close():  # pragma: no cover
             server_map.set_dynamic_response("grz_close_browser", _dyn_close, mime_type="text/html")
             server_map.set_dynamic_response("grz_harness", lambda: self._harness, mime_type="text/html")
 
-        success = False
+        # track unprocessed results
+        reports = dict()
+        # track unpacked testcases
         unpacked = list()
         try:
+            sig_hash = Report.calc_hash(self._signature) if self._signature else None
+            test_count = len(testcases)
             LOG.debug("unpacking testcases (%d)...", test_count)
             for test in testcases:
                 dst_path = mkdtemp(prefix="tc_", dir=grz_tmp("serve"))
@@ -181,22 +162,16 @@ def _dyn_close():  # pragma: no cover
                             self.server.port,
                             close_after=self.target.rl_reset * test_count,
                             forced_close=self.target.forced_close)
-                    try:
-                        # The environment from the initial testcase is used because
-                        # a sequence of testcases is expected to be run without
-                        # relaunching the Target to match the functionality of
-                        # Grizzly. If this is not the case each TestCase should
-                        # be run individually.
-                        self._runner.launch(location, env_mod=testcases[0].env_vars)
-                    except TargetLaunchError:
-                        LOG.error("Target launch error. Check browser logs for details.")
-                        log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
-                        self.target.save_logs(log_path)
-                        self._reports_other["STARTUP"] = Report(log_path, self.target.binary)
-                        raise
+                    # The environment from the initial testcase is used because
+                    # a sequence of testcases is expected to be run without
+                    # relaunching the Target to match the functionality of
+                    # Grizzly. If this is not the case each TestCase should
+                    # be run individually.
+                    self._runner.launch(location, env_mod=testcases[0].env_vars)
                 self.target.step()
                 LOG.info("Performing replay (%d/%d)...", self.status.iteration, repeat)
                 # run tests
+                served = list()
                 for test_idx in range(test_count):
                     LOG.debug("running test: %d of %d", test_idx + 1, test_count)
                     # update redirects
@@ -211,23 +186,24 @@ def _dyn_close():  # pragma: no cover
                         testcases[test_idx].landing_page,
                         required=False)
                     # run testcase
-                    result = self._runner.run(
+                    run_result = self._runner.run(
                         self.ignore,
                         server_map,
                         testcases[test_idx],
                         test_path=unpacked[test_idx],
                         wait_for_callback=self._harness is None)
-                    if result.status != RunResult.COMPLETE:
+                    served.append(run_result.served)
+                    if run_result.status != RunResult.COMPLETE:
                         break
-                # process results
-                if result.status == RunResult.FAILED:
+                # process run results
+                if run_result.status == RunResult.FAILED:
                     log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
                     self.target.save_logs(log_path)
                     report = Report(log_path, self.target.binary)
                     # check signatures
                     short_sig = report.crash_info.createShortSignature()
                     if not self._any_crash and self._signature is None and short_sig != "No crash detected":
-                        # signature has not been specified use the first one created
+                        LOG.debug("no signature given, using %r", short_sig)
                         self._signature = report.crash_signature
                     if short_sig == "No crash detected":
                         # TODO: verify report.major == "NO_STACK" otherwise FM failed to parse the logs
@@ -237,31 +213,37 @@ def _dyn_close():  # pragma: no cover
                         self.status.count_result(short_sig)
                         LOG.info("Result: %s (%s:%s)",
                                  short_sig, report.major[:8], report.minor[:8])
-                        if report.crash_hash not in self._reports_expected:
-                            LOG.debug("now tracking %s", report.crash_hash)
-                            self._reports_expected[report.crash_hash] = report
+                        if sig_hash:
+                            LOG.debug("using provided signature (hash) to bucket")
+                            bucket_hash = sig_hash
+                        else:
+                            bucket_hash = report.crash_hash
+                        if bucket_hash not in reports:
+                            reports[bucket_hash] = ReplayResult(report, served, True)
+                            LOG.debug("now tracking %s", bucket_hash)
                             report = None  # don't remove report
                         else:
-                            LOG.debug("already tracking %s", report.crash_hash)
-                        assert self._any_crash or len(self._reports_expected) == 1
+                            reports[bucket_hash].count += 1
+                            LOG.debug("already tracking %s", bucket_hash)
                     else:
                         LOG.info("Result: Different signature: %s (%s:%s)",
                                  short_sig, report.major[:8], report.minor[:8])
                         self.status.ignored += 1
-                        if report.crash_hash not in self._reports_other:
+                        if report.crash_hash not in reports:
+                            reports[report.crash_hash] = ReplayResult(report, served, False)
                             LOG.debug("now tracking %s", report.crash_hash)
-                            self._reports_other[report.crash_hash] = report
                             report = None  # don't remove report
                         else:
+                            reports[report.crash_hash].count += 1
                             LOG.debug("already tracking %s", report.crash_hash)
                     # purge untracked report
                     if report is not None:
                         report.cleanup()
                         report = None
-                elif result.status == RunResult.IGNORED:
+                elif run_result.status == RunResult.IGNORED:
                     self.status.ignored += 1
                     LOG.info("Result: Ignored (%d)", self.status.ignored)
-                elif result.status == RunResult.ERROR:
+                elif run_result.status == RunResult.ERROR:
                     LOG.error("ERROR: Replay malfunction, test case was not served")
                     break
 
@@ -270,13 +252,14 @@ def _dyn_close():  # pragma: no cover
                     if self.status.iteration < repeat:
                         LOG.debug("skipping remaining attempts")
                     # failed to reproduce issue
-                    LOG.debug("results (%d) < expected (%s) after %d attempts",
+                    LOG.debug("results (%d) < expected, %s after %d attempts",
                               self.status.results, min_results, self.status.iteration)
                     break
+                # check if complete (results found)
                 if self.status.results >= min_results:
                     assert self.status.results == min_results
-                    success = True
-                    LOG.debug("results == expected (%s) after %d attempts",
+                    assert sum(x.count for x in reports.values() if x.expected) >= min_results
+                    LOG.debug("results == expected, %s after %d attempts",
                               min_results, self.status.iteration)
                     break
 
@@ -287,15 +270,40 @@ def _dyn_close():  # pragma: no cover
 
                 # trigger relaunch by closing the browser if needed
                 self.target.check_relaunch()
+
+            # process results
+            results = list()
+            if self._any_crash:
+                assert all(x.expected for x in reports.values())
+                if sum(x.count for x in reports.values()) >= min_results:
+                    results = list(reports.values())
+                else:
+                    LOG.debug("%d (any_crash) less than minimum %d", self.status.results, min_results)
+                    for report in reports.values():
+                        report.report.cleanup()
+            else:
+                assert sum(x.expected for x in reports.values()) <= 1
+                # filter out unreliable expected results
+                for crash_hash, report in reports.items():
+                    if report.expected and report.count < min_results:
+                        LOG.debug("%r less than minimum (%d/%d)", crash_hash, report.count, min_results)
+                        report.report.cleanup()
+                        continue
+                    results.append(report)
+            # active reports have been moved to results
+            # clear reports to avoid cleanup of active reports
+            reports.clear()
+            return results
+
         finally:
+            # remove unpacked testcase data
             for tc_path in unpacked:
                 rmtree(tc_path)
-        if success:
-            LOG.info("Result successfully reproduced")
-        else:
-            LOG.info("Failed to reproduce results")
-        self.target.close()
-        return success
+            self.target.close()
+            # remove unprocessed reports
+            for report in reports.values():
+                report.report.cleanup()
+
 
     @classmethod
     def main(cls, args):
@@ -329,6 +337,7 @@ def main(cls, args):
             return 1
 
         replay = None
+        results = None
         target = None
         tmp_prefs = None
         try:
@@ -380,12 +389,17 @@ def main(cls, args):
                     any_crash=args.any_crash,
                     signature=signature,
                     use_harness=not args.no_harness)
-                success = replay.run(testcases, repeat=repeat, min_results=args.min_crashes)
-            if args.logs:
+                results = replay.run(testcases, repeat=repeat, min_results=args.min_crashes)
+            # handle results
+            success = any(x.expected for x in results)
+            if success:
+                LOG.info("Result successfully reproduced")
+            else:
+                LOG.info("Failed to reproduce results")
+            if args.logs and results:
                 replay.report_to_filesystem(
                     args.logs,
-                    replay.reports,
-                    replay.other_reports,
+                    results,
                     testcases if args.include_test else None)
             # TODO: add fuzzmanager reporting
             return 0 if success else 1
@@ -393,18 +407,23 @@ def main(cls, args):
         except KeyboardInterrupt:
             return 1
 
-        except (TargetLaunchError, TargetLaunchTimeout):
-            if args.logs and replay is not None:
-                replay.report_to_filesystem(
-                    args.logs,
-                    replay.reports,
-                    replay.other_reports)
+        except (TargetLaunchError, TargetLaunchTimeout) as exc:
+            LOG.error(str(exc))
+            if isinstance(exc, TargetLaunchError) and exc.report:
+                path = grz_tmp("launch_failures")
+                LOG.error("Logs can be found here %r", path)
+                reporter = FilesystemReporter(path, major_bucket=False)
+                reporter.submit([], exc.report)
             return 1
 
         finally:
             LOG.warning("Shutting down...")
             if replay is not None:
                 replay.cleanup()
+            if results:
+                # cleanup unreported results
+                for result in results:
+                    result.report.cleanup()
             if target is not None:
                 target.cleanup()
             for testcase in testcases:
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index b6b404c4..6324dfc1 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -11,7 +11,7 @@
 
 from pytest import raises
 
-from ..common import TestCase, TestCaseLoadFailure
+from ..common import Report, TestCase, TestCaseLoadFailure
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from ..replay import ReplayManager
 from ..replay.args import ReplayArgs
@@ -87,21 +87,21 @@ def _fake_save_logs(result_logs):
     target.save_logs = _fake_save_logs
     load_target.return_value.return_value = target
     # setup args
-    args = mocker.Mock()
-    args.fuzzmanager = False
-    args.ignore = ["fake", "timeout"]
     log_path = (tmp_path / "logs")
-    args.logs = str(log_path)
     (tmp_path / "test.html").touch()
-    args.input = str(tmp_path / "test.html")
-    args.min_crashes = 2
     (tmp_path / "prefs.js").touch()
-    args.prefs = str(tmp_path / "prefs.js")
-    args.relaunch = 1
-    args.repeat = 4
     (tmp_path / "sig.json").write_bytes(b"{\"symptoms\": [{\"type\": \"crashAddress\", \"address\": \"0\"}]}")
-    args.sig = str(tmp_path / "sig.json")
-    args.timeout = 10
+    args = mocker.Mock(
+        fuzzmanager=False,
+        ignore=["fake", "timeout"],
+        input=str(tmp_path / "test.html"),
+        logs=str(log_path),
+        min_crashes=2,
+        prefs=str(tmp_path / "prefs.js"),
+        relaunch=1,
+        repeat=4,
+        sig=str(tmp_path / "sig.json"),
+        timeout=10)
     assert ReplayManager.main(args) == 0
     assert target.forced_close
     assert target.reverse.call_count == 1
@@ -134,12 +134,6 @@ def test_main_02(mocker):
         relaunch=1,
         repeat=1,
         sig=None)
-    # target launch error
-    mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchError)
-    assert ReplayManager.main(args) == 1
-    # target launch timeout
-    mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchTimeout)
-    assert ReplayManager.main(args) == 1
     # user abort
     fake_load_target.side_effect = KeyboardInterrupt
     assert ReplayManager.main(args) == 1
@@ -159,7 +153,38 @@ def test_main_02(mocker):
     assert ReplayManager.main(args) == 1
     assert fake_load_target.call_count == 0
 
-def test_main_03(mocker):
+def test_main_03(mocker, tmp_path):
+    """test ReplayManager.main() target exceptions"""
+    mocker.patch("grizzly.replay.replay.FuzzManagerReporter", autospec=True)
+    mocker.patch("grizzly.replay.replay.load_target", autospec=True)
+    mocker.patch("grizzly.replay.replay.Sapphire", autospec=True)
+    mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
+    fake_tmp = (tmp_path / "grz_tmp")
+    fake_tmp.mkdir()
+    mocker.patch("grizzly.replay.replay.grz_tmp", autospec=True, return_value=fake_tmp)
+    # setup args
+    args = mocker.Mock(
+        ignore=None,
+        input="test",
+        min_crashes=1,
+        no_harenss=True,
+        prefs=None,
+        relaunch=1,
+        repeat=1,
+        sig=None)
+    # target launch error
+    fake_logs = (tmp_path / "fake_report")
+    fake_logs.mkdir()
+    report = mocker.Mock(spec=Report, prefix="fake_report", path=str(fake_logs))
+    mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchError("", report))
+    assert ReplayManager.main(args) == 1
+    assert not fake_logs.is_dir()
+    assert any(fake_tmp.glob("fake_report_logs"))
+    # target launch timeout
+    mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchTimeout)
+    assert ReplayManager.main(args) == 1
+
+def test_main_04(mocker):
     """test ReplayManager.main() loading GRZ_FORCED_CLOSE from test case"""
     mocker.patch("grizzly.replay.replay.Sapphire.serve_path", return_value=(None, ["x.html"]))
     target = mocker.Mock(spec=Target, forced_close=True)
@@ -187,7 +212,7 @@ def test_main_03(mocker):
     assert target.cleanup.call_count == 1
     assert not target.forced_close
 
-def test_main_04(mocker, tmp_path):
+def test_main_05(mocker, tmp_path):
     """test ReplayManager.main() loading/generating prefs.js"""
     serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
     serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 6b9d90ce..f16fef61 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -11,9 +11,9 @@
 from pytest import raises
 
 from sapphire import Sapphire, SERVED_ALL, SERVED_REQUEST
-from .replay import ReplayManager
+from .replay import ReplayManager, ReplayResult
 from ..common import Report, Status, TestCase
-from ..target import Target, TargetLaunchError
+from ..target import Target
 
 
 def _fake_save_logs_result(result_logs, meta=False):  # pylint: disable=unused-argument
@@ -31,14 +31,8 @@ def _fake_save_logs_result(result_logs, meta=False):  # pylint: disable=unused-a
 def test_replay_01(mocker):
     """test ReplayManager.cleanup()"""
     replay = ReplayManager([], mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target), [mocker.Mock()])
-    replay._reports_expected = {"A":  mocker.Mock(spec=Report)}
-    replay._reports_other = {"B":  mocker.Mock(spec=Report)}
     replay.status = mocker.Mock(spec=Status)
-    ereport = tuple(replay.reports)[0]
-    oreport = tuple(replay.other_reports)[0]
     replay.cleanup()
-    assert ereport.cleanup.call_count == 1
-    assert oreport.cleanup.call_count == 1
     assert replay.status.cleanup.call_count == 1
 
 def test_replay_02(mocker, tmp_path):
@@ -46,42 +40,66 @@ def test_replay_02(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target)
+    target = mocker.Mock(spec=Target, closed=True, forced_close=True, rl_reset=1)
     target.RESULT_NONE = Target.RESULT_NONE
-    target.closed = True
     target.detect_failure.return_value = Target.RESULT_NONE
-    target.forced_close = True
-    target.rl_reset = 1
-    with TestCase("land_page.html", "redirect.html", "test-adapter") as testcase:
+    with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True) as replay:
             assert not replay.run([testcase])
+            assert replay._signature is None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
             assert replay.status.results == 0
-            assert not replay.reports
+            assert target.close.call_count == 1
+            assert target.check_relaunch.call_count == 0
         assert not any(tmp_path.glob("*"))
 
-def test_replay_03(mocker, tmp_path):
+def test_replay_03(mocker):
+    """test ReplayManager.run() - no repro - with repeats"""
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    target = mocker.Mock(spec=Target, closed=True, rl_reset=100)
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.detect_failure.return_value = Target.RESULT_NONE
+    with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
+        with ReplayManager([], server, target, use_harness=True) as replay:
+            assert not replay.run([testcase], repeat=10, min_results=1)
+            assert replay._signature is None
+            assert replay.status.ignored == 0
+            assert replay.status.iteration == 10
+            assert replay.status.results == 0
+            assert target.close.call_count == 1
+            assert target.check_relaunch.call_count == 9
+
+def test_replay_04(mocker, tmp_path):
     """test ReplayManager.run() - successful repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
+    served = ["index.html"]
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target)
+    server.serve_path.return_value = (SERVED_ALL, served)
+    target = mocker.Mock(spec=Target, binary="C:\\fake_bin")
     target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.binary = "C:\\fake_bin"
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.save_logs = _fake_save_logs_result
-    with TestCase("land_page.html", "redirect.html", "test-adapter") as testcase:
+    with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=False) as replay:
-            assert replay.run([testcase])
+            results = replay.run([testcase])
+            assert replay._signature is not None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
             assert replay.status.results == 1
-            assert len(replay.reports) == 1
-            assert not replay.other_reports
+            assert target.close.call_count == 1
+            assert target.check_relaunch.call_count == 0
+        assert len(results) == 1
+        assert results[0].count == 1
+        assert results[0].expected
+        assert results[0].report
+        assert len(results[0].served) == 1
+        assert results[0].served[0] == served
+        results[0].report.cleanup()
         assert not any(tmp_path.glob("*"))
 
-def test_replay_04(mocker):
+def test_replay_05(mocker):
     """test ReplayManager.run() - Error (landing page not requested/served)"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_REQUEST, ["x"])
@@ -94,12 +112,13 @@ def test_replay_04(mocker):
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 0
-        assert not replay.reports
-        assert not replay.other_reports
+        # target.close() called once in runner and once by ReplayManager.run()
+        assert target.close.call_count == 2
     assert target.check_relaunch.call_count == 0
 
-def test_replay_05(mocker):
+def test_replay_06(mocker, tmp_path):
     """test ReplayManager.run() - ignored"""
+    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target)
@@ -108,14 +127,15 @@ def test_replay_05(mocker):
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases)
+        assert target.close.call_count == 1
         assert replay.status.ignored == 1
         assert replay.status.iteration == 1
         assert replay.status.results == 0
-        assert not replay.reports
-        assert not replay.other_reports
+    assert not any(tmp_path.glob("*"))
 
-def test_replay_06(mocker):
+def test_replay_07(mocker, tmp_path):
     """test ReplayManager.run() - early exit"""
+    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target, binary="path/fake_bin")
@@ -125,68 +145,105 @@ def test_replay_06(mocker):
     target.save_logs = _fake_save_logs_result
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     # early failure
-    target.detect_failure.side_effect = [Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_NONE]
+    target.detect_failure.side_effect = (Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_NONE)
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases, repeat=4, min_results=3)
+        assert target.close.call_count == 1
         assert replay.status.iteration == 3
         assert replay.status.results == 1
         assert replay.status.ignored == 1
-        assert len(replay.reports) == 1
     # early success
-    target.detect_failure.side_effect = [Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_FAILURE]
+    target.reset_mock()
+    target.detect_failure.side_effect = (Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_FAILURE)
     with ReplayManager([], server, target, use_harness=False) as replay:
-        assert replay.run(testcases, repeat=4, min_results=2)
+        results = replay.run(testcases, repeat=4, min_results=2)
+        assert target.close.call_count == 1
         assert replay.status.iteration == 3
         assert replay.status.results == 2
         assert replay.status.ignored == 1
-        assert len(replay._reports_expected) == 1
-        assert not replay._reports_other
-        assert len(replay.reports) == 1
+    assert len(results) == 1
 
-def test_replay_07(mocker, tmp_path):
-    """test ReplayManager.run() - test signatures"""
+def test_replay_08(mocker, tmp_path):
+    """test ReplayManager.run() - test signatures - fail to meet minimum"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report)
     report_0.crash_info.createShortSignature.return_value = "No crash detected"
-    report_1 = mocker.Mock(spec=Report, major="0123abcd", minor="01239999")
+    report_1 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
     report_1.crash_info.createShortSignature.return_value = "[@ test1]"
-    report_2 = mocker.Mock(spec=Report, major="0123abcd", minor="abcd9876")
+    report_2 = mocker.Mock(spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876")
     report_2.crash_info.createShortSignature.return_value = "[@ test2]"
+    report_3 = mocker.Mock(spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876")
+    report_3.crash_info.createShortSignature.return_value = "[@ test2]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
-    fake_report.side_effect = (report_0, report_1, report_2)
+    fake_report.side_effect = (report_0, report_1, report_2, report_3)
+    fake_report.calc_hash.return_value = "bucketHASH"
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     signature = mocker.Mock()
-    signature.matches.side_effect = (True, False)
+    signature.matches.side_effect = (True, False, False)
     target = mocker.Mock(spec=Target, binary="fake_bin")
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, signature=signature, use_harness=False) as replay:
-        assert not replay.run(testcases, repeat=3, min_results=2)
+        results = replay.run(testcases, repeat=4, min_results=2)
+        assert target.close.call_count == 1
         assert replay._signature == signature
-        assert fake_report.call_count == 3
-        assert replay.status.iteration == 3
+        assert replay.status.iteration == 4
         assert replay.status.results == 1
-        assert replay.status.ignored == 1
-        assert len(replay.reports) == 1
-        assert len(replay.other_reports) == 1
-        assert report_0.cleanup.call_count == 1
-        assert report_1.cleanup.call_count == 0
-        assert report_2.cleanup.call_count == 0
+        assert replay.status.ignored == 2
+    assert fake_report.call_count == 4
+    assert len(results) == 1
+    assert not results[0].expected
+    assert results[0].count == 2
+    assert report_0.cleanup.call_count == 1
+    assert report_1.cleanup.call_count == 1
+    assert report_2.cleanup.call_count == 0
+    assert report_3.cleanup.call_count == 1
+    assert signature.matches.call_count == 3
+
+def test_replay_09(mocker, tmp_path):
+    """test ReplayManager.run() - test signatures - multiple matches"""
+    mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
+    report_0 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
+    report_0.crash_info.createShortSignature.return_value = "[@ test1]"
+    report_1 = mocker.Mock(spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876")
+    report_1.crash_info.createShortSignature.return_value = "[@ test2]"
+    fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
+    fake_report.side_effect = (report_0, report_1)
+    fake_report.calc_hash.return_value = "bucketHASH"
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
+    signature = mocker.Mock()
+    signature.matches.side_effect = (True, True)
+    target = mocker.Mock(spec=Target, binary="fake_bin")
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Target.RESULT_FAILURE
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[])]
+    with ReplayManager([], server, target, signature=signature, use_harness=False) as replay:
+        results = replay.run(testcases, repeat=2, min_results=2)
+        assert target.close.call_count == 1
+        assert replay._signature == signature
+        assert replay.status.iteration == 2
+        assert replay.status.results == 2
+        assert replay.status.ignored == 0
+    assert fake_report.call_count == 2
+    assert len(results) == 1
+    assert results[0].expected
+    assert results[0].count == 2
+    assert report_0.cleanup.call_count == 0
+    assert report_1.cleanup.call_count == 1
     assert signature.matches.call_count == 2
 
-def test_replay_08(mocker, tmp_path):
-    """test ReplayManager.run() - any crash"""
+def test_replay_10(mocker, tmp_path):
+    """test ReplayManager.run() - any crash - success"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report)
     report_0.crash_info.createShortSignature.return_value = "No crash detected"
-    report_1 = mocker.Mock(spec=Report, major="0123abcd", minor="01239999")
+    report_1 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
     report_1.crash_info.createShortSignature.return_value = "[@ test1]"
-    report_1.crash_hash = "hash1"
-    report_2 = mocker.Mock(spec=Report, major="0123abcd", minor="abcd9876")
+    report_2 = mocker.Mock(spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876")
     report_2.crash_info.createShortSignature.return_value = "[@ test2]"
-    report_2.crash_hash = "hash2"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1, report_2)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
@@ -196,109 +253,157 @@ def test_replay_08(mocker, tmp_path):
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
-        assert replay.run(testcases, repeat=3, min_results=2)
+        results = replay.run(testcases, repeat=3, min_results=2)
+        assert target.close.call_count == 1
         assert replay._signature is None
-        assert fake_report.call_count == 3
         assert replay.status.iteration == 3
         assert replay.status.results == 2
         assert replay.status.ignored == 0
-        assert len(replay.reports) == 2
-        assert not replay.other_reports
-        assert report_0.cleanup.call_count == 1
-        assert report_1.cleanup.call_count == 0
-        assert report_2.cleanup.call_count == 0
+    assert fake_report.call_count == 3
+    assert len(results) == 2
+    assert all(x.expected for x in results)
+    assert sum(x.count for x in results if x.expected) == 2
+    assert report_0.cleanup.call_count == 1
+    assert report_1.cleanup.call_count == 0
+    assert report_2.cleanup.call_count == 0
 
-def test_replay_09(mocker, tmp_path):
-    """test ReplayManager.report_to_filesystem()"""
-    # no reports
-    ReplayManager.report_to_filesystem(str(tmp_path), [])
-    assert not any(tmp_path.glob("*"))
-    # with reports and tests
-    (tmp_path / "report_expected").mkdir()
-    expected = [
-        mocker.Mock(
-            spec=Report,
-            path=str(tmp_path / "report_expected"),
-            prefix="expected")]
-    (tmp_path / "report_other1").mkdir()
-    (tmp_path / "report_other2").mkdir()
-    other = [
-        mocker.Mock(
-            spec=Report,
-            path=str(tmp_path / "report_other1"),
-            prefix="other1"),
-        mocker.Mock(
-            spec=Report,
-            path=str(tmp_path / "report_other2"),
-            prefix="other2")]
-    test = mocker.Mock(spec=TestCase)
-    path = tmp_path / "dest"
-    ReplayManager.report_to_filesystem(str(path), expected, other, tests=[test])
-    assert test.dump.call_count == 3  # called once per report
-    assert not (tmp_path / "report_expected").is_dir()
-    assert not (tmp_path / "report_other1").is_dir()
-    assert not (tmp_path / "report_other2").is_dir()
-    assert path.is_dir()
-    assert (path / "reports").is_dir()
-    assert (path / "reports" / "expected_logs").is_dir()
-    assert (path / "other_reports").is_dir()
-    assert (path / "other_reports" / "other1_logs").is_dir()
-    assert (path / "other_reports" / "other2_logs").is_dir()
-    # with reports and not tests
-    (tmp_path / "report_expected").mkdir()
-    expected = [
-        mocker.Mock(
-            spec=Report,
-            path=str(tmp_path / "report_expected"),
-            prefix="expected")]
-    path = tmp_path / "dest2"
-    ReplayManager.report_to_filesystem(str(path), expected)
-    assert not (tmp_path / "report_expected").is_dir()
-    assert path.is_dir()
-    assert (path / "reports" / "expected_logs").is_dir()
+def test_replay_11(mocker, tmp_path):
+    """test ReplayManager.run() - any crash - fail to meet minimum"""
+    mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
+    report_0 = mocker.Mock(spec=Report)
+    report_0.crash_info.createShortSignature.return_value = "No crash detected"
+    report_1 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
+    report_1.crash_info.createShortSignature.return_value = "[@ test1]"
+    report_2 = mocker.Mock(spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876")
+    report_2.crash_info.createShortSignature.return_value = "[@ test2]"
+    report_3 = mocker.Mock(spec=Report)
+    report_3.crash_info.createShortSignature.return_value = "No crash detected"
+    fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
+    fake_report.side_effect = (report_0, report_1, report_2, report_3)
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    target = mocker.Mock(spec=Target, binary="fake_bin")
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Target.RESULT_FAILURE
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+    with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
+        assert not replay.run(testcases, repeat=4, min_results=3)
+        assert replay._signature is None
+        assert replay.status.iteration == 4
+        assert replay.status.results == 2
+        assert replay.status.ignored == 0
+    assert fake_report.call_count == 4
+    assert report_0.cleanup.call_count == 1
+    assert report_1.cleanup.call_count == 1
+    assert report_2.cleanup.call_count == 1
+    assert report_3.cleanup.call_count == 1
 
-def test_replay_10(mocker, tmp_path):
-    """test ReplayManager.run() - TargetLaunchError"""
+def test_replay_12(mocker, tmp_path):
+    """test ReplayManager.run() - no signature - use first crash"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
+    report_1 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123", minor="9999")
+    report_1.crash_info.createShortSignature.return_value = "[@ test1]"
+    auto_sig = mocker.Mock()
+    auto_sig.matches.side_effect = (True, False, True)
+    report_1.crash_signature = auto_sig
+    report_2 = mocker.Mock(spec=Report, crash_hash="hash2", major="abcd", minor="9876")
+    report_2.crash_info.createShortSignature.return_value = "[@ test2]"
+    report_3 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123", minor="9999")
+    report_3.crash_info.createShortSignature.return_value = "[@ test1]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
-    fake_report.side_effect = (mocker.Mock(spec=Report),)
+    fake_report.side_effect = (report_1, report_2, report_3)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target)
-    target.launch.side_effect = TargetLaunchError
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html")]
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    target = mocker.Mock(spec=Target, binary="fake_bin")
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Target.RESULT_FAILURE
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, use_harness=False) as replay:
-        with raises(TargetLaunchError):
-            replay.run(testcases)
-        assert not any(replay.reports)
-        assert any(replay.other_reports)
-        assert "STARTUP" in replay._reports_other
+        results = replay.run(testcases, repeat=3, min_results=2)
+        assert target.close.call_count == 1
+        assert replay._signature == auto_sig
+        assert replay.status.iteration == 3
+        assert replay.status.results == 2
+        assert replay.status.ignored == 1
+    assert fake_report.call_count == 3
+    assert len(results) == 2
+    assert sum(x.expected for x in results) == 1
+    assert sum(x.count for x in results if x.expected) == 2
+    assert report_1.cleanup.call_count == 0
+    assert report_2.cleanup.call_count == 0
+    assert report_3.cleanup.call_count == 1
 
-def test_replay_11(mocker):
+def test_replay_13(mocker, tmp_path):
+    """test ReplayManager.run() - unexpected exception"""
+    mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
+    report_0 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
+    report_0.crash_info.createShortSignature.return_value = "[@ test1]"
+    fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
+    fake_report.side_effect = (report_0,)
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server.serve_path.side_effect = ((SERVED_ALL, ["index.html"]), KeyboardInterrupt)
+    target = mocker.Mock(spec=Target, binary="fake_bin")
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Target.RESULT_FAILURE
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+    with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
+        with raises(KeyboardInterrupt):
+            replay.run(testcases, repeat=3, min_results=2)
+        assert target.close.call_count == 1
+        assert replay._signature is None
+        assert replay.status.iteration == 2
+        assert replay.status.results == 1
+        assert replay.status.ignored == 0
+    assert fake_report.call_count == 1
+    assert report_0.cleanup.call_count == 1
+
+def test_replay_14(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target)
+    target = mocker.Mock(spec=Target, closed=True, forced_close=True, rl_reset=1)
     target.RESULT_NONE = Target.RESULT_NONE
-    target.closed = True
     target.detect_failure.return_value = Target.RESULT_NONE
-    target.forced_close = True
-    target.rl_reset = 1
     testcases = [
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, use_harness=True) as replay:
         assert not replay.run(testcases)
+        assert target.close.call_count == 1
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 0
-        assert not replay.reports
     assert all(x.dump.call_count == 1 for x in testcases)
 
-def test_replay_12(mocker):
-    """test ReplayManager.run() - multiple TestCases - successful repro"""
+def test_replay_15(mocker):
+    """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    target = mocker.Mock(spec=Target, closed=True, forced_close=True, rl_reset=100)
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.detect_failure.return_value = Target.RESULT_NONE
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+    with ReplayManager([], server, target, use_harness=True) as replay:
+        assert not replay.run(testcases, repeat=10)
+        assert server.serve_path.call_count == 30
+        assert target.close.call_count == 1
+        assert replay.status.ignored == 0
+        assert replay.status.iteration == 10
+        assert replay.status.results == 0
+    assert all(x.dump.call_count == 1 for x in testcases)
+
+def test_replay_16(mocker, tmp_path):
+    """test ReplayManager.run() - multiple TestCases - successful repro"""
+    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server.serve_path.side_effect = (
+        (SERVED_ALL, ["a.html"]),
+        (SERVED_ALL, ["b.html"]),
+        (SERVED_ALL, ["c.html"]))
     target = mocker.Mock(spec=Target, binary="fake_bin", rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
@@ -308,14 +413,64 @@ def test_replay_12(mocker):
         Target.RESULT_FAILURE)
     target.save_logs = _fake_save_logs_result
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[]),
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="b.html", optional=[]),
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="c.html", optional=[])]
     with ReplayManager([], server, target, use_harness=True) as replay:
-        assert replay.run(testcases)
+        results = replay.run(testcases)
+        assert target.close.call_count == 1
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 1
-        assert len(replay.reports) == 1
-        assert not replay.other_reports
+    assert len(results) == 1
+    assert len(results[0].served) == len(testcases)
+    assert results[0].served[0][0] == "a.html"
+    assert results[0].served[1][0] == "b.html"
+    assert results[0].served[2][0] == "c.html"
     assert all(x.dump.call_count == 1 for x in testcases)
+
+def test_replay_17(mocker, tmp_path):
+    """test ReplayManager.report_to_filesystem()"""
+    # no reports
+    ReplayManager.report_to_filesystem(str(tmp_path), [])
+    assert not any(tmp_path.glob("*"))
+    # with reports and tests
+    (tmp_path / "report_expected").mkdir()
+    result0 = mocker.Mock(ReplayResult, count=1, expected=True, served=[])
+    result0.report = mocker.Mock(
+        spec=Report,
+        path=str(tmp_path / "report_expected"),
+        prefix="expected")
+    (tmp_path / "report_other1").mkdir()
+    result1 = mocker.Mock(ReplayResult, count=1, expected=False, served=None)
+    result1.report = mocker.Mock(
+        spec=Report,
+        path=str(tmp_path / "report_other1"),
+        prefix="other1")
+    (tmp_path / "report_other2").mkdir()
+    result2 = mocker.Mock(ReplayResult, count=1, expected=False, served=None)
+    result2.report = mocker.Mock(
+        spec=Report,
+        path=str(tmp_path / "report_other2"),
+        prefix="other2")
+    test = mocker.Mock(spec=TestCase)
+    path = tmp_path / "dest"
+    ReplayManager.report_to_filesystem(str(path), [result0, result1, result2], tests=[test])
+    assert test.dump.call_count == 3  # called once per report
+    assert not (tmp_path / "report_expected").is_dir()
+    assert not (tmp_path / "report_other1").is_dir()
+    assert not (tmp_path / "report_other2").is_dir()
+    assert path.is_dir()
+    assert (path / "reports").is_dir()
+    assert (path / "reports" / "expected_logs").is_dir()
+    assert (path / "other_reports").is_dir()
+    assert (path / "other_reports" / "other1_logs").is_dir()
+    assert (path / "other_reports" / "other2_logs").is_dir()
+    # with reports and no tests
+    (tmp_path / "report_expected").mkdir()
+    result0.reset_mock()
+    path = tmp_path / "dest2"
+    ReplayManager.report_to_filesystem(str(path), [result0])
+    assert not (tmp_path / "report_expected").is_dir()
+    assert path.is_dir()
+    assert (path / "reports" / "expected_logs").is_dir()
diff --git a/grizzly/session.py b/grizzly/session.py
index aac7027d..6dc4e24c 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -10,7 +10,6 @@
 from time import sleep, time
 
 from .common import grz_tmp, Report, Runner, RunResult, Status, TestFile
-from .target import TargetLaunchError
 
 
 __all__ = ("SessionError", "LogOutputLimiter", "Session")
@@ -156,13 +155,7 @@ def _dyn_close():  # pragma: no cover
                         forced_close=self.target.forced_close,
                         timeout=self.adapter.TEST_DURATION)
                 log.info("Launching target")
-                try:
-                    runner.launch(location, max_retries=3, retry_delay=0)
-                except TargetLaunchError:
-                    # this result likely has nothing to do with Grizzly
-                    log.error("Target launch error. Check browser logs for details.")
-                    self.report_result()
-                    raise
+                runner.launch(location, max_retries=3, retry_delay=0)
             self.target.step()
 
             # create and populate a test case
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 3aef4f56..366e048a 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -3,11 +3,11 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
-from os import close, getenv, kill, makedirs, unlink
-from os.path import abspath, isdir, isfile
+from os import close, kill, unlink
+from os.path import abspath, isfile
 from platform import system
 import signal
-from time import localtime, sleep, strftime, time
+from time import sleep, time
 from tempfile import mkdtemp, mkstemp
 
 from psutil import AccessDenied, NoSuchProcess, Process, process_iter
@@ -17,6 +17,7 @@
 
 from .target_monitor import TargetMonitor
 from .target import Target, TargetLaunchError, TargetLaunchTimeout, TargetError
+from ..common.reporter import Report
 from ..common.utils import grz_tmp
 
 
@@ -28,14 +29,13 @@
 
 
 class PuppetTarget(Target):
-    __slots__ = ("use_rr", "use_valgrind", "_browser_logs", "_puppet", "_remove_prefs")
+    __slots__ = ("use_rr", "use_valgrind", "_puppet", "_remove_prefs")
 
     def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, relaunch, **kwds):
         super(PuppetTarget, self).__init__(binary, extension, launch_timeout,
                                            log_limit, memory_limit, relaunch)
         self.use_rr = kwds.pop("rr", False)
         self.use_valgrind = kwds.pop("valgrind", False)
-        self._browser_logs = None
         self._remove_prefs = False
         # create Puppet object
         self._puppet = FFPuppet(
@@ -59,8 +59,6 @@ def add_abort_token(self, token):
 
     def cleanup(self):
         # prevent parallel calls to FFPuppet.close() and/or FFPuppet.clean_up()
-        if self._browser_logs:
-            self.close()
         with self._lock:
             self._puppet.clean_up()
         if self._remove_prefs and self._prefs and isfile(self._prefs):
@@ -70,16 +68,6 @@ def close(self):
         # prevent parallel calls to FFPuppet.close() and/or FFPuppet.clean_up()
         with self._lock:
             self._puppet.close()
-            # save logs in lock to avoid a parallel clean_up() removing them
-            if self._browser_logs:
-                log_path = mkdtemp(
-                    prefix=strftime("%Y%m%d-%H%M%S_", localtime()),
-                    suffix="_browser_logs",
-                    dir=self._browser_logs)
-                LOG.debug("saving browser logs to %r", log_path)
-                self._puppet.save_logs(log_path)
-                # only save logs once per launch
-                self._browser_logs = None
 
     @property
     def closed(self):
@@ -208,12 +196,6 @@ def dump_coverage(self, timeout=15):
             sleep(delay)
 
     def launch(self, location, env_mod=None):
-        # GRZ_BROWSER_LOGS is intended to be used to aid in debugging.
-        # when close() is called a copy of the browser logs will be saved
-        # to the directory specified by GRZ_BROWSER_LOGS
-        self._browser_logs = getenv("GRZ_BROWSER_LOGS")
-        if self._browser_logs and not isdir(self._browser_logs):
-            makedirs(self._browser_logs)
         self.rl_countdown = self.rl_reset
         # setup environment
         env_mod = dict(env_mod or [])
@@ -235,7 +217,9 @@ def launch(self, location, env_mod=None):
             self.close()
             if isinstance(exc, BrowserTimeoutError):
                 raise TargetLaunchTimeout(str(exc))
-            raise TargetLaunchError(str(exc))
+            log_path = mkdtemp(prefix="launch_fail_", dir=grz_tmp("logs"))
+            self.save_logs(log_path)
+            raise TargetLaunchError(str(exc), Report(log_path, self.binary))
 
     def log_size(self):
         return self._puppet.log_length("stderr") + self._puppet.log_length("stdout")
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 08bb733d..7bd0ac16 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -44,6 +44,9 @@ class TargetError(Exception):
 
 class TargetLaunchError(TargetError):
     """Raised if a failure during launch occurs"""
+    def __init__(self, message, report):
+        super().__init__(message)
+        self.report = report
 
 
 class TargetLaunchTimeout(TargetError):
@@ -111,6 +114,8 @@ def close(self):
     def closed(self):
         pass
 
+    # TODO: add collect_report()?
+
     @abstractmethod
     def detect_failure(self, ignored, was_timeout):
         pass
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 951af45a..0ecf0b51 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -21,7 +21,6 @@ def test_puppet_target_01(mocker, tmp_path):
     fake_file.touch()
     with PuppetTarget(str(fake_file), None, 300, 25, 5000, 25) as target:
         assert target.closed
-        assert target._browser_logs is None
         assert not target._remove_prefs
         prefs_file = target.prefs
         assert isfile(prefs_file)
@@ -50,18 +49,26 @@ def test_puppet_target_02(mocker, tmp_path):
     with PuppetTarget(str(fake_file), None, 300, 25, 5000, 35) as target:
         target.prefs = str(fake_file)
         assert not target._remove_prefs
+        # launch success
         target.launch("launch_target_page")
-        assert target._browser_logs is None
         assert fake_ffp.return_value.launch.call_count == 1
         assert fake_ffp.return_value.close.call_count == 0
-        fake_ffp.return_value.launch.side_effect = BrowserTimeoutError
-        with raises(TargetLaunchTimeout):
+        target.close()
+        # launch timeout
+        fake_ffp.reset_mock()
+        fake_ffp.return_value.launch.side_effect = BrowserTimeoutError("timeout")
+        with raises(TargetLaunchTimeout, match="timeout"):
             target.launch("launch_target_page")
-        assert fake_ffp.return_value.launch.call_count == 2
-        assert fake_ffp.return_value.close.call_count == 1
-        fake_ffp.return_value.launch.side_effect = BrowserTerminatedError
-        with raises(TargetLaunchError):
+        assert fake_ffp.return_value.save_logs.call_count == 0
+        # launch failure
+        fake_ffp.reset_mock()
+        (tmp_path / "log_stderr.txt").write_text("fake log")
+        (tmp_path / "log_stdout.txt").write_text("fake log")
+        mocker.patch("grizzly.target.puppet_target.mkdtemp", autospec=True, return_value=str(tmp_path))
+        fake_ffp.return_value.launch.side_effect = BrowserTerminatedError("fail")
+        with raises(TargetLaunchError, match="fail"):
             target.launch("launch_target_page")
+        assert fake_ffp.return_value.save_logs.call_count == 1
 
 def test_puppet_target_03(mocker, tmp_path):
     """test PuppetTarget.detect_failure()"""
@@ -278,22 +285,6 @@ def test_puppet_target_06(mocker, tmp_path):
         assert fake_ffp.return_value.clone_log.call_count == 1
 
 def test_puppet_target_07(mocker, tmp_path):
-    """test PuppetTarget with GRZ_BROWSER_LOGS set"""
-    browser_logs = (tmp_path / "browser_logs")
-    fake_getenv = mocker.patch("grizzly.target.puppet_target.getenv", autospec=True)
-    fake_getenv.return_value = str(browser_logs)
-    fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
-    fake_file = tmp_path / "fake"
-    fake_file.touch()
-    with PuppetTarget(str(fake_file), None, 300, 25, 5000, 35) as target:
-        target.launch("launch_target_page")
-        assert target._browser_logs == str(browser_logs)
-        assert browser_logs.is_dir()
-        target.cleanup()
-        assert target._browser_logs is None
-    assert fake_ffp.return_value.save_logs.call_count == 1
-
-def test_puppet_target_08(mocker, tmp_path):
     """test PuppetTarget.prefs"""
     mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_file = tmp_path / "fake"
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 19952119..1ee28d42 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -7,7 +7,7 @@
 from pytest import raises
 
 from sapphire import Sapphire
-from .common import Adapter
+from .common import Adapter, Report
 from .main import main
 from .session import Session
 from .target import TargetLaunchError
@@ -89,7 +89,7 @@ def test_main_02(mocker):
     with raises(RuntimeError, match=r"Test duration \([0-9]+s\) should be less than browser timeout \([0-9]+s\)"):
         main(args)
 
-def test_main_03(mocker):
+def test_main_03(mocker, tmp_path):
     """test main() exit codes"""
     fake_adapter = mocker.Mock(spec=Adapter)
     fake_adapter.TEST_DURATION = 10
@@ -107,5 +107,14 @@ def test_main_03(mocker):
     args.input = "fake"
     fake_session.return_value.run.side_effect = KeyboardInterrupt
     assert main(args) == Session.EXIT_ABORT
-    fake_session.return_value.run.side_effect = TargetLaunchError("test")
+    # test TargetLaunchError
+    fake_tmp = (tmp_path / "grz_tmp")
+    fake_tmp.mkdir()
+    mocker.patch("grizzly.main.grz_tmp", return_value=str(fake_tmp))
+    fake_logs = (tmp_path / "report")
+    report = mocker.Mock(spec=Report, prefix="fake_report", path=str(fake_logs))
+    fake_logs.mkdir()
+    fake_session.return_value.run.side_effect = TargetLaunchError("test", report)
     assert main(args) == Session.EXIT_LAUNCH_FAILURE
+    assert any(fake_tmp.glob("fake_report_logs"))
+    assert not fake_logs.is_dir()
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index fb07082e..0bbb2353 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -237,7 +237,7 @@ def test_session_09(tmp_path, mocker):
     Status.PATH = str(tmp_path)
     mocker.patch("grizzly.session.Report", autospec=True)
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
-    fake_runner.return_value.launch.side_effect = TargetLaunchError
+    fake_runner.return_value.launch.side_effect = TargetLaunchError("test", mocker.Mock(spec=Report))
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter)
     fake_iomgr = mocker.Mock(
@@ -249,14 +249,12 @@ def test_session_09(tmp_path, mocker):
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_target = mocker.Mock(spec=Target)
     fake_target.monitor.launches = 1
-    reporter = NullReporter()
-    with Session(fake_adapter, fake_iomgr, reporter, fake_serv, fake_target) as session:
-        with raises(TargetLaunchError, match=""):
+    with Session(fake_adapter, fake_iomgr, mocker.Mock(), fake_serv, fake_target) as session:
+        with raises(TargetLaunchError, match="test"):
             session.run([], iteration_limit=1)
         assert session.status.iteration == 1
-        assert session.status.results == 1
+        assert session.status.results == 0
         assert session.status.ignored == 0
-    assert reporter.submit_calls == 1
 
 def test_session_10(tmp_path, mocker):
     """test Session.report_result()"""

From b60f3d9942481a7a8ccb9ac2505e3e5bf616f297 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Sep 2020 15:07:40 -0700
Subject: [PATCH 016/531] Add TestCase.purge_optional() sanity checking

---
 grizzly/common/storage.py      | 28 ++++++++++++++++++++--------
 grizzly/common/test_storage.py | 17 +++++++++++++----
 grizzly/replay/test_main.py    | 28 ++++------------------------
 grizzly/replay/test_replay.py  |  8 ++++----
 grizzly/test_session.py        | 12 +++++++++++-
 5 files changed, 52 insertions(+), 41 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 352c3650..58de4a08 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -384,13 +384,13 @@ def load_single(cls, path, load_prefs, adjacent=False):
 
     @property
     def optional(self):
-        """Get file names of optional TestFiles
+        """Get file names of optional TestFiles.
 
         Args:
             None
 
-        Returns:
-            generator: file names (str) of optional files
+        Yields:
+            str: File names of optional files.
         """
         for test in self._files.optional:
             yield test.file_name
@@ -404,14 +404,26 @@ def purge_optional(self, keep):
         Returns:
             None
         """
-        # TODO: should we limit or warn on multiple calls to prevent issues?
-        keep = set(keep)
-        to_remove = []
-        for idx, tfile in enumerate(self._files.optional):
-            if tfile.file_name not in keep:
+        # filter required files from opt_files files to keep
+        keep_opt = list()
+        for fname in set(keep):
+            if fname not in (x.file_name for x in self._files.required):
+                keep_opt.append(fname)
+        opt_files = tuple(x.file_name for x in self._files.optional)
+        if not opt_files:
+            assert not keep_opt
+            # nothing to purge
+            return None
+        # sanity check keep (cannot remove file that does not exist)
+        assert all(fname in opt_files for fname in keep_opt)
+        # purge
+        to_remove = list()
+        for idx, fname in enumerate(opt_files):
+            if fname not in keep_opt:
                 to_remove.append(idx)
         for idx in reversed(to_remove):
             self._files.optional.pop(idx).close()
+        return None
 
     @staticmethod
     def scan_path(path):
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index c090e48c..aef61d1e 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -4,6 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
 
+from itertools import chain
 import json
 import re
 import os
@@ -100,7 +101,7 @@ def test_testcase_04(tmp_path):
         assert data["env"]["TEST_ENV_VAR"] == "1"
         assert data["env"]["TEST_NONE"] is None
 
-def test_testcase_05(tmp_path):
+def test_testcase_05():
     """test TestCase.purge_optional()"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
         tcase.add_from_data("foo", "testfile1.bin")
@@ -108,13 +109,21 @@ def test_testcase_05(tmp_path):
         tcase.add_from_data("foo", "testfile3.bin", required=False)
         tcase.add_from_data("foo", "not_served.bin", required=False)
         assert len(tuple(tcase.optional)) == 3
+        # nothing to remove - with required
+        tcase.purge_optional(chain(["testfile1.bin"], tcase.optional))
+        assert len(tuple(tcase.optional)) == 3
+        # nothing to remove - without required
         tcase.purge_optional(tcase.optional)
         assert len(tuple(tcase.optional)) == 3
+        # remove not_served.bin
         tcase.purge_optional(["testfile2.bin", "testfile3.bin"])
         assert len(tuple(tcase.optional)) == 2
-        tcase.dump(str(tmp_path))
-        assert tmp_path.glob("testfile1.bin")
-        assert not any(tmp_path.glob("not_served.bin"))
+        assert "testfile2.bin" in tcase.optional
+        assert "testfile3.bin" in tcase.optional
+        assert "not_served.bin" not in tcase.optional
+        # remove remaining optional
+        tcase.purge_optional(["testfile1.bin"])
+        assert not any(tcase.optional)
 
 def test_testcase_06():
     """test TestCase.data_size"""
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 6324dfc1..5f70a878 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -6,7 +6,6 @@
 """
 unit tests for grizzly.replay.main
 """
-from os.path import join as pathjoin
 from shutil import rmtree
 
 from pytest import raises
@@ -16,6 +15,8 @@
 from ..replay import ReplayManager
 from ..replay.args import ReplayArgs
 
+from .test_replay import _fake_save_logs
+
 
 def test_args_01(capsys, tmp_path):
     """test parsing args"""
@@ -73,17 +74,6 @@ def test_main_01(mocker, tmp_path):
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.side_effect = (Target.RESULT_FAILURE, Target.RESULT_NONE, Target.RESULT_FAILURE)
-    def _fake_save_logs(result_logs):
-        """write fake log data to disk"""
-        with open(pathjoin(result_logs, "log_stderr.txt"), "w") as log_fp:
-            log_fp.write("STDERR log\n")
-        with open(pathjoin(result_logs, "log_stdout.txt"), "w") as log_fp:
-            log_fp.write("STDOUT log\n")
-        with open(pathjoin(result_logs, "log_asan_blah.txt"), "w") as log_fp:
-            log_fp.write("==1==ERROR: AddressSanitizer: ")
-            log_fp.write("SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n")
-            log_fp.write("    #0 0xbad000 in foo /file1.c:123:234\n")
-            log_fp.write("    #1 0x1337dd in bar /file2.c:1806:19\n")
     target.save_logs = _fake_save_logs
     load_target.return_value.return_value = target
     # setup args
@@ -220,16 +210,6 @@ def test_main_05(mocker, tmp_path):
     target = mocker.Mock(spec=Target, binary="bin", forced_close=True)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
-    def _fake_save_logs(result_logs):
-        """write fake log data to disk"""
-        with open(pathjoin(result_logs, "log_stderr.txt"), "w") as log_fp:
-            pass
-        with open(pathjoin(result_logs, "log_stdout.txt"), "w") as log_fp:
-            pass
-        with open(pathjoin(result_logs, "log_asan_blah.txt"), "w") as log_fp:
-            log_fp.write("==1==ERROR: AddressSanitizer: ")
-            log_fp.write("SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n")
-            log_fp.write("    #0 0xbad000 in foo /file1.c:123:234\n")
     target.save_logs = _fake_save_logs
     load_target = mocker.patch("grizzly.replay.replay.load_target")
     load_target.return_value.return_value = target
@@ -247,9 +227,9 @@ def _fake_save_logs(result_logs):
     input_path = (tmp_path / "input")
     input_path.mkdir()
     # build a test case
-    entry_point = (input_path / "target.bin")
+    entry_point = (input_path / "test.html")
     entry_point.touch()
-    with TestCase("target.bin", None, "test-adapter") as src:
+    with TestCase("test.html", None, "test-adapter") as src:
         src.add_from_file(str(entry_point))
         src.dump(str(input_path), include_details=True)
     args.input = str(input_path)
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index f16fef61..50af40f9 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -16,7 +16,7 @@
 from ..target import Target
 
 
-def _fake_save_logs_result(result_logs, meta=False):  # pylint: disable=unused-argument
+def _fake_save_logs(result_logs, meta=False):  # pylint: disable=unused-argument
     """write fake log data to disk"""
     with open(pathjoin(result_logs, "log_stderr.txt"), "w") as log_fp:
         log_fp.write("STDERR log\n")
@@ -80,7 +80,7 @@ def test_replay_04(mocker, tmp_path):
     target = mocker.Mock(spec=Target, binary="C:\\fake_bin")
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
-    target.save_logs = _fake_save_logs_result
+    target.save_logs = _fake_save_logs
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=False) as replay:
             results = replay.run([testcase])
@@ -142,7 +142,7 @@ def test_replay_07(mocker, tmp_path):
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
-    target.save_logs = _fake_save_logs_result
+    target.save_logs = _fake_save_logs
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     # early failure
     target.detect_failure.side_effect = (Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_NONE)
@@ -411,7 +411,7 @@ def test_replay_16(mocker, tmp_path):
         Target.RESULT_NONE,
         Target.RESULT_NONE,
         Target.RESULT_FAILURE)
-    target.save_logs = _fake_save_logs_result
+    target.save_logs = _fake_save_logs
     testcases = [
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="b.html", optional=[]),
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 0bbb2353..82b5720e 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -41,6 +41,7 @@ def setup(self, input_path, server_map):
         def generate(self, testcase, server_map):
             assert testcase.adapter_name == self.NAME
             testcase.input_fname = "file.bin"
+            testcase.add_from_data("test", testcase.landing_page)
             self.remaining -= 1
     Status.PATH = str(tmp_path)
     adapter = PlaybackAdapter()
@@ -66,6 +67,7 @@ def setup(self, input_path, server_map):
             self.enable_harness()
         def generate(self, testcase, server_map):
             assert testcase.adapter_name == self.NAME
+            testcase.add_from_data("test", testcase.landing_page)
     Status.PATH = str(tmp_path)
     adapter = FuzzAdapter()
     adapter.setup(None, None)
@@ -85,8 +87,16 @@ def generate(self, testcase, server_map):
 
 def test_session_03(tmp_path, mocker):
     """test Session.dump_coverage()"""
+    class FuzzAdapter(Adapter):
+        NAME = "fuzz"
+        def setup(self, input_path, server_map):
+            self.enable_harness()
+        def generate(self, testcase, server_map):
+            assert testcase.adapter_name == self.NAME
+            testcase.add_from_data("test", testcase.landing_page)
     Status.PATH = str(tmp_path)
-    adapter = mocker.Mock(spec=Adapter, remaining=None)
+    adapter = FuzzAdapter()
+    adapter.setup(None, None)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_target = mocker.Mock(spec=Target, prefs=None, rl_reset=2)
     fake_target.log_size.return_value = 1000

From 00d4c7ae18602163bf553218fe28c850ae2102bf Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Sep 2020 15:56:43 -0700
Subject: [PATCH 017/531] [replay] Allow multiple calls to ReplayManager.run()

---
 grizzly/replay/replay.py      |  4 +++-
 grizzly/replay/test_replay.py | 18 ++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index fd0e5ffa..18596dea 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -120,8 +120,10 @@ def run(self, testcases, repeat=1, min_results=1):
         assert min_results > 0
         assert min_results <= repeat
         assert testcases
-        assert self.status is None
 
+        if self.status is not None:
+            LOG.debug("clearing previous status data")
+            self.status.cleanup()
         self.status = Status.start()
 
         server_map = ServerMap()
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 50af40f9..1d85e274 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -430,6 +430,24 @@ def test_replay_16(mocker, tmp_path):
     assert all(x.dump.call_count == 1 for x in testcases)
 
 def test_replay_17(mocker, tmp_path):
+    """test ReplayManager.run() - multiple calls"""
+    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    target = mocker.Mock(spec=Target, closed=True, forced_close=True, rl_reset=1)
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.detect_failure.return_value = Target.RESULT_NONE
+    with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
+        with ReplayManager([], server, target, use_harness=True) as replay:
+            assert not replay.run([testcase])
+            assert replay.status.iteration == 1
+            assert not replay.run([testcase])
+            assert replay.status.iteration == 1
+            assert not replay.run([testcase])
+            assert replay.status.iteration == 1
+    assert server.serve_path.call_count == 3
+
+def test_replay_18(mocker, tmp_path):
     """test ReplayManager.report_to_filesystem()"""
     # no reports
     ReplayManager.report_to_filesystem(str(tmp_path), [])

From 7c2f5a5222636eb49bacb82d70527e68ea79cd8e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Sep 2020 16:07:02 -0700
Subject: [PATCH 018/531] [tests] Fix replay test_main_03

---
 grizzly/common/reporter.py  | 2 +-
 grizzly/replay/test_main.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index aafce0f9..1a81bd16 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -403,7 +403,7 @@ class FilesystemReporter(Reporter):
 
     def __init__(self, report_path, major_bucket=True):
         self.major_bucket = major_bucket
-        assert report_path
+        assert isinstance(report_path, str) and report_path
         self.report_path = report_path
 
     def _pre_submit(self, report):
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 5f70a878..0167a52a 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -151,7 +151,7 @@ def test_main_03(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
     fake_tmp = (tmp_path / "grz_tmp")
     fake_tmp.mkdir()
-    mocker.patch("grizzly.replay.replay.grz_tmp", autospec=True, return_value=fake_tmp)
+    mocker.patch("grizzly.replay.replay.grz_tmp", autospec=True, return_value=str(fake_tmp))
     # setup args
     args = mocker.Mock(
         ignore=None,

From e67c6a65f87092120880fe5296f4fb78e5451a24 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 29 Sep 2020 10:50:41 -0700
Subject: [PATCH 019/531] Add debugger flag checks

---
 grizzly/args.py             |  3 +++
 grizzly/main.py             |  4 ++--
 grizzly/replay/args.py      |  3 +++
 grizzly/replay/replay.py    |  5 +++--
 grizzly/replay/test_main.py | 15 ++++++++++++++-
 5 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 62c0d274..cee2b57a 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -212,3 +212,6 @@ def sanity_check(self, args):
 
         if args.tool is not None and not (args.fuzzmanager or args.s3_fuzzmanager):
             self.parser.error("--tool can only be given with --fuzzmanager/--s3-fuzzmanager")
+
+        if args.rr and args.valgrind:
+            self.parser.error("'--rr' and '--valgrind' cannot be used together")
diff --git a/grizzly/main.py b/grizzly/main.py
index b52c9f9a..081d0f8a 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -41,10 +41,10 @@ def main(args):
         log.info("Ignoring: %s", ", ".join(args.ignore))
     if args.xvfb:
         log.info("Running with Xvfb")
-    if args.valgrind:
-        log.info("Running with Valgrind. This will be SLOW!")
     if args.rr:
         log.info("Running with RR")
+    elif args.valgrind:
+        log.info("Running with Valgrind. This will be SLOW!")
 
     adapter = None
     iomanager = None
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index 78696a14..c66567c4 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -72,5 +72,8 @@ def sanity_check(self, args):
         if args.repeat < 1:
             self.parser.error("'--repeat' value must be positive")
 
+        if args.rr and args.valgrind:
+            self.parser.error("'--rr' and '--valgrind' cannot be used together")
+
         if args.sig is not None and not isfile(args.sig):
             self.parser.error("signature file not found: %r" % (args.sig,))
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 18596dea..72357f0d 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -312,6 +312,7 @@ def main(cls, args):
         configure_logging(args.log_level)
         if args.fuzzmanager:
             FuzzManagerReporter.sanity_check(args.binary)
+            # TODO: add fuzzmanager support
 
         LOG.info("Starting Grizzly Replay")
 
@@ -319,10 +320,10 @@ def main(cls, args):
             LOG.info("Ignoring: %s", ", ".join(args.ignore))
         if args.xvfb:
             LOG.info("Running with Xvfb")
-        if args.valgrind:
-            LOG.info("Running with Valgrind. This will be SLOW!")
         if args.rr:
             LOG.info("Running with RR")
+        elif args.valgrind:
+            LOG.info("Running with Valgrind. This will be SLOW!")
 
         if args.sig:
             signature = CrashSignature.fromFile(args.sig)
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 0167a52a..2f91334b 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -54,6 +54,10 @@ def test_args_01(capsys, tmp_path):
     with raises(SystemExit):
         ReplayArgs().parse_args([str(exe), str(inp), "--any-crash", "--sig", "x"])
     assert "error: signature is ignored when running with '--any-crash'" in capsys.readouterr()[-1]
+    # multiple debuggers
+    with raises(SystemExit):
+        ReplayArgs().parse_args([str(exe), str(inp), "--rr", "--valgrind"])
+    assert "'--rr' and '--valgrind' cannot be used together" in capsys.readouterr()[-1]
     # force relaunch == 1 with --no-harness
     args = ReplayArgs().parse_args([str(exe), str(inp), "--no-harness"])
     assert args.relaunch == 1
@@ -90,8 +94,10 @@ def test_main_01(mocker, tmp_path):
         prefs=str(tmp_path / "prefs.js"),
         relaunch=1,
         repeat=4,
+        rr=False,
         sig=str(tmp_path / "sig.json"),
-        timeout=10)
+        timeout=10,
+        valgrind=False)
     assert ReplayManager.main(args) == 0
     assert target.forced_close
     assert target.reverse.call_count == 1
@@ -126,13 +132,20 @@ def test_main_02(mocker):
         sig=None)
     # user abort
     fake_load_target.side_effect = KeyboardInterrupt
+    # coverage
+    args.rr = True
+    args.valgrind = False
     assert ReplayManager.main(args) == 1
     # invalid test case
     fake_load_target.reset_mock()
     fake_tc.load.side_effect = TestCaseLoadFailure
+    # coverage
+    args.rr = False
+    args.valgrind = True
     assert ReplayManager.main(args) == 1
     assert fake_load_target.call_count == 0
     # no test cases
+    args.valgrind = False
     fake_tc.load.side_effect = None
     fake_tc.load.return_value = list()
     assert ReplayManager.main(args) == 1

From 5b2bb99caec91439c18cf1b7a65390cc117f9287 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 29 Sep 2020 11:07:26 -0700
Subject: [PATCH 020/531] [pylint] Address 'raise-missing-from' reports

---
 grizzly/common/storage.py       | 6 +++---
 grizzly/target/puppet_target.py | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 58de4a08..38dfc373 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -282,7 +282,7 @@ def load(cls, path, load_prefs, adjacent=False):
                     zip_fp.extractall(path=unpacked)
             except (BadZipfile, zlib_error):
                 shutil.rmtree(unpacked, ignore_errors=True)
-                raise TestCaseLoadFailure("Testcase archive is corrupted")
+                raise TestCaseLoadFailure("Testcase archive is corrupted") from None
             path = unpacked
         else:
             unpacked = None
@@ -339,9 +339,9 @@ def load_single(cls, path, load_prefs, adjacent=False):
                 with open(os.path.join(path, "test_info.json"), "r") as in_fp:
                     info = json.load(in_fp)
             except IOError:
-                raise TestCaseLoadFailure("Missing 'test_info.json'")
+                raise TestCaseLoadFailure("Missing 'test_info.json'") from None
             except ValueError:
-                raise TestCaseLoadFailure("Invalid 'test_info.json'")
+                raise TestCaseLoadFailure("Invalid 'test_info.json'") from None
             if not isinstance(info.get("target"), str):
                 raise TestCaseLoadFailure("'test_info.json' has invalid 'target' entry")
             entry_point = os.path.basename(info["target"])
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 366e048a..1382d839 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -216,10 +216,10 @@ def launch(self, location, env_mod=None):
             LOG.error("FFPuppet LaunchError: %s", str(exc))
             self.close()
             if isinstance(exc, BrowserTimeoutError):
-                raise TargetLaunchTimeout(str(exc))
+                raise TargetLaunchTimeout(str(exc)) from None
             log_path = mkdtemp(prefix="launch_fail_", dir=grz_tmp("logs"))
             self.save_logs(log_path)
-            raise TargetLaunchError(str(exc), Report(log_path, self.binary))
+            raise TargetLaunchError(str(exc), Report(log_path, self.binary)) from None
 
     def log_size(self):
         return self._puppet.log_length("stderr") + self._puppet.log_length("stdout")

From ede2a058e8d6c0b4d73aa65d59be23be48b02bbd Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 29 Sep 2020 12:19:53 -0700
Subject: [PATCH 021/531] Remove result duration tracking from testcase

---
 grizzly/common/runner.py      | 13 +++++++------
 grizzly/common/test_runner.py |  5 +++++
 grizzly/reduce/reduce.py      |  1 +
 grizzly/replay/replay.py      | 11 +++++++----
 grizzly/replay/test_replay.py |  8 +++++---
 grizzly/session.py            |  1 +
 grizzly/test_session.py       |  4 ++--
 7 files changed, 28 insertions(+), 15 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 2933df2b..5142b43e 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -175,12 +175,12 @@ def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait
                 forever=wait_for_callback,
                 optional_files=tuple(testcase.optional),
                 server_map=server_map)
-            testcase.duration = time() - serve_start
+            duration = time() - serve_start
         finally:
             # remove temporary files
             if test_path is None:
                 rmtree(wwwdir)
-        result = RunResult(served, timeout=server_status == SERVED_TIMEOUT)
+        result = RunResult(served, duration, timeout=server_status == SERVED_TIMEOUT)
         # TODO: fix calling TestCase.add_batch() for multi-test replay
         # add all include files that were served
         for url, resource in server_map.include.items():
@@ -208,8 +208,8 @@ def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait
         return result
 
     def _keep_waiting(self):
-        """Callback used by the server to determine if should continue to wait
-        for the requests from the target.
+        """Callback used by the server to determine if it should continue to
+        wait for the requests from the target.
 
         Args:
             None
@@ -229,9 +229,10 @@ class RunResult(object):
     FAILED = 3
     IGNORED = 4
 
-    __slots__ = ("served", "status", "timeout")
+    __slots__ = ("duration", "served", "status", "timeout")
 
-    def __init__(self, served, status=None, timeout=False):
+    def __init__(self, served, duration, status=None, timeout=False):
+        self.duration = duration
         self.served = served
         self.status = status
         self.timeout = timeout
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index b8d89935..9233a283 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -16,6 +16,7 @@
 
 def test_runner_01(mocker, tmp_path):
     """test Runner()"""
+    fake_time = mocker.patch("grizzly.common.runner.time", autospec=True)
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
     target.detect_failure.return_value = target.RESULT_NONE
@@ -24,8 +25,10 @@ def test_runner_01(mocker, tmp_path):
     serv_files = ["a.bin", "/another/file.bin"]
     testcase = mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[])
     # all files served
+    fake_time.side_effect = (1, 2)
     server.serve_path.return_value = (SERVED_ALL, serv_files)
     result = runner.run([], ServerMap(), testcase)
+    assert result.duration == 1
     assert result.status == RunResult.COMPLETE
     assert result.served == serv_files
     assert not result.timeout
@@ -33,6 +36,7 @@ def test_runner_01(mocker, tmp_path):
     assert target.dump_coverage.call_count == 0
     assert testcase.dump.call_count == 1
     # some files served
+    fake_time.side_effect = (1, 2)
     server.serve_path.return_value = (SERVED_REQUEST, serv_files)
     result = runner.run([], ServerMap(), testcase, coverage=True)
     assert result.status == RunResult.COMPLETE
@@ -41,6 +45,7 @@ def test_runner_01(mocker, tmp_path):
     assert target.close.call_count == 0
     assert target.dump_coverage.call_count == 1
     # existing test path
+    fake_time.side_effect = (1, 2)
     testcase.reset_mock()
     tc_path = (tmp_path / "tc")
     tc_path.mkdir()
diff --git a/grizzly/reduce/reduce.py b/grizzly/reduce/reduce.py
index 008f8f5a..bced7f70 100644
--- a/grizzly/reduce/reduce.py
+++ b/grizzly/reduce/reduce.py
@@ -647,6 +647,7 @@ def _dyn_resp_close():  # pragma: no cover
 
         # run test case
         result = runner.run(self._ignore, self._server_map, testcase, wait_for_callback=self._no_harness)
+        testcase.duration = result.duration
 
         # handle failure if detected
         if result.status == RunResult.FAILED:
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 72357f0d..d87a49df 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -27,10 +27,11 @@
 
 
 class ReplayResult(object):
-    __slots__ = ("count", "expected", "report", "served")
+    __slots__ = ("count", "durations", "expected", "report", "served")
 
-    def __init__(self, report, served, expected):
+    def __init__(self, report, served, durations, expected):
         self.count = 1
+        self.durations = durations
         self.expected = expected
         self.report = report
         self.served = served
@@ -173,6 +174,7 @@ def _dyn_close():  # pragma: no cover
                 self.target.step()
                 LOG.info("Performing replay (%d/%d)...", self.status.iteration, repeat)
                 # run tests
+                durations = list()
                 served = list()
                 for test_idx in range(test_count):
                     LOG.debug("running test: %d of %d", test_idx + 1, test_count)
@@ -194,6 +196,7 @@ def _dyn_close():  # pragma: no cover
                         testcases[test_idx],
                         test_path=unpacked[test_idx],
                         wait_for_callback=self._harness is None)
+                    durations.append(run_result.duration)
                     served.append(run_result.served)
                     if run_result.status != RunResult.COMPLETE:
                         break
@@ -221,7 +224,7 @@ def _dyn_close():  # pragma: no cover
                         else:
                             bucket_hash = report.crash_hash
                         if bucket_hash not in reports:
-                            reports[bucket_hash] = ReplayResult(report, served, True)
+                            reports[bucket_hash] = ReplayResult(report, served, durations, True)
                             LOG.debug("now tracking %s", bucket_hash)
                             report = None  # don't remove report
                         else:
@@ -232,7 +235,7 @@ def _dyn_close():  # pragma: no cover
                                  short_sig, report.major[:8], report.minor[:8])
                         self.status.ignored += 1
                         if report.crash_hash not in reports:
-                            reports[report.crash_hash] = ReplayResult(report, served, False)
+                            reports[report.crash_hash] = ReplayResult(report, served, durations, False)
                             LOG.debug("now tracking %s", report.crash_hash)
                             report = None  # don't remove report
                         else:
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 1d85e274..6707ecda 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -96,6 +96,7 @@ def test_replay_04(mocker, tmp_path):
         assert results[0].report
         assert len(results[0].served) == 1
         assert results[0].served[0] == served
+        assert len(results[0].durations) == 1
         results[0].report.cleanup()
         assert not any(tmp_path.glob("*"))
 
@@ -427,6 +428,7 @@ def test_replay_16(mocker, tmp_path):
     assert results[0].served[0][0] == "a.html"
     assert results[0].served[1][0] == "b.html"
     assert results[0].served[2][0] == "c.html"
+    assert len(results[0].durations) == len(testcases)
     assert all(x.dump.call_count == 1 for x in testcases)
 
 def test_replay_17(mocker, tmp_path):
@@ -454,19 +456,19 @@ def test_replay_18(mocker, tmp_path):
     assert not any(tmp_path.glob("*"))
     # with reports and tests
     (tmp_path / "report_expected").mkdir()
-    result0 = mocker.Mock(ReplayResult, count=1, expected=True, served=[])
+    result0 = mocker.Mock(ReplayResult, count=1, durations=[1], expected=True, served=[])
     result0.report = mocker.Mock(
         spec=Report,
         path=str(tmp_path / "report_expected"),
         prefix="expected")
     (tmp_path / "report_other1").mkdir()
-    result1 = mocker.Mock(ReplayResult, count=1, expected=False, served=None)
+    result1 = mocker.Mock(ReplayResult, count=1, durations=[1], expected=False, served=None)
     result1.report = mocker.Mock(
         spec=Report,
         path=str(tmp_path / "report_other1"),
         prefix="other1")
     (tmp_path / "report_other2").mkdir()
-    result2 = mocker.Mock(ReplayResult, count=1, expected=False, served=None)
+    result2 = mocker.Mock(ReplayResult, count=1, durations=[1], expected=False, served=None)
     result2.report = mocker.Mock(
         spec=Report,
         path=str(tmp_path / "report_other2"),
diff --git a/grizzly/session.py b/grizzly/session.py
index 6dc4e24c..b4b4fa7f 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -165,6 +165,7 @@ def _dyn_close():  # pragma: no cover
 
             # run test case
             result = runner.run(ignore, self.iomanager.server_map, current_test, coverage=self.coverage)
+            current_test.duration = result.duration
             # adapter callbacks
             if result.timeout:
                 log.debug("calling self.adapter.on_timeout()")
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 82b5720e..531cb6e9 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -189,7 +189,7 @@ def test_session_07(tmp_path, mocker):
     Status.PATH = str(tmp_path)
     mocker.patch("grizzly.session.Report", autospec=True)
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
-    fake_runner.return_value.run.return_value = RunResult(["/fake/file"], status=RunResult.FAILED)
+    fake_runner.return_value.run.return_value = RunResult(["/fake/file"], 1, status=RunResult.FAILED)
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
     fake_adapter.IGNORE_UNSERVED = True
@@ -216,7 +216,7 @@ def test_session_08(tmp_path, mocker):
     """test Session.run() ignoring failures"""
     Status.PATH = str(tmp_path)
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
-    fake_runner.return_value.run.return_value = RunResult([], status=RunResult.IGNORED)
+    fake_runner.return_value.run.return_value = RunResult([], 0.1, status=RunResult.IGNORED)
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
     fake_adapter.IGNORE_UNSERVED = True

From 9cbefba8a646797906fc9ac6f563e18c4593453a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 29 Sep 2020 13:54:18 -0700
Subject: [PATCH 022/531] [replay] Add idle detection support

---
 grizzly/common/runner.py    |  3 ++-
 grizzly/replay/args.py      | 11 ++++++----
 grizzly/replay/replay.py    | 41 ++++++++++++++++++++++---------------
 grizzly/replay/test_main.py | 12 ++++++++++-
 4 files changed, 44 insertions(+), 23 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 5142b43e..5ffddd9c 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -76,8 +76,9 @@ def schedule_poll(self, initial=False, now=None):
 class Runner(object):
     __slots__ = ("_idle", "_server", "_target")
 
-    def __init__(self, server, target, idle_threshold=0, idle_delay=60):
+    def __init__(self, server, target, idle_threshold=0, idle_delay=0):
         if idle_threshold > 0:
+            assert idle_delay > 0
             self._idle = _IdleChecker(target.is_idle, idle_threshold, idle_delay)
         else:
             self._idle = None
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index c66567c4..d7e764a8 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -25,11 +25,11 @@ def __init__(self):
             "--any-crash", action="store_true",
             help="Any crash is interesting, not only crashes which match the original signature.")
         replay_args.add_argument(
-            "--idle-threshold", type=int, default=25,
-            help="CPU usage threshold to mark the process as idle (default: %(default)s)")
+            "--idle-delay", type=int, default=30,
+            help="Number of seconds to wait before polling for idle (default: %(default)s)")
         replay_args.add_argument(
-            "--idle-timeout", type=int, default=60,
-            help="Number of seconds to wait before polling testcase for idle (default: %(default)s)")
+            "--idle-threshold", type=int, default=0,
+            help="CPU usage threshold to mark the process as idle (default: disabled)")
         replay_args.add_argument(
             "-l", "--logs",
             help="Location to save logs. If the path exists it must be empty, if it " \
@@ -63,6 +63,9 @@ def sanity_check(self, args):
         if args.any_crash and args.sig is not None:
             self.parser.error("signature is ignored when running with '--any-crash'")
 
+        if args.idle_threshold and args.idle_delay <= 0:
+            self.parser.error("'--idle-delay' value must be positive")
+
         if args.min_crashes < 1:
             self.parser.error("'--min-crashes' value must be positive")
 
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index d87a49df..58517cda 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -41,7 +41,7 @@ class ReplayManager(object):
     HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
 
     __slots__ = ("ignore", "server", "status", "target", "_any_crash",
-                 "_harness", "_runner", "_signature", "_unpacked")
+                 "_harness", "_signature", "_unpacked")
 
     def __init__(self, ignore, server, target, any_crash=False, signature=None, use_harness=True):
         self.ignore = ignore
@@ -50,7 +50,6 @@ def __init__(self, ignore, server, target, any_crash=False, signature=None, use_
         self.target = target
         self._any_crash = any_crash
         self._harness = None
-        self._runner = Runner(self.server, self.target)
         # TODO: make signature a property
         self._signature = signature
         if use_harness:
@@ -105,7 +104,7 @@ def report_to_filesystem(path, results, tests=None):
             for result in expected:
                 reporter.submit(tests or [], report=result.report)
 
-    def run(self, testcases, repeat=1, min_results=1):
+    def run(self, testcases, repeat=1, min_results=1, idle_delay=0, idle_threshold=0):
         """Run testcase replay.
 
         Args:
@@ -113,13 +112,17 @@ def run(self, testcases, repeat=1, min_results=1):
             repeat (int): Maximum number of times to run the TestCase.
             min_results (int): Minimum number of results needed before run can
                                be considered successful.
+            idle_delay (int): Number of seconds to wait before polling for idle.
+            idle_threshold (int): CPU usage threshold to mark the process as idle.
 
         Returns:
-            list: List of ReplayResults that were found running testcases.
+            list: ReplayResults that were found running testcases.
         """
-        assert repeat > 0
+        assert idle_delay >= 0
+        assert idle_threshold >= 0
         assert min_results > 0
-        assert min_results <= repeat
+        assert repeat > 0
+        assert repeat >= min_results
         assert testcases
 
         if self.status is not None:
@@ -138,6 +141,7 @@ def _dyn_close():  # pragma: no cover
             server_map.set_dynamic_response("grz_close_browser", _dyn_close, mime_type="text/html")
             server_map.set_dynamic_response("grz_harness", lambda: self._harness, mime_type="text/html")
 
+        runner = Runner(self.server, self.target, idle_threshold=idle_threshold, idle_delay=idle_delay)
         # track unprocessed results
         reports = dict()
         # track unpacked testcases
@@ -156,11 +160,11 @@ def _dyn_close():  # pragma: no cover
                 if self.target.closed:
                     LOG.info("Launching target...")
                     if self._harness is None:
-                        location = self._runner.location(
+                        location = runner.location(
                             "/grz_current_test",
                             self.server.port)
                     else:
-                        location = self._runner.location(
+                        location = runner.location(
                             "/grz_harness",
                             self.server.port,
                             close_after=self.target.rl_reset * test_count,
@@ -170,7 +174,7 @@ def _dyn_close():  # pragma: no cover
                     # relaunching the Target to match the functionality of
                     # Grizzly. If this is not the case each TestCase should
                     # be run individually.
-                    self._runner.launch(location, env_mod=testcases[0].env_vars)
+                    runner.launch(location, env_mod=testcases[0].env_vars)
                 self.target.step()
                 LOG.info("Performing replay (%d/%d)...", self.status.iteration, repeat)
                 # run tests
@@ -190,7 +194,7 @@ def _dyn_close():  # pragma: no cover
                         testcases[test_idx].landing_page,
                         required=False)
                     # run testcase
-                    run_result = self._runner.run(
+                    run_result = runner.run(
                         self.ignore,
                         server_map,
                         testcases[test_idx],
@@ -342,7 +346,6 @@ def main(cls, args):
             LOG.error("Error: %s", str(exc))
             return 1
 
-        replay = None
         results = None
         target = None
         tmp_prefs = None
@@ -388,14 +391,20 @@ def main(cls, args):
             # launch HTTP server used to serve test cases
             with Sapphire(auto_close=1, timeout=args.timeout) as server:
                 target.reverse(server.port, server.port)
-                replay = ReplayManager(
+                with cls(
                     args.ignore,
                     server,
                     target,
                     any_crash=args.any_crash,
                     signature=signature,
-                    use_harness=not args.no_harness)
-                results = replay.run(testcases, repeat=repeat, min_results=args.min_crashes)
+                    use_harness=not args.no_harness
+                ) as replay:
+                    results = replay.run(
+                        testcases,
+                        idle_delay=args.idle_delay,
+                        idle_threshold=args.idle_threshold,
+                        min_results=args.min_crashes,
+                        repeat=repeat)
             # handle results
             success = any(x.expected for x in results)
             if success:
@@ -403,7 +412,7 @@ def main(cls, args):
             else:
                 LOG.info("Failed to reproduce results")
             if args.logs and results:
-                replay.report_to_filesystem(
+                cls.report_to_filesystem(
                     args.logs,
                     results,
                     testcases if args.include_test else None)
@@ -424,8 +433,6 @@ def main(cls, args):
 
         finally:
             LOG.warning("Shutting down...")
-            if replay is not None:
-                replay.cleanup()
             if results:
                 # cleanup unreported results
                 for result in results:
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 2f91334b..965df971 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -54,10 +54,14 @@ def test_args_01(capsys, tmp_path):
     with raises(SystemExit):
         ReplayArgs().parse_args([str(exe), str(inp), "--any-crash", "--sig", "x"])
     assert "error: signature is ignored when running with '--any-crash'" in capsys.readouterr()[-1]
-    # multiple debuggers
+    # test multiple debuggers
     with raises(SystemExit):
         ReplayArgs().parse_args([str(exe), str(inp), "--rr", "--valgrind"])
     assert "'--rr' and '--valgrind' cannot be used together" in capsys.readouterr()[-1]
+    # test idle args
+    with raises(SystemExit):
+        ReplayArgs().parse_args([str(exe), str(inp), "--idle-threshold", "1", "--idle-delay", "0"])
+    assert "'--idle-delay' value must be positive" in capsys.readouterr()[-1]
     # force relaunch == 1 with --no-harness
     args = ReplayArgs().parse_args([str(exe), str(inp), "--no-harness"])
     assert args.relaunch == 1
@@ -87,6 +91,8 @@ def test_main_01(mocker, tmp_path):
     (tmp_path / "sig.json").write_bytes(b"{\"symptoms\": [{\"type\": \"crashAddress\", \"address\": \"0\"}]}")
     args = mocker.Mock(
         fuzzmanager=False,
+        idle_delay=0,
+        idle_threshold=0,
         ignore=["fake", "timeout"],
         input=str(tmp_path / "test.html"),
         logs=str(log_path),
@@ -202,6 +208,8 @@ def test_main_04(mocker):
     # setup args
     args = mocker.Mock(
         fuzzmanager=False,
+        idle_delay=0,
+        idle_threshold=0,
         ignore=None,
         input="test",
         min_crashes=1,
@@ -229,6 +237,8 @@ def test_main_05(mocker, tmp_path):
     # setup args
     args = mocker.Mock(
         fuzzmanager=False,
+        idle_delay=0,
+        idle_threshold=0,
         ignore=None,
         min_crashes=1,
         relaunch=1,

From 1e7e240043135c9951c8256fac76b47c477174f9 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 30 Sep 2020 16:33:09 -0700
Subject: [PATCH 023/531] Add additional idle config sanity checks

---
 grizzly/common/runner.py      | 3 ++-
 grizzly/common/test_runner.py | 7 +++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 5ffddd9c..729e3246 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -30,7 +30,7 @@ def __init__(self, check_cb, threshold, initial_delay, poll_delay=1):
         assert callable(check_cb)
         assert initial_delay >= 0
         assert poll_delay >= 0
-        assert threshold >= 0
+        assert 100 > threshold >= 0
         self._check_cb = check_cb  # callback used to check if target is idle
         self._init_delay = initial_delay  # time to wait before the initial idle poll
         self._poll_delay = poll_delay  # time to wait between subsequent polls
@@ -79,6 +79,7 @@ class Runner(object):
     def __init__(self, server, target, idle_threshold=0, idle_delay=0):
         if idle_threshold > 0:
             assert idle_delay > 0
+            LOG.debug("using idle check, th %d, delay %ds", idle_threshold, idle_delay)
             self._idle = _IdleChecker(target.is_idle, idle_threshold, idle_delay)
         else:
             self._idle = None
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 9233a283..d36f470a 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -227,8 +227,8 @@ def test_runner_09(mocker, tmp_path):
 def test_idle_check_01(mocker):
     """test simple _IdleChecker"""
     fake_time = mocker.patch("grizzly.common.runner.time", autospec=True)
-    ichk = _IdleChecker(mocker.Mock(), 100, 10, poll_delay=1)
-    assert ichk._threshold == 100
+    ichk = _IdleChecker(mocker.Mock(), 95, 10, poll_delay=1)
+    assert ichk._threshold == 95
     assert ichk._init_delay == 10
     assert ichk._poll_delay == 1
     assert ichk._next_poll is None
@@ -243,8 +243,7 @@ def test_idle_check_02(mocker):
     fake_time = mocker.patch("grizzly.common.runner.time", autospec=True)
     callbk = mocker.Mock()
     callbk.return_value = False
-    #check_cb, delay, duration, threshold
-    ichk = _IdleChecker(callbk, 100, 10, poll_delay=1)
+    ichk = _IdleChecker(callbk, 99, 10, poll_delay=1)
     fake_time.return_value = 0
     ichk.schedule_poll()
     # early check

From 0f095a0570f80cd4bafe0f82977da42e7b41ccb6 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 30 Sep 2020 16:34:37 -0700
Subject: [PATCH 024/531] Remove harness default time_limit

---
 grizzly/common/harness.html | 22 ++++++----------------
 1 file changed, 6 insertions(+), 16 deletions(-)

diff --git a/grizzly/common/harness.html b/grizzly/common/harness.html
index 7a9792ca..04f86c36 100644
--- a/grizzly/common/harness.html
+++ b/grizzly/common/harness.html
@@ -25,10 +25,6 @@
     grzDump('Test case time limit already set')
     return
   }
-  if (time_limit === 0) {
-    // test case time limit disabled
-    return
-  }
   limit_tmr = setTimeout(() => {
     grzDump('Test case time limit exceeded')
     if (!sub.closed){
@@ -71,9 +67,12 @@
   }
 
   // set the test case timeout once the test loading ends
-  sub.addEventListener('abort', setTestTimeout)
-  sub.addEventListener('error', setTestTimeout)
-  sub.addEventListener('load', setTestTimeout)
+  if (time_limit > 0) {
+    grzDump(`Using test case time limit of ${time_limit}`)
+    sub.addEventListener('abort', setTestTimeout)
+    sub.addEventListener('error', setTestTimeout)
+    sub.addEventListener('load', setTestTimeout)
+  }
 
   setTimeout(main, 50)
 }
@@ -97,15 +96,6 @@
     }
   }
 
-  if ((time_limit === undefined) || (time_limit < 0)) {
-    time_limit = 15000
-    grzDump(`No valid time limit given, using default of ${time_limit}`)
-  } else if (time_limit > 0) {
-    grzDump(`Using test case time limit of ${time_limit}`)
-  } else {
-    grzDump(`Test case time limit diabled`)
-  }
-
   // update banner
   setBanner('&#x1f43b; &sdot; Grizzly Harness &sdot; &#x1f98a;')
   main()

From 78055c0b440ed6597117dbd0fcc8b8cc2a11e7ee Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Oct 2020 09:35:31 -0700
Subject: [PATCH 025/531] Update timeout related messages

---
 grizzly/args.py          | 4 +++-
 grizzly/replay/replay.py | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index cee2b57a..796ea32b 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -82,7 +82,9 @@ def __init__(self):
             help="Number of iterations performed before relaunching the browser (default: %(default)s)")
         self.launcher_grp.add_argument(
             "-t", "--timeout", type=int, default=60,
-            help="Iteration timeout in seconds (default: %(default)s)")
+            help="Iteration or test case timeout in seconds (default: %(default)s)."
+                 " Browser build types and debuggers can affect the amount of time"
+                 " required to run a test case.")
         self.launcher_grp.add_argument(
             "--valgrind", action="store_true",
             help="Use Valgrind (Linux only)")
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 58517cda..20f5bb02 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -253,7 +253,7 @@ def _dyn_close():  # pragma: no cover
                     self.status.ignored += 1
                     LOG.info("Result: Ignored (%d)", self.status.ignored)
                 elif run_result.status == RunResult.ERROR:
-                    LOG.error("ERROR: Replay malfunction, test case was not served")
+                    LOG.error("ERROR: Test case was not served. Timeout too short?")
                     break
 
                 # check status and exit early if possible

From ba48dedb595a135b1c7c35420f161b845d09044b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Oct 2020 12:28:02 -0700
Subject: [PATCH 026/531] Use __name__ as logger name

---
 grizzly/adapters/__init__.py      | 2 +-
 grizzly/common/reporter.py        | 2 +-
 grizzly/common/runner.py          | 2 +-
 grizzly/common/stack_hasher.py    | 2 +-
 grizzly/common/status.py          | 2 +-
 grizzly/main.py                   | 2 +-
 grizzly/reduce/bucket.py          | 2 +-
 grizzly/reduce/crash.py           | 2 +-
 grizzly/reduce/reduce.py          | 2 +-
 grizzly/reduce/strategies.py      | 2 +-
 grizzly/replay/replay.py          | 2 +-
 grizzly/session.py                | 2 +-
 grizzly/target/__init__.py        | 2 +-
 grizzly/target/puppet_target.py   | 2 +-
 grizzly/target/target.py          | 2 +-
 loki/loki.py                      | 2 +-
 sapphire/conftest.py              | 2 +-
 sapphire/core.py                  | 2 +-
 sapphire/sapphire_job.py          | 2 +-
 sapphire/sapphire_load_manager.py | 2 +-
 sapphire/sapphire_worker.py       | 2 +-
 sapphire/server_map.py            | 2 +-
 22 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/grizzly/adapters/__init__.py b/grizzly/adapters/__init__.py
index 20e48d5c..1da3d466 100644
--- a/grizzly/adapters/__init__.py
+++ b/grizzly/adapters/__init__.py
@@ -6,7 +6,7 @@
 
 from grizzly.common import Adapter
 
-log = logging.getLogger("grizzly")  # pylint: disable=invalid-name
+log = logging.getLogger(__name__)  # pylint: disable=invalid-name
 
 __all__ = ("get", "load", "names")
 __adapters__ = dict()
diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 1a81bd16..b402990a 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -44,7 +44,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-LOG = getLogger("grizzly")
+LOG = getLogger(__name__)
 
 # NOTE: order matters, aux -> stderr -> stdout
 LogMap = namedtuple("LogMap", "aux stderr stdout")
diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 729e3246..b7797fa3 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -15,7 +15,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-LOG = getLogger("grz_runner")
+LOG = getLogger(__name__)
 
 # _IdleChecker is used to help determine if the target is hung (actively using CPU)
 # or if it has not made expected the HTTP requests for other reasons (idle).
diff --git a/grizzly/common/stack_hasher.py b/grizzly/common/stack_hasher.py
index 2817f500..4664871f 100644
--- a/grizzly/common/stack_hasher.py
+++ b/grizzly/common/stack_hasher.py
@@ -21,7 +21,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-LOG = getLogger("stack_hasher")
+LOG = getLogger(__name__)
 
 MAJOR_DEPTH = 5
 MAJOR_DEPTH_RUST = 10
diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index b61d7c7b..8b77e1b2 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -19,7 +19,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-LOG = getLogger("status")
+LOG = getLogger(__name__)
 
 
 class Status(object):
diff --git a/grizzly/main.py b/grizzly/main.py
index 081d0f8a..21de9186 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -20,7 +20,7 @@
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
 
-log = getLogger("grizzly")  # pylint: disable=invalid-name
+log = getLogger(__name__)  # pylint: disable=invalid-name
 
 def configure_logging(log_level):
     if log_level == DEBUG:
diff --git a/grizzly/reduce/bucket.py b/grizzly/reduce/bucket.py
index a64ed40c..edb8e73f 100644
--- a/grizzly/reduce/bucket.py
+++ b/grizzly/reduce/bucket.py
@@ -15,7 +15,7 @@
 from .crash import CrashReductionJob
 
 
-LOG = logging.getLogger("grizzly.reduce.bucket")
+LOG = logging.getLogger(__name__)
 
 
 def bucket_crashes(bucket_id, quality_filter):
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index 0acd61ca..dd17a6d4 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -15,7 +15,7 @@
 from ..common import FuzzManagerReporter
 
 
-LOG = logging.getLogger("grizzly.reduce.crash")
+LOG = logging.getLogger(__name__)
 
 
 def crashentry_data(crash_id, raw=False):
diff --git a/grizzly/reduce/reduce.py b/grizzly/reduce/reduce.py
index bced7f70..cede6ced 100644
--- a/grizzly/reduce/reduce.py
+++ b/grizzly/reduce/reduce.py
@@ -39,7 +39,7 @@
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber", "Jason Kratzer"]
 
 
-LOG = logging.getLogger("grizzly.reduce")
+LOG = logging.getLogger(__name__)
 
 
 class LithiumInterestingProxy(object):
diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index 528d677d..22263407 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -23,7 +23,7 @@
 from . import testcase_contents
 
 
-LOG = logging.getLogger("grizzly.reduce.strategies")
+LOG = logging.getLogger(__name__)
 
 
 class ReduceStage(metaclass=abc.ABCMeta):
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 20f5bb02..b9b676c7 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -23,7 +23,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-LOG = getLogger("replay")
+LOG = getLogger(__name__)
 
 
 class ReplayResult(object):
diff --git a/grizzly/session.py b/grizzly/session.py
index b4b4fa7f..4f5addc6 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -17,7 +17,7 @@
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
 
-log = getLogger("grizzly")  # pylint: disable=invalid-name
+log = getLogger(__name__)  # pylint: disable=invalid-name
 
 
 class SessionError(Exception):
diff --git a/grizzly/target/__init__.py b/grizzly/target/__init__.py
index e97b91ac..5b6e6661 100644
--- a/grizzly/target/__init__.py
+++ b/grizzly/target/__init__.py
@@ -15,7 +15,7 @@
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
 TARGETS = None
-LOG = getLogger("grizzly")
+LOG = getLogger(__name__)
 
 
 def _load_targets():
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 1382d839..9e3e6fc7 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -25,7 +25,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
-LOG = getLogger("puppet_target")
+LOG = getLogger(__name__)
 
 
 class PuppetTarget(Target):
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 7bd0ac16..6ad91bc4 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -15,7 +15,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
-LOG = getLogger("grizzly")
+LOG = getLogger(__name__)
 
 
 def sanitizer_opts(env_data):
diff --git a/loki/loki.py b/loki/loki.py
index eb2773bb..536e9749 100644
--- a/loki/loki.py
+++ b/loki/loki.py
@@ -15,7 +15,7 @@
 
 
 __author__ = "Tyson Smith"
-LOG = logging.getLogger("loki")
+LOG = logging.getLogger(__name__)
 
 
 class Loki(object):
diff --git a/sapphire/conftest.py b/sapphire/conftest.py
index 6090eba6..97877c76 100644
--- a/sapphire/conftest.py
+++ b/sapphire/conftest.py
@@ -18,7 +18,7 @@
 import pytest
 
 
-LOG = logging.getLogger("sphr_test")
+LOG = logging.getLogger(__name__)
 
 
 @pytest.fixture
diff --git a/sapphire/core.py b/sapphire/core.py
index 0efd5372..5c89ca24 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -21,7 +21,7 @@
 __credits__ = ["Tyson Smith"]
 
 
-LOG = logging.getLogger("sapphire")
+LOG = logging.getLogger(__name__)
 
 
 class Sapphire(object):
diff --git a/sapphire/sapphire_job.py b/sapphire/sapphire_job.py
index 789713d9..c29b8d40 100644
--- a/sapphire/sapphire_job.py
+++ b/sapphire/sapphire_job.py
@@ -19,7 +19,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-LOG = getLogger("sphr_job")
+LOG = getLogger(__name__)
 
 
 Tracker = namedtuple("Tracker", "files lock")
diff --git a/sapphire/sapphire_load_manager.py b/sapphire/sapphire_load_manager.py
index 9c735955..02236a70 100644
--- a/sapphire/sapphire_load_manager.py
+++ b/sapphire/sapphire_load_manager.py
@@ -13,7 +13,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-LOG = getLogger("sphr_loadmgr")
+LOG = getLogger(__name__)
 
 
 class SapphireLoadManager(object):
diff --git a/sapphire/sapphire_worker.py b/sapphire/sapphire_worker.py
index 90a3d6db..6bc46d5a 100644
--- a/sapphire/sapphire_worker.py
+++ b/sapphire/sapphire_worker.py
@@ -20,7 +20,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-LOG = getLogger("sphr_worker")
+LOG = getLogger(__name__)
 
 
 class SapphireWorkerError(Exception):
diff --git a/sapphire/server_map.py b/sapphire/server_map.py
index 0a48111c..8ada3433 100644
--- a/sapphire/server_map.py
+++ b/sapphire/server_map.py
@@ -12,7 +12,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-LOG = logging.getLogger("sphr_map")  # pylint: disable=invalid-name
+LOG = logging.getLogger(__name__)  # pylint: disable=invalid-name
 
 
 class InvalidURLError(Exception):

From 1ba060ff2e16aafa8b95ebb61fb2fb0cb68cdc24 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Oct 2020 12:30:11 -0700
Subject: [PATCH 027/531] Update debug log format

---
 grizzly/__main__.py  | 3 +--
 grizzly/main.py      | 6 ++++--
 sapphire/__main__.py | 6 ++++--
 3 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/grizzly/__main__.py b/grizzly/__main__.py
index eb579e83..1dbd9537 100644
--- a/grizzly/__main__.py
+++ b/grizzly/__main__.py
@@ -20,8 +20,7 @@
 # is where basicConfig should be called).
 if getenv("DEBUG"):
     basicConfig(
-        format="%(levelname).1s %(name)s [%(asctime)s] %(message)s",
-        datefmt="%Y-%m-%d %H:%M:%S",
+        format="%(asctime)s %(levelname).1s %(name)s | %(message)s",
         level=DEBUG)
 # load Adapters
 load()
diff --git a/grizzly/main.py b/grizzly/main.py
index 21de9186..32abd73c 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -24,10 +24,12 @@
 
 def configure_logging(log_level):
     if log_level == DEBUG:
-        log_fmt = "%(levelname).1s %(name)s [%(asctime)s] %(message)s"
+        date_fmt = None
+        log_fmt = "%(asctime)s %(levelname).1s %(name)s | %(message)s"
     else:
+        date_fmt = "%Y-%m-%d %H:%M:%S"
         log_fmt = "[%(asctime)s] %(message)s"
-    basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
+    basicConfig(format=log_fmt, datefmt=date_fmt, level=log_level)
 
 def main(args):
     configure_logging(args.log_level)
diff --git a/sapphire/__main__.py b/sapphire/__main__.py
index 6f813305..a5e81d15 100644
--- a/sapphire/__main__.py
+++ b/sapphire/__main__.py
@@ -11,10 +11,12 @@
 
 def configure_logging(log_level):
     if log_level == DEBUG:
-        log_fmt = "%(levelname).1s %(name)s [%(asctime)s] %(message)s"
+        date_fmt = None
+        log_fmt = "%(asctime)s %(levelname).1s %(name)s | %(message)s"
     else:
+        date_fmt = "%Y-%m-%d %H:%M:%S"
         log_fmt = "[%(asctime)s] %(message)s"
-    basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
+    basicConfig(format=log_fmt, datefmt=date_fmt, level=log_level)
 
 def parse_args(argv=None):
     # log levels for console logging

From 0eb4d913de98321710acec969c82b154bdcc3264 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 8 Oct 2020 17:51:43 -0700
Subject: [PATCH 028/531] [ci] Add Python3.9

---
 .travis.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 0abee774..3cf0f519 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,6 +7,7 @@ python:
   - 3.6
   - 3.7
   - 3.8
+  - 3.9
 jobs:
   include:
     - os: osx
@@ -15,8 +16,10 @@ jobs:
     - os: windows
       language: shell
       before_install:
-        - choco install python
+        - choco install python --version 3.8
       env: PATH=/c/Python38:/c/Python38/Scripts:$PATH
+  allow_failures:
+    - python: 3.9
 before_install:
   - pip3 install --upgrade setuptools pip
 install:

From dc5300937453cd186ee1903c5d42870e4937d0a9 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 9 Oct 2020 10:56:58 -0700
Subject: [PATCH 029/531] Remove invalid assertion

---
 grizzly/common/storage.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 38dfc373..3fa30bbd 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -404,16 +404,15 @@ def purge_optional(self, keep):
         Returns:
             None
         """
+        opt_files = tuple(x.file_name for x in self._files.optional)
+        if not opt_files:
+            # nothing to purge
+            return None
         # filter required files from opt_files files to keep
         keep_opt = list()
         for fname in set(keep):
             if fname not in (x.file_name for x in self._files.required):
                 keep_opt.append(fname)
-        opt_files = tuple(x.file_name for x in self._files.optional)
-        if not opt_files:
-            assert not keep_opt
-            # nothing to purge
-            return None
         # sanity check keep (cannot remove file that does not exist)
         assert all(fname in opt_files for fname in keep_opt)
         # purge

From 0279df1f54015b5e99c68ff40584af1d0b1a59ac Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Oct 2020 13:30:56 -0700
Subject: [PATCH 030/531] [sapphire] Update imports

---
 sapphire/core.py                       | 37 ++++++++++++------------
 sapphire/sapphire_load_manager.py      | 32 ++++++++++-----------
 sapphire/server_map.py                 | 19 ++++++------
 sapphire/test_sapphire.py              |  6 ++--
 sapphire/test_sapphire_load_manager.py | 40 +++++++++++++-------------
 5 files changed, 66 insertions(+), 68 deletions(-)

diff --git a/sapphire/core.py b/sapphire/core.py
index 5c89ca24..8bb37ea6 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -1,16 +1,17 @@
 # coding=utf-8
-"""
-Sapphire HTTP server
-"""
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-import errno
-import logging
-import os
-import random
-import socket
-import time
+"""
+Sapphire HTTP server
+"""
+from errno import EADDRINUSE
+from logging import getLogger
+from os.path import abspath
+from random import randint
+from socket import AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
+from socket import error as sock_error, gethostname, socket
+from time import sleep
 
 from .sapphire_job import SapphireJob
 from .sapphire_load_manager import SapphireLoadManager
@@ -21,7 +22,7 @@
 __credits__ = ["Tyson Smith"]
 
 
-LOG = logging.getLogger(__name__)
+LOG = getLogger(__name__)
 
 
 class Sapphire(object):
@@ -46,19 +47,19 @@ def _create_listening_socket(allow_remote, requested_port, retries=20):
         for retry in reversed(range(retries)):
             sock = None
             try:
-                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                sock = socket(AF_INET, SOCK_STREAM)
+                sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
                 sock.settimeout(0.25)
                 # find an unused port and avoid blocked ports
                 # see: dxr.mozilla.org/mozilla-central/source/netwerk/base/nsIOService.cpp
-                port = random.randint(0x2000, 0xFFFF) if requested_port is None else requested_port
+                port = requested_port or randint(0x2000, 0xFFFF)
                 sock.bind(("0.0.0.0" if allow_remote else "127.0.0.1", port))
                 sock.listen(5)
-            except (OSError, socket.error) as soc_e:
+            except (OSError, sock_error) as soc_e:
                 if sock is not None:
                     sock.close()
-                if retry > 1 and soc_e.errno in (errno.EADDRINUSE, 10013):
-                    time.sleep(0.1)
+                if retry > 1 and soc_e.errno in (EADDRINUSE, 10013):
+                    sleep(0.1)
                     continue
                 raise
             break
@@ -131,8 +132,8 @@ def main(cls, args):
             with cls(allow_remote=args.remote, port=args.port, timeout=args.timeout) as serv:
                 LOG.info(
                     "Serving %r @ http://%s:%d/",
-                    os.path.abspath(args.path),
-                    socket.gethostname() if args.remote else "127.0.0.1",
+                    abspath(args.path),
+                    gethostname() if args.remote else "127.0.0.1",
                     serv.port)
                 status = serv.serve_path(args.path)[0]
             if status == SERVED_ALL:
diff --git a/sapphire/sapphire_load_manager.py b/sapphire/sapphire_load_manager.py
index 02236a70..36fd97a7 100644
--- a/sapphire/sapphire_load_manager.py
+++ b/sapphire/sapphire_load_manager.py
@@ -3,10 +3,10 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
-import sys
-import threading
-import time
-import traceback
+from sys import exc_info
+from threading import active_count, Thread, ThreadError
+from time import sleep, time
+from traceback import format_exception
 
 from .sapphire_worker import SapphireWorker
 
@@ -44,14 +44,14 @@ def close(self):
             exc_type, exc_obj, exc_tb = self._job.exceptions.get()
             LOG.error(
                 "Unexpected exception:\n%s",
-                "".join(traceback.format_exception(exc_type, exc_obj, exc_tb)))
+                "".join(format_exception(exc_type, exc_obj, exc_tb)))
             # re-raise exception from worker once all workers are closed
             raise exc_obj
 
     def start(self):
         assert self._job.pending
         # create the listener thread to handle incoming requests
-        listener = threading.Thread(
+        listener = Thread(
             target=self.listener,
             args=(self._socket, self._job, self._workers),
             kwargs={"shutdown_delay": self.SHUTDOWN_DELAY})
@@ -59,12 +59,12 @@ def start(self):
         for retry in reversed(range(10)):
             try:
                 listener.start()
-            except threading.ThreadError:
+            except ThreadError:
                 # thread errors can be due to low system resources while fuzzing
-                LOG.warning("ThreadError (listener), threads: %d", threading.active_count())
+                LOG.warning("ThreadError (listener), threads: %d", active_count())
                 if retry < 1:
                     raise
-                time.sleep(1)
+                sleep(1)
                 continue
             self._listener = listener
             break
@@ -72,7 +72,7 @@ def start(self):
     def wait(self, timeout, continue_cb=None, poll=0.5):
         assert self._listener is not None
         if timeout > 0:
-            deadline = time.time() + timeout
+            deadline = time() + timeout
         else:
             deadline = None
         if continue_cb is not None and not callable(continue_cb):
@@ -81,7 +81,7 @@ def wait(self, timeout, continue_cb=None, poll=0.5):
         # the total iteration rate of Grizzly
         while not self._job.is_complete(wait=poll):
             # check for a timeout
-            if deadline and deadline <= time.time():
+            if deadline and deadline <= time():
                 return False
             # check if callback returns False
             if continue_cb is not None and not continue_cb():
@@ -118,25 +118,25 @@ def listener(serv_sock, serv_job, max_workers, shutdown_delay=0):
                         pool_size = len(worker_pool)
                         if pool_size < max_workers:
                             break
-                        time.sleep(0.5)  # pragma: no cover
+                        sleep(0.5)  # pragma: no cover
                     else:  # pragma: no cover
                         # this should never happen
                         raise RuntimeError("Failed to trim worker pool!")
                     LOG.debug("trimmed worker pool (size: %d)", pool_size)
         except Exception:  # pylint: disable=broad-except
             if serv_job.exceptions.empty():
-                serv_job.exceptions.put(sys.exc_info())
+                serv_job.exceptions.put(exc_info())
             serv_job.finish()
         finally:
             LOG.debug("listener cleaning up workers")
-            deadline = time.time() + shutdown_delay
-            while time.time() < deadline:
+            deadline = time() + shutdown_delay
+            while time() < deadline:
                 worker_pool = list(w for w in worker_pool if not w.done)
                 if not worker_pool:
                     break
                 # avoid cutting off connections
                 LOG.debug("waiting for %d worker(s)...", len(worker_pool))
-                time.sleep(0.1)
+                sleep(0.1)
             else:  # pragma: no cover
                 LOG.debug("closing remaining workers")
                 for worker in (w for w in worker_pool if not w.done):
diff --git a/sapphire/server_map.py b/sapphire/server_map.py
index 8ada3433..47fb181c 100644
--- a/sapphire/server_map.py
+++ b/sapphire/server_map.py
@@ -3,16 +3,15 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-import logging
-import os
-import re
-
+from logging import getLogger
+from os.path import abspath, isdir, relpath
+from re import search as re_search
 
 __all__ = ("Resource", "ServerMap")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-LOG = logging.getLogger(__name__)  # pylint: disable=invalid-name
+LOG = getLogger(__name__)  # pylint: disable=invalid-name
 
 
 class InvalidURLError(Exception):
@@ -50,7 +49,7 @@ def __init__(self):
     def _check_url(url):
         # check and sanitize URL
         url = url.strip("/")
-        if re.search(r"\W", url) is not None:
+        if re_search(r"\W", url) is not None:
             raise InvalidURLError("Only alpha-numeric characters accepted in URL.")
         return url
 
@@ -70,11 +69,11 @@ def set_dynamic_response(self, url, callback, mime_type="application/octet-strea
 
     def set_include(self, url, target_path):
         url = self._check_url(url)
-        if not os.path.isdir(target_path):
+        if not isdir(target_path):
             raise IOError("Include path not found: %s" % (target_path,))
         if url in self.dynamic or url in self.redirect:
             raise MapCollisionError("URL collision on %r" % (url,))
-        target_path = os.path.abspath(target_path)
+        target_path = abspath(target_path)
         # sanity check to prevent mapping overlapping paths
         # Note: This was added to help map file served via includes back to
         # the files on disk. This is a temporary workaround until mapping of
@@ -83,10 +82,10 @@ def set_include(self, url, target_path):
             if url == existing_url:
                 # allow overwriting entry
                 continue
-            if not os.path.relpath(target_path, resource.target).startswith(".."):
+            if not relpath(target_path, resource.target).startswith(".."):
                 LOG.error("%r mapping includes path %r", existing_url, target_path)
                 raise MapCollisionError("%r and %r include %r" % (url, existing_url, target_path))
-            if not os.path.relpath(resource.target, target_path).startswith(".."):
+            if not relpath(resource.target, target_path).startswith(".."):
                 LOG.error("%r mapping includes path %r", url, resource.target)
                 raise MapCollisionError("%r and %r include %r" % (url, existing_url, resource.target))
         LOG.debug("mapping include %r -> %r", url, target_path)
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 0d82cd24..793f1812 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -11,8 +11,6 @@
 
 import pytest
 
-from grizzly.common import TestCase
-
 from .core import Sapphire
 from .sapphire_worker import SapphireWorker
 from .server_map import ServerMap
@@ -600,8 +598,8 @@ def test_sapphire_30(client, tmp_path):
 
 def test_sapphire_31(mocker):
     """test Sapphire._create_listening_socket()"""
-    fake_sleep = mocker.patch("sapphire.core.time.sleep", autospec=True)
-    fake_sock = mocker.patch("sapphire.core.socket.socket", autospec=True)
+    fake_sleep = mocker.patch("sapphire.core.sleep", autospec=True)
+    fake_sock = mocker.patch("sapphire.core.socket", autospec=True)
     assert Sapphire._create_listening_socket(False, None)
     assert fake_sock.return_value.close.call_count == 0
     assert fake_sock.return_value.setsockopt.call_count == 1
diff --git a/sapphire/test_sapphire_load_manager.py b/sapphire/test_sapphire_load_manager.py
index 6f5670f5..96785cfe 100644
--- a/sapphire/test_sapphire_load_manager.py
+++ b/sapphire/test_sapphire_load_manager.py
@@ -4,10 +4,10 @@
 """
 # pylint: disable=protected-access
 
-import socket
-import threading
+from socket import socket
+from threading import ThreadError
 
-import pytest
+from pytest import raises
 
 from .sapphire_load_manager import SapphireLoadManager
 from .sapphire_job import SapphireJob
@@ -17,9 +17,9 @@ def test_sapphire_load_manager_01(mocker, tmp_path):
     """test basic SapphireLoadManager"""
     (tmp_path / "testfile").write_bytes(b"test")
     job = SapphireJob(str(tmp_path))
-    clnt_sock = mocker.Mock(spec=socket.socket)
+    clnt_sock = mocker.Mock(spec=socket)
     clnt_sock.recv.return_value = b"GET /testfile HTTP/1.1"
-    serv_sock = mocker.Mock(spec=socket.socket)
+    serv_sock = mocker.Mock(spec=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
     assert not job.is_complete()
     with SapphireLoadManager(job, serv_sock) as loadmgr:
@@ -31,13 +31,13 @@ def test_sapphire_load_manager_01(mocker, tmp_path):
 
 def test_sapphire_load_manager_02(mocker):
     """test SapphireLoadManager.start() failure"""
-    mocker.patch("sapphire.sapphire_load_manager.time.sleep", autospec=True)
-    fake_thread = mocker.patch("sapphire.sapphire_load_manager.threading.Thread", autospec=True)
-    fake_thread.return_value.start.side_effect = threading.ThreadError
+    mocker.patch("sapphire.sapphire_load_manager.sleep", autospec=True)
+    fake_thread = mocker.patch("sapphire.sapphire_load_manager.Thread", autospec=True)
+    fake_thread.return_value.start.side_effect = ThreadError
     job = mocker.Mock(spec=SapphireJob)
     job.pending = True
     loadmgr = SapphireLoadManager(job, None)
-    with pytest.raises(threading.ThreadError):
+    with raises(ThreadError):
         loadmgr.start()
     loadmgr.close()
     assert job.is_complete()
@@ -48,7 +48,7 @@ def test_sapphire_load_manager_03(mocker, tmp_path):
     (tmp_path / "test2").touch()
     (tmp_path / "test3").touch()
     job = SapphireJob(str(tmp_path))
-    clnt_sock = mocker.Mock(spec=socket.socket)
+    clnt_sock = mocker.Mock(spec=socket)
     clnt_sock.recv.side_effect = (
         b"GET /test1 HTTP/1.1",
         b"GET /missing HTTP/1.1",
@@ -58,7 +58,7 @@ def test_sapphire_load_manager_03(mocker, tmp_path):
         b"GET /test1 HTTP/1.1",
         b"GET /test1 HTTP/1.1",
         b"GET /test3 HTTP/1.1")
-    serv_sock = mocker.Mock(spec=socket.socket)
+    serv_sock = mocker.Mock(spec=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
     assert not job.is_complete()
     with SapphireLoadManager(job, serv_sock, max_workers=2) as loadmgr:
@@ -70,20 +70,20 @@ def test_sapphire_load_manager_04(mocker, tmp_path):
     """test SapphireLoadManager.wait()"""
     (tmp_path / "test1").touch()
     job = SapphireJob(str(tmp_path))
-    clnt_sock = mocker.Mock(spec=socket.socket)
+    clnt_sock = mocker.Mock(spec=socket)
     clnt_sock.recv.return_value = b""
-    serv_sock = mocker.Mock(spec=socket.socket)
+    serv_sock = mocker.Mock(spec=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
     with SapphireLoadManager(job, serv_sock, max_workers=10) as loadmgr:
         # invalid callback
-        with pytest.raises(TypeError, match="continue_cb must be callable"):
+        with raises(TypeError, match="continue_cb must be callable"):
             loadmgr.wait(0, continue_cb="test")
         # callback abort
         assert loadmgr.wait(1, continue_cb=lambda: False, poll=0.01)
     # timeout
     job = SapphireJob(str(tmp_path))
     fake_time = mocker.patch("sapphire.sapphire_load_manager.time", autospec=True)
-    fake_time.time.side_effect = (1, 2, 3)
+    fake_time.side_effect = (1, 2, 3)
     with SapphireLoadManager(job, serv_sock, max_workers=10) as loadmgr:
         assert not loadmgr.wait(1, continue_cb=lambda: False, poll=0.01)
 
@@ -91,11 +91,11 @@ def test_sapphire_load_manager_05(mocker, tmp_path):
     """test SapphireLoadManager re-raise worker exceptions"""
     (tmp_path / "test1").touch()
     job = SapphireJob(str(tmp_path))
-    clnt_sock = mocker.Mock(spec=socket.socket)
+    clnt_sock = mocker.Mock(spec=socket)
     clnt_sock.recv.side_effect = Exception("worker exception")
-    serv_sock = mocker.Mock(spec=socket.socket)
+    serv_sock = mocker.Mock(spec=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
-    with pytest.raises(Exception, match="worker exception"):
+    with raises(Exception, match="worker exception"):
         with SapphireLoadManager(job, serv_sock) as loadmgr:
             loadmgr.wait(1)
     assert clnt_sock.close.call_count == 1
@@ -106,9 +106,9 @@ def test_sapphire_load_manager_06(mocker, tmp_path):
     """test SapphireLoadManager re-raise launcher exceptions"""
     (tmp_path / "test1").touch()
     job = SapphireJob(str(tmp_path))
-    serv_sock = mocker.Mock(spec=socket.socket)
+    serv_sock = mocker.Mock(spec=socket)
     serv_sock.accept.side_effect = Exception("launcher exception")
-    with pytest.raises(Exception, match="launcher exception"):
+    with raises(Exception, match="launcher exception"):
         with SapphireLoadManager(job, serv_sock) as loadmgr:
             loadmgr.wait(1)
     assert job.is_complete()

From cd3e47792ce2525355b400e3dc6fdcdec567807a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Oct 2020 13:54:33 -0700
Subject: [PATCH 031/531] [sapphire] Modules and Classes

---
 ..._load_manager.py => connection_manager.py} |  6 +-
 sapphire/core.py                              |  8 +-
 sapphire/{sapphire_job.py => job.py}          |  2 +-
 ..._manager.py => test_connection_manager.py} | 64 ++++++++--------
 .../{test_sapphire_job.py => test_job.py}     | 76 +++++++++----------
 sapphire/test_sapphire.py                     | 10 +--
 ...test_sapphire_worker.py => test_worker.py} | 56 +++++++-------
 sapphire/{sapphire_worker.py => worker.py}    | 10 +--
 8 files changed, 116 insertions(+), 116 deletions(-)
 rename sapphire/{sapphire_load_manager.py => connection_manager.py} (97%)
 rename sapphire/{sapphire_job.py => job.py} (99%)
 rename sapphire/{test_sapphire_load_manager.py => test_connection_manager.py} (61%)
 rename sapphire/{test_sapphire_job.py => test_job.py} (82%)
 rename sapphire/{test_sapphire_worker.py => test_worker.py} (65%)
 rename sapphire/{sapphire_worker.py => worker.py} (97%)

diff --git a/sapphire/sapphire_load_manager.py b/sapphire/connection_manager.py
similarity index 97%
rename from sapphire/sapphire_load_manager.py
rename to sapphire/connection_manager.py
index 36fd97a7..3d1035d4 100644
--- a/sapphire/sapphire_load_manager.py
+++ b/sapphire/connection_manager.py
@@ -8,7 +8,7 @@
 from time import sleep, time
 from traceback import format_exception
 
-from .sapphire_worker import SapphireWorker
+from .worker import Worker
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
@@ -16,7 +16,7 @@
 LOG = getLogger(__name__)
 
 
-class SapphireLoadManager(object):
+class ConnectionManager(object):
     SHUTDOWN_DELAY = 0.5  # allow extra time before closing socket if needed
 
     __slots__ = ("_job", "_listener", "_socket", "_workers")
@@ -100,7 +100,7 @@ def listener(serv_sock, serv_job, max_workers, shutdown_delay=0):
             while not serv_job.is_complete():
                 if not serv_job.accepting.wait(0.05):
                     continue
-                worker = SapphireWorker.launch(serv_sock, serv_job)
+                worker = Worker.launch(serv_sock, serv_job)
                 if worker is not None:
                     worker_pool.append(worker)
                     pool_size += 1
diff --git a/sapphire/core.py b/sapphire/core.py
index 8bb37ea6..6742c7cb 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -13,8 +13,8 @@
 from socket import error as sock_error, gethostname, socket
 from time import sleep
 
-from .sapphire_job import SapphireJob
-from .sapphire_load_manager import SapphireLoadManager
+from .job import Job
+from .connection_manager import ConnectionManager
 from .status_codes import SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT
 
 
@@ -100,7 +100,7 @@ def serve_path(self, path, continue_cb=None, forever=False, optional_files=None,
         files served is a list of the files that were served
         """
         LOG.debug("serving %r (forever=%r)", path, forever)
-        job = SapphireJob(
+        job = Job(
             path,
             auto_close=self._auto_close,
             forever=forever,
@@ -110,7 +110,7 @@ def serve_path(self, path, continue_cb=None, forever=False, optional_files=None,
             job.finish()
             LOG.debug("nothing to serve")
             return (SERVED_NONE, tuple())
-        with SapphireLoadManager(job, self._socket, self._max_workers) as loadmgr:
+        with ConnectionManager(job, self._socket, self._max_workers) as loadmgr:
             was_timeout = not loadmgr.wait(self.timeout, continue_cb=continue_cb)
         LOG.debug("status: %r, timeout: %r", job.status, was_timeout)
         return (SERVED_TIMEOUT if was_timeout else job.status, tuple(job.served))
diff --git a/sapphire/sapphire_job.py b/sapphire/job.py
similarity index 99%
rename from sapphire/sapphire_job.py
rename to sapphire/job.py
index c29b8d40..ddea30b9 100644
--- a/sapphire/sapphire_job.py
+++ b/sapphire/job.py
@@ -25,7 +25,7 @@
 Tracker = namedtuple("Tracker", "files lock")
 
 
-class SapphireJob(object):
+class Job(object):
     # MIME_MAP is used to support new or uncommon mime types.
     # Definitions in here take priority over mimetypes.guess_type().
     MIME_MAP = {
diff --git a/sapphire/test_sapphire_load_manager.py b/sapphire/test_connection_manager.py
similarity index 61%
rename from sapphire/test_sapphire_load_manager.py
rename to sapphire/test_connection_manager.py
index 96785cfe..c9c3c3a8 100644
--- a/sapphire/test_sapphire_load_manager.py
+++ b/sapphire/test_connection_manager.py
@@ -1,6 +1,6 @@
 # coding=utf-8
 """
-SapphireLoadManager unit tests
+ConnectionManager unit tests
 """
 # pylint: disable=protected-access
 
@@ -9,45 +9,45 @@
 
 from pytest import raises
 
-from .sapphire_load_manager import SapphireLoadManager
-from .sapphire_job import SapphireJob
+from .connection_manager import ConnectionManager
+from .job import Job
 
 
-def test_sapphire_load_manager_01(mocker, tmp_path):
-    """test basic SapphireLoadManager"""
+def test_connection_manager_01(mocker, tmp_path):
+    """test basic ConnectionManager"""
     (tmp_path / "testfile").write_bytes(b"test")
-    job = SapphireJob(str(tmp_path))
+    job = Job(str(tmp_path))
     clnt_sock = mocker.Mock(spec=socket)
     clnt_sock.recv.return_value = b"GET /testfile HTTP/1.1"
     serv_sock = mocker.Mock(spec=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
     assert not job.is_complete()
-    with SapphireLoadManager(job, serv_sock) as loadmgr:
+    with ConnectionManager(job, serv_sock) as loadmgr:
         assert loadmgr.wait(1)
     assert clnt_sock.close.call_count == 1
     assert job.is_complete()
     assert not job.accepting.is_set()
     assert job.exceptions.empty()
 
-def test_sapphire_load_manager_02(mocker):
-    """test SapphireLoadManager.start() failure"""
-    mocker.patch("sapphire.sapphire_load_manager.sleep", autospec=True)
-    fake_thread = mocker.patch("sapphire.sapphire_load_manager.Thread", autospec=True)
+def test_connection_manager_02(mocker):
+    """test ConnectionManager.start() failure"""
+    mocker.patch("sapphire.connection_manager.sleep", autospec=True)
+    fake_thread = mocker.patch("sapphire.connection_manager.Thread", autospec=True)
     fake_thread.return_value.start.side_effect = ThreadError
-    job = mocker.Mock(spec=SapphireJob)
+    job = mocker.Mock(spec=Job)
     job.pending = True
-    loadmgr = SapphireLoadManager(job, None)
+    loadmgr = ConnectionManager(job, None)
     with raises(ThreadError):
         loadmgr.start()
     loadmgr.close()
     assert job.is_complete()
 
-def test_sapphire_load_manager_03(mocker, tmp_path):
-    """test SapphireLoadManager multiple files and requests"""
+def test_connection_manager_03(mocker, tmp_path):
+    """test ConnectionManager multiple files and requests"""
     (tmp_path / "test1").touch()
     (tmp_path / "test2").touch()
     (tmp_path / "test3").touch()
-    job = SapphireJob(str(tmp_path))
+    job = Job(str(tmp_path))
     clnt_sock = mocker.Mock(spec=socket)
     clnt_sock.recv.side_effect = (
         b"GET /test1 HTTP/1.1",
@@ -61,55 +61,55 @@ def test_sapphire_load_manager_03(mocker, tmp_path):
     serv_sock = mocker.Mock(spec=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
     assert not job.is_complete()
-    with SapphireLoadManager(job, serv_sock, max_workers=2) as loadmgr:
+    with ConnectionManager(job, serv_sock, max_workers=2) as loadmgr:
         assert loadmgr.wait(1)
     assert clnt_sock.close.call_count == 8
     assert job.is_complete()
 
-def test_sapphire_load_manager_04(mocker, tmp_path):
-    """test SapphireLoadManager.wait()"""
+def test_connection_manager_04(mocker, tmp_path):
+    """test ConnectionManager.wait()"""
     (tmp_path / "test1").touch()
-    job = SapphireJob(str(tmp_path))
+    job = Job(str(tmp_path))
     clnt_sock = mocker.Mock(spec=socket)
     clnt_sock.recv.return_value = b""
     serv_sock = mocker.Mock(spec=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
-    with SapphireLoadManager(job, serv_sock, max_workers=10) as loadmgr:
+    with ConnectionManager(job, serv_sock, max_workers=10) as loadmgr:
         # invalid callback
         with raises(TypeError, match="continue_cb must be callable"):
             loadmgr.wait(0, continue_cb="test")
         # callback abort
         assert loadmgr.wait(1, continue_cb=lambda: False, poll=0.01)
     # timeout
-    job = SapphireJob(str(tmp_path))
-    fake_time = mocker.patch("sapphire.sapphire_load_manager.time", autospec=True)
+    job = Job(str(tmp_path))
+    fake_time = mocker.patch("sapphire.connection_manager.time", autospec=True)
     fake_time.side_effect = (1, 2, 3)
-    with SapphireLoadManager(job, serv_sock, max_workers=10) as loadmgr:
+    with ConnectionManager(job, serv_sock, max_workers=10) as loadmgr:
         assert not loadmgr.wait(1, continue_cb=lambda: False, poll=0.01)
 
-def test_sapphire_load_manager_05(mocker, tmp_path):
-    """test SapphireLoadManager re-raise worker exceptions"""
+def test_connection_manager_05(mocker, tmp_path):
+    """test ConnectionManager re-raise worker exceptions"""
     (tmp_path / "test1").touch()
-    job = SapphireJob(str(tmp_path))
+    job = Job(str(tmp_path))
     clnt_sock = mocker.Mock(spec=socket)
     clnt_sock.recv.side_effect = Exception("worker exception")
     serv_sock = mocker.Mock(spec=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
     with raises(Exception, match="worker exception"):
-        with SapphireLoadManager(job, serv_sock) as loadmgr:
+        with ConnectionManager(job, serv_sock) as loadmgr:
             loadmgr.wait(1)
     assert clnt_sock.close.call_count == 1
     assert job.is_complete()
     assert job.exceptions.empty()
 
-def test_sapphire_load_manager_06(mocker, tmp_path):
-    """test SapphireLoadManager re-raise launcher exceptions"""
+def test_connection_manager_06(mocker, tmp_path):
+    """test ConnectionManager re-raise launcher exceptions"""
     (tmp_path / "test1").touch()
-    job = SapphireJob(str(tmp_path))
+    job = Job(str(tmp_path))
     serv_sock = mocker.Mock(spec=socket)
     serv_sock.accept.side_effect = Exception("launcher exception")
     with raises(Exception, match="launcher exception"):
-        with SapphireLoadManager(job, serv_sock) as loadmgr:
+        with ConnectionManager(job, serv_sock) as loadmgr:
             loadmgr.wait(1)
     assert job.is_complete()
     assert job.exceptions.empty()
diff --git a/sapphire/test_sapphire_job.py b/sapphire/test_job.py
similarity index 82%
rename from sapphire/test_sapphire_job.py
rename to sapphire/test_job.py
index 658dccdc..30cdbc8d 100644
--- a/sapphire/test_sapphire_job.py
+++ b/sapphire/test_job.py
@@ -1,6 +1,6 @@
 # coding=utf-8
 """
-SapphireJob unit tests
+Job unit tests
 """
 # pylint: disable=protected-access
 
@@ -8,14 +8,14 @@
 
 import pytest
 
-from .sapphire_job import SapphireJob
+from .job import Job
 from .server_map import Resource, ServerMap
 from .status_codes import SERVED_ALL, SERVED_NONE, SERVED_REQUEST
 
 
-def test_sapphire_job_01(tmp_path):
-    """test creating an empty SapphireJob"""
-    job = SapphireJob(str(tmp_path))
+def test_job_01(tmp_path):
+    """test creating an empty Job"""
+    job = Job(str(tmp_path))
     assert not job.forever
     assert job.status == SERVED_ALL
     assert job.check_request("") is None
@@ -31,8 +31,8 @@ def test_sapphire_job_01(tmp_path):
     assert not any(job.served)
     assert job.is_complete()
 
-def test_sapphire_job_02(tmp_path):
-    """test SapphireJob two required files and one optional file"""
+def test_job_02(tmp_path):
+    """test Job two required files and one optional file"""
     opt_path = tmp_path / "opt_file.txt"
     opt_path.write_bytes(b"a")
     req1_path = tmp_path / "req_file_1.txt"
@@ -40,7 +40,7 @@ def test_sapphire_job_02(tmp_path):
     (tmp_path / "test").mkdir()
     req2_path = tmp_path / "test" / "req_file_2.txt"
     req2_path.write_bytes(b"a")
-    job = SapphireJob(str(tmp_path), optional_files=[opt_path.name])
+    job = Job(str(tmp_path), optional_files=[opt_path.name])
     assert job.status == SERVED_NONE
     assert not job.is_complete()
     resource = job.check_request("req_file_1.txt")
@@ -65,12 +65,12 @@ def test_sapphire_job_02(tmp_path):
     job.finish()
     assert job.is_complete()
 
-def test_sapphire_job_03(tmp_path):
-    """test SapphireJob redirects"""
+def test_job_03(tmp_path):
+    """test Job redirects"""
     smap = ServerMap()
     smap.set_redirect("one", "somefile.txt", required=False)
     smap.set_redirect("two", "reqfile.txt")
-    job = SapphireJob(str(tmp_path), server_map=smap)
+    job = Job(str(tmp_path), server_map=smap)
     assert job.status == SERVED_NONE
     resource = job.check_request("one")
     assert resource.type == Resource.URL_REDIRECT
@@ -81,8 +81,8 @@ def test_sapphire_job_03(tmp_path):
     assert job.remove_pending("two")
     assert job.pending == 0
 
-def test_sapphire_job_04(mocker, tmp_path):
-    """test SapphireJob includes"""
+def test_job_04(mocker, tmp_path):
+    """test Job includes"""
     srv_root = tmp_path / "root"
     srv_include = tmp_path / "test"
     srv_include_2 = tmp_path / "test_2"
@@ -109,7 +109,7 @@ def test_sapphire_job_04(mocker, tmp_path):
     smap.include["testinc/1/2/3"] = Resource(Resource.URL_INCLUDE, str(srv_include))
     smap.include[""] = Resource(Resource.URL_INCLUDE, str(srv_include))
     smap.set_include("testinc/inc2", str(srv_include_2))
-    job = SapphireJob(str(srv_root), server_map=smap)
+    job = Job(str(srv_root), server_map=smap)
     assert job.status == SERVED_NONE
     # test includes that map to 'srv_include'
     for incl, inc_path in smap.include.items():
@@ -133,8 +133,8 @@ def test_sapphire_job_04(mocker, tmp_path):
     assert not job.is_forbidden(str(srv_root / ".." / "test" / "test_file.txt"))
     assert not job.is_forbidden(str(srv_include / ".." / "root" / "req_file.txt"))
 
-def test_sapphire_job_05(tmp_path):
-    """test SapphireJob.check_request() with tricky includes"""
+def test_job_05(tmp_path):
+    """test Job.check_request() with tricky includes"""
     srv_root = tmp_path / "root"
     srv_root.mkdir()
     req = srv_root / "req_file.txt"
@@ -149,7 +149,7 @@ def test_sapphire_job_05(tmp_path):
     # test url matching part of the file name
     smap = ServerMap()
     smap.include["inc"] = Resource(Resource.URL_INCLUDE, str(inc_dir))
-    job = SapphireJob(str(srv_root), server_map=smap)
+    job = Job(str(srv_root), server_map=smap)
     resource = job.check_request("inc/sub/include.js")
     assert resource.type == Resource.URL_INCLUDE
     assert resource.target == str(inc_file1)
@@ -179,12 +179,12 @@ def test_sapphire_job_05(tmp_path):
     #assert resource.type == Resource.URL_INCLUDE
     #assert resource.target == str(inc_c_d)
 
-def test_sapphire_job_06(tmp_path):
-    """test SapphireJob dynamic"""
+def test_job_06(tmp_path):
+    """test Job dynamic"""
     smap = ServerMap()
     smap.set_dynamic_response("cb1", lambda: 0, mime_type="mime_type")
     smap.set_dynamic_response("cb2", lambda: 1)
-    job = SapphireJob(str(tmp_path), server_map=smap)
+    job = Job(str(tmp_path), server_map=smap)
     assert job.status == SERVED_ALL
     assert job.pending == 0
     resource = job.check_request("cb1")
@@ -197,7 +197,7 @@ def test_sapphire_job_06(tmp_path):
     assert callable(resource.target)
     assert isinstance(resource.mime, str)
 
-def test_sapphire_job_07(tmp_path):
+def test_job_07(tmp_path):
     """test accessing forbidden files"""
     srv_root = tmp_path / "root"
     srv_root.mkdir()
@@ -205,7 +205,7 @@ def test_sapphire_job_07(tmp_path):
     test_1.write_bytes(b"a")
     no_access = tmp_path / "no_access.txt"
     no_access.write_bytes(b"a")
-    job = SapphireJob(str(srv_root))
+    job = Job(str(srv_root))
     assert job.status == SERVED_NONE
     assert job.pending == 1
     resource = job.check_request("../no_access.txt")
@@ -216,35 +216,35 @@ def test_sapphire_job_07(tmp_path):
 
 @pytest.mark.skipif(platform.system() == "Windows",
                     reason="Unsupported on Windows")
-def test_sapphire_job_08(tmp_path):
-    """test SapphireJob with file names containing invalid characters"""
+def test_job_08(tmp_path):
+    """test Job with file names containing invalid characters"""
     test_file = tmp_path / "test.txt"
     test_file.write_bytes(b"a")
     (tmp_path / "?_2.txt").write_bytes(b"a")
-    job = SapphireJob(str(tmp_path))
+    job = Job(str(tmp_path))
     assert job.status == SERVED_NONE
     assert job.pending == 1
     assert job.check_request("test.txt").target == str(test_file)
 
-def test_sapphire_job_09():
-    """test SapphireJob with missing directory"""
+def test_job_09():
+    """test Job with missing directory"""
     with pytest.raises(OSError):
-        SapphireJob("missing")
+        Job("missing")
 
-def test_sapphire_job_10(tmp_path):
-    """test SapphireJob.increment_served() and SapphireJob.served"""
-    job = SapphireJob(str(tmp_path))
+def test_job_10(tmp_path):
+    """test Job.increment_served() and Job.served"""
+    job = Job(str(tmp_path))
     assert not any(job.served)
     job.increment_served(str(tmp_path / "file.bin"))
     assert "file.bin" in job.served
     job.increment_served("/some/include/path/inc.bin")
     assert "/some/include/path/inc.bin" in job.served
 
-def test_sapphire_job_11():
-    """test SapphireJob.lookup_mime()"""
-    assert SapphireJob.lookup_mime("unknown") == "application/octet-stream"
-    # look up from SapphireJob.MIME_MAP
-    assert ".avif" in SapphireJob.MIME_MAP, "test is broken"
-    assert SapphireJob.lookup_mime("test.avif") == "image/avif"
+def test_job_11():
+    """test Job.lookup_mime()"""
+    assert Job.lookup_mime("unknown") == "application/octet-stream"
+    # look up from Job.MIME_MAP
+    assert ".avif" in Job.MIME_MAP, "test is broken"
+    assert Job.lookup_mime("test.avif") == "image/avif"
     # look up known ext
-    assert SapphireJob.lookup_mime("test.html") == "text/html"
+    assert Job.lookup_mime("test.html") == "text/html"
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 793f1812..36f3569e 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -12,7 +12,7 @@
 import pytest
 
 from .core import Sapphire
-from .sapphire_worker import SapphireWorker
+from .worker import Worker
 from .server_map import ServerMap
 from .status_codes import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
 
@@ -186,10 +186,10 @@ def is_running():
 def test_sapphire_09(client, tmp_path):
     """test serving interesting sized files"""
     tests = [
-        {"size": SapphireWorker.DEFAULT_TX_SIZE, "name": "even.html"},
-        {"size": SapphireWorker.DEFAULT_TX_SIZE - 1, "name": "minus_one.html"},
-        {"size": SapphireWorker.DEFAULT_TX_SIZE + 1, "name": "plus_one.html"},
-        {"size": SapphireWorker.DEFAULT_TX_SIZE * 2, "name": "double.html"},
+        {"size": Worker.DEFAULT_TX_SIZE, "name": "even.html"},
+        {"size": Worker.DEFAULT_TX_SIZE - 1, "name": "minus_one.html"},
+        {"size": Worker.DEFAULT_TX_SIZE + 1, "name": "plus_one.html"},
+        {"size": Worker.DEFAULT_TX_SIZE * 2, "name": "double.html"},
         {"size": 1, "name": "one.html"},
         {"size": 0, "name": "zero.html"},
     ]
diff --git a/sapphire/test_sapphire_worker.py b/sapphire/test_worker.py
similarity index 65%
rename from sapphire/test_sapphire_worker.py
rename to sapphire/test_worker.py
index 03aad2b8..db9bf980 100644
--- a/sapphire/test_sapphire_worker.py
+++ b/sapphire/test_worker.py
@@ -9,14 +9,14 @@
 
 import pytest
 
-from .sapphire_job import SapphireJob
-from .sapphire_worker import SapphireWorker, SapphireWorkerError
+from .job import Job
+from .worker import Worker, WorkerError
 
-def test_sapphire_worker_01(mocker):
-    """test simple SapphireWorker in running state"""
+def test_worker_01(mocker):
+    """test simple Worker in running state"""
     wthread = mocker.Mock(spec=threading.Thread)
     wthread.is_alive.return_value = True
-    worker = SapphireWorker(mocker.Mock(spec=socket.socket), wthread)
+    worker = Worker(mocker.Mock(spec=socket.socket), wthread)
     assert worker._conn is not None
     assert worker._thread is not None
     # it is assumed that launch() has already been called at this point
@@ -33,44 +33,44 @@ def test_sapphire_worker_01(mocker):
     assert worker._thread is None
     assert worker.done
 
-def test_sapphire_worker_02(mocker):
-    """test simple SapphireWorker fails to close"""
-    worker = SapphireWorker(
+def test_worker_02(mocker):
+    """test simple Worker fails to close"""
+    worker = Worker(
         mocker.Mock(spec=socket.socket),
         mocker.Mock(spec=threading.Thread))
     # it is assumed that launch() has already been called at this point
     worker._thread.is_alive.return_value = True
-    with pytest.raises(SapphireWorkerError, match="Worker thread failed to join!"):
+    with pytest.raises(WorkerError, match="Worker thread failed to join!"):
         worker.close()
 
-def test_sapphire_worker_03(mocker):
-    """test SapphireWorker.launch() fail cases"""
+def test_worker_03(mocker):
+    """test Worker.launch() fail cases"""
     serv_con = mocker.Mock(spec=socket.socket)
-    serv_job = mocker.Mock(spec=SapphireJob)
-    fake_thread = mocker.patch("sapphire.sapphire_worker.Thread", autospec=True)
-    mocker.patch("sapphire.sapphire_worker.sleep", autospec=True)
+    serv_job = mocker.Mock(spec=Job)
+    fake_thread = mocker.patch("sapphire.worker.Thread", autospec=True)
+    mocker.patch("sapphire.worker.sleep", autospec=True)
 
     serv_con.accept.side_effect = socket.timeout
-    assert SapphireWorker.launch(serv_con, serv_job) is None
+    assert Worker.launch(serv_con, serv_job) is None
 
     serv_con.accept.side_effect = None
     conn = mocker.Mock(spec=socket.socket)
     serv_con.accept.return_value = (conn, None)
     fake_thread.side_effect = threading.ThreadError
-    assert SapphireWorker.launch(serv_con, serv_job) is None
+    assert Worker.launch(serv_con, serv_job) is None
     assert conn.close.call_count == 1
     assert serv_job.accepting.clear.call_count == 0
     assert serv_job.accepting.set.call_count == 1
 
-def test_sapphire_worker_04(mocker, tmp_path):
-    """test SapphireWorker.launch()"""
+def test_worker_04(mocker, tmp_path):
+    """test Worker.launch()"""
     (tmp_path / "testfile").touch()
-    job = SapphireJob(str(tmp_path))
+    job = Job(str(tmp_path))
     clnt_sock = mocker.Mock(spec=socket.socket)
     clnt_sock.recv.return_value = b"GET /testfile HTTP/1.1"
     serv_sock = mocker.Mock(spec=socket.socket)
     serv_sock.accept.return_value = (clnt_sock, None)
-    worker = SapphireWorker.launch(serv_sock, job)
+    worker = Worker.launch(serv_sock, job)
     assert worker is not None
     try:
         assert job.is_complete(wait=1)
@@ -80,37 +80,37 @@ def test_sapphire_worker_04(mocker, tmp_path):
     assert serv_sock.accept.call_count == 1
     assert clnt_sock.close.call_count == 2
 
-def test_sapphire_worker_05(mocker):
-    """test SapphireWorker.handle_request() socket errors"""
+def test_worker_05(mocker):
+    """test Worker.handle_request() socket errors"""
     serv_con = mocker.Mock(spec=socket.socket)
     serv_con.recv.side_effect = socket.error
-    serv_job = mocker.Mock(spec=SapphireJob)
-    SapphireWorker.handle_request(serv_con, serv_job)
+    serv_job = mocker.Mock(spec=Job)
+    Worker.handle_request(serv_con, serv_job)
     assert serv_job.accepting.set.call_count == 1
     assert serv_con.sendall.call_count == 0
     assert serv_con.close.call_count == 1
 
 def test_response_data_01():
     """test _200_header()"""
-    output = SapphireWorker._200_header(10, "text/html")
+    output = Worker._200_header(10, "text/html")
     assert b"Content-Length: 10" in output
     assert b"Content-Type: text/html" in output
 
 def test_response_data_02():
     """test _307_redirect()"""
-    output = SapphireWorker._307_redirect("http://some.test.url")
+    output = Worker._307_redirect("http://some.test.url")
     assert b"Location: http://some.test.url" in output
 
 def test_response_data_03():
     """test _4xx_page() without close timeout"""
-    output = SapphireWorker._4xx_page(400, "Bad Request")
+    output = Worker._4xx_page(400, "Bad Request")
     assert b"Content-Length: " in output
     assert b"HTTP/1.1 400 Bad Request" in output
     assert b"400!" in output
 
 def test_response_data_04():
     """test _4xx_page() with close timeout"""
-    output = SapphireWorker._4xx_page(404, "Not Found", close=10)
+    output = Worker._4xx_page(404, "Not Found", close=10)
     assert b"Content-Length: " in output
     assert b"HTTP/1.1 404 Not Found" in output
     assert b"<script>window.setTimeout(window.close, 10000)</script>" in output
diff --git a/sapphire/sapphire_worker.py b/sapphire/worker.py
similarity index 97%
rename from sapphire/sapphire_worker.py
rename to sapphire/worker.py
index 6bc46d5a..5d892f21 100644
--- a/sapphire/sapphire_worker.py
+++ b/sapphire/worker.py
@@ -23,11 +23,11 @@
 LOG = getLogger(__name__)
 
 
-class SapphireWorkerError(Exception):
-    """Raised by SapphireWorker"""
+class WorkerError(Exception):
+    """Raised by Worker"""
 
 
-class SapphireWorker(object):
+class Worker(object):
     DEFAULT_REQUEST_LIMIT = 0x1000  # 4KB
     DEFAULT_TX_SIZE = 0x10000  # 64KB
     REQ_PATTERN = re_compile(b"^GET\\s/(?P<request>\\S*)\\sHTTP/1")
@@ -77,7 +77,7 @@ def close(self):
         self.join(timeout=60)
         if self._thread is not None and self._thread.is_alive():
             # this is here to catch unexpected hangs
-            raise SapphireWorkerError("Worker thread failed to join!")
+            raise WorkerError("Worker thread failed to join!")
 
     @property
     def done(self):
@@ -115,7 +115,7 @@ def handle_request(cls, conn, serv_job):
                 finish_job = serv_job.remove_pending(request)
             elif resource.type != Resource.URL_DYNAMIC:  # pragma: no cover
                 # this should never happen
-                raise SapphireWorkerError("Unknown resource type %r" % (resource.type,))
+                raise WorkerError("Unknown resource type %r" % (resource.type,))
 
             if finish_job and serv_job.forever:
                 LOG.debug("serv_job.forever is set, resetting finish_job")

From 4a45df176de7754bea5af6781ca25c76260b5204 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Oct 2020 14:01:38 -0700
Subject: [PATCH 032/531] [sapphire] Add __slots__ to Sapphire

---
 sapphire/core.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/sapphire/core.py b/sapphire/core.py
index 6742c7cb..5a607329 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -26,6 +26,8 @@
 
 
 class Sapphire(object):
+    __slots__ = ("_auto_close", "_max_workers", "_socket", "_timeout")
+
     def __init__(self, allow_remote=False, auto_close=-1, max_workers=10, port=None, timeout=60):
         self._auto_close = auto_close  # call 'window.close()' on 4xx error pages
         self._max_workers = max_workers  # limit worker threads

From bd1fcf088059e81215d93a2dfeb951a77c2cf673 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Oct 2020 14:13:58 -0700
Subject: [PATCH 033/531] [sapphire] Move status codes to job.py

---
 sapphire/__init__.py      | 2 +-
 sapphire/core.py          | 3 +--
 sapphire/job.py           | 8 +++++++-
 sapphire/status_codes.py  | 9 ---------
 sapphire/test_job.py      | 3 +--
 sapphire/test_sapphire.py | 2 +-
 6 files changed, 11 insertions(+), 16 deletions(-)
 delete mode 100644 sapphire/status_codes.py

diff --git a/sapphire/__init__.py b/sapphire/__init__.py
index 7f4370ce..49c6cb9f 100644
--- a/sapphire/__init__.py
+++ b/sapphire/__init__.py
@@ -7,8 +7,8 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from .core import Sapphire
+from .job import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
 from .server_map import ServerMap
-from .status_codes import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
 
 __all__ = ("Sapphire", "SERVED_ALL", "SERVED_NONE", "SERVED_REQUEST", "SERVED_TIMEOUT", "ServerMap")
 __author__ = "Tyson Smith"
diff --git a/sapphire/core.py b/sapphire/core.py
index 5a607329..2df8cdf2 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -13,9 +13,8 @@
 from socket import error as sock_error, gethostname, socket
 from time import sleep
 
-from .job import Job
+from .job import Job, SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT
 from .connection_manager import ConnectionManager
-from .status_codes import SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT
 
 
 __author__ = "Tyson Smith"
diff --git a/sapphire/job.py b/sapphire/job.py
index ddea30b9..625f533a 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -14,7 +14,6 @@
 from threading import Event, Lock
 
 from .server_map import Resource
-from .status_codes import SERVED_ALL, SERVED_NONE, SERVED_REQUEST
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
@@ -22,6 +21,13 @@
 LOG = getLogger(__name__)
 
 
+# job status codes
+SERVED_ALL = 0      # all expected requests for required files have been received
+SERVED_NONE = 1     # no requests for required files have been received
+SERVED_REQUEST = 2  # some requests for required files have been received
+SERVED_TIMEOUT = 3  # timeout occurred
+
+
 Tracker = namedtuple("Tracker", "files lock")
 
 
diff --git a/sapphire/status_codes.py b/sapphire/status_codes.py
deleted file mode 100644
index ef95b4ce..00000000
--- a/sapphire/status_codes.py
+++ /dev/null
@@ -1,9 +0,0 @@
-# coding=utf-8
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-SERVED_ALL = 0      # all expected requests for required files have been received
-SERVED_NONE = 1     # no requests for required files have been received
-SERVED_REQUEST = 2  # some requests for required files have been received
-SERVED_TIMEOUT = 3  # timeout occurred
diff --git a/sapphire/test_job.py b/sapphire/test_job.py
index 30cdbc8d..205fb215 100644
--- a/sapphire/test_job.py
+++ b/sapphire/test_job.py
@@ -8,9 +8,8 @@
 
 import pytest
 
-from .job import Job
+from .job import Job, SERVED_ALL, SERVED_NONE, SERVED_REQUEST
 from .server_map import Resource, ServerMap
-from .status_codes import SERVED_ALL, SERVED_NONE, SERVED_REQUEST
 
 
 def test_job_01(tmp_path):
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 36f3569e..41e0e752 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -12,9 +12,9 @@
 import pytest
 
 from .core import Sapphire
+from .job import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
 from .worker import Worker
 from .server_map import ServerMap
-from .status_codes import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
 
 
 class _TestFile(object):

From 5ef110f4604b01b3ead3939c799aa7df7ef540e3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Oct 2020 15:43:09 -0700
Subject: [PATCH 034/531] [sapphire] Update comments

---
 sapphire/core.py | 90 ++++++++++++++++++++++++++++++++++--------------
 1 file changed, 64 insertions(+), 26 deletions(-)

diff --git a/sapphire/core.py b/sapphire/core.py
index 2df8cdf2..efb6aaf7 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -41,10 +41,21 @@ def __exit__(self, *exc):
         self.close()
 
     @staticmethod
-    def _create_listening_socket(allow_remote, requested_port, retries=20):
-        # The intention of this function is to contain the socket creation code
-        # along with all the searching and retrying code. If a specific port is requested
-        # and it is not available a socket.error will be raised.
+    def _create_listening_socket(remote, port=None, retries=20):
+        """Create listening socket. Search for an open socket if needed and
+        and configure the socket. If a specific port is unavailable or no
+        available ports can be found a socket.error will be raised.
+
+        Args:
+            remote (bool): Accept all (non-local) incoming connections.
+            port (int): Port to listen on. If None is given a random port will
+                        be used.
+            retries (int): Number of attempts to the socket.
+
+        Returns:
+            socket: A listening socket.
+        """
+        addr = "0.0.0.0" if remote else "127.0.0.1"
         for retry in reversed(range(retries)):
             sock = None
             try:
@@ -53,8 +64,7 @@ def _create_listening_socket(allow_remote, requested_port, retries=20):
                 sock.settimeout(0.25)
                 # find an unused port and avoid blocked ports
                 # see: dxr.mozilla.org/mozilla-central/source/netwerk/base/nsIOService.cpp
-                port = requested_port or randint(0x2000, 0xFFFF)
-                sock.bind(("0.0.0.0" if allow_remote else "127.0.0.1", port))
+                sock.bind((addr, port or randint(0x2000, 0xFFFF)))
                 sock.listen(5)
             except (OSError, sock_error) as soc_e:
                 if sock is not None:
@@ -67,38 +77,48 @@ def _create_listening_socket(allow_remote, requested_port, retries=20):
         return sock
 
     def close(self):
-        """
-        close()
+        """Close listening server socket.
 
-        This function closes the listening server socket if it is open.
+        Args:
+            None
+
+        Returns:
+            None
         """
         if self._socket is not None:
             self._socket.close()
 
     @property
     def port(self):
-        """
-        port -> int
+        """Port number of listening socket.
 
-        returns the port number the socket is listening on
-        """
+        Args:
+            None
 
+        Returns:
+            int: Listening port number.
+        """
         return self._socket.getsockname()[1]
 
     def serve_path(self, path, continue_cb=None, forever=False, optional_files=None, server_map=None):
-        """
-        serve_path() -> tuple
-        path is the directory that will be used as wwwroot. The callback continue_cb should
-        be a function that returns True or False. If continue_cb is specified and returns False
-        the server serve loop will exit. optional_files is list of files that do not need to be
-        served in order to exit the serve loop.
-
-        returns a tuple (server status, files served)
-        server status is an int:
-        - SERVED_ALL: All files excluding files int the optional_files list were served
-        - SERVED_NONE: No files were served
-        - SERVED_REQUEST: Some files were requested
-        files served is a list of the files that were served
+        """Serve files in path. On completion a list served files and a status
+        code will be returned.
+        The status codes include:
+            - SERVED_ALL: All files excluding files in optional_files were served
+            - SERVED_NONE: No files were served
+            - SERVED_REQUEST: Some files were requested
+
+        Args:
+            path (str): Directory to use a wwwroot.
+            continue_cb (str): A callback that can be used to exit the serve loop.
+                               This should a function that returns a bool.
+            forever (bool): Continue to handle requests even after all files have
+                            been served. This is meant to be used with continue_cb.
+            optional_files (list): Files that do not need to be served in order
+                                   to exit the serve loop.
+            server_map (ServerMap):
+        Returns:
+            tuple: Files served and status code
         """
         LOG.debug("serving %r (forever=%r)", path, forever)
         job = Job(
@@ -118,10 +138,28 @@ def serve_path(self, path, continue_cb=None, forever=False, optional_files=None,
 
     @property
     def timeout(self):
+        """The amount of time that must pass before exit the serve loop and
+        indicating a timeout.
+
+        Args:
+            None
+
+        Returns:
+            int: Timeout in seconds.
+        """
         return self._timeout
 
     @timeout.setter
     def timeout(self, value):
+        """The amount of time that must pass before exit the serve loop and
+        indicating a timeout.
+
+        Args:
+            value (int): Timeout in seconds.
+
+        Returns:
+            None
+        """
         if not value:
             self._timeout = 0
         else:

From 13869aa57ef291162c1bcc319be62474eaa34f2d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Oct 2020 16:49:04 -0700
Subject: [PATCH 035/531] [sapphire] Debug log nit

---
 sapphire/worker.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sapphire/worker.py b/sapphire/worker.py
index 5d892f21..46915eda 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -172,8 +172,8 @@ def handle_request(cls, conn, serv_job):
             serv_job.increment_served(resource.target)
 
         except (sock_error, sock_timeout):
-            exc_type, exc_obj, exc_tb = exc_info()
-            LOG.debug("%s: %r (line %d)", exc_type.__name__, exc_obj, exc_tb.tb_lineno)
+            _, exc_obj, exc_tb = exc_info()
+            LOG.debug("%r - line %d", exc_obj, exc_tb.tb_lineno)
             if not finish_job:
                 serv_job.accepting.set()
 

From b9ca752b399f938c3669388b2442fc8ccfb0f6b9 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 8 Oct 2020 14:57:53 -0700
Subject: [PATCH 036/531] [replay] Update debug output

---
 grizzly/replay/replay.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index b9b676c7..bd2ece2c 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -261,14 +261,14 @@ def _dyn_close():  # pragma: no cover
                     if self.status.iteration < repeat:
                         LOG.debug("skipping remaining attempts")
                     # failed to reproduce issue
-                    LOG.debug("results (%d) < expected, %s after %d attempts",
+                    LOG.debug("results (%d) < minimum (%d), after %d attempts",
                               self.status.results, min_results, self.status.iteration)
                     break
                 # check if complete (results found)
                 if self.status.results >= min_results:
                     assert self.status.results == min_results
                     assert sum(x.count for x in reports.values() if x.expected) >= min_results
-                    LOG.debug("results == expected, %s after %d attempts",
+                    LOG.debug("results == expected (%d), after %d attempts",
                               min_results, self.status.iteration)
                     break
 

From cc42b56b251074a1f039eb06c1835ed392e091d7 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 8 Oct 2020 14:59:26 -0700
Subject: [PATCH 037/531] [sapphire] Remove old pylint suppression

---
 sapphire/server_map.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sapphire/server_map.py b/sapphire/server_map.py
index 47fb181c..1b565f8f 100644
--- a/sapphire/server_map.py
+++ b/sapphire/server_map.py
@@ -11,7 +11,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-LOG = getLogger(__name__)  # pylint: disable=invalid-name
+LOG = getLogger(__name__)
 
 
 class InvalidURLError(Exception):

From 827d83420541c196798b795a497a8e4918417c03 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 14 Oct 2020 13:18:07 -0700
Subject: [PATCH 038/531] [reduce] Add cssbeautifier to dependencies list

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 592c172c..846b8df5 100755
--- a/setup.py
+++ b/setup.py
@@ -10,7 +10,7 @@
 
 
 EXTRAS = {
-    'reduce': ['lithium-reducer', 'jsbeautifier'],
+    'reduce': ['cssbeautifier', 'lithium-reducer', 'jsbeautifier'],
     's3': ['boto3'],
 }
 EXTRAS['all'] = list(set(chain.from_iterable(EXTRAS.values())))

From 2937aadb0d37af1dd5a6892e6523a57affb0a045 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 16 Oct 2020 10:16:12 -0700
Subject: [PATCH 039/531] Update comments

---
 grizzly/common/storage.py | 82 ++++++++++++++++++++-------------------
 1 file changed, 43 insertions(+), 39 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 3fa30bbd..831f7b34 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -62,8 +62,8 @@ def _add(self, target, test_file):
         """Add a test file to test case and perform sanity checks.
 
         Args:
-            target (list): Specific list of Files to append target test_file to.
-            test_file (TestFile): TestFile to append
+            target (list): Specific list of files to append target test_file to.
+            test_file (TestFile): TestFile to append.
 
         Returns:
             None
@@ -76,14 +76,14 @@ def _add(self, target, test_file):
 
     def add_batch(self, path, include_files, prefix=None):
         """Iterate over files in include_files and attach the files that are
-        located in path to testcase.
+        located in path to TestCase.
 
         Args:
             path (str): Path to the root of the directory that contains files.
             include_files (iterable): Paths of the files to be added to the
-                                      test case if they exist in path.
+                                      TestCase if they exist in path.
             prefix (str): Path prefix to prepend to file when adding to
-                          test case.
+                          the TestCase.
 
         Returns:
             None
@@ -98,10 +98,10 @@ def add_batch(self, path, include_files, prefix=None):
             self.add_from_file(fname, file_name=test_path)
 
     def add_meta(self, meta_file):
-        """Add a test file to test case as a meta file.
+        """Add a TestFile to TestCase as a meta file.
 
         Args:
-            meta_file (TestFile): TestFile to add to TestCase
+            meta_file (TestFile): TestFile to add to TestCase.
 
         Returns:
             None
@@ -109,11 +109,11 @@ def add_meta(self, meta_file):
         self._add(self._files.meta, meta_file)
 
     def add_environ_var(self, name, value):
-        """Add environment variable to test case.
+        """Add environment variable to TestCase.
 
         Args:
-            name (str): Environment variable name
-            value (str): Environment variable value
+            name (str): Environment variable name.
+            value (str): Environment variable value.
 
         Returns:
             None
@@ -121,11 +121,11 @@ def add_environ_var(self, name, value):
         self.env_vars[name] = value
 
     def add_file(self, test_file, required=True):
-        """Add a test file to test case.
+        """Add a TestFile to TestCase.
 
         Args:
-            meta_file (TestFile): TestFile to add to TestCase
-            required (bool): Indicates if test file must be served
+            meta_file (TestFile): TestFile to add to TestCase.
+            required (bool): Indicates if test file must be served.
 
         Returns:
             None
@@ -136,13 +136,14 @@ def add_file(self, test_file, required=True):
             self._add(self._files.optional, test_file)
 
     def add_from_data(self, data, file_name, encoding="UTF-8", required=True):
-        """Create a TestFile and add it to the test case.
+        """Create a TestFile and add it to the TestCase.
 
         Args:
-            data (bytes): Data to write to file
-            file_name (str): Name for the test file
-            encoding (str): Encoding to be used
-            required (bool): Indicates if test file must be served
+            data (bytes or str): Data to write to file. If data is of type str
+                                 encoding must be given.
+            file_name (str): Name for the TestFile.
+            encoding (str): Encoding to be used.
+            required (bool): Indicates whether the TestFile must be served.
 
         Returns:
             None
@@ -155,12 +156,13 @@ def add_from_data(self, data, file_name, encoding="UTF-8", required=True):
             raise
 
     def add_from_file(self, input_file, file_name=None, required=True):
-        """Create a TestFile from an existing file and add it to the test case.
+        """Create a TestFile from an existing file and add it to the TestCase.
 
         Args:
-            input_file (str): Path to existing file to use
-            file_name (str): Name for the test file
-            required (bool): Indicates if test file must be served
+            input_file (str): Path to existing file to use.
+            file_name (str): Name for the TestFile. If file_name is not given
+                             the name of the input_file will be used.
+            required (bool): Indicates whether the TestFile must be served.
 
         Returns:
             None
@@ -192,7 +194,7 @@ def contains(self, file_name):
             file_name (str): File name to search for in TestCase.
 
         Returns:
-            bool: True if file exists in the TestCase otherwise False
+            bool: True if file exists in the TestCase otherwise False.
         """
         return file_name in self._existing_paths
 
@@ -215,8 +217,8 @@ def dump(self, out_path, include_details=False):
         """Write all the test case data to the filesystem.
 
         Args:
-            out_path (str): Path to directory to output data
-            include_details (bool): Output "test_info.json" file
+            out_path (str): Path to directory to output data.
+            include_details (bool): Output "test_info.json" file.
 
         Returns:
             None
@@ -407,7 +409,7 @@ def purge_optional(self, keep):
         opt_files = tuple(x.file_name for x in self._files.optional)
         if not opt_files:
             # nothing to purge
-            return None
+            return
         # filter required files from opt_files files to keep
         keep_opt = list()
         for fname in set(keep):
@@ -422,7 +424,6 @@ def purge_optional(self, keep):
                 to_remove.append(idx)
         for idx in reversed(to_remove):
             self._files.optional.pop(idx).close()
-        return None
 
     @staticmethod
     def scan_path(path):
@@ -465,7 +466,8 @@ def __init__(self, file_name):
                 or ("/" in file_name and not file_name.rsplit("/", 1)[-1]) \
                 or file_name.startswith("../"):
             raise TypeError("file_name is invalid %r" % (file_name,))
-        self._file_name = os.path.normpath(file_name)  # name including path relative to wwwroot
+        # name including path relative to wwwroot
+        self._file_name = os.path.normpath(file_name)
         self._fp = SpooledTemporaryFile(
             dir=grz_tmp("storage"),
             max_size=self.CACHE_LIMIT,
@@ -498,7 +500,7 @@ def close(self):
             None
 
         Returns:
-            None TestFile instance
+            None
         """
         self._fp.close()
 
@@ -519,10 +521,10 @@ def data(self):
         return data
 
     def dump(self, path):
-        """Write test file data to the filesystem.
+        """Write TestFile data to the filesystem.
 
         Args:
-            path (str): Path to output data
+            path (str): Path to output data.
 
         Returns:
             None
@@ -543,12 +545,13 @@ def from_data(cls, data, file_name, encoding="UTF-8"):
         """Create a TestFile and add it to the test case.
 
         Args:
-            data (bytes): Data to write to file
-            file_name (str): Name for the test file
-            encoding (str): Encoding to be used
+            data (bytes or str): Data to write to file. If data is of type str
+                                 encoding must be given.
+            file_name (str): Name for the TestFile.
+            encoding (str): Encoding to be used.
 
         Returns:
-            TestFile: new instance
+            TestFile: A TestFile.
         """
         t_file = cls(file_name)
         if data:
@@ -563,11 +566,12 @@ def from_file(cls, input_file, file_name=None):
         """Create a TestFile from an existing file.
 
         Args:
-            input_file (str): Path to existing file to use
-            file_name (str): Name for the test file
+            input_file (str): Path to existing file to use.
+            file_name (str): Name for the TestFile. If file_name is not given
+                             the name of the input_file will be used.
 
         Returns:
-            TestFile: new instance
+            TestFile: A TestFile.
         """
         if file_name is None:
             file_name = os.path.basename(input_file)
@@ -596,7 +600,7 @@ def write(self, data):
         """Add data to the TestFile.
 
         Args:
-            data (bytes): Data to add to the TestFile
+            data (bytes): Data to add to the TestFile.
 
         Returns:
             None

From 76b2a9cc2abb0e09e3ba80bc7e068e4d553ad562 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 20 Oct 2020 10:59:44 -0700
Subject: [PATCH 040/531] Bump version to 0.9.7

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 846b8df5..65d47c67 100755
--- a/setup.py
+++ b/setup.py
@@ -70,4 +70,4 @@
         ],
         package_data={"grizzly.common": ["harness.html"]},
         url='https://github.com/MozillaSecurity/grizzly',
-        version='0.9.6')
+        version='0.9.7')

From e7c56b8a6597f6531297f318321289f7ebd613c2 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 21 Oct 2020 11:23:47 -0700
Subject: [PATCH 041/531] [reduce] Pin lithium-reducer version

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 65d47c67..564de532 100755
--- a/setup.py
+++ b/setup.py
@@ -10,7 +10,7 @@
 
 
 EXTRAS = {
-    'reduce': ['cssbeautifier', 'lithium-reducer', 'jsbeautifier'],
+    'reduce': ['cssbeautifier', 'lithium-reducer<0.4', 'jsbeautifier'],
     's3': ['boto3'],
 }
 EXTRAS['all'] = list(set(chain.from_iterable(EXTRAS.values())))

From 88ed28f0e4914473195010cd54424f83b56a23f4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 21 Oct 2020 11:24:29 -0700
Subject: [PATCH 042/531] Bump version to 0.9.8

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 564de532..d46c4108 100755
--- a/setup.py
+++ b/setup.py
@@ -70,4 +70,4 @@
         ],
         package_data={"grizzly.common": ["harness.html"]},
         url='https://github.com/MozillaSecurity/grizzly',
-        version='0.9.7')
+        version='0.9.8')

From 52af6b9f03ecbf3589a26c17b02d4a2111da0fa4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 23 Oct 2020 09:39:53 -0700
Subject: [PATCH 043/531] Fix docstrings

---
 grizzly/common/storage.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 831f7b34..3015c891 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -200,7 +200,8 @@ def contains(self, file_name):
 
     @property
     def data_size(self):
-        """The total amount of data used by the test case (bytes).
+        """The total amount of data used (bytes) by the TestFiles in the
+        TestCase.
 
         Args:
             None
@@ -244,7 +245,7 @@ def dump(self, out_path, include_details=False):
                 meta_file.dump(out_path)
 
     def get_file(self, file_name):
-        """Look up and return the TestFile with the specified file name.
+        """Lookup and return the TestFile with the specified file name.
 
         Args:
             file_name (str): Name of file to retrieve.
@@ -327,9 +328,9 @@ def load_single(cls, path, load_prefs, adjacent=False):
         Args:
             path (str): Path to the directory or file to load.
             load_prefs (bool): Load prefs.js file if available.
-            adjacent (str): Load adjacent files as part of the test case.
-                            This is always the case when loading a directory.
-                            WARNING: This should be used with caution!
+            adjacent (bool): Load adjacent files as part of the TestCase.
+                             This is always true when loading a directory.
+                             WARNING: This should be used with caution!
 
         Returns:
             TestCase: A TestCase.

From 759ed7e39d30f4473f457dc2423e0b3c3af1f03e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tysmith@users.noreply.github.com>
Date: Fri, 23 Oct 2020 13:57:17 -0700
Subject: [PATCH 044/531] Update TravisCI badge

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index ba90a278..00db32f5 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 Grizzly
 =======
-[![Build Status](https://travis-ci.org/MozillaSecurity/grizzly.svg?branch=master)](https://travis-ci.org/MozillaSecurity/grizzly)
+[![Build Status](https://travis-ci.com/MozillaSecurity/grizzly.svg?branch=master)](https://travis-ci.com/MozillaSecurity/grizzly)
 [![codecov](https://codecov.io/gh/MozillaSecurity/grizzly/branch/master/graph/badge.svg)](https://codecov.io/gh/MozillaSecurity/grizzly)
 [![Matrix](https://img.shields.io/badge/dynamic/json?color=green&label=chat&query=%24.chunk[%3F(%40.canonical_alias%3D%3D%22%23fuzzing%3Amozilla.org%22)].num_joined_members&suffix=%20users&url=https%3A%2F%2Fmozilla.modular.im%2F_matrix%2Fclient%2Fr0%2FpublicRooms&style=flat&logo=matrix)](https://riot.im/app/#/room/#fuzzing:mozilla.org)
 [![PyPI](https://img.shields.io/pypi/v/grizzly-framework)](https://pypi.org/project/grizzly-framework)
@@ -14,7 +14,7 @@ be served to and processed by the browser.
 Cross platform compatibility is available for Windows, Linux and MacOS.
 However not all features may be available.
 
-For additional information please check out the [wiki](https://github.com/MozillaSecurity/grizzly/wiki) or the [announcement](https://blog.mozilla.org/security/2019/07/10/grizzly/)
+For additional information please check out the [wiki](https://github.com/MozillaSecurity/grizzly/wiki) or the [announcement](https://blog.mozilla.org/security/2019/07/10/grizzly/).
 
 Installation
 ------------

From e90a30e65240282d2e1af7bc1f69e81fe4f11f6c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 28 Oct 2020 11:15:17 -0700
Subject: [PATCH 045/531] Reduce log output during run

---
 grizzly/common/runner.py        |  1 +
 grizzly/reduce/test_common.py   |  1 +
 grizzly/replay/replay.py        |  1 -
 grizzly/session.py              |  1 -
 grizzly/target/puppet_target.py | 10 +++++-----
 5 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index b7797fa3..1f9b9f6a 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -102,6 +102,7 @@ def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
         assert self._target is not None
         assert max_retries >= 0
         assert retry_delay >= 0
+        LOG.debug("launching target (timeout %ds)", self._target.launch_timeout)
         for retries in reversed(range(max_retries)):
             try:
                 self._target.launch(location, env_mod=env_mod)
diff --git a/grizzly/reduce/test_common.py b/grizzly/reduce/test_common.py
index 7a24a239..02b386ee 100644
--- a/grizzly/reduce/test_common.py
+++ b/grizzly/reduce/test_common.py
@@ -32,6 +32,7 @@ def __init__(self, *args, **kwds):
         self.closed = True
         self.binary = ""
         self.forced_close = os.getenv("GRZ_FORCED_CLOSE", "1").lower() not in ("false", "0")
+        self.launch_timeout = 300
         self.prefs = None
         self.rl_countdown = 0
         self.use_valgrind = False
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index bd2ece2c..648709d8 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -158,7 +158,6 @@ def _dyn_close():  # pragma: no cover
             for _ in range(repeat):
                 self.status.iteration += 1
                 if self.target.closed:
-                    LOG.info("Launching target...")
                     if self._harness is None:
                         location = runner.location(
                             "/grz_current_test",
diff --git a/grizzly/session.py b/grizzly/session.py
index 4f5addc6..da0ef748 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -154,7 +154,6 @@ def _dyn_close():  # pragma: no cover
                         close_after=self.target.rl_reset,
                         forced_close=self.target.forced_close,
                         timeout=self.adapter.TEST_DURATION)
-                log.info("Launching target")
                 runner.launch(location, max_retries=3, retry_delay=0)
             self.target.step()
 
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 9e3e6fc7..3eb052ea 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -116,24 +116,24 @@ def detect_failure(self, ignored, was_timeout):
         # if something has happened figure out what
         if not is_healthy:
             if self._puppet.reason == FFPuppet.RC_CLOSED:
-                LOG.info("target.close() was called")
+                LOG.debug("target.close() was called")
             elif self._puppet.reason == FFPuppet.RC_EXITED:
-                LOG.info("Target closed itself")
+                LOG.debug("target closed itself")
             elif (self._puppet.reason == FFPuppet.RC_WORKER
                   and "memory" in ignored
                   and "ffp_worker_memory_usage" in self._puppet.available_logs()):
                 status = self.RESULT_IGNORED
-                LOG.info("Memory limit exceeded")
+                LOG.debug("memory limit exceeded")
             elif (self._puppet.reason == FFPuppet.RC_WORKER
                   and "log-limit" in ignored
                   and "ffp_worker_log_size" in self._puppet.available_logs()):
                 status = self.RESULT_IGNORED
-                LOG.info("Log size limit exceeded")
+                LOG.debug("log size limit exceeded")
             else:
                 LOG.debug("failure detected, ffpuppet return code: %r", self._puppet.reason)
                 status = self.RESULT_FAILURE
         elif was_timeout:
-            LOG.info("Timeout detected")
+            LOG.debug("timeout detected")
             status = self.RESULT_IGNORED if "timeout" in ignored else self.RESULT_FAILURE
         return status
 

From 3bf198136f5b501d733da37f2487b925d95cfba4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 28 Oct 2020 12:58:30 -0700
Subject: [PATCH 046/531] [replay] Add exit_early argument to
 ReplayManager.run()

---
 grizzly/replay/replay.py      | 38 ++++++++++++++++++++---------------
 grizzly/replay/test_replay.py | 22 ++++++++++++++++++++
 2 files changed, 44 insertions(+), 16 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 648709d8..d1f25f0a 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -104,7 +104,7 @@ def report_to_filesystem(path, results, tests=None):
             for result in expected:
                 reporter.submit(tests or [], report=result.report)
 
-    def run(self, testcases, repeat=1, min_results=1, idle_delay=0, idle_threshold=0):
+    def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0, idle_threshold=0):
         """Run testcase replay.
 
         Args:
@@ -112,6 +112,11 @@ def run(self, testcases, repeat=1, min_results=1, idle_delay=0, idle_threshold=0
             repeat (int): Maximum number of times to run the TestCase.
             min_results (int): Minimum number of results needed before run can
                                be considered successful.
+            exit_early (bool): If True the minimum required number of iterations
+                               are performed to either meet `min_results` or
+                               determine that it is not possible to do so.
+                               If False `repeat` number of iterations are
+                               performed.
             idle_delay (int): Number of seconds to wait before polling for idle.
             idle_threshold (int): CPU usage threshold to mark the process as idle.
 
@@ -255,21 +260,22 @@ def _dyn_close():  # pragma: no cover
                     LOG.error("ERROR: Test case was not served. Timeout too short?")
                     break
 
-                # check status and exit early if possible
-                if repeat - self.status.iteration + self.status.results < min_results:
-                    if self.status.iteration < repeat:
-                        LOG.debug("skipping remaining attempts")
-                    # failed to reproduce issue
-                    LOG.debug("results (%d) < minimum (%d), after %d attempts",
-                              self.status.results, min_results, self.status.iteration)
-                    break
-                # check if complete (results found)
-                if self.status.results >= min_results:
-                    assert self.status.results == min_results
-                    assert sum(x.count for x in reports.values() if x.expected) >= min_results
-                    LOG.debug("results == expected (%d), after %d attempts",
-                              min_results, self.status.iteration)
-                    break
+                if exit_early:
+                    # failed to meet minimum number of results
+                    if repeat - self.status.iteration + self.status.results < min_results:
+                        if self.status.iteration < repeat:
+                            LOG.debug("skipping remaining attempts")
+                        # failed to reproduce issue
+                        LOG.debug("results (%d) < minimum (%d), after %d attempts",
+                                  self.status.results, min_results, self.status.iteration)
+                        break
+                    # check if complete (minimum number of results found)
+                    if self.status.results >= min_results:
+                        assert self.status.results == min_results
+                        assert sum(x.count for x in reports.values() if x.expected) >= min_results
+                        LOG.debug("results == expected (%d), after %d attempts",
+                                  min_results, self.status.iteration)
+                        break
 
                 # warn about large browser logs
                 #self.status.log_size = self.target.log_size()
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 6707ecda..558ca40f 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -163,6 +163,28 @@ def test_replay_07(mocker, tmp_path):
         assert replay.status.results == 2
         assert replay.status.ignored == 1
     assert len(results) == 1
+    assert sum(x.count for x in results) == 2
+    target.reset_mock()
+    # ignore early failure (perform all repeats)
+    target.detect_failure.return_value = Target.RESULT_NONE
+    target.detect_failure.side_effect = None
+    with ReplayManager([], server, target, use_harness=False) as replay:
+        assert not replay.run(testcases, repeat=4, min_results=4, exit_early=False)
+        assert target.close.call_count == 1
+        assert replay.status.iteration == 4
+        assert replay.status.results == 0
+        assert replay.status.ignored == 0
+    target.reset_mock()
+    # ignore early success (perform all repeats)
+    target.detect_failure.return_value = Target.RESULT_FAILURE
+    with ReplayManager([], server, target, use_harness=False) as replay:
+        results = replay.run(testcases, repeat=4, min_results=1, exit_early=False)
+        assert target.close.call_count == 1
+        assert replay.status.iteration == 4
+        assert replay.status.results == 4
+        assert replay.status.ignored == 0
+    assert len(results) == 1
+    assert sum(x.count for x in results) == 4
 
 def test_replay_08(mocker, tmp_path):
     """test ReplayManager.run() - test signatures - fail to meet minimum"""

From f0c8542fd1156a9cfe06581273c82c1c792134b9 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 28 Oct 2020 12:59:11 -0700
Subject: [PATCH 047/531] Update puppet_target imports

---
 grizzly/target/puppet_target.py | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 3eb052ea..34795e37 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -6,7 +6,11 @@
 from os import close, kill, unlink
 from os.path import abspath, isfile
 from platform import system
-import signal
+from signal import SIGABRT
+try:
+    from signal import SIGUSR1
+except ImportError:
+    SIGUSR1 = None
 from time import sleep, time
 from tempfile import mkdtemp, mkstemp
 
@@ -32,8 +36,7 @@ class PuppetTarget(Target):
     __slots__ = ("use_rr", "use_valgrind", "_puppet", "_remove_prefs")
 
     def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, relaunch, **kwds):
-        super(PuppetTarget, self).__init__(binary, extension, launch_timeout,
-                                           log_limit, memory_limit, relaunch)
+        super().__init__(binary, extension, launch_timeout, log_limit, memory_limit, relaunch)
         self.use_rr = kwds.pop("rr", False)
         self.use_valgrind = kwds.pop("valgrind", False)
         self._remove_prefs = False
@@ -51,7 +54,7 @@ def _abort_hung_proc(self):
             proc_usage = self._puppet.cpu_usage()
         for pid, cpu in sorted(proc_usage, reverse=True, key=lambda x: x[1]):
             LOG.debug("sending SIGABRT to pid: %r, cpu: %0.2f%%", pid, cpu)
-            kill(pid, signal.SIGABRT)
+            kill(pid, SIGABRT)
             break
 
     def add_abort_token(self, token):
@@ -130,7 +133,7 @@ def detect_failure(self, ignored, was_timeout):
                 status = self.RESULT_IGNORED
                 LOG.debug("log size limit exceeded")
             else:
-                LOG.debug("failure detected, ffpuppet return code: %r", self._puppet.reason)
+                LOG.debug("failure detected, ffpuppet reason %r", self._puppet.reason)
                 status = self.RESULT_FAILURE
         elif was_timeout:
             LOG.debug("timeout detected")
@@ -138,6 +141,7 @@ def detect_failure(self, ignored, was_timeout):
         return status
 
     def dump_coverage(self, timeout=15):
+        assert SIGUSR1 is not None
         pid = self._puppet.get_pid()
         if pid is None or not self._puppet.is_healthy():
             LOG.debug("Skipping coverage dump (target is not in a good state)")
@@ -147,11 +151,11 @@ def dump_coverage(self, timeout=15):
         try:
             for child in Process(pid).children(recursive=True):
                 LOG.debug("Sending SIGUSR1 to %d (child)", child.pid)
-                kill(child.pid, signal.SIGUSR1)
+                kill(child.pid, SIGUSR1)
         except (AccessDenied, NoSuchProcess):  # pragma: no cover
             pass
         LOG.debug("Sending SIGUSR1 to %d (parent)", pid)
-        kill(pid, signal.SIGUSR1)
+        kill(pid, SIGUSR1)
         start_time = time()
         gcda_found = False
         delay = 0.1
@@ -179,7 +183,7 @@ def dump_coverage(self, timeout=15):
                 if elapsed >= timeout:
                     # timeout failure
                     LOG.warning("gcda file open by pid %d after %0.2fs", gcda_open, elapsed)
-                    kill(gcda_open, signal.SIGABRT)
+                    kill(gcda_open, SIGABRT)
                     sleep(1)
                     self.close()
                     break

From 362409383d3756786c2afa53b20f6b20e253b76d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 28 Oct 2020 14:35:35 -0700
Subject: [PATCH 048/531] [tests] Simplify test_status_08

---
 grizzly/common/test_status.py | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 07a2f935..b2232312 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -130,7 +130,7 @@ def test_status_07(tmp_path):
     status.timestamp += 1
     assert status.rate == 0.5
 
-def _client_writer(done, working_path):
+def _client_writer(done, reported, working_path):
     """Used by test_status_08"""
     # NOTE: this must be at the top level to work on Windows
     Status.PATH = working_path
@@ -139,6 +139,9 @@ def _client_writer(done, working_path):
         while not done.is_set():
             status.iteration += 1
             status.report(force=True)
+            # perform two reports before setting flag
+            if not reported.is_set() and status.iteration > 1:
+                reported.set()
             sleep(0.01)
     finally:
         status.cleanup()
@@ -146,27 +149,28 @@ def _client_writer(done, working_path):
 def test_status_08(tmp_path):
     """test Status.loadall() with multiple active reporters"""
     Status.PATH = str(tmp_path)
-    best_rate = 0
     done = Event()
     procs = list()
+    report_events = list()
     try:
+        # launch processes
         for _ in range(5):
-            procs.append(Process(target=_client_writer, args=(done, Status.PATH)))
+            report_events.append(Event())
+            procs.append(Process(target=_client_writer, args=(done, report_events[-1], Status.PATH)))
             procs[-1].start()
-        deadline = time() + 60
-        while len(tuple(Status.loadall())) < len(procs):
-            sleep(0.1)
-            assert time() < deadline, "timeout waiting for processes to launch!"
-        for _ in range(20):
-            for obj in Status.loadall():
-                if obj.rate > best_rate:
-                    best_rate = obj.rate
+        # wait for processes to launch and report
+        for has_reported in report_events:
+            assert has_reported.wait(60)
+        # collect reports
+        reports = tuple(Status.loadall())
+        assert len(reports) == len(procs)
+        assert max(x.rate for x in reports) > 0
     finally:
         done.set()
         for proc in procs:
             if proc.pid is not None:
                 proc.join()
-    assert best_rate > 0
+    # verify cleanup
     assert not any(Status.loadall())
 
 def test_reducer_stats_01(tmp_path):

From cf6ab8fab08606db8ec1fd6804feb349d20f1e17 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 28 Oct 2020 14:55:21 -0700
Subject: [PATCH 049/531] [tests] Fix test_reducer_stats_04

---
 grizzly/common/test_status.py | 25 +++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index b2232312..5a259726 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -160,7 +160,7 @@ def test_status_08(tmp_path):
             procs[-1].start()
         # wait for processes to launch and report
         for has_reported in report_events:
-            assert has_reported.wait(60)
+            assert has_reported.wait(timeout=60)
         # collect reports
         reports = tuple(Status.loadall())
         assert len(reports) == len(procs)
@@ -212,32 +212,37 @@ def test_reducer_stats_03(tmp_path):
     with ReducerStats() as stats:
         assert stats.passed == 0
 
-def _reducer_client(working_path, limit, unrestrict):
+def _reducer_client(working_path, reported, unrestrict):
     """Used by test_reducer_stats_04"""
     # NOTE: this must be at the top level to work on Windows
     ReducerStats.PATH = working_path
-    for _ in range(50):
+    for _ in range(20):
         with ReducerStats() as stats:
             stats.passed += 1
-            if stats.passed == limit:
-                unrestrict.set()
-        unrestrict.wait(timeout=60)
+        if not reported.is_set():
+            reported.set()
+            unrestrict.wait(timeout=60)
 
 def test_reducer_stats_04(tmp_path):
     """test ReducerStats() with multiple processes"""
     ReducerStats.PATH = str(tmp_path)
+    report_events = list()
     procs = list()
     unrestrict = Event()  # used to sync client procs
     try:
-        proc_count = 5
-        for _ in range(proc_count):
+        # launch processes
+        for _ in range(5):
+            report_events.append(Event())
             procs.append(Process(
-                target=_reducer_client, args=(ReducerStats.PATH, proc_count, unrestrict)))
+                target=_reducer_client, args=(ReducerStats.PATH, report_events[-1], unrestrict)))
             procs[-1].start()
+        # wait for processes to report
+        for has_reported in report_events:
+            assert has_reported.wait(timeout=60)
     finally:
         unrestrict.set()
         for proc in procs:
             if proc.pid is not None:
                 proc.join()
     with ReducerStats() as stats:
-        assert stats.passed == 250
+        assert stats.passed == 100

From ef2d268ce95dbc28bb989a6e3912860ce6fa884f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 29 Oct 2020 10:12:08 -0700
Subject: [PATCH 050/531] [tests] Run pytest with '--log-level DEBUG'

---
 grizzly/common/test_runner.py |  2 +-
 grizzly/replay/test_main.py   |  6 +++---
 grizzly/replay/test_replay.py | 32 ++++++++++++++++----------------
 grizzly/test_session.py       |  8 ++++----
 tox.ini                       |  1 +
 5 files changed, 25 insertions(+), 24 deletions(-)

diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index d36f470a..435991ff 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -175,7 +175,7 @@ def test_runner_07():
 def test_runner_08(mocker):
     """test Runner.launch()"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target)
+    target = mocker.Mock(spec=Target, launch_timeout=30)
 
     runner = Runner(server, target)
     runner.launch("http://a/")
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 965df971..98ae1638 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -77,7 +77,7 @@ def test_main_01(mocker, tmp_path):
     serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_target")
-    target = mocker.Mock(spec=Target, binary="bin", forced_close=True)
+    target = mocker.Mock(spec=Target, binary="bin", forced_close=True, launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
@@ -196,7 +196,7 @@ def test_main_03(mocker, tmp_path):
 def test_main_04(mocker):
     """test ReplayManager.main() loading GRZ_FORCED_CLOSE from test case"""
     mocker.patch("grizzly.replay.replay.Sapphire.serve_path", return_value=(None, ["x.html"]))
-    target = mocker.Mock(spec=Target, forced_close=True)
+    target = mocker.Mock(spec=Target, forced_close=True, launch_timeout=30)
     load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
     load_target.return_value.return_value = target
     testcase = mocker.Mock(
@@ -228,7 +228,7 @@ def test_main_05(mocker, tmp_path):
     serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
     serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
-    target = mocker.Mock(spec=Target, binary="bin", forced_close=True)
+    target = mocker.Mock(spec=Target, binary="bin", forced_close=True, launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.save_logs = _fake_save_logs
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 558ca40f..398c6486 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -40,7 +40,7 @@ def test_replay_02(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, forced_close=True, rl_reset=1)
+    target = mocker.Mock(spec=Target, closed=True, forced_close=True, launch_timeout=30, rl_reset=1)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
@@ -58,7 +58,7 @@ def test_replay_03(mocker):
     """test ReplayManager.run() - no repro - with repeats"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, rl_reset=100)
+    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, rl_reset=100)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
@@ -77,7 +77,7 @@ def test_replay_04(mocker, tmp_path):
     served = ["index.html"]
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, served)
-    target = mocker.Mock(spec=Target, binary="C:\\fake_bin")
+    target = mocker.Mock(spec=Target, binary="C:\\fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.save_logs = _fake_save_logs
@@ -104,7 +104,7 @@ def test_replay_05(mocker):
     """test ReplayManager.run() - Error (landing page not requested/served)"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_REQUEST, ["x"])
-    target = mocker.Mock(spec=Target)
+    target = mocker.Mock(spec=Target, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -122,7 +122,7 @@ def test_replay_06(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target)
+    target = mocker.Mock(spec=Target, launch_timeout=30)
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = Target.RESULT_IGNORED
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -139,7 +139,7 @@ def test_replay_07(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="path/fake_bin")
+    target = mocker.Mock(spec=Target, binary="path/fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
@@ -204,7 +204,7 @@ def test_replay_08(mocker, tmp_path):
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, False, False)
-    target = mocker.Mock(spec=Target, binary="fake_bin")
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -239,7 +239,7 @@ def test_replay_09(mocker, tmp_path):
     server.serve_path.return_value = (SERVED_ALL, ["a.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, True)
-    target = mocker.Mock(spec=Target, binary="fake_bin")
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[])]
@@ -271,7 +271,7 @@ def test_replay_10(mocker, tmp_path):
     fake_report.side_effect = (report_0, report_1, report_2)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="fake_bin")
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -305,7 +305,7 @@ def test_replay_11(mocker, tmp_path):
     fake_report.side_effect = (report_0, report_1, report_2, report_3)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="fake_bin")
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -337,7 +337,7 @@ def test_replay_12(mocker, tmp_path):
     fake_report.side_effect = (report_1, report_2, report_3)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="fake_bin")
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -365,7 +365,7 @@ def test_replay_13(mocker, tmp_path):
     fake_report.side_effect = (report_0,)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.side_effect = ((SERVED_ALL, ["index.html"]), KeyboardInterrupt)
-    target = mocker.Mock(spec=Target, binary="fake_bin")
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -384,7 +384,7 @@ def test_replay_14(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, forced_close=True, rl_reset=1)
+    target = mocker.Mock(spec=Target, closed=True, forced_close=True, launch_timeout=30, rl_reset=1)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [
@@ -403,7 +403,7 @@ def test_replay_15(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, forced_close=True, rl_reset=100)
+    target = mocker.Mock(spec=Target, closed=True, forced_close=True, launch_timeout=30, rl_reset=100)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [
@@ -427,7 +427,7 @@ def test_replay_16(mocker, tmp_path):
         (SERVED_ALL, ["a.html"]),
         (SERVED_ALL, ["b.html"]),
         (SERVED_ALL, ["c.html"]))
-    target = mocker.Mock(spec=Target, binary="fake_bin", rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.side_effect = (
@@ -458,7 +458,7 @@ def test_replay_17(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, forced_close=True, rl_reset=1)
+    target = mocker.Mock(spec=Target, closed=True, forced_close=True, launch_timeout=30, rl_reset=1)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 531cb6e9..ffc1e780 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -49,7 +49,7 @@ def generate(self, testcase, server_map):
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     prefs = tmp_path / "prefs.js"
     prefs.touch()
-    fake_target = mocker.Mock(spec=Target, prefs=str(prefs))
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=str(prefs))
     # set target.log_size to test warning code path
     fake_target.log_size.return_value = Session.TARGET_LOG_SIZE_WARN + 1
     with IOManager() as iomgr:
@@ -74,7 +74,7 @@ def generate(self, testcase, server_map):
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     prefs = tmp_path / "prefs.js"
     prefs.touch()
-    fake_target = mocker.Mock(spec=Target, prefs=str(prefs), rl_reset=10)
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=str(prefs), rl_reset=10)
     fake_target.log_size.return_value = 1000
     fake_target.monitor.launches = 1
     with IOManager() as iomgr:
@@ -122,7 +122,7 @@ def generate(self, testcase, server_map):
     adapter = FuzzAdapter()
     adapter.setup(None, None)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target, prefs=None)
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
     fake_target.monitor.launches = 1
     with IOManager() as iomgr:
         fake_serv.serve_path.return_value = (SERVED_NONE, [])
@@ -149,7 +149,7 @@ def test_session_05(tmp_path, mocker):
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     # return SERVED_TIMEOUT to test IGNORE_UNSERVED code path
     fake_serv.serve_path.return_value = (SERVED_TIMEOUT, [fake_testcase.landing_page])
-    fake_target = mocker.Mock(spec=Target, prefs=None)
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
     fake_target.monitor.launches = 1
     with Session(fake_adapter, fake_iomgr, None, fake_serv, fake_target) as session:
         session.run([], iteration_limit=1)
diff --git a/tox.ini b/tox.ini
index 44cd55e8..b9ed51be 100644
--- a/tox.ini
+++ b/tox.ini
@@ -27,6 +27,7 @@ addopts =
     --cache-clear
     --cov .
     --cov-report term-missing
+    --log-level DEBUG
 filterwarnings =
     ignore:cannot collect test class 'Test.*' because it has a __init__ constructor:pytest.PytestCollectionWarning
     ignore:Using or importing the ABCs:DeprecationWarning:botocore

From ca0e620594894f0fc8506291c5b32f2e4fc2f774 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 29 Oct 2020 12:10:43 -0700
Subject: [PATCH 051/531] [ci] Update tox.ini

---
 tox.ini | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tox.ini b/tox.ini
index b9ed51be..33e367ce 100644
--- a/tox.ini
+++ b/tox.ini
@@ -27,10 +27,10 @@ addopts =
     --cache-clear
     --cov .
     --cov-report term-missing
-    --log-level DEBUG
 filterwarnings =
     ignore:cannot collect test class 'Test.*' because it has a __init__ constructor:pytest.PytestCollectionWarning
     ignore:Using or importing the ABCs:DeprecationWarning:botocore
+log_level = DEBUG
 
 [testenv]
 commands = pytest -v --cache-clear --cov="{toxinidir}" --cov-report term-missing --basetemp="{envtmpdir}" {posargs}
@@ -40,7 +40,7 @@ extras =
 usedevelop = true
 
 [tox]
-envlist = py27,py35,py36,py37,py38
-minversion = 3.2
+envlist = py35,py36,py37,py38
+minversion = 3.5
 skip_missing_interpreters = true
 tox_pip_extensions_ext_venv_update = true

From d66770545381c178ccd2e63c7d38ee485da4b338 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 4 Nov 2020 09:32:20 -0800
Subject: [PATCH 052/531] [replay] Add '--test-index' argument

---
 grizzly/replay/args.py      |  5 +++++
 grizzly/replay/replay.py    | 14 +++++++++++++-
 grizzly/replay/test_main.py | 29 ++++++++++++++++++++++-------
 3 files changed, 40 insertions(+), 8 deletions(-)

diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index d7e764a8..d11b201a 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -48,6 +48,11 @@ def __init__(self):
         replay_args.add_argument(
             "--sig",
             help="Signature (JSON) file to match.")
+        replay_args.add_argument(
+            "--test-index", type=int,
+            help="Select a testcase to run when multiple testcases are loaded. " \
+                 "Testscases are ordered oldest to newest. Indexing is 0 based. " \
+                 "0 == Oldest, -1 == Newest (default: run all testcases)")
 
         self.launcher_grp.add_argument(
             "--rr", action="store_true",
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index d1f25f0a..374ad969 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -347,6 +347,16 @@ def main(cls, args):
             testcases = TestCase.load(args.input, args.prefs is None)
             if not testcases:
                 raise TestCaseLoadFailure("Failed to load TestCases")
+            if args.test_index is not None:
+                LOG.debug("using TestCase with index %d", args.test_index)
+                try:
+                    selected = testcases.pop(args.test_index)
+                except IndexError:
+                    raise TestCaseLoadFailure("Invalid '--test-index'") from None
+                finally:
+                    for test in testcases:
+                        test.cleanup()
+                testcases = [selected]
         except TestCaseLoadFailure as exc:
             LOG.error("Error: %s", str(exc))
             return 1
@@ -356,7 +366,9 @@ def main(cls, args):
         tmp_prefs = None
         try:
             if args.no_harness and len(testcases) > 1:
-                LOG.error("'--no-harness' cannot be used with multiple testcases")
+                LOG.error(
+                    "'--no-harness' cannot be used with multiple testcases. " \
+                    "Perhaps '--test-index' can help.")
                 return 1
             repeat = max(args.min_crashes, args.repeat)
             relaunch = min(args.relaunch, repeat)
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 98ae1638..b23e0ebd 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -102,6 +102,7 @@ def test_main_01(mocker, tmp_path):
         repeat=4,
         rr=False,
         sig=str(tmp_path / "sig.json"),
+        test_index=None,
         timeout=10,
         valgrind=False)
     assert ReplayManager.main(args) == 0
@@ -135,15 +136,16 @@ def test_main_02(mocker):
         prefs=None,
         relaunch=1,
         repeat=1,
-        sig=None)
+        sig=None,
+        test_index=None)
     # user abort
     fake_load_target.side_effect = KeyboardInterrupt
     # coverage
     args.rr = True
     args.valgrind = False
     assert ReplayManager.main(args) == 1
-    # invalid test case
     fake_load_target.reset_mock()
+    # invalid test case
     fake_tc.load.side_effect = TestCaseLoadFailure
     # coverage
     args.rr = False
@@ -156,8 +158,14 @@ def test_main_02(mocker):
     fake_tc.load.return_value = list()
     assert ReplayManager.main(args) == 1
     assert fake_load_target.call_count == 0
+    fake_load_target.reset_mock()
     # multiple test cases with --no-harness
+    fake_tc.load.return_value = [mocker.Mock(), mocker.Mock()]
+    assert ReplayManager.main(args) == 1
+    assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
+    # multiple test cases with invalid --test-index
+    args.test_index = 100
     fake_tc.load.return_value = [mocker.Mock(), mocker.Mock()]
     assert ReplayManager.main(args) == 1
     assert fake_load_target.call_count == 0
@@ -180,7 +188,8 @@ def test_main_03(mocker, tmp_path):
         prefs=None,
         relaunch=1,
         repeat=1,
-        sig=None)
+        sig=None,
+        test_index=None)
     # target launch error
     fake_logs = (tmp_path / "fake_report")
     fake_logs.mkdir()
@@ -194,17 +203,18 @@ def test_main_03(mocker, tmp_path):
     assert ReplayManager.main(args) == 1
 
 def test_main_04(mocker):
-    """test ReplayManager.main() loading GRZ_FORCED_CLOSE from test case"""
+    """test ReplayManager.main() loading GRZ_FORCED_CLOSE from selected test case"""
     mocker.patch("grizzly.replay.replay.Sapphire.serve_path", return_value=(None, ["x.html"]))
     target = mocker.Mock(spec=Target, forced_close=True, launch_timeout=30)
     load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
     load_target.return_value.return_value = target
-    testcase = mocker.Mock(
+    test0 = mocker.Mock(
         spec=TestCase,
         env_vars={"GRZ_FORCED_CLOSE": "0"},
         landing_page="x.html",
         optional=[])
-    mocker.patch("grizzly.replay.replay.TestCase.load", return_value=[testcase])
+    test1 = mocker.Mock(spec=TestCase)
+    mocker.patch("grizzly.replay.replay.TestCase.load", return_value=[test0, test1])
     # setup args
     args = mocker.Mock(
         fuzzmanager=False,
@@ -217,9 +227,13 @@ def test_main_04(mocker):
         relaunch=1,
         repeat=1,
         sig=None,
+        test_index=0,
         timeout=1)
     ReplayManager.main(args)
-    assert testcase.cleanup.call_count == 1
+    assert test0.cleanup.call_count == 1
+    assert test0.dump.call_count == 1
+    assert test1.cleanup.call_count == 1
+    assert test1.dump.call_count == 0
     assert target.cleanup.call_count == 1
     assert not target.forced_close
 
@@ -244,6 +258,7 @@ def test_main_05(mocker, tmp_path):
         relaunch=1,
         repeat=1,
         sig=None,
+        test_index=None,
         timeout=1)
     log_path = (tmp_path / "logs")
     args.logs = str(log_path)

From da581a9581454912184f49ebc1df4d5cf3905cf0 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 4 Nov 2020 18:28:11 -0800
Subject: [PATCH 053/531] [replay] Update log output and sanity checks

---
 grizzly/replay/replay.py      | 11 +++++++++--
 grizzly/replay/test_main.py   | 13 +++++++++----
 grizzly/replay/test_replay.py | 24 ++++++++++++------------
 3 files changed, 30 insertions(+), 18 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 374ad969..79fb9880 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -55,6 +55,9 @@ def __init__(self, ignore, server, target, any_crash=False, signature=None, use_
         if use_harness:
             with open(self.HARNESS_FILE, "rb") as in_fp:
                 self._harness = in_fp.read()
+        else:
+            # target must relaunch every iteration when not using harness
+            assert target.rl_reset == 1
 
     def __enter__(self):
         return self
@@ -129,6 +132,7 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
         assert repeat > 0
         assert repeat >= min_results
         assert testcases
+        assert len(testcases) == 1 or self._harness is not None
 
         if self.status is not None:
             LOG.debug("clearing previous status data")
@@ -185,7 +189,11 @@ def _dyn_close():  # pragma: no cover
                 durations = list()
                 served = list()
                 for test_idx in range(test_count):
-                    LOG.debug("running test: %d of %d", test_idx + 1, test_count)
+                    if test_count > 1:
+                        LOG.info("Running test, part %d/%d (%d/%d)...",
+                                 test_idx + 1, test_count, self.status.iteration, repeat)
+                    else:
+                        LOG.info("Running test (%d/%d)...", self.status.iteration, repeat)
                     # update redirects
                     if self._harness is not None:
                         next_idx = (test_idx + 1) % test_count
@@ -372,7 +380,6 @@ def main(cls, args):
                 return 1
             repeat = max(args.min_crashes, args.repeat)
             relaunch = min(args.relaunch, repeat)
-            assert not args.no_harness or (args.no_harness and relaunch == 1)
             LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
                      repeat, args.min_crashes, relaunch)
             LOG.debug("initializing the Target")
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index b23e0ebd..960e0a3a 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -77,7 +77,7 @@ def test_main_01(mocker, tmp_path):
     serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_target")
-    target = mocker.Mock(spec=Target, binary="bin", forced_close=True, launch_timeout=30)
+    target = mocker.Mock(spec=Target, binary="bin", forced_close=True, launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
@@ -97,6 +97,7 @@ def test_main_01(mocker, tmp_path):
         input=str(tmp_path / "test.html"),
         logs=str(log_path),
         min_crashes=2,
+        no_harness=True,
         prefs=str(tmp_path / "prefs.js"),
         relaunch=1,
         repeat=4,
@@ -173,9 +174,11 @@ def test_main_02(mocker):
 def test_main_03(mocker, tmp_path):
     """test ReplayManager.main() target exceptions"""
     mocker.patch("grizzly.replay.replay.FuzzManagerReporter", autospec=True)
-    mocker.patch("grizzly.replay.replay.load_target", autospec=True)
     mocker.patch("grizzly.replay.replay.Sapphire", autospec=True)
     mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
+    target = mocker.Mock(spec=Target, forced_close=True, launch_timeout=30, rl_reset=1)
+    load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
+    load_target.return_value.return_value = target
     fake_tmp = (tmp_path / "grz_tmp")
     fake_tmp.mkdir()
     mocker.patch("grizzly.replay.replay.grz_tmp", autospec=True, return_value=str(fake_tmp))
@@ -205,7 +208,7 @@ def test_main_03(mocker, tmp_path):
 def test_main_04(mocker):
     """test ReplayManager.main() loading GRZ_FORCED_CLOSE from selected test case"""
     mocker.patch("grizzly.replay.replay.Sapphire.serve_path", return_value=(None, ["x.html"]))
-    target = mocker.Mock(spec=Target, forced_close=True, launch_timeout=30)
+    target = mocker.Mock(spec=Target, forced_close=True, launch_timeout=30, rl_reset=1)
     load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
     load_target.return_value.return_value = target
     test0 = mocker.Mock(
@@ -223,6 +226,7 @@ def test_main_04(mocker):
         ignore=None,
         input="test",
         min_crashes=1,
+        no_harness=True,
         prefs=None,
         relaunch=1,
         repeat=1,
@@ -242,7 +246,7 @@ def test_main_05(mocker, tmp_path):
     serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
     serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
-    target = mocker.Mock(spec=Target, binary="bin", forced_close=True, launch_timeout=30)
+    target = mocker.Mock(spec=Target, binary="bin", forced_close=True, launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.save_logs = _fake_save_logs
@@ -255,6 +259,7 @@ def test_main_05(mocker, tmp_path):
         idle_threshold=0,
         ignore=None,
         min_crashes=1,
+        no_harness=True,
         relaunch=1,
         repeat=1,
         sig=None,
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 398c6486..9aca0404 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -77,12 +77,12 @@ def test_replay_04(mocker, tmp_path):
     served = ["index.html"]
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, served)
-    target = mocker.Mock(spec=Target, binary="C:\\fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec=Target, binary="C:\\fake_bin", launch_timeout=30, rl_reset=10)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.save_logs = _fake_save_logs
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
-        with ReplayManager([], server, target, use_harness=False) as replay:
+        with ReplayManager([], server, target) as replay:
             results = replay.run([testcase])
             assert replay._signature is not None
             assert replay.status.ignored == 0
@@ -104,7 +104,7 @@ def test_replay_05(mocker):
     """test ReplayManager.run() - Error (landing page not requested/served)"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_REQUEST, ["x"])
-    target = mocker.Mock(spec=Target, launch_timeout=30)
+    target = mocker.Mock(spec=Target, launch_timeout=30, rl_reset=1)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -122,7 +122,7 @@ def test_replay_06(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, launch_timeout=30)
+    target = mocker.Mock(spec=Target, launch_timeout=30, rl_reset=1)
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = Target.RESULT_IGNORED
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -139,7 +139,7 @@ def test_replay_07(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="path/fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec=Target, binary="path/fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
@@ -204,7 +204,7 @@ def test_replay_08(mocker, tmp_path):
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, False, False)
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -239,7 +239,7 @@ def test_replay_09(mocker, tmp_path):
     server.serve_path.return_value = (SERVED_ALL, ["a.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, True)
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[])]
@@ -271,7 +271,7 @@ def test_replay_10(mocker, tmp_path):
     fake_report.side_effect = (report_0, report_1, report_2)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -305,11 +305,11 @@ def test_replay_11(mocker, tmp_path):
     fake_report.side_effect = (report_0, report_1, report_2, report_3)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
+    with ReplayManager([], server, target, any_crash=True) as replay:
         assert not replay.run(testcases, repeat=4, min_results=3)
         assert replay._signature is None
         assert replay.status.iteration == 4
@@ -337,7 +337,7 @@ def test_replay_12(mocker, tmp_path):
     fake_report.side_effect = (report_1, report_2, report_3)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -365,7 +365,7 @@ def test_replay_13(mocker, tmp_path):
     fake_report.side_effect = (report_0,)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.side_effect = ((SERVED_ALL, ["index.html"]), KeyboardInterrupt)
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]

From 3c888eba054c7d586380348805c3ddaac558eb9b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 5 Nov 2020 07:51:05 -0800
Subject: [PATCH 054/531] [replay] Remove duplicate log line

---
 grizzly/replay/replay.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 79fb9880..9705541d 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -184,7 +184,6 @@ def _dyn_close():  # pragma: no cover
                     # be run individually.
                     runner.launch(location, env_mod=testcases[0].env_vars)
                 self.target.step()
-                LOG.info("Performing replay (%d/%d)...", self.status.iteration, repeat)
                 # run tests
                 durations = list()
                 served = list()

From cf8f1415c2a3724c2d21e1d2e7f4f35ac68d6b54 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 30 Sep 2020 14:23:36 -0400
Subject: [PATCH 055/531] Initial rewrite of grizzly.reduce

---
 grizzly/common/reporter.py         |    8 +-
 grizzly/reduce/__init__.py         |   24 +-
 grizzly/reduce/__main__.py         |    8 +-
 grizzly/reduce/args.py             |  170 +---
 grizzly/reduce/bucket.py           |  136 ---
 grizzly/reduce/crash.py            |  182 ----
 grizzly/reduce/exceptions.py       |   23 -
 grizzly/reduce/reduce.py           | 1459 ++++++----------------------
 grizzly/reduce/strategies.py       |  581 ++++-------
 grizzly/reduce/test_common.py      |  235 -----
 grizzly/reduce/test_interesting.py |  484 ---------
 grizzly/reduce/test_main.py        |  472 ---------
 grizzly/reduce/test_reduce.py      |  700 -------------
 grizzly/replay/__init__.py         |    4 +-
 grizzly/replay/replay.py           |    5 +-
 grizzly/target/target.py           |    9 +
 setup.py                           |    7 +-
 tox.ini                            |    3 +-
 18 files changed, 555 insertions(+), 3955 deletions(-)
 delete mode 100644 grizzly/reduce/bucket.py
 delete mode 100644 grizzly/reduce/crash.py
 delete mode 100644 grizzly/reduce/exceptions.py
 delete mode 100644 grizzly/reduce/test_common.py
 delete mode 100644 grizzly/reduce/test_interesting.py
 delete mode 100644 grizzly/reduce/test_main.py
 delete mode 100644 grizzly/reduce/test_reduce.py

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index b402990a..6e723eee 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -385,15 +385,16 @@ def submit(self, test_cases, report):
             report (Report): Report to submit.
 
         Returns:
-            None
+            *: implementation specific result indicating where the report was created
         """
         assert isinstance(report, Report)
         assert report.path is not None
         self._pre_submit(report)
-        self._submit_report(report, test_cases)
+        result = self._submit_report(report, test_cases)
         if report is not None:
             report.cleanup()
         self._post_submit()
+        return result
 
 
 class FilesystemReporter(Reporter):
@@ -435,6 +436,7 @@ def _submit_report(self, report, test_cases):
         free_space = disk_usage(log_path).free
         if free_space < self.DISK_SPACE_ABORT:
             raise RuntimeError("Running low on disk space (%0.1fMB)" % (free_space / 1048576.0,))
+        return dest_path
 
 
 class FuzzManagerReporter(Reporter):
@@ -611,6 +613,8 @@ def _submit_report(self, report, test_cases):
         if isfile(zip_name):
             unlink(zip_name)
 
+        return new_entry["id"]
+
 
 class S3FuzzManagerReporter(FuzzManagerReporter):
     @staticmethod
diff --git a/grizzly/reduce/__init__.py b/grizzly/reduce/__init__.py
index a7af2a63..ac6ceed3 100644
--- a/grizzly/reduce/__init__.py
+++ b/grizzly/reduce/__init__.py
@@ -2,26 +2,8 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-import os
-import re
 
-__all__ = ("ReductionJob",)
+__all__ = ("ReduceManager", "ReduceArgs")
 
-
-def testcase_contents(path="."):
-    for dir_name, _, dir_files in os.walk(path):
-        arc_path = os.path.relpath(dir_name, path)
-        # skip tmp folders
-        if re.match(r"^tmp.+$", arc_path.split(os.sep, 1)[0]) is not None:
-            continue
-        for file_name in dir_files:
-            # skip core files
-            if re.match(r"^core.\d+$", file_name) is not None:
-                continue
-            if arc_path == ".":
-                yield file_name
-            else:
-                yield os.path.join(arc_path, file_name)
-
-
-from .reduce import ReductionJob  # noqa pylint: disable=wrong-import-position
+from .reduce import ReduceManager
+from .args import ReduceArgs
diff --git a/grizzly/reduce/__main__.py b/grizzly/reduce/__main__.py
index 3fe92b5b..ab5d8aa9 100644
--- a/grizzly/reduce/__main__.py
+++ b/grizzly/reduce/__main__.py
@@ -2,10 +2,10 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from sys import exit as sysexit
+import sys
 
-from .args import ReducerArgs
-from .reduce import ReductionJob
+from .args import ReduceArgs
+from .reduce import ReduceManager
 
 
-sysexit(ReductionJob.main(ReducerArgs().parse_args()))
+sys.exit(ReduceManager.main(ReduceArgs().parse_args()))
diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 2c25c3c8..29afc0e4 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -2,139 +2,59 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from os.path import isdir, isfile
+from logging import getLogger
+from pathlib import Path
 
-from .reduce import ReductionJob
-from .strategies import strategies_by_name
-from ..args import CommonArgs
+from ..replay.args import ReplayArgs
+from .strategies import DEFAULT_STRATEGIES, STRATEGIES
 
 
-class ReducerArgs(CommonArgs):
+LOG = getLogger(__name__)
 
-    def __init__(self):
-        super(ReducerArgs, self).__init__()
-        self.parser.add_argument(
-            "input",
-            help="Test case or directory containing test cases")
-
-        replay_args = self.parser.add_argument_group("Reduce Arguments")
-        replay_args.add_argument(
-            "--any-crash", action="store_true",
-            help="Any crash is interesting, not only crashes which match the original first crash")
-        replay_args.add_argument(
-            "--environ",
-            help="DEPRICATED: File containing line separated environment variables (VAR=value)" \
-                "to be set in the firefox process.")
-        replay_args.add_argument(
-            "--idle-threshold", type=int, default=25,
-            help="CPU usage threshold to mark the process as idle (default: %(default)s)")
-        replay_args.add_argument(
-            "--idle-timeout", type=int, default=60,
-            help="Number of seconds to wait before polling testcase for idle (default: %(default)s)")
-        replay_args.add_argument(
-            "--min-crashes", type=int, default=1,
-            help="Require the testcase to crash n times before accepting the result. (default: %(default)sx)")
-        replay_args.add_argument(
-            "--no-analysis", action="store_true",
-            help="Disable analysis to auto-set --repeat/--min-crashes.")
-        replay_args.add_argument(
-            "--no-cache", action="store_true",
-            help="Disable testcase caching")
-        replay_args.add_argument(
-            "--no-harness", action="store_true",
-            help="Don't use the harness for sapphire redirection")
-        replay_args.add_argument(
-            "--reduce-file",
-            help="Value passed to lithium's --testcase option, needed for testcase cache " \
-                "(default: input param)")
-        replay_args.add_argument(
-            "--repeat", type=int, default=1,
-            help="Try to run the testcase multiple times, for intermittent testcases (default: %(default)sx)")
-        replay_args.add_argument(
-            "--sig",
-            help="Signature (JSON) file to match.")
-        replay_args.add_argument(
-            "--skip", type=int, default=0,
-            help="Return interesting = False for the first n reductions (default: %(default)s)")
-        replay_args.add_argument(
-            "--static-timeout", action="store_true", dest="fixed_timeout",
-            help="Disable automatically updating the iteration timeout.")
-        replay_args.add_argument(
-            "--strategy", nargs="+", default=list(), metavar="STRATEGY", dest="strategies",
-            help="One or more strategies (space-separated). Available: %s (default: %s)"
-            % (" ".join(sorted(strategies_by_name())), " ".join(ReductionJob.DEFAULT_STRATEGIES)))
-
-    def sanity_check(self, args):
-        super(ReducerArgs, self).sanity_check(args)
-
-        if "input" not in self._sanity_skip:
-            if not (isdir(args.input)
-                    or (isfile(args.input) and (args.input.lower().endswith(".zip")
-                                                or args.input.lower().endswith(".html")))):
-                self.parser.error("Testcase should be a folder, zip, or html file")
-
-        if args.sig is not None and not isfile(args.sig):
-            self.parser.error("file not found: %r" % args.sig)
-
-        if args.repeat < 1:
-            self.parser.error("'--repeat' value must be positive")
-
-        if args.min_crashes < 1:
-            self.parser.error("'--min-crashes' value must be positive")
-
-        if args.environ is not None and not isfile(args.environ):
-            self.parser.error("file not found: %r" % args.environ)
-
-        if args.strategies:
-            known_strategies = set(strategies_by_name())
-            for strategy in args.strategies:
-                if strategy not in known_strategies:
-                    self.parser.error("invalid strategy: %s" % (strategy,))
-        else:
-            args.strategies = None
 
-        if args.reduce_file is None:
-            args.reduce_file = args.input
-
-
-class ReducerFuzzManagerIDArgs(ReducerArgs):
+class ReduceArgs(ReplayArgs):
 
     def __init__(self):
-        super(ReducerFuzzManagerIDArgs, self).__init__()
-
-        # madhax alert!
-        #
-        # We need to modify the meaning of the 'input' positional to accept an int ID instead of a
-        # local testcase. This is not possible with the public argparse API.
-        #
-        # refs: https://stackoverflow.com/questions/32807319/disable-remove-argument-in-argparse
-        #       https://bugs.python.org/issue19462
-
-        # look up the action for the positional `input` arg
-        action = None
-        for arg in self.parser._actions:
-            if arg.dest == "input" and not arg.option_strings:
-                action = arg
-                break
-        assert action is not None
-
-        # modify it's type and help string
-        action.type = int
-        action.help = "FuzzManager ID to reduce"
-
-        # ... and Bob's your uncle
-        self._sanity_skip.add("input")
+        super().__init__()
 
+        # these arguments have other defaults vs how they are defined in ReplayArgs
+        self.parser.set_defaults(
+            include_test=True,
+            logs='.',
+        )
 
-class ReducerFuzzManagerIDQualityArgs(ReducerFuzzManagerIDArgs):
-
-    def __init__(self):
-        super(ReducerFuzzManagerIDQualityArgs, self).__init__()
-        self.parser.add_argument("--quality", type=int,
-                                 help="Only try crashes with a given quality value")
+        reduce_args = self.parser.add_argument_group("Reduce Arguments")
+        reduce_args.add_argument(
+            "--no-analysis", action="store_true",
+            help="Disable analysis to auto-set --repeat/--min-crashes.")
+        reduce_args.add_argument(
+            "--strategy", nargs="+", default=DEFAULT_STRATEGIES, metavar="STRATEGY",
+            dest="strategies",
+            help="One or more strategies (space-separated). Available: %s (default: %s)"
+            % (" ".join(sorted(STRATEGIES)), " ".join(DEFAULT_STRATEGIES)))
 
     def sanity_check(self, args):
-        super(ReducerFuzzManagerIDQualityArgs, self).sanity_check(args)
-
-        if args.quality is not None and args.quality < 0:
-            self.parser.error("'--quality' value must be positive or zero")
+        super().sanity_check(args)
+
+        # if logs is specified, we need it to be a directory (whether existent or not)
+        if Path(args.logs).is_file():
+            self.parser.error("'--logs' cannot be a file")
+
+        # check that specified strategies exist
+        for strategy in args.strategies:
+            if strategy not in STRATEGIES:
+                self.parser.error("Unrecognized '--strategy': '%s'" % (strategy,))
+
+        if not args.no_analysis:
+            # analysis is enabled, but repeat/min_crashes specified. doesn't make sense
+            errors = []
+            if args.repeat != self.parser.get_default("repeat"):
+                errors.append("'--repeat'")
+            if args.min_crashes != self.parser.get_default("min_crashes"):
+                errors.append("'--min-crashes'")
+            if errors:
+                error_str = " and ".join(errors)
+                LOG.warning(
+                    "%s specified, with analysis enabled, they will be ignored",
+                    error_str
+                )
diff --git a/grizzly/reduce/bucket.py b/grizzly/reduce/bucket.py
deleted file mode 100644
index edb8e73f..00000000
--- a/grizzly/reduce/bucket.py
+++ /dev/null
@@ -1,136 +0,0 @@
-# coding=utf-8
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-import collections
-import json
-import logging
-import os
-import sys
-import tempfile
-
-from Collector.Collector import Collector
-
-from .args import ReducerFuzzManagerIDQualityArgs
-from .crash import CrashReductionJob
-
-
-LOG = logging.getLogger(__name__)
-
-
-def bucket_crashes(bucket_id, quality_filter):
-    """Fetch all crash IDs for the specified FuzzManager bucket.
-    Only crashes with testcases are returned.
-
-    Args:
-        bucket_id (int): ID of the requested bucket on the server side
-        quality_filter (int): Filter crashes by quality value (None for all)
-
-    Returns:
-        generator: generator of crash ID (int)
-    """
-    coll = Collector()
-
-    def _get_results(endpoint, params=None):
-        """
-        Function to get paginated results from FuzzManager
-
-        Args:
-            endpoint (str): FuzzManager REST API to query (eg. "crashes").
-            params (dict): Params to pass through to requests.get
-
-        Returns:
-            generator: objects returned by FuzzManager (as dicts)
-        """
-        LOG.debug("first request to /%s/", endpoint)
-
-        url = "%s://%s:%d/crashmanager/rest/%s/" \
-            % (coll.serverProtocol, coll.serverHost, coll.serverPort, endpoint)
-
-        response = coll.get(url, params=params).json()
-
-        while True:
-            LOG.debug("got %d/%d %s", len(response["results"]), response["count"], endpoint)
-            while response["results"]:
-                yield response["results"].pop()
-
-            if response["next"] is None:
-                break
-
-            LOG.debug("next request to /%s/", endpoint)
-            response = coll.get(response["next"]).json()
-
-    # Get all crashes for bucket
-    query_args = [
-        ("op", "AND"),
-        ("bucket", bucket_id),
-    ]
-    if quality_filter is not None:
-        query_args.append(("testcase__quality", quality_filter))
-    query = json.dumps(collections.OrderedDict(query_args))
-
-    n_yielded = 0
-    for crash in _get_results("crashes", params={"query": query, "include_raw": "0"}):
-
-        if not crash["testcase"]:
-            LOG.warning("crash %d has no testcase, skipping", crash["id"])
-            continue
-
-        n_yielded += 1
-        LOG.debug("yielding crash #%d", n_yielded)
-        yield crash["id"]
-
-
-def get_signature(bucket_id):
-    """
-    Download the signature for the specified FuzzManager bucket.
-
-    Args:
-        bucket_id (int): ID of the requested bucket on the server side
-
-    Returns:
-        str: temp filename to the JSON signature. caller must remove filename when done
-    """
-    coll = Collector()
-
-    url = "%s://%s:%d/crashmanager/rest/buckets/%d/" \
-        % (coll.serverProtocol, coll.serverHost, coll.serverPort, bucket_id)
-
-    response = coll.get(url).json()
-
-    sig_fd, sig_fn = tempfile.mkstemp(suffix=".json")
-    with os.fdopen(sig_fd, "w") as sig_fp:
-        sig_fp.write(response["signature"])
-
-    return sig_fn
-
-
-def main(args):
-    LOG.info("Trying all crashes in bucket %d until one reduces", args.input)
-
-    # if no signature specified, download the signature from FM
-    rm_sig = False
-    if not args.sig:
-        args.sig = get_signature(args.input)
-        rm_sig = True
-
-    try:
-        for crash_id in bucket_crashes(args.input, args.quality):
-
-            # reduce.main expects input to be a crash ID
-            args.input = crash_id
-
-            if CrashReductionJob.main(args) == 0:
-                # success!
-                return 0
-
-        # none of the testcases reduced
-        return 1
-
-    finally:
-        if rm_sig:
-            os.unlink(args.sig)
-
-
-if __name__ == "__main__":
-    sys.exit(main(ReducerFuzzManagerIDQualityArgs().parse_args()))
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
deleted file mode 100644
index dd17a6d4..00000000
--- a/grizzly/reduce/crash.py
+++ /dev/null
@@ -1,182 +0,0 @@
-# coding=utf-8
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-import logging
-import os
-import re
-import sys
-import tempfile
-
-from Collector.Collector import Collector
-
-from .args import ReducerFuzzManagerIDArgs
-from .reduce import ReductionJob
-from ..common import FuzzManagerReporter
-
-
-LOG = logging.getLogger(__name__)
-
-
-def crashentry_data(crash_id, raw=False):
-    """Get the CrashEntry data for the specified FuzzManager crash
-
-    Args:
-        crash_id (int): ID of the requested crash on the server side
-        raw (bool): include rawCrashData, rawStderr, rawStdout in result
-
-    Returns:
-        dict: crash entry data (crashmanager.models.CrashEntry)
-    """
-    coll = Collector()
-
-    LOG.debug("crash %d, downloading metadata...", crash_id)
-
-    url = "%s://%s:%d/crashmanager/rest/crashes/%s/" \
-        % (coll.serverProtocol, coll.serverHost, coll.serverPort, crash_id)
-
-    return coll.get(url, params={"include_raw": "1" if raw else "0"}).json()
-
-
-def download_crash(crash_id):
-    """Download testcase for the specified FuzzManager crash.
-
-    Args:
-        crash_id (int): ID of the requested crash on the server side
-
-    Returns:
-        str: Temporary filename of the testcase. Caller must remove when finished.
-    """
-    coll = Collector()
-
-    LOG.debug("crash %d, downloading testcase...", crash_id)
-
-    url = "%s://%s:%d/crashmanager/rest/crashes/%s/download/" \
-        % (coll.serverProtocol, coll.serverHost, coll.serverPort, crash_id)
-
-    response = coll.get(url)
-
-    disp_m = re.match(r'^attachment; filename="(.*)"$',
-                      response.headers.get("content-disposition", ""))
-
-    if disp_m is None:
-        raise RuntimeError("Server sent malformed response: %r" % (response,))
-
-    prefix = "crash.%d." % (crash_id,)
-    suffix = os.path.splitext(disp_m.group(1))[1]
-    testcase_fd, testcase_fn = tempfile.mkstemp(prefix=prefix, suffix=suffix)
-    with os.fdopen(testcase_fd, "wb") as testcase_fp:
-        testcase_fp.write(response.content)
-
-    return testcase_fn
-
-
-def change_quality(crash_id, quality):
-    """Update a FuzzManager crash entry quality.
-
-    Args:
-        crash_id (int): Crash ID on FuzzManager server
-        quality (int): Quality constant defined in FuzzManagerReporter.QUAL_*
-
-    Returns:
-        None
-    """
-    LOG.info("Updating crash %d to quality %s", crash_id, FuzzManagerReporter.quality_name(quality))
-    coll = Collector()
-
-    url = "%s://%s:%d/crashmanager/rest/crashes/%d/" \
-        % (coll.serverProtocol, coll.serverHost, coll.serverPort, crash_id)
-    try:
-        Collector().patch(url, data={"testcase_quality": quality})
-    except RuntimeError as exc:
-        # let 404's go .. evidently the crash was deleted
-        if str(exc) == "Unexpected HTTP response: 404":
-            LOG.warning("Failed to update (404), does the crash still exist?")
-        else:
-            raise
-
-
-class CrashReductionJob(ReductionJob):
-    __slots__ = ['_crash_id', '_fm_reporter', '_quality', '_testcase_path', '_tool_override',
-                 '_was_interesting']
-
-    def __init__(self, *args, **kwds):
-        super(CrashReductionJob, self).__init__(*args, **kwds)
-        self._crash_id = None
-        self._fm_reporter = False
-        self._quality = None
-        self._testcase_path = None
-        self._tool_override = False
-        self._was_interesting = False
-
-    def on_result(self, result_code):
-        # only update quality of the original crash if we are reporting to FuzzManager
-        if not self._fm_reporter:
-            return
-
-        if result_code == FuzzManagerReporter.QUAL_REDUCED_ORIGINAL:
-            # reduce succeeded
-            change_quality(self._crash_id, result_code)
-
-        elif result_code == FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE:
-            if self._quality == FuzzManagerReporter.QUAL_UNREDUCED:
-                # override result to request platform specific reduction
-                result_code = FuzzManagerReporter.QUAL_REQUEST_SPECIFIC
-            change_quality(self._crash_id, result_code)
-
-        # for these cases, something went wrong. a reduce log/result would be really valuable
-        elif result_code in {FuzzManagerReporter.QUAL_REDUCER_BROKE,
-                             FuzzManagerReporter.QUAL_REDUCER_ERROR}:
-            # for now just change the quality
-            change_quality(self._crash_id, result_code)
-
-        else:
-            LOG.error("Got unhandled quality: %s", FuzzManagerReporter.quality_name(result_code))
-
-    def on_interesting_crash(self, *args, **kwds):
-        super(CrashReductionJob, self).on_interesting_crash(*args, **kwds)
-        if self._was_interesting:
-            return
-        LOG.info("Crash %d reproduced!", self._crash_id)
-        if self._fm_reporter:
-            change_quality(self._crash_id, FuzzManagerReporter.QUAL_REPRODUCIBLE)
-        self._was_interesting = True
-
-    def run(self, *args, **kwds):
-        try:
-            return super(CrashReductionJob, self).run(*args, **kwds)
-        finally:
-            os.unlink(self._testcase_path)
-
-    @classmethod
-    def from_args(cls, args, target):
-        LOG.info("Trying crash %d", args.input)
-
-        try:
-            crash_id = args.input
-            testcase = download_crash(crash_id)
-            tool_override = args.tool is None
-            crash = crashentry_data(crash_id)
-            quality = crash["testcase_quality"]
-            if tool_override:
-                args.tool = crash["tool"]
-                LOG.info("Using toolname from crash: %s", args.tool)
-
-            # reduce.main expects input to be a path to testcase
-            args.input = testcase
-
-            job = super(CrashReductionJob, cls).from_args(args, target)
-            job._fm_reporter = args.fuzzmanager
-            job._crash_id = crash_id
-            job._tool_override = tool_override
-            job._quality = quality
-            job._testcase_path = testcase
-            return job
-
-        except:  # noqa
-            os.unlink(testcase)
-            raise
-
-
-if __name__ == "__main__":
-    sys.exit(CrashReductionJob.main(ReducerFuzzManagerIDArgs().parse_args()))
diff --git a/grizzly/reduce/exceptions.py b/grizzly/reduce/exceptions.py
deleted file mode 100644
index f9ed245a..00000000
--- a/grizzly/reduce/exceptions.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# coding=utf-8
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-__author__ = "Jesse Schwartzentruber"
-__credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
-
-
-class ReducerError(Exception):
-    pass
-
-
-class TestcaseError(ReducerError):
-    pass
-
-
-class NoTestcaseError(TestcaseError):
-    pass
-
-
-class CorruptTestcaseError(TestcaseError):
-    pass
diff --git a/grizzly/reduce/reduce.py b/grizzly/reduce/reduce.py
index cede6ced..7aaeaf4e 100644
--- a/grizzly/reduce/reduce.py
+++ b/grizzly/reduce/reduce.py
@@ -3,1225 +3,340 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """
-Given a build and testcase, try to reproduce it using a set of strategies.
+Given a build and testcase, try to reduce it using a set of strategies.
 """
-from __future__ import absolute_import
-import hashlib
-import io
-import json
-import logging
-import os
-import re
-import shutil
-import tempfile
-import time
-import zipfile
-import zlib
+from logging import getLogger
+from math import ceil, log
+from pathlib import Path
+from shutil import rmtree
+from tempfile import mkdtemp
 
-import lithium
-import sapphire
+from Collector.Collector import Collector
 from FTB.Signatures.CrashInfo import CrashSignature
+from sapphire import Sapphire
 
-from . import strategies as strategies_module, testcase_contents
-from .exceptions import CorruptTestcaseError, NoTestcaseError, ReducerError
-from ..common.reporter import FilesystemReporter, FuzzManagerReporter, Report
-from ..common.runner import Runner, RunResult
-from ..common.status import ReducerStats, Status
-from ..common.storage import TestCase, TestFile
+from ..common.reporter import FilesystemReporter, FuzzManagerReporter
+from ..common.storage import TestCase, TestCaseLoadFailure, TestFile
 from ..common.utils import grz_tmp
 from ..main import configure_logging
-from ..session import Session
-from ..target import load as load_target, sanitizer_opts, TargetLaunchError, \
-    TargetLaunchTimeout
+from ..replay import ReplayManager, ReplayResult
+from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
+from .strategies import STRATEGIES
 
 
 __author__ = "Jesse Schwartzentruber"
-__credits__ = ["Tyson Smith", "Jesse Schwartzentruber", "Jason Kratzer"]
+__credits__ = ["Jesse Schwartzentruber", "Tyson Smith"]
 
 
-LOG = logging.getLogger(__name__)
+LOG = getLogger(__name__)
 
 
-class LithiumInterestingProxy(object):
-    """Proxy to use a ReductionJob object as a Lithium interestingness script object.
-    """
-    __slots__ = ['_job']
-
-    def __init__(self, job):
-        self._job = job
-
-    def init(self, _args):
-        """Lithium initialization entrypoint.
-
-        Do any per-reduction loop setup needed.
-
-        Args:
-            _args (unused): Command line arguments from Lithium (N/A)
-
-        Returns:
-            None
-        """
-        self._job.lithium_init()
-
-    def interesting(self, _args, temp_prefix):
-        """Lithium main iteration entrypoint.
-
-        This should try the reduction and return True or False based on whether the reduction was
-        good or bad.
-
-        Args:
-            _args (unused): Command line arguments from Lithium (N/A)
-            temp_prefix (str): A unique prefix for any files written during this iteration.
-
-        Returns:
-            bool: True if reduced testcase is still interesting.
-        """
-        return self._job.lithium_interesting(temp_prefix)
-
-    def cleanup(self, _args):
-        """Lithium cleanup entrypoint.
-
-        Do any per-reduction loop cleanup needed.
-
-        Args:
-            _args (unused): Command line arguments from Lithium (N/A)
-
-        Returns:
-            None
-        """
-        self._job.lithium_cleanup()
-
-
-class IterationParamsProxy(object):
-    __slots__ = ['_fixed_timeout', '_job', '_use_result_cache']
-
-    def __init__(self, job):
-        self._job = job
-        self._use_result_cache = None
-        self._fixed_timeout = None
-
-    def __enter__(self):
-        # disable result cache setting
-        self._use_result_cache = self._job._use_result_cache
-        self._job._use_result_cache = False
-
-        # do not update the iteration timeout during analysis
-        self._fixed_timeout = self._job._fixed_timeout
-        self._job._fixed_timeout = True
-
-        return self
-
-    def __exit__(self, *_args):
-        # restore saved values
-        self._job._use_result_cache = self._use_result_cache
-        self._job._fixed_timeout = self._fixed_timeout
-
-    @property
-    def force_no_harness(self):
-        return self._job._force_no_harness
-
-    @property
-    def min_crashes(self):
-        return self._job._min_crashes
-
-    @min_crashes.setter
-    def min_crashes(self, value):
-        self._job._min_crashes = value
-
-    @property
-    def no_harness(self):
-        return self._job._no_harness
-
-    @no_harness.setter
-    def no_harness(self, value):
-        self._job._no_harness = value
-
-    @property
-    def relaunch(self):
-        return self._job._target.rl_reset
-
-    @relaunch.setter
-    def relaunch(self, value):
-        self._job._target.rl_reset = min(self._job._original_relaunch, value)
-
-    @property
-    def repeat(self):
-        return self._job._repeat
-
-    @repeat.setter
-    def repeat(self, value):
-        self._job._repeat = value
-
-    def commit(self):
-        # close target so new parameters take effect
-        self._job.close_target()
-
-
-class TimeoutsUpdateProxy(object):
-    __slots__ = ['_job']
-
-    def __init__(self, job):
-        self._job = job
-
-    @property
-    def idle(self):
-        return self._job._idle_timeout
-
-    @idle.setter
-    def idle(self, value):
-        self._job._idle_timeout = value
-
-    @property
-    def iteration(self):
-        return self._job._iter_timeout
-
-    @iteration.setter
-    def iteration(self, value):
-        self._job._iter_timeout = value
-
-
-class RunState(object):
-    __slots__ = ['files_to_reduce', 'original_size']
-
-    def __init__(self, files_to_reduce):
-        self.files_to_reduce = files_to_reduce
-        self.original_size = -1
-
-    def total_size(self):
-        return sum(os.stat(fn).st_size for fn in self.files_to_reduce)
-
-
-class TestcaseUpdateProxy(object):
-    __slots__ = ['_job', '_run_state']
-
-    def __init__(self, job, run_state):
-        self._job = job
-        self._run_state = run_state
-
-    @property
-    def cache_iter_harness_created(self):
-        return self._job._cache_iter_harness_created
-
-    @property
-    def root(self):
-        return self._job._tcroot
-
-    @root.setter
-    def root(self, value):
-        self._job._tcroot = value
-
-    @property
-    def entry(self):
-        return self._job._testcase
-
-    @entry.setter
-    def entry(self, value):
-        self._job._testcase = value
-
-    @property
-    def landing_page(self):
-        return self._job.landing_page
-
-    @landing_page.setter
-    def landing_page(self, value):
-        self._job.landing_page = value
-
-    @property
-    def files_to_reduce(self):
-        return self._run_state.files_to_reduce
-
-    @property
-    def original_size(self):
-        return self._run_state.original_size
-
-    @original_size.setter
-    def original_size(self, value):
-        self._run_state.original_size = value
-
-    def total_size(self):
-        return self._run_state.total_size()
-
-
-class ReductionJob(object):
-    LOGGERS_TO_WATCH = ("ffpuppet", "grizzly", "lithium", "sapphire")
-    DEFAULT_STRATEGIES = ("line", "cssbeautify", "jsbeautify", "collapsebraces", "jschar")
-    __slots__ = [
-        '_any_crash', '_best_testcase', '_cache_iter_harness_created', '_env_mod',
-        '_fixed_timeout', '_force_no_harness', '_idle_threshold', '_idle_timeout', '_ignore',
-        '_input_fname', '_interesting_report', '_iter_timeout', '_landing_page', '_log_handler',
-        '_min_crashes', '_no_harness', '_orig_sig', '_original_relaunch', '_other_crashes',
-        '_reduce_file', '_repeat', '_reporter', '_result_cache', '_result_code', '_server', '_server_map',
-        '_signature', '_skip', '_skip_analysis', '_skipped', '_status', '_target', '_tcroot', '_testcase',
-        '_tmpdir', '_use_result_cache',
-    ]
-
-    def __init__(self, ignore, target, iter_timeout, no_harness, any_crash, skip, min_crashes,
-                 repeat, idle_threshold, idle_timeout, testcase_cache=True, skip_analysis=False):
-        """Use lithium to reduce a testcase.
-
-        Args:
-            target (grizzly.target.Target): Target object to use for reduction.
-        """
-        self._any_crash = any_crash
-        self._best_testcase = None
-        self._cache_iter_harness_created = None
-        self._env_mod = None  # environment if specified in the testcase
-        self._fixed_timeout = False  # if True iter_timeout will not be changed
-        self._force_no_harness = no_harness
-        self._idle_threshold = idle_threshold
-        self._idle_timeout = idle_timeout
-        self._ignore = ignore  # things to ignore
-        self._input_fname = None
-        self._interesting_report = None
-        self._iter_timeout = iter_timeout
-        self._landing_page = None  # the file to point the target at
-        self._min_crashes = min_crashes
-        self._no_harness = no_harness
-        self._orig_sig = None  # signature to reduce to (if specified)
-        self._original_relaunch = target.rl_reset
-        self._other_crashes = {}
-        self._reduce_file = None  # the file to reduce
-        self._repeat = repeat
-        self._reporter = None
-        self._result_cache = {}
-        self._result_code = None
-        self._server = None  # a server to serve with
-        self._server_map = sapphire.ServerMap()  # manage dynamic requests, includes and redirects
-        self._signature = None
-        self._skip = skip
-        self._skip_analysis = skip_analysis
-        self._skipped = None
-        self._status = Status.start()
-        self._target = target  # a Puppet to run with
-        self._testcase = None
-        # testcase cache remembers if we have seen this reduce_file before and if so return the same
-        # interesting result
-        self._use_result_cache = testcase_cache
-        self._tmpdir = tempfile.mkdtemp(prefix="grzreduce", dir=grz_tmp("reduce"))
-        self._tcroot = os.path.join(self._tmpdir, "tc")
-        self._log_handler = self._start_log_capture()
-        if not self._skip_analysis:
-            # see if any of the args tweaked by analysis were overridden
-            # --relaunch is regarded as a maximum, so overriding the default is not a deal-breaker for this
-            if self._min_crashes != 1:
-                LOG.warning("--min-crashes=%d was given, skipping analysis", self._min_crashes)
-                self._skip_analysis = True
-            elif self._repeat != 1:
-                LOG.warning("--repeat=%d was given, skipping analysis", self._repeat)
-                self._skip_analysis = True
-
-    @property
-    def landing_page(self):
-        return os.path.basename(self._landing_page)
-
-    @landing_page.setter
-    def landing_page(self, value):
-        # this looks pointless, but it isn't since it affects both landing_page and wwwdir getters
-        self._landing_page = value
-
-    @property
-    def reduce_file(self):
-        return self._reduce_file
-
-    @reduce_file.setter
-    def reduce_file(self, value):
-        self._reduce_file = value
-        # landing page should default to same value as reduce file
-        if self._landing_page is None:
-            self._landing_page = value
-
-    @property
-    def result_code(self):
-        return self._result_code
-
-    @property
-    def server(self):
-        return self._server
-
-    @property
-    def target(self):
-        return self._target
-
-    @property
-    def wwwdir(self):
-        return os.path.dirname(os.path.realpath(self._landing_page))
-
-    def timeouts_proxy(self):
-        """Return a proxy for modifying the job timeouts.
-
-        Returns:
-            (object): an object used to modify the timeouts for this job
-                      attributes:
-                          - iteration (iteration timeout)
-                          - idle (idle timeout)
-        """
-        return TimeoutsUpdateProxy(self)
-
-    def testcase_proxy(self, run_state):
-        """Return a proxy for modifying the testcase.
-
-        Returns:
-            (object): an object used to modify the testcase for this job
-                      attributes:
-                          - iteration (iteration timeout)
-                          - idle (idle timeout)
-        """
-        return TestcaseUpdateProxy(self, run_state)
-
-    def analysis_mode(self, min_crashes=1, relaunch=1, repeat=1):
-        """Set parameters for testcase analysis. This has side-effects besides being a proxy:
-
-            - min_crashes/repeat/relaunch are preset according to the function parameters
-            - result cache is disabled (so every iteration runs fully) if used as a with-statement context
-            - times are not dynamically adjusted if used as a with-statement context
-
-        Args:
-            min_crashes (int): How many crashes are needed for a success.
-            relaunch (int): How many iterations between relaunch.
-            repeat (int): How many times to repeat the testcase per iteration.
-
-        Returns:
-            (context manager): an object that can be used to set new parameters
-                               as a result of analysis:
-                               attributes:
-                                   - min_crashes
-                                   - no_harness
-                                   - relaunch
-                                   - repeat
-        """
-        # pylint: disable=no-self-argument,no-self-use,protected-access
-
-        proxy = IterationParamsProxy(self)
-
-        # Set parameters for analysis
-        proxy.min_crashes = min_crashes
-        proxy.repeat = repeat
-        proxy.relaunch = relaunch
-
-        return proxy
-
-    def close_target(self):
-        if not self._target.closed:
-            self._target.close()
-
-    def lithium_init(self):
-        """Lithium initialization entrypoint. Do any per-reduction loop setup needed.
-
-        Args:
-            None
-
-        Returns:
-            None
-        """
-        self._skipped = None
-        self._best_testcase = None
-        self._result_cache = {}
-
-    def lithium_interesting(self, temp_prefix):
-        """Lithium main iteration entrypoint.
-
-        This should try the reduction and return True or False based on whether the reduction was
-        good or bad.  This is subject to a number of options (skip, repeat, cache) and so may
-        result in 0 or more actual runs of the target.
-
-        Args:
-            temp_prefix (str): A unique prefix for any files written during this iteration.
-
-        Returns:
-            bool: True if reduced testcase is still interesting.
-        """
-        # ensure the target is closed so "repeat" and "relaunch" never get out of sync
-        self.close_target()
-        if self._skip:
-            if self._skipped is None:
-                self._skipped = 0
-            elif self._skipped < self._skip:
-                self._skipped += 1
-                return False
-        n_crashes = 0
-        n_tries = max(self._repeat, self._min_crashes)
-        if self._use_result_cache:
-            with open(self.reduce_file, "rb") as test_fp:
-                cache_key = hashlib.sha1(test_fp.read()).hexdigest()
-            if cache_key in self._result_cache:
-                result = self._result_cache[cache_key]['result']
-                if result:
-                    LOG.info("Interesting (cached)")
-                else:
-                    LOG.info("Uninteresting (cached)")
-                return result
-
-        # create the TestCase to try
-        testcase = TestCase(self.landing_page, None, "grizzly.reduce", input_fname=self._input_fname)
-
-        # add testcase contents
-        for file_name in testcase_contents(self.wwwdir):
-            testcase.add_from_file(os.path.join(self.wwwdir, file_name), file_name,
-                                   required=bool(file_name == self.landing_page))
-
-        # add prefs
-        if self._target.prefs is not None:
-            testcase.add_meta(TestFile.from_file(self._target.prefs, "prefs.js"))
-
-        # add environment variables
-        if self._env_mod is not None:
-            for name, value in self._env_mod.items():
-                testcase.add_environ_var(name, value)
-
-        max_duration = 0
-        run_prefix = None
-        for try_num in range(n_tries):
-            if (n_tries - try_num) < (self._min_crashes - n_crashes):
-                break  # no longer possible to get min_crashes, so stop
-            self._status.report()
-            self._status.iteration += 1
-            run_prefix = "%s(%d)" % (temp_prefix, try_num)
-            interesting_report = self._run(testcase, run_prefix)
-            if interesting_report:
-                # track the maximum duration of the successful reduction attempts
-                if testcase.duration > max_duration:
-                    max_duration = testcase.duration
-                n_crashes += 1
-                if n_crashes >= self._min_crashes:
-                    self.on_interesting_crash(interesting_report)
-                    if self._use_result_cache:
-                        self._result_cache[cache_key] = {
-                            'result': interesting_report,
-                            'prefix': run_prefix
-                        }
-                    self._best_testcase = testcase
-                    # the amount of time it can take to replay a test case can vary
-                    # when under Valgrind so do not update the timeout in that case
-                    if not self._fixed_timeout and not getattr(self._target, "use_valgrind", False):
-                        self.update_timeout(max_duration)
-                    return True
-        if self._use_result_cache:
-            # No need to save the temp_prefix on uninteresting testcases
-            # But let's do it anyway to stay consistent
-            self._result_cache[cache_key] = {
-                'result': None,
-                'prefix': run_prefix
-            }
-        return False
-
-    def lithium_cleanup(self):
-        """Lithium cleanup entrypoint. Do any per-reduction loop cleanup needed.
-
-        Args:
-            None
-
-        Returns:
-            None
-        """
-        try:
-            if self._server is not None:
-                self._server.close()
-                self._server = None
-        finally:
-            if self._target is not None:
-                self._target.close()
-
-    def _add_san_suppressions(self, supp_file):
-        # Update the sanitizer *SAN_OPTIONS environment variable to use provided
-        # suppressions file
-        opt_key = '%s_OPTIONS' % os.path.basename(supp_file).split('.')[0].upper()
-        opts_data = self._env_mod.get(opt_key, '')
-        # the value matching *SAN_OPTIONS can be set to None
-        if opts_data is None:
-            opts_data = ''
-        opts = sanitizer_opts(opts_data)
-        opts['suppressions'] = '\'%s\'' % (supp_file,)
-        self._env_mod[opt_key] = ':'.join('='.join((k, v)) for k, v in opts.items())
-
-    def _start_log_capture(self):
-        """Add a log handler for grizzly and lithium messages generated during this job.
-        The handler is removed again by close()
-
-        Args:
-            None
-
-        Returns:
-            logging.Handler: The log handler to be removed later.
-        """
-        formatter = logging.Formatter("%(levelname).1s %(name)s [%(asctime)s] %(message)s")
-        handler = logging.FileHandler(os.path.join(self._tmpdir, "reducelog.txt"))
-        handler.setLevel(logging.DEBUG)
-        handler.setFormatter(formatter)
-        for logname in self.LOGGERS_TO_WATCH:
-            logging.getLogger(logname).addHandler(handler)
-
-        # check that DEBUG messages will actually get through
-        # if the root logger level is > DEBUG, messages will not get through to our log handler
-        # set root to DEBUG, and propagate the old root level to each root handler
-        root_logger = logging.getLogger()
-        root_level = root_logger.getEffectiveLevel()
-        if root_level > logging.DEBUG:
-            root_logger.setLevel(logging.DEBUG)
-            for root_handler in root_logger.handlers:
-                if root_handler.level < root_level:
-                    root_handler.setLevel(root_level)
-
-        return handler
-
-    def update_timeout(self, run_time):
-        # If run_time is less than poll-time, update it
-        LOG.debug('Run time %r', run_time)
-        new_poll_timeout = max(10, min(run_time * 1.5, self._idle_timeout))
-        if new_poll_timeout < self._idle_timeout:
-            LOG.info("Updating poll timeout to: %r", new_poll_timeout)
-            self._idle_timeout = new_poll_timeout
-        # If run_time * 2 is less than iter_timeout, update it
-        # in other words, decrease the timeout if this ran in less than half the timeout
-        # (floored at 10s)
-        new_iter_timeout = max(10, min(run_time * 2, self._iter_timeout))
-        if new_iter_timeout < self._iter_timeout:
-            LOG.info("Updating max timeout to: %r", new_iter_timeout)
-            self._iter_timeout = new_iter_timeout
-
-    def _run(self, testcase, temp_prefix):
-        """Run a single iteration against the target and determine if it is interesting. This is the
-        low-level iteration function used by `interesting`.
-
-        Args:
-            testcase (TestCase): The testcase to serve
-            temp_prefix (str): A unique prefix for any files written during this iteration.
-
-        Returns:
-            Report: Report from reduced testcase if still interesting else None.
-        """
-        interesting = None
-
-        # if target is closed and server is alive, we should restart it or else the first request
-        #   against /first_test will 404
-        if self._target.closed and self._server is not None:
-            self._server.close()
-            self._server = None
-        self._server_map.dynamic.clear()
-        self._server_map.redirect.clear()
-
-        # launch sapphire if needed
-        if self._server is None:
-            # have client error pages (code 4XX) call window.close() after a few seconds
-            self._server = sapphire.Sapphire(auto_close=2)
-
-            if not self._no_harness:
-                harness = os.path.join(os.path.dirname(__file__), '..', 'common', 'harness.html')
-                with open(harness, 'rb') as harness_fp:
-                    harness = harness_fp.read()
-                self._server_map.set_dynamic_response("grz_harness", lambda: harness, mime_type="text/html")
-            self._server_map.set_redirect("grz_current_test", str(self.landing_page), required=False)
+def change_quality(crash_id, quality):
+    """Update a FuzzManager crash entry quality.
 
-        runner = Runner(self._server, self._target, self._idle_threshold, self._idle_timeout)
-        if self._no_harness:
-            self._server.timeout = self._iter_timeout
-        else:
-            # wait a few extra seconds to avoid races between the harness & sapphire timing out
-            self._server.timeout = self._iter_timeout + 10
-
-        # (re)launch Target
-        if self._target.closed:
-            if self._no_harness:
-                location = runner.location(
-                    "/grz_current_test",
-                    self._server.port)
-            else:
-                location = runner.location(
-                    "/grz_harness",
-                    self._server.port,
-                    close_after=self._target.rl_reset,
-                    forced_close=self._target.forced_close,
-                    timeout=self._iter_timeout)
-            # Try to launch the browser, retry 4 times at most
-            runner.launch(location, env_mod=self._env_mod, max_retries=4, retry_delay=15)
-            self._target.step()
-
-        if not self._no_harness:
-            def _dyn_resp_close():  # pragma: no cover
-                if self.target.monitor.is_healthy():
-                    # delay to help catch window close/shutdown related crashes
-                    time.sleep(0.1)
-                    self.target.close()
-                return b"<h1>Close Browser</h1>"
-            self._server_map.set_dynamic_response("grz_close_browser", _dyn_resp_close, mime_type="text/html")
-            self._server_map.set_redirect("grz_next_test", str(self.landing_page), required=True)
-
-        # run test case
-        result = runner.run(self._ignore, self._server_map, testcase, wait_for_callback=self._no_harness)
-        testcase.duration = result.duration
-
-        # handle failure if detected
-        if result.status == RunResult.FAILED:
-            self._target.close()
-            testcase.purge_optional(result.served)
-
-            # save logs
-            result_logs = temp_prefix + "_logs"
-            if not os.path.exists(result_logs):
-                os.mkdir(result_logs)
-            self._target.save_logs(result_logs)
-
-            # create report
-            report = Report(result_logs, self._target.binary)
-
-            short_sig = report.crash_info.createShortSignature()
-            if short_sig == "No crash detected":
-                # XXX: need to change this to support reducing timeouts?
-                LOG.info("Uninteresting: no crash detected")
-            elif self._orig_sig is None or self._orig_sig.matches(report.crash_info):
-                interesting = report
-                LOG.info("Interesting: %s", short_sig)
-                if self._orig_sig is None and not self._any_crash:
-                    self._orig_sig = report.crash_signature
-            else:
-                LOG.info("Uninteresting: different signature: %s", short_sig)
-                self.on_other_crash_found(testcase, report)
-
-        elif result.status == RunResult.IGNORED:
-            LOG.info("Uninteresting: ignored")
-            self._target.close()
-
-        else:
-            LOG.info("Uninteresting: no failure detected")
-
-        # trigger relaunch by closing the browser if needed
-        self._target.check_relaunch()
-
-        return interesting
-
-    def _stop_log_capture(self):
-        """Stop handling reduce logs.
+    Args:
+        crash_id (int): Crash ID on FuzzManager server
+        quality (int): Quality constant defined in FuzzManagerReporter.QUAL_*
 
-        Args:
-            None
-
-        Returns:
-            None
-        """
-        if self._log_handler is None:
-            return
-        for logname in self.LOGGERS_TO_WATCH:
-            logging.getLogger(logname).removeHandler(self._log_handler)
-        self._log_handler.flush()
-        self._log_handler.close()
-        self._log_handler = None
-
-    def config_environ(self, environ):
-        with open(environ) as in_fp:
-            try:
-                self._env_mod = json.load(in_fp).get('env', {})
-            except ValueError:
-                # TODO: remove this once switched to 'test_info.json'
-                # legacy support for 'env_vars.txt'
-                self._env_mod = {}
-                in_fp.seek(0)
-                for line in in_fp:
-                    line = line.rstrip()
-                    if not line:
-                        continue
-                    key, value = line.split('=', 1)
-                    if not value:
-                        value = None
-                    self._env_mod[key] = value
-        # known sanitizer suppression files
-        known_suppressions = ('lsan.supp', 'ubsan.supp')
-        working_dir = os.path.dirname(environ)
-        for file_name in os.listdir(working_dir):
-            if file_name in known_suppressions:
-                self._add_san_suppressions(os.path.join(working_dir, file_name))
-
-    def config_signature(self, signature):
-        """Configure a signature to use for reduction.  If none is given, an automatic signature is
-        created based on the initial repro.
-
-        Args:
-            signature (str): A JSON signature to match for reduction.
-
-        Returns:
-            None
-        """
-        self._signature = CrashSignature(signature)
-
-    @staticmethod
-    def _get_landing_page(testpath):
-        """Parse test_info.json for landing page
-
-        Args:
-            testpath (str): Path to a testcase folder (containing a test_info.json from Grizzly).
-
-        Returns:
-            str: Path to the landing page within testpath
-        """
-        info_file = os.path.join(testpath, "test_info.json")
-        if os.path.isfile(info_file):
-            with open(info_file) as info:
-                landing_page = json.load(info).get("target", None)
-            if landing_page is None:
-                raise ReducerError("Could not find landing page in %s!" % (os.path.abspath(info_file),))
-            landing_page = os.path.join(testpath, landing_page)
+    Returns:
+        None
+    """
+    LOG.info("Updating crash %d to quality %s", crash_id, FuzzManagerReporter.quality_name(quality))
+    coll = Collector()
+
+    url = "%s://%s:%d/crashmanager/rest/crashes/%d/" \
+        % (coll.serverProtocol, coll.serverHost, coll.serverPort, crash_id)
+    try:
+        Collector().patch(url, data={"testcase_quality": quality})
+    except RuntimeError as exc:
+        # let 404's go .. evidently the crash was deleted
+        if str(exc) == "Unexpected HTTP response: 404":
+            LOG.warning("Failed to update (404), does the crash still exist?")
         else:
-            LOG.warning("Using deprecated test_info.txt")
-            with io.open(os.path.join(testpath, "test_info.txt"), encoding="utf-8") as info:
-                for line in info:
-                    if line.lower().startswith("landing page: "):
-                        landing_page = os.path.join(testpath,
-                                                    line.split(": ", 1)[1].strip())
-                        break
-                else:
-                    raise ReducerError("Could not find landing page in %s!"
-                                       % (os.path.abspath(info.name),))
-        if not os.path.isfile(landing_page):
-            raise ReducerError("Landing page %s does not exist in %s!"
-                               % (landing_page, os.path.abspath(info.name)))
-        return landing_page
-
-    def _http_abspath(self, path):
-        """Return an absolute HTTP path to `path` relative to tcroot"""
-        path = os.path.relpath(path, self._tcroot)
-        return '/' + '/'.join(path.split(os.sep))
-
-    def config_testcase(self, testcase):
-        """Prepare a user provided testcase for reduction.
-
-        Args:
-            testcase (str): Path to a testcase. This should be a Grizzly testcase (zip or folder) or html
-                            file.
-
-        Returns:
-            None
-        """
-        try:
-            # extract the testcase if necessary
-            if os.path.exists(self._tcroot):
-                raise ReducerError("Testcase already configured?")
-            if os.path.isfile(testcase):
-                if testcase.lower().endswith(".html"):
-                    os.mkdir(self._tcroot)
-                    shutil.copy(testcase, self._tcroot)
-                    info = {"target": os.path.basename(testcase)}
-                    with open(os.path.join(self._tcroot, "test_info.json"), "w") as info_fp:
-                        json.dump(info, info_fp, indent=2, sort_keys=True)
-                elif testcase.lower().endswith(".zip"):
-                    os.mkdir(self._tcroot)
-                    try:
-                        with zipfile.ZipFile(testcase) as zip_fp:
-                            zip_fp.extractall(path=self._tcroot)
-                    except (zlib.error, zipfile.BadZipfile):
-                        raise CorruptTestcaseError("Testcase is corrupted")
-                else:
-                    raise ReducerError("Testcase must be zip, html, or directory")
-            elif os.path.isdir(testcase):
-                shutil.copytree(testcase, self._tcroot)
-            else:
-                raise ReducerError("Testcase must be zip, html or directory")
-
-            self._input_fname = os.path.basename(testcase)
-
-            # get a list of all directories containing testcases (1-n, depending on how much history
-            # grizzly saved)
-            entries = set(os.listdir(self._tcroot))
-            if "test_info.json" in entries:
-                dirs = [self._tcroot]
-            elif "test_info.txt" in entries:
-                dirs = [self._tcroot]
-            else:
-                dirs = sorted([os.path.join(self._tcroot, entry) for entry in entries
-                               if os.path.exists(os.path.join(self._tcroot, entry, "test_info.json"))
-                               or os.path.exists(os.path.join(self._tcroot, entry, "test_info.txt"))],
-                              key=lambda x: -int(x.rsplit('-', 1)[1]))
-                if not dirs:
-                    raise NoTestcaseError("No testcase recognized at %r" % (testcase,))
-
-            # check for included prefs and environment
-            if "prefs.js" in os.listdir(dirs[0]):
-                # move the file out of tcroot because we prune these non-testcase files later
-                os.rename(os.path.join(dirs[0], "prefs.js"), os.path.join(self._tmpdir, "prefs.js"))
-                self._target.prefs = os.path.abspath(os.path.join(self._tmpdir, "prefs.js"))
-                LOG.warning("Using prefs included in testcase: %r", self._target.prefs)
-            if "test_info.json" in os.listdir(dirs[0]):
-                self.config_environ(os.path.join(dirs[0], "test_info.json"))
-            elif "env_vars.txt" in os.listdir(dirs[0]):
-                # TODO: remove this block once move to 'test_info.json' is complete
-                self.config_environ(os.path.join(dirs[0], "env_vars.txt"))
-            if self._env_mod:
-                LOG.warning("Using environment included in testcase")
-                self._target.forced_close = self._env_mod.get("GRZ_FORCED_CLOSE") != "0"
-
-            # if dirs is singular, we can use the testcase directly, otherwise we need to iterate over
-            # them all in order
-            pages = [self._get_landing_page(d) for d in dirs]
-            if len(pages) == 1:
-                self._testcase = pages[0]
-                self._cache_iter_harness_created = False
-
-            else:
-                # create a harness to iterate over the whole history
-                harness_path = os.path.join(os.path.dirname(__file__), '..', 'common', 'harness.html')
-                with io.open(harness_path, encoding="utf-8") as harness_fp:
-                    harness = harness_fp.read()
-                # change dump string so that logs can be told apart
-                harness = harness.replace("[grz harness]", "[cache iter]")
-                # change the window name so that window.open doesn't clobber self
-                harness = harness.replace("'GrizzlyFuzz'", "'CacheIterator'")
-                # insert the iteration timeout. insert it directly because we can't set a hash value
-                new_harness = re.sub(r"^(\s*let\s.*\btime_limit\b)",
-                                     r"\1 = %d" % (self._iter_timeout * 1000),
-                                     harness,
-                                     flags=re.MULTILINE)
-                if new_harness == harness:
-                    raise ReducerError("Unable to set time_limit in harness, please update pattern "
-                                       "to match harness!")
-                harness = new_harness
-                # make first test and next test grab from the array
-                harness = harness.replace("'/grz_current_test'", "_reduce_next()")
-                harness = harness.replace("'/grz_next_test'", "_reduce_next()")
-                # insert the close condition. we are iterating over the array of landing pages,
-                # undefined means we hit the end and the harness should close
-                # newer harness uses conditional operator in open() call
-                if re.search(r'open\(.*_reduce_next\(\)\s*:\s*_reduce_next\(\)', harness) is None:
-                    raise ReducerError("Unable to insert finish condition, please update pattern "
-                                       "to match harness!")
-                # insert the landing page loop
-                harness = harness.replace("<script>", "\n".join([
-                    "<script>",
-                    "let _reduce_tests = [",
-                    "//DDBEGIN",
-                    "'" + "',\n'".join(self._http_abspath(p) for p in pages) + "',",
-                    "//DDEND",
-                    "]",
-                    "let _reduce_next = () => {",
-                    "  if (!_reduce_tests.length) window.close()",
-                    "  return _reduce_tests.shift()",
-                    "}"
-                ]))
-
-                harness_fp, harness_path = \
-                    tempfile.mkstemp(prefix="harness_", suffix=".html", dir=self._tcroot)
-                os.close(harness_fp)
-                with io.open(harness_path, "w", encoding="utf-8") as harness_fp:
-                    harness_fp.write(harness)
-                self._testcase = harness_path
-                self._cache_iter_harness_created = True
-
-            # prune unnecessary files from the testcase
-            prune = {"env_vars.txt", "grizzly_fuzz_harness.html",
-                     "log_metadata.json", "prefs.js", "reducelog.txt",
-                     "screenlog.txt", "test_info.json", "test_info.txt"}
-            for root, _, files in os.walk(self._tcroot):
-                for file_ in files:
-                    if file_ in prune or (file_.startswith("log_") and file_.endswith(".txt")):
-                        os.unlink(os.path.join(root, file_))
-        except NoTestcaseError as exc:
-            LOG.warning("Could not set-up testcase: %s", exc)
-            self._result_code = FuzzManagerReporter.QUAL_NO_TESTCASE
-            raise
-        except Exception as exc:
-            LOG.warning("Could not set-up testcase: %s", exc)
-            self._result_code = FuzzManagerReporter.QUAL_REDUCER_ERROR
             raise
 
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *_args):
-        self.close()
-
-    def close(self, keep_temp=False):
-        """Clean up any resources used for this job.
-
-        Args:
-            None
-
-        Returns:
-            None
-        """
-        self._stop_log_capture()
-        if self._tmpdir is not None and os.path.isdir(self._tmpdir):
-            if keep_temp:
-                LOG.warning("Leaving working files at %r for inspection.", self._tmpdir)
-            else:
-                shutil.rmtree(self._tmpdir)
-                self._tmpdir = None
-        if self._target is not None:
-            self._target.cleanup()
-        self._status.cleanup()
-
-    def _report_result(self, testcase, report, quality_value, force=False):
-        self._reporter.quality = quality_value
-        self._reporter.force_report = force
-        self._reporter.submit([testcase], report)
-
-    def on_interesting_crash(self, report):
-        # called for any interesting crash
-        self._interesting_report = report
-
-    def on_result(self, result_code):
-        pass
-
-    def on_other_crash_found(self, testcase, report):
-        """
-        If we hit an alternate crash, store the testcase in a tmp folder.
-        If the same crash is encountered again, only keep the newest one.
-        """
-        short_sig = report.crash_info.createShortSignature()
-        if report.crash_hash in self._other_crashes:
-            LOG.info("Found alternate crash (newer): %s", short_sig)
-            # already counted when initially found
-            self._status.ignored += 1
-        else:
-            LOG.info("Found alternate crash: %s", short_sig)
-            self._status.count_result(short_sig)
-        self._other_crashes[report.crash_hash] = {"tc": testcase, "report": report}
-
-    def _report_other_crashes(self):
-        """
-        After reduce is finished, report any alternate results (if they don't match the collector cache).
-        """
-        for entry in self._other_crashes.values():
-            self._report_result(entry["tc"], entry["report"], FuzzManagerReporter.QUAL_UNREDUCED)
-
-    def run(self, strategies=None):
-        """Run reduction.
-        """
-        assert self._testcase is not None
-        assert self._reporter is not None
-
-        try:
-            # set up lithium
-            reducer = lithium.Lithium()
-            self._orig_sig = self._signature
-            self.landing_page = self._testcase
-            reducer.conditionScript = LithiumInterestingProxy(self)
-
-            # if we created a harness to iterate over history, files_to_reduce is initially just
-            #   that harness
-            # otherwise, the first stage will be skipped and we will scan for all testcases to
-            #   reduce in the second stage
-
-            run_state = RunState([self._testcase])
-
-            # resolve list of strategies to apply
-            reduce_stages = [strategies_module.MinimizeCacheIterHarness, strategies_module.ScanFilesToReduce]
-            if not self._skip_analysis:
-                if self._cache_iter_harness_created:
-                    # if we created a cache iterator harness analyze that first
-                    reduce_stages.insert(0, strategies_module.AnalyzeTestcase)
-                reduce_stages.append(strategies_module.AnalyzeTestcase)
-            if strategies is None:
-                strategies = self.DEFAULT_STRATEGIES
-            strategies_lut = strategies_module.strategies_by_name()
-            for strat in strategies:
-                try:
-                    strat = strategies_lut[strat]
-                except KeyError:
-                    raise ReducerError("Unknown strategy given: %r" % (strat,))
-                reduce_stages.append(strat)
-
-            # run lithium reduce with strategies
-
-            files_reduced = 0
-            for strategy_num, strategy_type in enumerate(reduce_stages):
-
-                result = -1
-                strategy = strategy_type(self, run_state, reducer)
-
-                for testcase_path in run_state.files_to_reduce:
-
-                    strategy.read_testcase(testcase_path)
-                    if strategy.should_skip():
-                        result = 0
-                        continue
-
-                    self.reduce_file = testcase_path
-                    # set up tempdir manually so it doesn't go in cwd
-                    reducer.tempDir = tempfile.mkdtemp(
-                        prefix="lith-%d-%s" % (strategy_num, strategy_type.name),
-                        dir=self._tmpdir)
-
-                    reducer.testCount = reducer.testTotal = 0
-                    result = reducer.run()
 
+class ReduceManager(object):
+    ANALYSIS_ITERATIONS = 11  # number of iterations to analyze
+    ANALYSIS_MIN_CRASHES = 2  # --min-crashes value when analysis is used
+    ANALYSIS_TARGET_PROBABILITY = 0.95  # probability that successful reduction will observe the crash
+    # to see the worst case, run the `repeat` calculation in run_reliability_analysis using
+    # crashes_percent = 1.0/ANALYSIS_ITERATIONS
+
+    def __init__(self, ignore, server, target, testcases, strategies, log_path, tool=None,
+                 report_to_fuzzmanager=False, any_crash=False, signature=None, use_harness=True,
+                 use_analysis=True):
+        self.ignore = ignore
+        self.server = server
+        self.strategies = strategies
+        self.target = target
+        self.testcases = testcases
+        self._any_crash = any_crash
+        self._log_path = log_path
+        # these parameters may be overwritten during analysis, so keep a copy of them
+        self._original_relaunch = target.relaunch
+        self._original_use_harness = use_harness
+        self._report_to_fuzzmanager = report_to_fuzzmanager
+        self._report_tool = tool
+        self._signature = signature
+        self._use_analysis = use_analysis
+        self._use_harness = use_harness
+
+    def run_reliability_analysis(self):
+        harness_crashes = 0
+        non_harness_crashes = 0
+
+        # Reset parameters.
+        # Use repeat=1 & relaunch=ITERATIONS because this is closer to how we will run post-analysis.
+        # We're only using repeat=1 instead of repeat=ITERATIONS so we can get feedback on every
+        #   call to interesting.
+        self.target.relaunch = self.ANALYSIS_ITERATIONS
+
+        for use_harness in [True, False]:
+            if use_harness and self._original_use_harness:
+                continue
+            if not use_harness and harness_crashes != self.ANALYSIS_ITERATIONS:
+                continue
+
+            with ReplayManager(self.ignore, self.server, self.target, any_crash=self._any_crash,
+                               signature=self._signature, use_harness=use_harness) as replay:
+                LOG.info("Running for %d iterations to assess reliability %s harness.",
+                         "using" if use_harness else "without", self.ANALYSIS_ITERATIONS)
+                for _ in range(self.ANALYSIS_ITERATIONS):
                     try:
-                        if result == 0:
-                            strategy.on_success()
-                            files_reduced += 1
-
-                        else:
-                            strategy.on_failure()
-                            result = 0  # if we passed on failure, don't fail below
-
-                    except StopIteration:
-                        break
-
-                if result != 0:
-                    # reducer failed to repro the crash
-                    if files_reduced == 0:
-                        # first stage, couldn't repro at all
-                        LOG.warning("Could not reduce: The testcase was not reproducible")
-                        self._result_code = FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE
-
-                    else:
-                        # subsequent stage, reducing broke the testcase?
-                        # unclear how to recover from this.
-                        # just report failure and hopefully we have another to try
-                        LOG.warning("%s failed to reproduce. Previous stage broke the testcase?",
-                                    strategy_type.__name__)
-                        self._result_code = FuzzManagerReporter.QUAL_REDUCER_BROKE
-
-                    return False
-
-            # all stages succeeded
-            reduced_size = run_state.total_size()
-            if reduced_size == run_state.original_size:
-                raise ReducerError("Reducer succeeded but nothing was reduced!")
-
-            self._report_result(self._best_testcase,
-                                self._interesting_report,
-                                FuzzManagerReporter.QUAL_REDUCED_RESULT,
-                                force=True)
-
-            # change original quality so unbucketed crashes don't reduce again
-            self._result_code = FuzzManagerReporter.QUAL_REDUCED_ORIGINAL
-            return True
-
-        except ReducerError as exc:
-            LOG.warning("Could not reduce: %s", exc)
-            self._result_code = FuzzManagerReporter.QUAL_REDUCER_ERROR
-            return False
-
-        except Exception:  # pylint: disable=broad-except
-            LOG.exception("Exception during reduce")
-            self._result_code = FuzzManagerReporter.QUAL_REDUCER_ERROR
-            return False
-
-        finally:
-            self._report_other_crashes()
-
-    def set_reporter(self, reporter):
-        self._reporter = reporter
-
-    @classmethod
-    def from_args(cls, args, target):
-        job = cls(
-            args.ignore,
-            target,
-            args.timeout,
-            args.no_harness,
-            args.any_crash,
-            args.skip,
-            args.min_crashes,
-            args.repeat,
-            args.idle_threshold,
-            args.idle_timeout,
-            not args.no_cache,
-            args.no_analysis)
-
-        job.config_testcase(args.input)
-
-        # arguments for environ and prefs should override the testcase
-        if args.environ:
-            LOG.warning("Overriding environment with %r", args.environ)
-            job.config_environ(args.environ)
-        if args.prefs:
-            LOG.warning("Overriding prefs with %r", args.prefs)
-            job.target.prefs = os.path.abspath(args.prefs)
-
-        if args.sig is not None:
-            with io.open(args.sig, encoding="utf-8") as sig_fp:
-                job.config_signature(sig_fp.read())
-
-        LOG.debug("initializing the Reporter")
-        if args.fuzzmanager:
-            LOG.info("Reporting issues via FuzzManager")
-            job.set_reporter(FuzzManagerReporter(tool=args.tool))
+                        results = replay.run(self.testcases, repeat=1, min_results=1)
+                    except (TargetLaunchError, TargetLaunchTimeout) as exc:
+                        if isinstance(exc, TargetLaunchError) and exc.report:
+                            self.report([ReplayResult(exc.report, None, False)], self.testcases)
+                            exc.report.cleanup()
+                        raise
+                    try:
+                        success = any(result.expected for result in results)
+                        LOG.info("result: %s", "interesting." if success else "not interesting.")
+                        self.report([result for result in results if not result.expected], self.testcases)
+                    finally:
+                        for result in results:
+                            result.cleanup()
+                    if success and use_harness:
+                        harness_crashes += 1
+                    elif success:
+                        non_harness_crashes += 1
+                LOG.info("Testcase was interesting %0.1f%% of %d attempts %s harness.",
+                         100.0 * harness_crashes / self.ANALYSIS_ITERATIONS, self.ANALYSIS_ITERATIONS,
+                         "using" if use_harness else "without")
+                # ensure same signature is always used
+                self._signature = replay.signature
+
+        if harness_crashes == 0 and non_harness_crashes == 0:
+            raise RuntimeError("TODO: Did not reproduce during analysis")
+
+        # should we use the harness? go with whichever crashed more
+        self._use_harness = non_harness_crashes <= harness_crashes
+
+        # this is max 99.9% to avoid domain errors in the calculation below
+        crashes_percent = min(1.0 * max(non_harness_crashes, harness_crashes) / self.ANALYSIS_ITERATIONS,
+                              0.999)
+
+        # adjust repeat/min-crashes depending on how reliable the testcase was
+        min_crashes = self.ANALYSIS_MIN_CRASHES
+        repeat = int(ceil(log(1 - self.ANALYSIS_TARGET_PROBABILITY, 1 - crashes_percent))
+                     * self.ANALYSIS_MIN_CRASHES)
+
+        LOG.info("Analysis results:")
+        if harness_crashes == self.ANALYSIS_ITERATIONS:
+            LOG.info("* testcase was perfectly reliable with the harness (--no-harness not assessed)")
+        elif harness_crashes == non_harness_crashes:
+            LOG.info("* testcase was equally reliable with/without the harness")
+        elif not self._original_use_harness:
+            LOG.info("* --no-harness was already set")
         else:
-            reporter = FilesystemReporter(os.path.join(os.getcwd(), "results"))
-            job.set_reporter(reporter)
-            LOG.info("Results will be stored in %r", reporter.report_path)
-
-        if args.fixed_timeout:
-            LOG.info("Using a fixed iteration timeout")
-        job._fixed_timeout = args.fixed_timeout
-
-        return job
+            LOG.info("* testcase was %s reliable with the harness",
+                     "more" if harness_crashes > non_harness_crashes else "less")
+        return (repeat, min_crashes)
+
+    def run(self, repeat=1, min_results=1):
+        last_reports = None
+        for strategy_no, strategy in enumerate(self.strategies):
+            LOG.info("Using strategy %s (%d/%d)", strategy, strategy_no + 1, len(self.strategies))
+            if self._use_analysis:
+                repeat, min_results = self.run_reliability_analysis()
+            self.target.relaunch = min(self._original_relaunch, repeat)
+            LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
+                     repeat, min_results, self.target.relaunch)
+            replay = ReplayManager(self.ignore, self.server, self.target, any_crash=self._any_crash,
+                                   signature=self._signature, use_harness=self._use_harness)
+            strategy = STRATEGIES[strategy](self.testcases)
+            with replay, strategy:
+                best_results = []
+                attempt_no = 0
+                try:
+                    for reduction in strategy:
+                        attempt_no += 1
+                        LOG.info("Attempt #%d", attempt_no)
+                        keep_reduction = False
+                        results = []
+                        try:
+                            try:
+                                # reduction is a new list of testcases to be replayed
+                                results = replay.run(reduction, repeat=repeat, min_results=min_results)
+                            except (TargetLaunchError, TargetLaunchTimeout) as exc:
+                                if isinstance(exc, TargetLaunchError) and exc.report:
+                                    self.report([ReplayResult(exc.report, None, False)], reduction)
+                                    exc.report.cleanup()
+                                raise
+                            success = any(report.expected for report in results)
+                            strategy.update(success)
+                            # if the reduction reproduced, update self.testcases (new best)
+                            if success:
+                                LOG.info("Interesting")
+                                for testcase in self.testcases:
+                                    testcase.cleanup()
+                                self.testcases = reduction
+                                keep_reduction = True
+                                # cleanup old best results
+                                for result in best_results:
+                                    result.cleanup()
+                                # filter expected results out into `best_results`
+                                best_results = [result for result in results if result.expected]
+                                results = [result for result in results if not result.expected]
+                            else:
+                                LOG.info("Uninteresting")
+                            # if the reduction found other crashes, report those immediately
+                            self.report(results, reduction)
+                        finally:  # noqa pylint: disable=bare-except
+                            if not keep_reduction:
+                                for testcase in reduction:
+                                    testcase.cleanup()
+                            for result in results:
+                                result.cleanup()
+                    last_reports = self.report(best_results, self.testcases)
+                finally:
+                    for result in best_results:
+                        result.cleanup()
+                # if self._signature was already set, this will do nothing
+                # otherwise, ensure the first found signature is used throughout
+                self._signature = replay.signature
+        # if we complete all strategies, mark the last reported crashes as reduced
+        if self._report_to_fuzzmanager and last_reports:
+            for crash_id in last_reports:
+                change_quality(crash_id, FuzzManagerReporter.QUAL_REDUCED_RESULT)
+        return bool(last_reports)  # true if anything expected was reported in the last round
+
+    def report(self, results, tests):
+        """Report results, either to fuzzmanager or to filesystem.
+        """
+        ret_values = []
+        for result in results:
+            if self._report_to_fuzzmanager:
+                reporter = FuzzManagerReporter(self.target.binary, self._report_tool)
+                if result.expected:
+                    reporter.force_report = True
+            else:
+                report_dir = "reports" if result.expected else "other_reports"
+                reporter = FilesystemReporter(
+                    report_path=str(Path(self._log_path) / report_dir),
+                    major_bucket=False)
+            ret_values.append(reporter.submit(tests, report=result.report))
+        return ret_values
 
     @classmethod
     def main(cls, args):
-        # NOTE: this mirrors grizzly.core.main pretty closely
-        #       please check if updates here should go there too
         configure_logging(args.log_level)
-        LOG.info("Starting Grizzly Reducer")
         if args.fuzzmanager:
             FuzzManagerReporter.sanity_check(args.binary)
 
+        LOG.info("Starting Grizzly Reduce")
+
         if args.ignore:
             LOG.info("Ignoring: %s", ", ".join(args.ignore))
         if args.xvfb:
             LOG.info("Running with Xvfb")
         if args.valgrind:
             LOG.info("Running with Valgrind. This will be SLOW!")
+        if args.rr:
+            LOG.info("Running with RR")
 
-        target = None
-        job = None
+        if args.sig:
+            signature = CrashSignature.fromFile(args.sig)
+        else:
+            signature = None
 
-        job_cancelled = False
+        LOG.debug("loading the TestCases")
         try:
-            LOG.debug("initializing the Target")
+            testcases = TestCase.load(args.input, args.prefs is None)
+            if not testcases:
+                raise TestCaseLoadFailure("Failed to load TestCases")
+        except TestCaseLoadFailure as exc:
+            LOG.error("Error: %s", str(exc))
+            return 1
 
+        target = None
+        tmp_prefs = None
+        try:
+            if args.no_harness:
+                LOG.debug("--no-harness specified relaunch set to 1")
+                args.relaunch = 1
+            args.repeat = max(args.min_crashes, args.repeat)
+            relaunch = min(args.relaunch, args.repeat)
+            LOG.debug("initializing the Target")
             target = load_target(args.platform)(
                 args.binary,
                 args.extension,
                 args.launch_timeout,
                 args.log_limit,
                 args.memory,
-                args.relaunch,
+                relaunch,
+                rr=args.rr,
                 valgrind=args.valgrind,
                 xvfb=args.xvfb)
-            job = cls.from_args(args, target)
-
-            result = job.run(strategies=args.strategies)
-
-            # report result out if callback requested
-            job.on_result(job.result_code)
-
-            # update stats
-            with ReducerStats() as stats:
-                if result:
-                    stats.passed += 1
-                elif job.result_code in (6, 10):
-                    stats.failed += 1
-                elif job.result_code in (7, 8, 9):
-                    stats.error += 1
-
-            if result:
-                LOG.info("Reduction succeeded: %s", FuzzManagerReporter.quality_name(job.result_code))
-                return Session.EXIT_SUCCESS
-
-            LOG.warning("Reduction failed: %s", FuzzManagerReporter.quality_name(job.result_code))
-            return Session.EXIT_ERROR
-
-        except NoTestcaseError:
-            with ReducerStats() as stats:
-                stats.error += 1
-            # TODO: test should be marked as Q7
-            return Session.EXIT_ERROR
-
-        except KeyboardInterrupt:
-            job_cancelled = True
-            return Session.EXIT_ABORT
-
-        except (TargetLaunchError, TargetLaunchTimeout) as exc:
-            LOG.error("Error launching target: %s", exc)
-            with ReducerStats() as stats:
-                stats.error += 1
-            return Session.EXIT_LAUNCH_FAILURE
+            # prioritize specified prefs.js file over included file
+            if args.prefs is not None:
+                for testcase in testcases:
+                    testcase.add_meta(TestFile.from_file(args.prefs, "prefs.js"))
+                LOG.info("Using specified prefs.js")
+                target.prefs = args.prefs
+            else:
+                for testcase in testcases:
+                    prefs_tf = testcase.get_file("prefs.js")
+                    if prefs_tf:
+                        tmp_prefs = Path(mkdtemp(prefix="prefs_", dir=grz_tmp("replay")))
+                        prefs_tf.dump(str(tmp_prefs))
+                        LOG.info("Using prefs.js from testcase")
+                        target.prefs = str(tmp_prefs / "prefs.js")
+                        break
+            if testcases[0].env_vars.get("GRZ_FORCED_CLOSE") == "0":
+                LOG.debug("setting target.forced_close=False")
+                target.forced_close = False
+
+            LOG.debug("starting sapphire server")
+            # launch HTTP server used to serve test cases
+            with Sapphire(auto_close=1, timeout=args.timeout) as server:
+                target.reverse(server.port, server.port)
+                mgr = ReduceManager(
+                    args.ignore,
+                    server,
+                    target,
+                    testcases,
+                    args.strategies,
+                    args.logs,
+                    tool=args.tool,
+                    report_to_fuzzmanager=args.fuzzmanager,
+                    any_crash=args.any_crash,
+                    signature=signature,
+                    use_harness=not args.no_harness,
+                    use_analysis=not args.no_analysis)
+                success = mgr.run(repeat=args.repeat, min_results=args.min_crashes)
+            return 0 if success else 1
+
+        except (KeyboardInterrupt, TargetLaunchError, TargetLaunchTimeout):
+            return 1
 
         finally:
             LOG.warning("Shutting down...")
-            if job is not None and not job_cancelled:
-                job_cancelled = job.result_code in {FuzzManagerReporter.QUAL_REDUCER_BROKE,
-                                                    FuzzManagerReporter.QUAL_REDUCER_ERROR}
-            if job is not None:
-                job.close(keep_temp=job_cancelled)
-            elif target is not None:
-                # job handles calling cleanup if it was created
+            if target is not None:
                 target.cleanup()
+            for testcase in testcases:
+                testcase.cleanup()
+            if tmp_prefs is not None:
+                rmtree(str(tmp_prefs), ignore_errors=True)
+            LOG.info("Done.")
diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index 22263407..558ce194 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -2,409 +2,202 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-import abc
-import logging
-import math
-import os
-import re
-
-try:
-    import cssbeautifier
-    HAVE_CSSBEAUTIFIER = True
-except ImportError:
-    HAVE_CSSBEAUTIFIER = False
-try:
-    import jsbeautifier
-    HAVE_JSBEAUTIFIER = True
-except ImportError:
-    HAVE_JSBEAUTIFIER = False
-import lithium
-
-from . import testcase_contents
-
-
-LOG = logging.getLogger(__name__)
-
-
-class ReduceStage(metaclass=abc.ABCMeta):
-    strategy_type = None
-    testcase_type = None
-
-    def __init__(self, job, run_state, reducer):
-        if getattr(self, "USES_ANALYSIS_MODE", False):
-            self._analysis_mode = job.analysis_mode
-        else:
-            self._analysis_mode = None
-
-        if getattr(self, "ALTERS_JOB_TESTCASE", False):
-            self.job_testcase = job.testcase_proxy(run_state)
-
-        if getattr(self, "ALTERS_JOB_TIMEOUTS", False):
-            self.job_timeouts = job.timeouts_proxy()
-
-        self.lithium = reducer
-
-    def read_testcase(self, testcase_path):
-        if self._analysis_mode is not None:
-            self.lithium.strategy = self.strategy_type(self._analysis_mode)  # pylint: disable=not-callable
-        else:
-            self.lithium.strategy = self.strategy_type()  # pylint: disable=not-callable
-        self.lithium.testcase = self.testcase_type()  # pylint: disable=not-callable
-        LOG.info("Reducing %s with %s on %ss",
-                 testcase_path, self.strategy_type.name, self.testcase_type.atom)
-        self.lithium.testcase.readTestcase(testcase_path)
-
-    def should_skip(self):  # pylint: disable=no-self-use
-        return False
-
-    def on_success(self):
-        LOG.info("%s succeeded", type(self).__name__)
-
-    def on_failure(self):  # pylint: disable=no-self-use
-        raise StopIteration()
-
-
-class MinimizeLines(ReduceStage):
-    name = "line"
-    strategy_type = lithium.Minimize
-    testcase_type = lithium.TestcaseLine
-
-
-class _AnalyzeReliability(lithium.Strategy):
-    name = "reliability-analysis"
-    ITERATIONS = 11  # number of iterations to analyze
-    MIN_CRASHES = 2  # --min-crashes value when analysis is used
-    TARGET_PROBABILITY = 0.95  # probability that successful reduction will observe the crash
-    # to see the worst case, run the `self.repeat` calculation below using
-    # crashes_percent = 1.0/ITERATIONS
-
-    def __init__(self, analysis_mode_cb):
-        super(_AnalyzeReliability, self).__init__()
-        self.analysis_mode_cb = analysis_mode_cb
-
-    def main(self, testcase, interesting, _temp_filename):
-
-        assert self.ITERATIONS > 0
-
-        harness_crashes = 0
-        non_harness_crashes = 0
-
-        # Reset parameters.
-        # Use repeat=1 & relaunch=ITERATIONS because this is closer to how we will run post-analysis.
-        # We're only using repeat=1 instead of repeat=ITERATIONS so we can get feedback on every
-        #   call to interesting.
-        with self.analysis_mode_cb(min_crashes=1, relaunch=self.ITERATIONS, repeat=1) as iter_params:
-
-            iter_params.commit()
-
-            if not iter_params.force_no_harness:
-                LOG.info("Running for %d iterations to assess reliability using harness.", self.ITERATIONS)
-                for _ in range(self.ITERATIONS):
-                    result = interesting(testcase, writeIt=False)  # pylint: disable=invalid-name
-                    LOG.info("Lithium result: %s", "interesting." if result else "not interesting.")
-                    if result:
-                        harness_crashes += 1
-                LOG.info("Testcase was interesting %0.1f%% of %d attempts using harness for iteration.",
-                         100.0 * harness_crashes / self.ITERATIONS, self.ITERATIONS)
-
-                # close target so new parameters take effect
-                iter_params.commit()
-
-            if harness_crashes != self.ITERATIONS:
-                # try without harness
-                iter_params.no_harness = True
-
-                LOG.info("Running for %d iterations to assess reliability without harness.",
-                         self.ITERATIONS)
-                for _ in range(self.ITERATIONS):
-                    result = interesting(testcase, writeIt=False)  # pylint: disable=invalid-name
-                    LOG.info("Lithium result: %s", "interesting." if result else "not interesting.")
-                    if result:
-                        non_harness_crashes += 1
-                LOG.info("Testcase was interesting %0.1f%% of %d attempts without harness.",
-                         100.0 * non_harness_crashes / self.ITERATIONS, self.ITERATIONS)
-
-                # close target so new parameters take effect
-                iter_params.commit()
-
-        if harness_crashes == 0 and non_harness_crashes == 0:
-            return 1  # no crashes ever?
-
-        # should we use the harness? go with whichever crashed more
-        iter_params.no_harness = non_harness_crashes > harness_crashes
-
-        # this is max 99% to avoid domain errors in the calculation below
-        crashes_percent = min(1.0 * max(non_harness_crashes, harness_crashes) / self.ITERATIONS, 0.99)
-
-        # adjust repeat/min-crashes depending on how reliable the testcase was
-        iter_params.min_crashes = self.MIN_CRASHES
-        iter_params.repeat = \
-            int(math.ceil(math.log(1 - self.TARGET_PROBABILITY, 1 - crashes_percent)) * self.MIN_CRASHES)
-        iter_params.relaunch = iter_params.repeat  # actual value used will respect relaunch requested by user
-
-        LOG.info("Analysis results:")
-        if harness_crashes == self.ITERATIONS:
-            LOG.info("* testcase was perfectly reliable with the harness (--no-harness not assessed)")
-        elif harness_crashes == non_harness_crashes:
-            LOG.info("* testcase was equally reliable with/without the harness")
-        elif iter_params.force_no_harness:
-            LOG.info("* --no-harness was already set")
-        else:
-            LOG.info("* testcase was %s reliable with the harness",
-                     "less" if iter_params.no_harness else "more")
-        LOG.info("* adjusted parameters: --min-crashes=%d --repeat=%d --relaunch=%d",
-                 iter_params.min_crashes, iter_params.repeat,
-                 iter_params.relaunch)
-
-        return 0
-
-
-class AnalyzeTestcase(ReduceStage):
-    name = "analyze"
-    USES_ANALYSIS_MODE = True
-    strategy_type = _AnalyzeReliability
-    testcase_type = lithium.TestcaseLine
-
-    def on_success(self):
-        super(AnalyzeTestcase, self).on_success()
-        # only run this strategy once, not once per reducible file in the testcase
-        raise StopIteration()
-
-
-class MinimizeCacheIterHarness(MinimizeLines):
-    name = "minimize-cache"
-    ALTERS_JOB_TESTCASE = True
-    ALTERS_JOB_TIMEOUTS = True
-
-    # job attributes:
-    # write: files_to_reduce (clear, append), tcroot, testcase, landing_page
-    # read: cache_iter_harness_created
-
-    def should_skip(self):
-        return not self.job_testcase.cache_iter_harness_created
-
-    def read_testcase(self, testcase_path):
-        if self.should_skip():
-            return
-
-        super(MinimizeCacheIterHarness, self).read_testcase(testcase_path)
-
-        # we are running multiple testcases in a single "iteration", so we need to
-        #   fix the timeout values
-
-        # start polling for idle after n-1 testcases have finished
-        self.job_timeouts.idle += \
-            self.job_timeouts.idle * (len(self.lithium.testcase) - 1)
-
-        # iteration timeout is * n testcases, but add 10 seconds for overhead from the
-        #   outer harness
-        self.job_timeouts.iteration = \
-            (self.job_timeouts.iteration + 10) * len(self.lithium.testcase)
-
-    def on_success(self):
-        # XXX: when py27 is dropped, this can be files_to_reduce.clear()
-        while self.job_testcase.files_to_reduce:
-            self.job_testcase.files_to_reduce.pop()
-        lines = lithium.TestcaseLine()
-        lines.readTestcase(self.job_testcase.entry)
-        if len(lines) == 1:
-            # we reduced this down to a single testcase, remove the harness
-            testcase_rel = lines.parts[0].strip().decode("utf-8")
-            assert testcase_rel.startswith("'/")
-            assert testcase_rel.endswith("',")
-            testcase_rel = testcase_rel[2:-2]  # trim chars asserted above
-            testcase_path = testcase_rel.split('/')
-            assert len(testcase_path) == 2
-            self.job_testcase.root = os.path.join(self.job_testcase.root, testcase_path[0])
-            self.job_testcase.entry = os.path.join(self.job_testcase.root, testcase_path[1])
-            self.job_testcase.landing_page = self.job_testcase.entry
-            self.job_testcase.files_to_reduce.append(self.job_testcase.entry)
-            LOG.info("Reduced history to a single file: %s", testcase_path[1])
-        else:
-            # don't bother trying to reduce the harness further,
-            #   leave harness out of files_to_reduce
-            LOG.info("Reduced history down to %d testcases", len(self.lithium.testcase))
-
-
-class ScanFilesToReduce(ReduceStage):
-    name = "scan-files"
-    ALTERS_JOB_TESTCASE = True
+"""
+Grizzly Reducer strategy definitions
+"""
+from abc import ABC, abstractmethod
+import json
+from logging import getLogger
+from pathlib import Path
+from shutil import rmtree
+from tempfile import mkdtemp
+from types import MappingProxyType
+
+from lithium.strategies import CheckOnly, Minimize
+from lithium.testcases import TestcaseLine
+from pkg_resources import iter_entry_points
+
+from ..common.utils import grz_tmp
+from ..common.storage import TestCase
+
+
+LOG = getLogger(__name__)
+
+
+DEFAULT_STRATEGIES = (
+    "list",
+    "lines",
+)
+
+
+def _load_strategies():
+    """STRATEGIES is created at the end of this file.
+    """
+    strategies = {}
+    for entry_point in iter_entry_points("grizzly_reduce_strategies"):
+        try:
+            strategy_cls = entry_point.load()
+            assert (
+                strategy_cls.name == entry_point.name
+            ), "entry_point name mismatch, check setup.py and %s.name" % (
+                strategy_cls.__name__,
+            )
+        except Exception as exc:  # pylint: disable=broad-except
+            LOG.debug("error loading strategy type %s: %s", entry_point.name, exc)
+            continue
+        strategies[entry_point.name] = strategy_cls
+    for strategy in DEFAULT_STRATEGIES:
+        assert (
+            strategy in strategies
+        ), "Unknown entry in DEFAULT_STRATEGIES: %s (STRATEGIES: [%s])" % (
+            strategy, ",".join(strategies)
+        )
+    return MappingProxyType(strategies)
 
-    # job attributes:
-    # read: tcroot, testcase, files_to_reduce (len, iter)
-    # modify: files_to_reduce (append, sort)
-    # write: original_size
 
-    def __init__(self, *args, **kwds):
-        super(ScanFilesToReduce, self).__init__(*args, **kwds)
-        # find all files for reduction
-        for file_name in testcase_contents(self.job_testcase.root):
-            file_name = os.path.join(self.job_testcase.root, file_name)
-            if file_name == self.job_testcase.entry:
-                continue
-            with open(file_name, "rb") as tc_fp:
-                for line in tc_fp:
-                    if b"DDBEGIN" in line:
-                        self.job_testcase.files_to_reduce.append(file_name)
-                        break
-        if len(self.job_testcase.files_to_reduce) > 1:
-            # sort by descending size
-            self.job_testcase.files_to_reduce.sort(key=lambda fn: os.stat(fn).st_size, reverse=True)
-        self.job_testcase.original_size = self.job_testcase.total_size()
+class Strategy(ABC):
+    def __init__(self, testcases):
+        self._testcase_root = Path(mkdtemp(prefix="tc_", dir=grz_tmp("reduce")))
+        for idx, testcase in enumerate(testcases):
+            LOG.debug("Extracting testcase %d/%d", idx + 1, len(testcases))
+            testpath = self._testcase_root / ("%03d" % (idx,))
+            testcase.dump(str(testpath), include_details=True)
 
-    def read_testcase(self, testcase_path):
+    @abstractmethod
+    def __iter__(self):
         pass
 
-    def should_skip(self):  # pylint: disable=no-self-argument
-        # no real reduce strategy, just used to scan for files
-        return True
-
-
-class CSSBeautify(ReduceStage):
-    name = "cssbeautify"
-    strategy_type = lithium.CheckOnly
-    testcase_type = lithium.TestcaseLine
-
-    def __init__(self, *args, **kwds):
-        super(CSSBeautify, self).__init__(*args, **kwds)
-        self.testcase_path = None
-        self.original_testcase = None
-        self._ext = None
-        self._force_skip = False
-
-    def read_testcase(self, testcase_path):
-        self.testcase_path = testcase_path
-        self._ext = testcase_path.rsplit(".", 1)[-1]
-
-        if self.should_skip():
-            return
-
-        # Beautify testcase
-        opts = (
-            ('end_with_newline', False),
-            ('indent_size', 2),
-            ('newline_between_rules', False),
-            ('preserve_newlines', False),
-        )
-        with open(testcase_path) as testcase_fp:
-            self.original_testcase = testcase_fp.read()
-        if self._ext == "css":
-            # DDBEGIN and DDEND are ignored here atm
-            LOG.info("Attempting to cssbeautify %s", testcase_path)
-            with open(testcase_path, "w") as testcase_fp:
-                testcase_fp.write(cssbeautifier.beautify(self.original_testcase, opts))
-        else:
-            # handle html files
-            begin = max(self.original_testcase.find("DDBEGIN"), 0)
-            end = self.original_testcase.find("DDEND")
-            if end == -1:
-                end = len(self.original_testcase)
-            re_tag = re.compile(r"(<style.*?>)(.*?)(</style>)", flags=re.DOTALL|re.IGNORECASE)
-            if not re_tag.search(self.original_testcase, begin, end):
-                LOG.debug("<style> tags not found in %r", testcase_path)
-                self._force_skip = True
-                self.original_testcase = None
-                return
-            pos = 0
-            with open(testcase_path, "w") as testcase_fp:
-                for match in re_tag.finditer(self.original_testcase, begin, end):
-                    testcase_fp.write(self.original_testcase[pos:match.start(2)])
-                    css = cssbeautifier.beautify(match.group(2), opts)
-                    if css:
-                        testcase_fp.write("\n")
-                        testcase_fp.write(css)
-                        testcase_fp.write("\n")
-                    pos = match.end(2)
-                testcase_fp.write(self.original_testcase[pos:])
-            LOG.info("Ran cssbeautify on %s", testcase_path)
-
-        self.lithium.strategy = self.strategy_type()  # pylint: disable=not-callable
-        self.lithium.testcase = self.testcase_type()  # pylint: disable=not-callable
-        self.lithium.testcase.readTestcase(testcase_path)
+    @abstractmethod
+    def update(self, success):
+        pass
 
-    def should_skip(self):
-        if HAVE_CSSBEAUTIFIER and not self._force_skip:
-            if self._ext in ("css", "htm", "html"):
-                return False
-        return True
+    def __enter__(self):
+        return self
 
-    def on_failure(self):
-        LOG.warning("CSSBeautification failed (reverting)")
-        with open(self.testcase_path, "w") as testcase_fp:
-            testcase_fp.write(self.original_testcase)
+    def __exit__(self, *args, **kwds):
+        self.cleanup()
 
+    def cleanup(self):
+        rmtree(str(self._testcase_root))
 
-class JSBeautify(ReduceStage):
-    name = "jsbeautify"
-    strategy_type = lithium.CheckOnly
-    testcase_type = lithium.TestcaseLine
 
+class _LithiumStrategy(Strategy, ABC):
+    """Must define name, testcase_cls (lithium.testcases.Testcase), and
+    strategy_cls (lithium.strategies.Strategy).
+    """
     def __init__(self, *args, **kwds):
-        super(JSBeautify, self).__init__(*args, **kwds)
-        self.testcase_path = None
-        self.original_testcase = None
-
-    def read_testcase(self, testcase_path):
-        self.testcase_path = testcase_path
-
-        if self.should_skip():
-            return
-
-        LOG.info("Attempting to jsbeautify %s", testcase_path)
-
-        self.lithium.strategy = self.strategy_type()  # pylint: disable=not-callable
-        self.lithium.testcase = self.testcase_type()  # pylint: disable=not-callable
-
-        # Beautify testcase
-        with open(testcase_path) as testcase_fp:
-            self.original_testcase = testcase_fp.read()
-
-        beautified_testcase = jsbeautifier.beautify(self.original_testcase)
-        # All try/catch pairs will be expanded on their own lines
-        # Collapse these pairs when only a single instruction is contained
-        #   within
-        regex = r"(\s*try {)\n\s*(.*)\n\s*(}\s*catch.*)"
-        beautified_testcase = re.sub(regex, r"\1 \2 \3", beautified_testcase)
-        with open(testcase_path, 'w') as testcase_fp:
-            testcase_fp.write(beautified_testcase)
-
-        self.lithium.testcase.readTestcase(testcase_path)
-
-    def should_skip(self):
-        if HAVE_JSBEAUTIFIER and self.testcase_path.endswith(".js"):
-            # jsbeautifier is only effective with JS files
-            return False
-        return True
+        super().__init__(*args, **kwds)
+        self._current_reducer = None
+        self._files_to_reduce = []
+        for path in self._testcase_root.glob("**/*"):
+            if path.is_file() and path.name not in {"test_info.json", "prefs.js"}:
+                self._files_to_reduce.append(path)
+
+    def update(self, success):
+        assert self._current_reducer is not None
+        self._current_reducer.feedback(success)
+
+    def __iter__(self):
+        LOG.info("Reducing %d files", len(self._files_to_reduce))
+        for file_no, file in enumerate(self._files_to_reduce):
+            LOG.info("Reducing %s (file %d/%d)", file, file_no + 1, len(self._files_to_reduce))
+            lithium_testcase = self.testcase_cls()  # pylint: disable=no-member
+            lithium_testcase.load(file)
+            # pylint: disable=no-member
+            self._current_reducer = self.strategy_cls().reduce(lithium_testcase)
+            for reduction in self._current_reducer:
+                reduction.dump()
+                yield TestCase.load(str(self._testcase_root), False)
+            # write out the best found testcase
+            self._current_reducer.testcase.dump()
+            self._current_reducer = None
+
+
+class MinimizeTestcaseList(Strategy):
+    """Try removing testcases from a list of sequential testcases (eg. Grizzly result
+    cache). The strategy favours testcases at the tail of the list, so for a list of
+    five testcases:
+                        testcases
+                0       1 2 3 4 5
+    iteration   1         2 3 4 5
+                2       1   3 4 5
+                3       1 2   4 5
+                4       1 2 3   5
+                5       1 2 3 4
+    """
+    name = "list"
 
-    def on_failure(self):
-        LOG.warning("JSBeautification failed (reverting)")
-        with open(self.testcase_path, 'w') as testcase_fp:
-            testcase_fp.write(self.original_testcase)
-
-
-class CollapseEmptyBraces(ReduceStage):
-    name = "collapsebraces"
-    strategy_type = lithium.CollapseEmptyBraces
-    testcase_type = lithium.TestcaseLine
-
-
-class MinimizeChars(ReduceStage):
-    name = "char"
-    strategy_type = lithium.Minimize
-    testcase_type = lithium.TestcaseChar
-
-
-class MinimizeJSChars(ReduceStage):
-    name = "jschar"
-    strategy_type = lithium.Minimize
-    testcase_type = lithium.TestcaseJsStr
-
-
-def strategies_by_name():
-    result = {}
-    for cls in globals().values():
-        if isinstance(cls, type) and issubclass(cls, ReduceStage) and cls is not ReduceStage:
-            if cls.name in result:
-                raise RuntimeError("Duplicate strategy name: %s" % (cls.name,))
-            result[cls.name] = cls
-    return result
+    def __init__(self, *args, **kwds):
+        super().__init__(*args, **kwds)
+        self._current_feedback = None
+
+    def update(self, success):
+        assert self._current_feedback is None
+        self._current_feedback = success
+
+    def __iter__(self):
+        assert self._current_feedback is None
+        idx = 0
+        testcases = None
+        try:
+            testcases = TestCase.load(str(self._testcase_root), False)
+            n_testcases = len(testcases)
+            while True:
+                if n_testcases <= 1:
+                    LOG.info("Testcase list has length %d, not enough to reduce!", n_testcases)
+                    break
+                if idx >= n_testcases:
+                    LOG.info("Attempted to remove every single testcase")
+                    break
+                # try removing the testcase at idx
+                if testcases is None:
+                    testcases = TestCase.load(str(self._testcase_root), False)
+                    assert n_testcases == len(testcases)
+                removed_ts = testcases[idx].timestamp
+                testcases.pop(idx).cleanup()
+                yield testcases
+                testcases = None  # caller owns testcases now
+                assert self._current_feedback is not None, "no feedback received!"
+                if self._current_feedback:
+                    # removal was success! find the testcase that matches timestamp,
+                    # and remove it
+                    LOG.info("Removing testcase %d/%d was successful!", idx, n_testcases)
+                    removed_path = None
+                    for test_info in self._testcase_root.glob("*/test_info.json"):
+                        info = json.loads(test_info.read_text())
+                        if removed_ts == info["timestamp"]:
+                            assert (
+                                removed_path is None
+                            ), "Duplicate testcases found with timestamp %s" % (
+                                removed_ts,
+                            )
+                            removed_path = test_info
+                    assert (
+                        removed_path is not None
+                    ), "No testcase found with timestamp %s" % (removed_ts,)
+                    rmtree(str(removed_path.parent))
+                    n_testcases -= 1
+                else:
+                    LOG.info("No result without testcase %d/%d", idx, n_testcases)
+                    idx += 1
+                # reset
+                self._current_feedback = None
+        finally:
+            if testcases is not None:
+                for testcase in testcases:
+                    testcase.cleanup()
+
+
+class Check(_LithiumStrategy):
+    name = "check"
+    strategy_cls = CheckOnly
+    testcase_cls = TestcaseLine
+
+
+class MinimizeLines(_LithiumStrategy):
+    name = "lines"
+    strategy_cls = Minimize
+    testcase_cls = TestcaseLine
+
+
+STRATEGIES = _load_strategies()
diff --git a/grizzly/reduce/test_common.py b/grizzly/reduce/test_common.py
deleted file mode 100644
index 02b386ee..00000000
--- a/grizzly/reduce/test_common.py
+++ /dev/null
@@ -1,235 +0,0 @@
-# coding=utf-8
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-# pylint: disable=protected-access
-from __future__ import unicode_literals
-import os
-from grizzly.target.target import Target
-from grizzly.common import Report, Reporter
-from grizzly.reduce import crash
-from grizzly.reduce.reduce import ReductionJob
-
-class BaseFakeReporter(Reporter):
-    def _post_submit(self):
-        pass
-
-    def _pre_submit(self, _):
-        pass
-
-    def _submit_report(self, *_args, **_kwds):
-        pass
-
-
-class FakeTarget(object):
-    "Stub to fake parts of grizzly.target.Target needed for testing the reduce loop"
-    RESULT_NONE = 0
-    RESULT_FAILURE = 1
-    RESULT_IGNORED = 2
-
-    def __init__(self, *args, **kwds):
-        self.rl_reset = 10
-        self.closed = True
-        self.binary = ""
-        self.forced_close = os.getenv("GRZ_FORCED_CLOSE", "1").lower() not in ("false", "0")
-        self.launch_timeout = 300
-        self.prefs = None
-        self.rl_countdown = 0
-        self.use_valgrind = False
-
-        self._calls = {
-            "check_relaunch": 0,
-            "cleanup": 0,
-            "close": 0,
-            "detect_failure": 0,
-            "is_idle": 0,
-            "launch": 0,
-            "save_logs": 0,
-        }
-        self._is_healthy = False
-
-        class FakeMonitor(object):  # pylint: disable=too-few-public-methods
-
-            @staticmethod
-            def is_healthy():
-                return self._is_healthy
-
-        self.monitor = FakeMonitor()
-
-    def save_logs(self, dest, **kwds):
-        self._calls["save_logs"] += 1
-        with open(os.path.join(dest, "log_stdout.txt"), "w") as log_fp:
-            log_fp.write("STDOUT")
-        with open(os.path.join(dest, "log_stderr.txt"), "w") as log_fp:
-            log_fp.write("Assertion failure: bad thing happened, at test.c:123")
-
-    def is_idle(self, *args, **kwds):
-        self._calls["is_idle"] += 1
-        return False
-
-    def launch(self, *args, **kwds):
-        self._calls["launch"] += 1
-
-    def check_relaunch(self):
-        self._calls["check_relaunch"] += 1
-
-    def close(self):
-        self._calls["close"] += 1
-
-    def cleanup(self):
-        self._calls["cleanup"] += 1
-
-    def detect_failure(self, *args, **kwds):
-        self._calls["detect_failure"] += 1
-        return Target.RESULT_FAILURE
-
-    @property
-    def expect_close(self):
-        return self.rl_countdown < 1 and not self.forced_close
-
-    def step(self):
-        self.rl_countdown -= 1
-
-
-def create_target_binary(target, tmp_path):
-    (tmp_path / "firefox.fuzzmanagerconf").write_text(
-        "[Main]\n"
-        "platform = x86-64\n"
-        "product = mozilla-central\n"
-        "os = linux\n"
-    )
-    target.binary = str(tmp_path / "firefox")
-
-def write_fail_log(path):
-    with open(os.path.join(path, "log_stderr.txt"), "wb") as log_fp:
-        log_fp.write(b"==1==ERROR: AddressSanitizer: SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n")
-        log_fp.write(b"    #0 0xbad000 in foo /file1.c:123:234\n")
-        log_fp.write(b"    #1 0x1337dd in bar /file2.c:1806:19")
-
-class TestReductionJob(ReductionJob):
-    """Stub to fake parts of grizzly.reduce.ReductionJob needed for testing the reduce loop"""
-    __slots__ = []
-
-    def __init__(self, tmp_path, create_binary=True, testcase_cache=False, skip_analysis=True):
-        super(TestReductionJob, self).__init__([], FakeTarget(), 60, False, False, 0, 1, 1, 3, 25,
-                                               testcase_cache=testcase_cache,
-                                               skip_analysis=skip_analysis)
-        if create_binary:
-            create_target_binary(self.target, tmp_path)
-
-    def lithium_init(self):
-        pass
-
-    def close(self, *_args, **_kwds):
-        super(TestReductionJob, self).close(keep_temp=False)
-
-    def _run(self, testcase, temp_prefix):
-        result_logs = temp_prefix + "_logs"
-        os.mkdir(result_logs)
-        self.target.save_logs(result_logs)
-        testcase.duration = 0.1
-        with open(self.reduce_file) as fp:
-            if "required" in fp.read():
-                write_fail_log(result_logs)
-                report = Report(result_logs, self.target.binary)
-            else:
-                report = None
-        return report
-
-
-    def lithium_cleanup(self):
-        pass
-
-
-class TestMainReductionJob(TestReductionJob):
-    __slots__ = []
-
-    def __init__(self, *_args, **_kwds):
-        super(TestMainReductionJob, self).__init__(None, create_binary=False)
-
-
-# this is the same as TestReductionJob, but for CrashReductionJob
-class TestMainCrashReductionJob(TestMainReductionJob, crash.CrashReductionJob):
-    """Stub to fake parts of grizzly.crash.CrashReductionJob needed for testing the reduce loop"""
-    __slots__ = []
-
-
-class TestReductionJobAlt(TestReductionJob):
-    """Version of TestReductionJob that only reports alternate crashes"""
-    __slots__ = ['__first_run']
-
-    def lithium_init(self):
-        self.__first_run = True
-
-    def _run(self, testcase, temp_prefix):
-        result_logs = temp_prefix + "_logs"
-        os.mkdir(result_logs)
-        self.target.save_logs(result_logs)
-        testcase.duration = 0.1
-        with open(self.reduce_file) as fp:
-            if "required" in fp.read():
-                write_fail_log(result_logs)
-                report = Report(result_logs, self.target.binary)
-                self.on_other_crash_found(testcase, report)
-            else:
-                report = None
-        if self.__first_run:
-            self.__first_run = False
-        return report
-
-
-class TestReductionJobKeepHarness(TestReductionJob):
-    """Version of TestReductionJob that keeps the entire harness"""
-    __slots__ = ['__init_data']
-
-    def lithium_init(self):
-        self.__init_data = None
-        if os.path.basename(self.reduce_file).startswith("harness_"):
-            with open(self.reduce_file) as harness_fp:
-                self.__init_data = harness_fp.read()
-
-    def _run(self, testcase, temp_prefix):
-        result_logs = temp_prefix + "_logs"
-        os.mkdir(result_logs)
-        self.target.save_logs(result_logs)
-        testcase.duration = 0.1
-        if self.__init_data is not None:
-            with open(self.reduce_file) as fp:
-                if self.__init_data == fp.read():
-                    write_fail_log(result_logs)
-                    return Report(result_logs, self.target.binary)
-        else:
-            with open(self.reduce_file) as fp:
-                if "required" in fp.read():
-                    write_fail_log(result_logs)
-                    return Report(result_logs, self.target.binary)
-        return None
-
-
-class TestReductionJobSemiReliable(TestReductionJob):
-    """Version of TestReductionJob that returns interesting N times only"""
-    __slots__ = ['__interesting_times', '__interesting_count', '__require_no_harness']
-
-    def __init__(self, *args, **kwds):
-        super(TestReductionJobSemiReliable, self).__init__(*args, **kwds)
-        self.__interesting_times = 0
-        self.__interesting_count = 0
-        self.__require_no_harness = False
-
-    def test_set_n(self, n, require_no_harness=False):
-        self.__interesting_times = n
-        self.__interesting_count = 0
-        self.__require_no_harness = require_no_harness
-
-    def _run(self, testcase, temp_prefix):
-        result_logs = temp_prefix + "_logs"
-        os.mkdir(result_logs)
-        self.target.save_logs(result_logs)
-        testcase.duration = 0.1
-        if self.__require_no_harness and not self._no_harness:
-            return None
-        self.__interesting_count += 1
-        if self.__interesting_count <= self.__interesting_times:
-            write_fail_log(result_logs)
-            return Report(result_logs, self.target.binary)
-        return None
diff --git a/grizzly/reduce/test_interesting.py b/grizzly/reduce/test_interesting.py
deleted file mode 100644
index 8622eada..00000000
--- a/grizzly/reduce/test_interesting.py
+++ /dev/null
@@ -1,484 +0,0 @@
-# coding=utf-8
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-# pylint: disable=protected-access
-from __future__ import unicode_literals
-import os
-import time
-import pytest
-import sapphire
-from ..common import Report
-from ..reduce.reduce import ReductionJob
-from ..target.target import Target, TargetLaunchError, TargetLaunchTimeout
-from .test_common import FakeTarget, create_target_binary
-
-
-class FakeServer(object):
-    _last_timeout = None
-
-    def __init__(self, **kwds):
-        FakeServer._last_timeout = kwds.get("timeout")
-
-    def close(self):
-        pass
-
-    @property
-    def port(self):  # pylint: disable=no-self-use
-        return 8000
-
-    def add_dynamic_response(self, *args, **kwds):
-        pass
-
-    def set_redirect(self, *args, **kwds):
-        pass
-
-    def serve_path(self, *args, **kwds):  # pylint: disable=no-self-use,unused-argument
-        return sapphire.SERVED_ALL, ["test.html"]
-
-    @property
-    def timeout(self):
-        return FakeServer._last_timeout
-
-    @timeout.setter
-    def timeout(self, value):  # pylint: disable=no-self-use
-        assert value is None or value >= 0
-        FakeServer._last_timeout = value
-
-
-@pytest.fixture
-def fake_sapphire(monkeypatch):
-    monkeypatch.setattr(sapphire, "Sapphire", FakeServer)
-    FakeServer._last_timeout = None
-
-pytestmark = pytest.mark.usefixtures("fake_sapphire")
-
-
-def test_interesting(tmp_path):
-    "simple case where the test is interesting"
-    with ReductionJob([], FakeTarget(), 30, False, False, 0, 1, 1, 0, 0) as obj:
-        create_target_binary(obj.target, tmp_path)
-        (tmp_path / "test.html").touch()
-        obj.reduce_file = str(tmp_path / "test.html")
-        obj.lithium_init()
-        (tmp_path / "lithium").mkdir()
-        assert obj.lithium_interesting(str(tmp_path / "lithium"))
-        assert "grz_close_browser" in obj._server_map.dynamic
-        assert "grz_harness" in obj._server_map.dynamic
-        assert "grz_current_test" in obj._server_map.redirect
-        assert "grz_next_test" in obj._server_map.redirect
-        assert obj.target._calls["close"] == 1
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-        assert obj.target._calls["detect_failure"] == 1
-
-
-def test_not_interesting(tmp_path):
-    "simple case where the test is not interesting"
-
-    class MyTarget(FakeTarget):
-
-        def detect_failure(self, *args, **kwds):
-            FakeTarget.detect_failure(self, *args, **kwds)
-            return Target.RESULT_NONE
-
-    with ReductionJob([], MyTarget(), 30, False, False, 0, 1, 1, 0, 0) as obj:
-        create_target_binary(obj.target, tmp_path)
-        obj.target._is_healthy = True
-        (tmp_path / "test.html").touch()
-        obj.reduce_file = str(tmp_path / "test.html")
-        obj.lithium_init()
-        (tmp_path / "lithium").mkdir()
-        assert not obj.lithium_interesting(str(tmp_path / "lithium"))
-        assert obj.server is not None
-        assert obj.target._calls["close"] == 0
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-        assert obj.target._calls["detect_failure"] == 1
-
-
-def test_ignored(tmp_path):
-    "if target says ignored, it's not interesting"
-
-    class MyTarget(FakeTarget):
-
-        def detect_failure(self, ignored, *args, **kwds):
-            FakeTarget.detect_failure(self, *args, **kwds)
-            assert ignored == ["foo", "bar"]
-            return Target.RESULT_IGNORED
-
-    with ReductionJob(["foo", "bar"], MyTarget(), 30, False, False, 0, 1, 1, 0, 0) as obj:
-        create_target_binary(obj.target, tmp_path)
-        (tmp_path / "test.html").touch()
-        obj.reduce_file = str(tmp_path / "test.html")
-        obj.lithium_init()
-        (tmp_path / "lithium").mkdir()
-        assert not obj.lithium_interesting(str(tmp_path / "lithium"))
-        assert obj.server is not None
-        assert obj.target._calls["close"] == 1
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-        assert obj.target._calls["detect_failure"] == 1
-
-
-def test_target_relaunch_error(mocker, tmp_path):
-    "target should be launched only once on TargetLaunchError"
-
-    class MyTarget(FakeTarget):
-
-        def launch(self, *args, **kwds):
-            FakeTarget.launch(self, *args, **kwds)
-            raise TargetLaunchError("test", mocker.Mock(spec=Report))
-
-    with ReductionJob([], MyTarget(), 30, False, False, 0, 1, 1, 0, 0) as obj:
-        create_target_binary(obj.target, tmp_path)
-        prefix = tmp_path / "lithium"
-        prefix.mkdir()
-        (tmp_path / "test.html").touch()
-        obj.reduce_file = str(tmp_path / "test.html")
-        obj.lithium_init()
-        with pytest.raises(TargetLaunchError, match="test"):
-            obj.lithium_interesting(str(prefix))
-        assert obj.server is not None
-        assert obj.target._calls["launch"] == 1
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-
-
-def test_target_relaunch_timeout(mocker, tmp_path):
-    "target should be launched more than once on TargetLaunchTimeout"
-
-    mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    class MyTarget(FakeTarget):
-
-        def launch(self, *args, **kwds):
-            FakeTarget.launch(self, *args, **kwds)
-            raise TargetLaunchTimeout()
-
-    with ReductionJob([], MyTarget(), 30, False, False, 0, 1, 1, 0, 0) as obj:
-        create_target_binary(obj.target, tmp_path)
-        prefix = tmp_path / "lithium"
-        prefix.mkdir()
-        (tmp_path / "test.html").touch()
-        obj.reduce_file = str(tmp_path / "test.html")
-        obj.lithium_init()
-        with pytest.raises(TargetLaunchTimeout):
-            obj.lithium_interesting(str(prefix))
-        assert obj.server is not None
-        assert obj.target._calls["launch"] > 1
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-
-
-def test_no_harness(tmp_path):
-    "simple case where harness is not used"
-    with ReductionJob([], FakeTarget(), 30, True, False, 0, 1, 1, 0, 0) as obj:
-        create_target_binary(obj.target, tmp_path)
-        prefix = tmp_path / "lithium"
-        prefix.mkdir()
-        reduce_file = tmp_path / "test.html"
-        reduce_file.touch()
-        obj.reduce_file = str(reduce_file)
-        obj.lithium_init()
-        assert obj.lithium_interesting(str(prefix))
-        assert "grz_close_browser" not in obj._server_map.dynamic
-        assert "grz_harness" not in obj._server_map.dynamic
-        assert "grz_current_test" in obj._server_map.redirect
-        assert "grz_next_test" not in obj._server_map.redirect
-        assert obj.target._calls["close"] == 1
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-        assert obj.target._calls["detect_failure"] == 1
-
-
-def test_skip(tmp_path):
-    "skip should assume interesting for the first n calls, without launching the target"
-    with ReductionJob([], FakeTarget(), 30, False, False, 7, 1, 1, 0, 0,
-                      testcase_cache=False) as obj:
-        create_target_binary(obj.target, tmp_path)
-        reduce_file = tmp_path / "test.html"
-        reduce_file.touch()
-        obj.reduce_file = str(reduce_file)
-        obj.lithium_init()
-        # first call is real, regardless of skip, since that is the initial repro
-        prefix = tmp_path / "lithium0"
-        prefix.mkdir()
-        assert obj.lithium_interesting(str(prefix))
-        assert obj.target._calls["launch"] == 1
-        assert obj.target._calls["close"] == 1
-        for _ in range(7):
-            assert not obj.lithium_interesting(None)
-        assert obj.target._calls["launch"] == 1
-        prefix = tmp_path / "lithium1"
-        prefix.mkdir()
-        assert obj.lithium_interesting(str(prefix))
-        assert obj.target._calls["launch"] == 2
-        assert obj.target._calls["close"] == 2
-        assert obj.server is not None
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-
-
-def test_any_crash_false(tmp_path):
-    "subsequent crashes must match the original if any_crash is False"
-    stderr = "Assertion failure: bad thing happened, at test.c:123"
-
-    class MyTarget(FakeTarget):
-
-        def save_logs(self, dest, **kwds):
-            FakeTarget.save_logs(self, dest, **kwds)
-            with open(os.path.join(dest, "log_stderr.txt"), "w") as log_fp:
-                log_fp.write(stderr)
-
-    with ReductionJob([], MyTarget(), 30, False, False, 0, 1, 1, 0, 0,
-                      testcase_cache=False) as obj:
-        create_target_binary(obj.target, tmp_path)
-        reduce_file = tmp_path / "test.html"
-        reduce_file.touch()
-        obj.reduce_file = str(reduce_file)
-        obj.lithium_init()
-        # first call is real, regardless of skip, since that is the initial repro
-        prefix = tmp_path / "lithium0"
-        prefix.mkdir()
-        assert obj.lithium_interesting(str(prefix))
-        assert obj.target._calls["launch"] == 1
-        assert obj.target._calls["close"] == 1
-        prefix = tmp_path / "lithium1"
-        prefix.mkdir()
-        stderr = "Assertion failure: some other thing happened, at test.c:456"
-        assert not obj.lithium_interesting(str(prefix))  # doesn't match original sig
-        assert obj.target._calls["launch"] == 2
-        assert obj.target._calls["close"] == 2
-        assert obj.server is not None
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-
-
-def test_any_crash_true(tmp_path):
-    "subsequent crashes need not match the original if any_crash is True"
-    stderr = "Assertion failure: bad thing happened, at test.c:123"
-
-    class MyTarget(FakeTarget):
-
-        def save_logs(self, dest, **kwds):
-            FakeTarget.save_logs(self, dest, **kwds)
-            with open(os.path.join(dest, "log_stderr.txt"), "w") as log_fp:
-                log_fp.write(stderr)
-
-    with ReductionJob([], MyTarget(), 30, False, True, 0, 1, 1, 0, 0,
-                      testcase_cache=False) as obj:
-        create_target_binary(obj.target, tmp_path)
-        reduce_file = tmp_path / "test.html"
-        reduce_file.touch()
-        obj.reduce_file = str(reduce_file)
-        obj.lithium_init()
-        # first call is real, regardless of skip, since that is the initial repro
-        prefix = tmp_path / "lithium0"
-        prefix.mkdir()
-        assert obj.lithium_interesting(str(prefix))
-        assert obj.target._calls["launch"] == 1
-        assert obj.target._calls["close"] == 1
-        prefix = tmp_path / "lithium1"
-        prefix.mkdir()
-        stderr = "Assertion failure: some other thing happened, at test.c:456"
-        assert obj.lithium_interesting(str(prefix))
-        assert obj.target._calls["launch"] == 2
-        assert obj.target._calls["close"] == 2
-        assert obj.server is not None
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-
-
-def test_min_crashes_repro(tmp_path):
-    "min_crashes will force n iterations if crash repros"
-    with ReductionJob([], FakeTarget(), 30, False, False, 0, 4, 1, 0, 0,
-                      testcase_cache=False) as obj:
-        create_target_binary(obj.target, tmp_path)
-        reduce_file = tmp_path / "test.html"
-        reduce_file.touch()
-        obj.reduce_file = str(reduce_file)
-        obj.lithium_init()
-        prefix = tmp_path / "lithium"
-        prefix.mkdir()
-        assert obj.lithium_interesting(str(prefix))
-        assert obj.target._calls["launch"] == 4
-        assert obj.target._calls["close"] == 4
-        assert obj.server is not None
-        assert obj.target._calls["detect_failure"] == 4
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-
-
-def test_min_crashes_norepro(tmp_path):
-    "min_crashes will return uninteresting if crash repros n-1 times"
-
-    class MyTarget(FakeTarget):
-        repros = 0
-
-        def detect_failure(self, *args, **kwds):
-            FakeTarget.detect_failure(self, *args, **kwds)
-            if self.repros == 3:
-                return Target.RESULT_NONE
-            self.repros += 1
-            return Target.RESULT_FAILURE
-
-    with ReductionJob([], MyTarget(), 30, False, False, 0, 4, 1, 0, 0,
-                      testcase_cache=False) as obj:
-        create_target_binary(obj.target, tmp_path)
-        reduce_file = tmp_path / "test.html"
-        reduce_file.touch()
-        obj.reduce_file = str(reduce_file)
-        obj.lithium_init()
-        prefix = tmp_path / "lithium"
-        prefix.mkdir()
-        assert not obj.lithium_interesting(str(prefix))
-        assert obj.target._calls["launch"] == 4
-        assert obj.target._calls["close"] == 3
-        assert obj.server is not None
-        assert obj.target._calls["detect_failure"] == 4
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-
-
-def test_repeat_repro(tmp_path):
-    "repeat will stop at min_crashes if crash repros"
-    with ReductionJob([], FakeTarget(), 30, False, False, 0, 4, 17, 0, 0,
-                      testcase_cache=False) as obj:
-        create_target_binary(obj.target, tmp_path)
-        reduce_file = tmp_path / "test.html"
-        reduce_file.touch()
-        obj.reduce_file = str(reduce_file)
-        obj.lithium_init()
-        prefix = tmp_path / "lithium"
-        prefix.mkdir()
-        assert obj.lithium_interesting(str(prefix))
-        assert obj.server is not None
-        assert obj.target._calls["detect_failure"] == 4
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-
-
-def test_repeat_norepro(tmp_path):
-    "repeat will force repeat - min_crashes + 1 iterations if crash doesn't repro"
-
-    class MyTarget(FakeTarget):
-
-        def detect_failure(self, *args, **kwds):
-            FakeTarget.detect_failure(self, *args, **kwds)
-            return Target.RESULT_NONE
-
-    with ReductionJob([], MyTarget(), 30, False, False, 0, 4, 17, 0, 0,
-                      testcase_cache=False) as obj:
-        create_target_binary(obj.target, tmp_path)
-        reduce_file = tmp_path / "test.html"
-        reduce_file.touch()
-        obj.reduce_file = str(reduce_file)
-        obj.lithium_init()
-        prefix = tmp_path / "lithium"
-        prefix.mkdir()
-        assert not obj.lithium_interesting(str(prefix))
-        assert obj.server is not None
-        assert obj.target._calls["detect_failure"] == 17 - 4 + 1
-        obj.lithium_cleanup()
-        assert obj.target._calls["cleanup"] == 0
-
-
-def test_cache(tmp_path):
-    "cache will be hit if same file is given twice"
-    with ReductionJob([], FakeTarget(), 30, False, False, 0, 1, 1, 0, 0) as obj:
-        create_target_binary(obj.target, tmp_path)
-        (tmp_path / "test.html").touch()
-        obj.reduce_file = str(tmp_path / "test.html")
-        obj.lithium_init()
-        (tmp_path / "lithium0").mkdir()
-        assert obj.lithium_interesting(tmp_path / "lithium0")
-        (tmp_path / "lithium1").mkdir()
-        assert obj.lithium_interesting(tmp_path / "lithium1")
-        assert obj.target._calls["detect_failure"] == 1
-        obj.lithium_cleanup()
-
-
-def test_no_cache(tmp_path):
-    "testcase_cache=False will disable cache"
-    with ReductionJob([], FakeTarget(), 30, False, False, 0, 1, 1, 0, 0,
-                      testcase_cache=False) as obj:
-        create_target_binary(obj.target, tmp_path)
-        (tmp_path / "test.html").touch()
-        obj.reduce_file = str(tmp_path / "test.html")
-        obj.lithium_init()
-        (tmp_path / "lithium0").mkdir()
-        assert obj.lithium_interesting(tmp_path / "lithium0")
-        (tmp_path / "lithium1").mkdir()
-        assert obj.lithium_interesting(tmp_path / "lithium1")
-        assert obj.target._calls["detect_failure"] == 2
-        obj.lithium_cleanup()
-
-
-def test_timeout_update(monkeypatch, tmp_path):
-    "timeout will be updated based on time to crash"
-    monkeypatch.setattr(time, "time", lambda: 0)  # run time will be calculated as 0
-    failure_result = Target.RESULT_NONE
-
-    class MyTarget(FakeTarget):
-
-        def detect_failure(self, *args, **kwds):
-            FakeTarget.detect_failure(self, *args, **kwds)
-            return failure_result
-
-    with ReductionJob([], MyTarget(), 30, False, False, 0, 1, 1, 0, 30,
-                      testcase_cache=False) as obj:
-        create_target_binary(obj.target, tmp_path)
-        (tmp_path / "test.html").touch()
-        obj.reduce_file = str(tmp_path / "test.html")
-        obj.lithium_init()
-        assert not obj._fixed_timeout
-        assert obj._idle_timeout == 30
-        (tmp_path / "lithium0").mkdir()
-        assert not obj.lithium_interesting(tmp_path / "lithium0")
-        assert obj._idle_timeout == 30
-        assert obj.server is not None
-        last_timeout = FakeServer._last_timeout
-        assert last_timeout >= 30
-        failure_result = Target.RESULT_FAILURE
-        obj._fixed_timeout = True
-        (tmp_path / "lithium1").mkdir()
-        assert obj.lithium_interesting(tmp_path / "lithium1")
-        assert obj._idle_timeout == 30
-        assert FakeServer._last_timeout == last_timeout
-        obj._fixed_timeout = False
-        (tmp_path / "lithium2").mkdir()
-        assert obj.lithium_interesting(tmp_path / "lithium2")
-        assert obj._idle_timeout < 30
-        idle_timeout = obj._idle_timeout
-        assert FakeServer._last_timeout == last_timeout
-        last_timeout = FakeServer._last_timeout
-        (tmp_path / "lithium3").mkdir()
-        assert obj.lithium_interesting(tmp_path / "lithium3")
-        assert obj._idle_timeout == idle_timeout
-        assert FakeServer._last_timeout  # assert that there is actually a timeout
-        assert FakeServer._last_timeout < last_timeout
-        last_timeout = FakeServer._last_timeout
-        assert obj.server is not None
-        (tmp_path / "lithium4").mkdir()
-        assert obj.lithium_interesting(tmp_path / "lithium4")
-        assert obj._idle_timeout == idle_timeout
-        assert FakeServer._last_timeout == last_timeout
-        assert obj.server is not None
-        obj.lithium_cleanup()
-
-
-def test_idle_timeout(mocker, tmp_path):
-    "idle is not polled until idle_timeout has passed, and idle_poll results in timeout"
-    fake_ichk = mocker.patch("grizzly.common.runner._IdleChecker", autospec=True)
-    with ReductionJob([], FakeTarget(), 30, False, False, 0, 1, 1, 25, 30,
-                      testcase_cache=False) as obj:
-        create_target_binary(obj.target, tmp_path)
-        (tmp_path / "test.html").touch()
-        obj.reduce_file = str(tmp_path / "test.html")
-        obj.lithium_init()
-        (tmp_path / "lithium0").mkdir()
-        assert obj.lithium_interesting(tmp_path / "lithium0")
-        assert fake_ichk.called
-        assert fake_ichk.call_args[0][1] == 25  # idle_threshold
-        assert fake_ichk.call_args[0][2] == 30  # idle_timeout
-        obj.lithium_cleanup()
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
deleted file mode 100644
index bfd4c5b1..00000000
--- a/grizzly/reduce/test_main.py
+++ /dev/null
@@ -1,472 +0,0 @@
-# coding=utf-8
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-# pylint: disable=protected-access
-from __future__ import unicode_literals
-import re
-import zipfile
-import pytest
-from grizzly.reduce.args import ReducerArgs, ReducerFuzzManagerIDArgs, ReducerFuzzManagerIDQualityArgs
-from grizzly.reduce import reduce, crash, bucket
-from grizzly.common import reporter
-from .test_common import BaseFakeReporter, TestMainReductionJob, TestMainCrashReductionJob
-
-
-def test_parse_args(capsys, tmp_path):
-    "test that grizzly.reduce args are accepted and validated"
-    exe = tmp_path / "binary"
-    inp = tmp_path / "input"
-
-    # missing arg tests
-    with pytest.raises(SystemExit):
-        ReducerArgs().parse_args([])
-    _, err = capsys.readouterr()
-    with pytest.raises(SystemExit):
-        ReducerArgs().parse_args([str(exe)])
-    _, err = capsys.readouterr()
-
-    # invalid binary tests
-    with pytest.raises(SystemExit):
-        ReducerArgs().parse_args([str(exe), str(inp)])
-    _, err = capsys.readouterr()
-    assert "error: file not found: %r" % (str(exe),) in err
-    exe.mkdir()
-    with pytest.raises(SystemExit):
-        ReducerArgs().parse_args([str(exe), str(inp)])
-    _, err = capsys.readouterr()
-    assert "error: file not found: %r" % (str(exe),) in err
-    exe.rmdir()
-    exe.touch()
-
-    # invalid input tests
-    with pytest.raises(SystemExit):
-        ReducerArgs().parse_args([str(exe), str(inp)])
-    _, err = capsys.readouterr()
-    assert "error: %r does not exist" % (str(inp),) in err
-    inp.touch()
-    with pytest.raises(SystemExit):
-        ReducerArgs().parse_args([str(exe), str(inp)])
-    _, err = capsys.readouterr()
-    assert "error: Testcase should be a folder, zip, or html file" in err
-    inp.unlink()
-    with pytest.raises(SystemExit):
-        ReducerFuzzManagerIDArgs().parse_args([str(exe), str(inp)])
-    _, err = capsys.readouterr()
-    assert "invalid int value" in err
-
-    # valid binary & inputs
-    (tmp_path / "input.zip").touch()
-    zipf = tmp_path / "input.zip"
-    ReducerArgs().parse_args([str(exe), str(zipf)])
-    zipf.unlink()
-    inp.mkdir()
-    (inp / "test_info.txt").touch()
-    ReducerArgs().parse_args([str(exe), str(inp)])
-    ReducerFuzzManagerIDArgs().parse_args([str(exe), '123'])
-
-    # sig/environ tests
-    fname = tmp_path / "file.txt"
-    for arg in ("--sig", "--environ"):
-        with pytest.raises(SystemExit):
-            ReducerArgs().parse_args([str(exe), str(inp), arg, str(fname)])
-        _, err = capsys.readouterr()
-        assert "error: file not found: %r" % (str(fname),) in err
-        fname.mkdir()
-        with pytest.raises(SystemExit):
-            ReducerArgs().parse_args([str(exe), str(inp), arg, str(fname)])
-        _, err = capsys.readouterr()
-        assert "error: file not found: %r" % (str(fname),) in err
-        fname.rmdir()
-        fname.touch()
-        ReducerArgs().parse_args([str(exe), str(inp), arg, str(fname)])
-        fname.unlink()
-
-    # repeat/min-crashes tests
-    for arg in ("--repeat", "--min-crashes"):
-        with pytest.raises(SystemExit):
-            ReducerArgs().parse_args([str(exe), str(inp), arg, "abc"])
-        with pytest.raises(SystemExit):
-            ReducerArgs().parse_args([str(exe), str(inp), arg, "-1"])
-        _, err = capsys.readouterr()
-        assert "'%s' value must be positive" % (arg,) in err
-        with pytest.raises(SystemExit):
-            ReducerArgs().parse_args([str(exe), str(inp), arg, "0"])
-        _, err = capsys.readouterr()
-        assert "'%s' value must be positive" % (arg,) in err
-        ReducerArgs().parse_args([str(exe), str(inp), arg, "1"])
-        ReducerArgs().parse_args([str(exe), str(inp), arg, "10"])
-
-
-def test_main(mocker, tmp_path):  # noqa pylint: disable=redefined-outer-name
-    "simple test that main functions"
-
-    (tmp_path / "binary").touch()
-    exe = tmp_path / "binary"
-    (tmp_path / "input").mkdir()
-    inp = tmp_path / "input"
-    (inp / "test_info.txt").write_text("landing page: test.html")
-    (inp / "test.html").write_text("fluff\nrequired\n")
-    args = ReducerArgs().parse_args([str(exe), str(inp)])
-    # uses the job fixture from test_reduce which reduces testcases to the string "required\n"
-    mocker.patch("grizzly.reduce.reduce.load_target")
-    assert TestMainReductionJob.main(args) == 0
-
-
-def test_main_prefs(mocker, tmp_path):
-    "cmd line prefs should override prefs in the testcase"
-    run_called = [0]
-
-    class MyReductionJob(TestMainReductionJob):
-        __slots__ = []
-
-        def __init__(self, *_args, **_kwds):
-            super(MyReductionJob, self).__init__(tmp_path, create_binary=False)
-
-        def run(self, *args, **kwds):
-            result = super(MyReductionJob, self).run(*args, **kwds)
-            with open(self.target.prefs) as prefs_fp:
-                assert prefs_fp.read() == "main prefs"
-            run_called[0] += 1
-            return result
-
-    (tmp_path / "binary").touch()
-    exe = tmp_path / "binary"
-    (tmp_path / "input").mkdir()
-    inp = tmp_path / "input"
-    (inp / "test_info.txt").write_text("landing page: test.html")
-    (inp / "prefs.js").write_text("test prefs")
-    (inp / "test.html").write_text("fluff\nrequired\n")
-    (tmp_path / "prefs.js").write_text("main prefs")
-    args = ReducerArgs().parse_args([str(exe), str(inp),
-                                     "-p", str(tmp_path / "prefs.js")])
-    mocker.patch("grizzly.reduce.reduce.load_target")
-    assert MyReductionJob.main(args) == 0
-    assert run_called[0] == 1
-
-
-def test_main_strategies(mocker, monkeypatch, tmp_path):  # noqa pylint: disable=redefined-outer-name
-    "strategies list should be respected"
-    # uses the job fixture from test_reduce which reduces testcases to the string "required\n"
-    report_data = {"num_reports": 0}
-
-    class FakeReporter(BaseFakeReporter):
-
-        def __init__(self, _):
-            super(FakeReporter, self).__init__()
-            self.report_path = "foo"
-
-        def _submit_report(self, _report, test_cases):
-            assert len(test_cases) == 1, "too many test_cases: %r" % (test_cases,)
-            tc = test_cases[0]
-            assert len(tc._files.required) == 1, \
-                "too many test_files: %r" % (tc._files.required,)
-            assert tc.landing_page == "test.html"
-            assert tc._files.required[0].data == b"'xxrequired'\n"
-            report_data["num_reports"] += 1
-    monkeypatch.setattr(reduce, "FilesystemReporter", FakeReporter)
-
-    (tmp_path / "binary").touch()
-    exe = tmp_path / "binary"
-    (tmp_path / "input").mkdir()
-    inp = tmp_path / "input"
-    (inp / "test_info.txt").write_text("landing page: test.html")
-    (inp / "test.html").write_bytes(b"fluff\n'xxrequired'\n")
-    mocker.patch("grizzly.reduce.reduce.load_target")
-    args = ReducerArgs().parse_args([str(exe), str(inp), "--strategy", "line"])
-    assert TestMainReductionJob.main(args) == 0
-    assert report_data["num_reports"] == 1
-
-
-def test_bucket_main(monkeypatch, tmp_path):  # noqa pylint: disable=redefined-outer-name
-    "bucket.main iterates using crash.main"
-    main_called = [0]
-
-    class FakeCollector(object):
-        serverProtocol = 'https'
-        serverHost = 'mozilla.org'
-        serverPort = 8000
-
-        def get(self, url, **kwds):
-            class response(object):
-                @staticmethod
-                def json():
-                    if "crashes" in url:
-                        return {
-                            "results": [
-                                {"testcase": None, "id": 123},
-                                {"testcase": True, "id": 456},
-                            ],
-                            "next": None,
-                            "count": 2,
-                        }
-                    return {
-                        "signature": '{"symptoms": []}',
-                    }
-            return response
-
-    class FakeCrashReductionJob(object):
-
-        @staticmethod
-        def main(args):
-            assert args.input == 456
-            main_called[0] += 1
-            return 0
-
-    monkeypatch.setattr(bucket, "Collector", FakeCollector)
-    monkeypatch.setattr(bucket, "CrashReductionJob", FakeCrashReductionJob)
-
-    (tmp_path / "binary").touch()
-    exe = tmp_path / "binary"
-    args = ReducerFuzzManagerIDQualityArgs().parse_args([str(exe), '789'])
-    assert bucket.main(args) == 0
-    assert main_called[0] == 1
-
-
-def test_crash_main_repro(mocker, monkeypatch, tmp_path):  # noqa pylint: disable=redefined-outer-name
-    "crash.main --fuzzmanager updates quality"
-    # expect Collector.patch to be called with these qualities
-    expect_patch = [reporter.FuzzManagerReporter.QUAL_REPRODUCIBLE,
-                    reporter.FuzzManagerReporter.QUAL_REDUCED_ORIGINAL]
-    submitted = [False]
-
-    class ReporterNoSubmit(reporter.FuzzManagerReporter):
-        (tmp_path / ".fuzzmanagerconf").touch()
-        FM_CONFIG = str(tmp_path / ".fuzzmanagerconf")
-
-        def _submit_report(self, *_args, **_kwds):
-            # check that the crash was already marked reproducible, but not yet marked reduced
-            assert expect_patch == [reporter.FuzzManagerReporter.QUAL_REDUCED_ORIGINAL]
-            submitted[0] = True
-
-    class FakeCollector(object):
-        serverProtocol = 'https'
-        serverHost = 'mozilla.org'
-        serverPort = 8000
-
-        def get(self, _url, **kwds):
-
-            class response(object):
-
-                class headers(object):
-
-                    @staticmethod
-                    def get(value, default):
-                        assert value.lower() == 'content-disposition'
-                        return 'attachment; filename="test.zip"'
-
-                @staticmethod
-                def json():
-                    return {
-                        'testcase_quality': reporter.FuzzManagerReporter.QUAL_UNREDUCED,
-                        'tool': 'test-tool'}
-                content = (inp / "test.zip").read_bytes()
-            return response
-
-        def patch(self, _url, **kwds):
-            data = kwds["data"]
-            assert set(data.keys()) == {"testcase_quality"}
-            assert expect_patch
-            assert data["testcase_quality"] == expect_patch.pop(0)
-
-    monkeypatch.setattr(reporter, "Collector", FakeCollector)
-    monkeypatch.setattr(reduce, "FuzzManagerReporter", ReporterNoSubmit)
-    monkeypatch.setattr(crash, "Collector", FakeCollector)
-
-    (tmp_path / "binary").touch()
-    exe = tmp_path / "binary"
-    (tmp_path / "binary.fuzzmanagerconf").write_text(
-        "[Main]\n"
-        "platform = x86-64\n"
-        "product = mozilla-central\n"
-        "os = linux\n"
-    )
-    (tmp_path / "input").mkdir()
-    inp = tmp_path / "input"
-    (inp / "test_info.txt").write_text("landing page: test.html")
-    (inp / "test.html").write_text("fluff\nrequired\n")
-    with zipfile.ZipFile(str(inp / "test.zip"), "w") as zip_fp:
-        zip_fp.write(str(inp / "test_info.txt"), "test_info.txt")
-        zip_fp.write(str(inp / "test.html"), "test.html")
-    args = ReducerFuzzManagerIDArgs().parse_args([str(exe), '1234', '--fuzzmanager'])
-    mocker.patch("grizzly.reduce.reduce.load_target")
-    assert TestMainCrashReductionJob.main(args) == 0
-    assert not expect_patch
-    assert submitted[0]
-
-
-def test_crash_main_no_repro(mocker, monkeypatch, tmp_path):  # noqa pylint: disable=redefined-outer-name
-    "crash.main --fuzzmanager updates quality"
-    expect_patch = [reporter.FuzzManagerReporter.QUAL_REQUEST_SPECIFIC]
-
-    class ReporterNoSubmit(reporter.FuzzManagerReporter):
-        (tmp_path / ".fuzzmanagerconf").touch()
-        FM_CONFIG = str(tmp_path / ".fuzzmanagerconf")
-
-        def _reset(self):
-            pass
-
-        def _submit_report(self, *_args, **_kwds):
-            # make sure _submit_report() is not called
-            assert False
-
-    class FakeCollector(object):
-        serverProtocol = 'https'
-        serverHost = 'mozilla.org'
-        serverPort = 8000
-
-        def get(self, _url, **kwds):
-
-            class response(object):
-
-                class headers(object):
-
-                    @staticmethod
-                    def get(value, default):
-                        assert value.lower() == 'content-disposition'
-                        return 'attachment; filename="test.zip"'
-
-                @staticmethod
-                def json():
-                    return {
-                        'testcase_quality': reporter.FuzzManagerReporter.QUAL_UNREDUCED,
-                        'tool': 'test-tool'}
-                content = (inp / "test.zip").read_bytes()
-            return response
-
-        def patch(self, _url, **kwds):
-            data = kwds["data"]
-            assert set(data.keys()) == {"testcase_quality"}
-            assert expect_patch
-            assert data["testcase_quality"] == expect_patch.pop(0)
-
-    # uses the job fixture from test_reduce which reduces testcases to the string "required\n"
-    monkeypatch.setattr(reporter, "Collector", FakeCollector)
-    monkeypatch.setattr(reduce, "FuzzManagerReporter", ReporterNoSubmit)
-    monkeypatch.setattr(crash, "Collector", FakeCollector)
-
-    (tmp_path / "binary").touch()
-    exe = tmp_path / "binary"
-    (tmp_path / "binary.fuzzmanagerconf").write_text(
-        "[Main]\n"
-        "platform = x86-64\n"
-        "product = mozilla-central\n"
-        "os = linux\n"
-    )
-    (tmp_path / "input").mkdir()
-    inp = tmp_path / "input"
-    (inp / "test_info.txt").write_text("landing page: test.html")
-    (inp / "test.html").write_text("fluff\n")
-    with zipfile.ZipFile(str(inp / "test.zip"), "w") as zip_fp:
-        zip_fp.write(str(inp / "test_info.txt"), "test_info.txt")
-        zip_fp.write(str(inp / "test.html"), "test.html")
-    args = ReducerFuzzManagerIDArgs().parse_args([str(exe), '1234', '--fuzzmanager'])
-    mocker.patch("grizzly.reduce.reduce.load_target")
-    assert TestMainCrashReductionJob.main(args) == 1
-    assert not expect_patch
-
-
-def test_crash_main_no_repro_specific(mocker, monkeypatch, tmp_path):  # noqa pylint: disable=redefined-outer-name
-    "crash.main --fuzzmanager updates quality"
-    expect_patch = [reporter.FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE]
-
-    class ReporterNoSubmit(reporter.FuzzManagerReporter):
-        (tmp_path / ".fuzzmanagerconf").touch()
-        FM_CONFIG = str(tmp_path / ".fuzzmanagerconf")
-
-        def _reset(self):
-            pass
-
-        def _submit_report(self, *_args, **_kwds):
-            # make sure _submit_report() is not called
-            assert False
-
-    class FakeCollector(object):
-        serverProtocol = 'https'
-        serverHost = 'mozilla.org'
-        serverPort = 8000
-
-        def get(self, _url, **kwds):
-
-            class response(object):
-
-                class headers(object):
-
-                    @staticmethod
-                    def get(value, default):
-                        assert value.lower() == 'content-disposition'
-                        return 'attachment; filename="test.zip"'
-
-                @staticmethod
-                def json():
-                    return {
-                        'testcase_quality': reporter.FuzzManagerReporter.QUAL_REQUEST_SPECIFIC,
-                        'tool': 'test-tool'}
-                content = (inp / "test.zip").read_bytes()
-            return response
-
-        def patch(self, _url, **kwds):
-            data = kwds["data"]
-            assert set(data.keys()) == {"testcase_quality"}
-            assert expect_patch
-            assert data["testcase_quality"] == expect_patch.pop(0)
-
-    monkeypatch.setattr(reporter, "Collector", FakeCollector)
-    monkeypatch.setattr(reduce, "FuzzManagerReporter", ReporterNoSubmit)
-    monkeypatch.setattr(crash, "Collector", FakeCollector)
-
-    (tmp_path / "binary").touch()
-    exe = tmp_path / "binary"
-    (tmp_path / "binary.fuzzmanagerconf").write_text(
-        "[Main]\n"
-        "platform = x86-64\n"
-        "product = mozilla-central\n"
-        "os = linux\n"
-    )
-    (tmp_path / "input").mkdir()
-    inp = tmp_path / "input"
-    (inp / "test_info.txt").write_text("landing page: test.html")
-    (inp / "test.html").write_text("fluff\n")
-    with zipfile.ZipFile(str(inp / "test.zip"), "w") as zip_fp:
-        zip_fp.write(str(inp / "test_info.txt"), "test_info.txt")
-        zip_fp.write(str(inp / "test.html"), "test.html")
-    args = ReducerFuzzManagerIDArgs().parse_args([str(exe), '1234', '--fuzzmanager'])
-    mocker.patch("grizzly.reduce.reduce.load_target")
-    assert TestMainCrashReductionJob.main(args) == 1
-    assert not expect_patch
-
-
-def test_environ_and_suppressions(mocker, tmp_path):
-    ""
-    run_called = [0]
-
-    class MyReductionJob(TestMainReductionJob):
-        __slots__ = []
-
-        def __init__(self, *_args, **_kwds):
-            super(MyReductionJob, self).__init__(tmp_path, create_binary=False)
-            assert self.target.forced_close
-
-        def run(self, *args, **kwds):
-            assert len(self._env_mod) == 2
-            assert "GRZ_FORCED_CLOSE" in self._env_mod
-            assert self._env_mod["GRZ_FORCED_CLOSE"] == "0"
-            assert not self.target.forced_close
-            assert "LSAN_OPTIONS" in self._env_mod
-            assert len(re.split(r":(?![\\|/])", self._env_mod["LSAN_OPTIONS"])) == 2
-            assert "detect_leaks=1" in self._env_mod["LSAN_OPTIONS"]
-            assert "lsan.supp" in self._env_mod["LSAN_OPTIONS"]
-            run_called[0] += 1
-
-    exe = tmp_path / "binary"
-    exe.touch()
-    inp = tmp_path / "input"
-    inp.mkdir()
-    (inp / "env_vars.txt").write_text("LSAN_OPTIONS=detect_leaks=1\nGRZ_FORCED_CLOSE=0")
-    (inp / "test_info.txt").write_text("landing page: test.html")
-    (inp / "lsan.supp").write_text("foo")
-    (inp / "test.html").write_text("fluff\nrequired\n")
-    args = ReducerArgs().parse_args([str(exe), str(inp)])
-    mocker.patch("grizzly.reduce.reduce.load_target")
-    MyReductionJob.main(args)
-    assert run_called[0] == 1
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
deleted file mode 100644
index 2f04f0a3..00000000
--- a/grizzly/reduce/test_reduce.py
+++ /dev/null
@@ -1,700 +0,0 @@
-# coding=utf-8
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-# pylint: disable=protected-access
-from __future__ import unicode_literals
-import json
-import os.path
-import zipfile
-import pytest
-from grizzly.reduce import exceptions, strategies
-from grizzly.common import FuzzManagerReporter
-from .test_common import BaseFakeReporter, TestReductionJob
-from .test_common import TestReductionJobAlt, TestReductionJobKeepHarness, TestReductionJobSemiReliable
-
-
-def test_config_testcase_0(tmp_path):
-    """empty directory fails config_testcase"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        with pytest.raises(exceptions.NoTestcaseError) as exc:
-            job.config_testcase(str(tmp_path))
-        assert "No testcase recognized" in str(exc.value)
-        assert job.result_code == FuzzManagerReporter.QUAL_NO_TESTCASE
-
-
-def test_config_testcase_1(tmp_path):
-    """non-zip file fails config_testcase"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        tmp_file = tmp_path / "test.txt"
-        tmp_file.touch()
-        with pytest.raises(exceptions.ReducerError) as exc:
-            job.config_testcase(str(tmp_file))
-        assert "Testcase must be zip, html, or directory" in str(exc.value)
-        tmp_file.unlink()
-        assert job.result_code == FuzzManagerReporter.QUAL_REDUCER_ERROR
-
-
-def test_config_testcase_2(tmp_path):
-    """config_testcase can't be called twice"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        with pytest.raises(exceptions.ReducerError) as exc:
-            job.config_testcase(str(tmp_path))
-        with pytest.raises(exceptions.ReducerError) as exc:
-            job.config_testcase(str(tmp_path))
-        assert "Testcase already configured?" in str(exc.value)
-        assert job.result_code == FuzzManagerReporter.QUAL_REDUCER_ERROR
-
-
-def test_config_testcase_3(tmp_path):
-    """bad zip file fails config_testcase"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        test_zip = tmp_path / "test.zip"
-        test_zip.touch()
-        with pytest.raises(exceptions.CorruptTestcaseError):
-            job.config_testcase(str(test_zip))
-        assert job.result_code == FuzzManagerReporter.QUAL_REDUCER_ERROR
-
-
-def test_config_testcase_4(tmp_path):
-    """missing landing page causes failure"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "test_info.json").write_text("{}")
-        with pytest.raises(exceptions.ReducerError) as exc:
-            job.config_testcase(str(tmp_path))
-        assert "Could not find landing page" in str(exc.value)
-        assert job.result_code == FuzzManagerReporter.QUAL_REDUCER_ERROR
-
-
-def test_config_testcase_4_legacy(tmp_path):
-    """missing landing page causes failure"""
-    # TODO: remove this test
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "test_info.txt").touch()
-        with pytest.raises(exceptions.ReducerError) as exc:
-            job.config_testcase(str(tmp_path))
-        assert "Could not find landing page" in str(exc.value)
-        assert job.result_code == FuzzManagerReporter.QUAL_REDUCER_ERROR
-
-
-def test_config_testcase_5(tmp_path):
-    """missing landing page causes failure"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "test_info.json").write_text("{\"target\":\"\",\"env\":{}}")
-        with pytest.raises(exceptions.ReducerError) as exc:
-            job.config_testcase(str(tmp_path))
-        assert "does not exist" in str(exc.value)
-        assert job.result_code == FuzzManagerReporter.QUAL_REDUCER_ERROR
-
-
-def test_config_testcase_5_legacy(tmp_path):
-    """missing landing page causes failure"""
-    # TODO: remove this test
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "test_info.txt").write_text("landing page: ")
-        with pytest.raises(exceptions.ReducerError) as exc:
-            job.config_testcase(str(tmp_path))
-        assert "does not exist" in str(exc.value)
-        assert job.result_code == FuzzManagerReporter.QUAL_REDUCER_ERROR
-
-
-def test_config_testcase_6(tmp_path):
-    """single testcase is loaded ok"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "test_info.json").write_text("{\"target\":\"test.html\",\"env\":{}}")
-        (tmp_path / "test.html").write_text("hello")
-        job.config_testcase(str(tmp_path))
-        assert job._testcase == os.path.join(job._tcroot, "test.html")
-        with open(job._testcase) as tc_fp:
-            assert tc_fp.read() == "hello"
-        assert job.result_code is None
-
-
-def test_config_testcase_6_legacy(tmp_path):
-    """single testcase is loaded ok"""
-    # TODO: remove this test
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "test_info.txt").write_text("landing page: test.html")
-        (tmp_path / "test.html").write_text("hello")
-        job.config_testcase(str(tmp_path))
-        assert job._testcase == os.path.join(job._tcroot, "test.html")
-        with open(job._testcase) as tc_fp:
-            assert tc_fp.read() == "hello"
-        assert job.result_code is None
-
-
-def test_config_testcase_7(tmp_path):
-    """single testcase in numbered subdir is loaded ok"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "-0").mkdir()
-        (tmp_path / "-0" / "test_info.json").write_text("{\"target\":\"test.html\",\"env\":{}}")
-        (tmp_path / "-0" / "test.html").write_text("hello")
-        job.config_testcase(str(tmp_path))
-        assert job._testcase == os.path.join(job._tcroot, "-0", "test.html")
-        with open(job._testcase) as tc_fp:
-            assert tc_fp.read() == "hello"
-        assert job.result_code is None
-
-
-def test_config_testcase_7_legacy(tmp_path):
-    """single testcase in numbered subdir is loaded ok"""
-    # TODO: remove this test
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "-0").mkdir()
-        (tmp_path / "-0" / "test_info.txt").write_text("landing page: test.html")
-        (tmp_path / "-0" / "test.html").write_text("hello")
-        job.config_testcase(str(tmp_path))
-        assert job._testcase == os.path.join(job._tcroot, "-0", "test.html")
-        with open(job._testcase) as tc_fp:
-            assert tc_fp.read() == "hello"
-        assert job.result_code is None
-
-
-def test_config_testcase_8(tmp_path):
-    """multiple testcase in numbered subdir creates a harness"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        for subdir in ("-0", "-1"):
-            (tmp_path / subdir).mkdir()
-            (tmp_path / subdir / "test_info.json").write_text("{\"target\":\"test.html\",\"env\":{}}")
-            (tmp_path / subdir / "test.html").write_text("hello")
-        job.config_testcase(str(tmp_path))
-        assert job._testcase.startswith(os.path.join(job._tcroot, "harness_"))
-        assert job._testcase.endswith(".html")
-        for subdir in ("-0", "-1"):
-            with open(os.path.join(job._tcroot, subdir, "test.html")) as tc_fp:
-                assert tc_fp.read() == "hello"
-        with open(job._testcase) as tc_fp:
-            harness = tc_fp.read()
-        loc0 = harness.index("'/-0/test.html',")
-        loc1 = harness.index("'/-1/test.html',")
-        assert loc1 < loc0, "testcases should occur in harness in descending order"
-        assert job.result_code is None
-
-
-def test_config_testcase_8_legacy(tmp_path):
-    """multiple testcase in numbered subdir creates a harness"""
-    # TODO: remove this test
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        for subdir in ("-0", "-1"):
-            (tmp_path / subdir).mkdir()
-            (tmp_path / subdir / "test_info.txt").write_text("landing page: test.html")
-            (tmp_path / subdir / "test.html").write_text("hello")
-        job.config_testcase(str(tmp_path))
-        assert job._testcase.startswith(os.path.join(job._tcroot, "harness_"))
-        assert job._testcase.endswith(".html")
-        for subdir in ("-0", "-1"):
-            with open(os.path.join(job._tcroot, subdir, "test.html")) as tc_fp:
-                assert tc_fp.read() == "hello"
-        with open(job._testcase) as tc_fp:
-            harness = tc_fp.read()
-        loc0 = harness.index("'/-0/test.html',")
-        loc1 = harness.index("'/-1/test.html',")
-        assert loc1 < loc0, "testcases should occur in harness in descending order"
-        assert job.result_code is None
-
-
-def test_config_testcase_9(tmp_path):
-    """single testcase is loaded from zip ok"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "test_info.json").write_text("{\"target\":\"test.html\",\"env\":{}}")
-        (tmp_path / "test.html").write_text("hello")
-        with zipfile.ZipFile(str(tmp_path / "test.zip"), "w") as zip_fp:
-            zip_fp.write(str(tmp_path / "test_info.json"), "test_info.json")
-            zip_fp.write(str(tmp_path / "test.html"), "test.html")
-        job.config_testcase(str(tmp_path / "test.zip"))
-        assert job._testcase == os.path.join(job._tcroot, "test.html")
-        with open(job._testcase) as tc_fp:
-            assert tc_fp.read() == "hello"
-        assert job.result_code is None
-
-
-def test_config_testcase_9_legacy(tmp_path):
-    """single testcase is loaded from zip ok"""
-    # TODO: remove this test
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "test_info.txt").write_text("landing page: test.html")
-        (tmp_path / "test.html").write_text("hello")
-        with zipfile.ZipFile(str(tmp_path / "test.zip"), "w") as zip_fp:
-            zip_fp.write(str(tmp_path / "test_info.txt"), "test_info.txt")
-            zip_fp.write(str(tmp_path / "test.html"), "test.html")
-        job.config_testcase(str(tmp_path / "test.zip"))
-        assert job._testcase == os.path.join(job._tcroot, "test.html")
-        with open(job._testcase) as tc_fp:
-            assert tc_fp.read() == "hello"
-        assert job.result_code is None
-
-
-def test_config_testcase_10(tmp_path):
-    """prefs from testcase are used and take precedence over target prefs"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "orig_prefs.js").write_text("orig prefs")
-        job.target.prefs = str(tmp_path / "orig_prefs.js")
-        (tmp_path / "test_info.json").write_text("{\"target\":\"test.html\",\"env\":{}}")
-        (tmp_path / "test.html").write_text("hello")
-        (tmp_path / "prefs.js").write_text("some prefs")
-        job.config_testcase(str(tmp_path))
-        assert os.path.normpath(job.target.prefs) \
-            != os.path.normpath(str(tmp_path / "prefs.js"))
-        with open(job.target.prefs) as prefs_fp:
-            assert prefs_fp.read() == "some prefs"
-        assert job.result_code is None
-
-
-def test_config_testcase_10_legacy(tmp_path):
-    """prefs from testcase are used and take precedence over target prefs"""
-    # TODO: remove this test
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "orig_prefs.js").write_text("orig prefs")
-        job.target.prefs = str(tmp_path / "orig_prefs.js")
-        (tmp_path / "test_info.txt").write_text("landing page: test.html")
-        (tmp_path / "test.html").write_text("hello")
-        (tmp_path / "prefs.js").write_text("some prefs")
-        job.config_testcase(str(tmp_path))
-        assert os.path.normpath(job.target.prefs) \
-            != os.path.normpath(str(tmp_path / "prefs.js"))
-        with open(job.target.prefs) as prefs_fp:
-            assert prefs_fp.read() == "some prefs"
-        assert job.result_code is None
-
-
-def test_config_testcase_11(tmp_path):
-    """env vars from testcase are used"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        with open(str(tmp_path / "test_info.json"), "w") as info:
-            json.dump({
-                "target": "test.html",
-                "env": {
-                    "foo": "bar",
-                    "var": "value"
-                }}, info)
-        (tmp_path / "test.html").write_text("hello")
-        job.config_testcase(str(tmp_path))
-        assert job._env_mod == dict(var="value", foo="bar")
-        assert job.result_code is None
-
-
-def test_config_testcase_11_legacy(tmp_path):
-    """env vars from testcase are used"""
-    # TODO: remove this test
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "test_info.txt").write_text("landing page: test.html")
-        (tmp_path / "test.html").write_text("hello")
-        (tmp_path / "env_vars.txt").write_text("var=value\nfoo=bar")
-        job.config_testcase(str(tmp_path))
-        assert job._env_mod == dict(var="value", foo="bar")
-        assert job.result_code is None
-
-
-def test_config_testcase_12(tmp_path):
-    """html testcase is loaded ok"""
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "test.html").write_text("hello")
-        job.config_testcase(str(tmp_path / "test.html"))
-        assert job._testcase == os.path.join(job._tcroot, "test.html")
-        with open(job._testcase) as tc_fp:
-            assert tc_fp.read() == "hello"
-        assert job.result_code is None
-
-
-def test_config_testcase_13(tmp_path):
-    """test test_info.json not test_info.txt is used"""
-    # TODO: remove this test
-    with TestReductionJob(tmp_path, create_binary=False) as job:
-        (tmp_path / "test_info.txt").write_text("landing page: test_old.html")
-        (tmp_path / "test_old.html").write_text("fail!")
-        (tmp_path / "env_vars.txt").write_text("var=fail\nfoo=fail")
-        with open(str(tmp_path / "test_info.json"), "w") as info:
-            json.dump({
-                "target": "test.html",
-                "env": {
-                    "foo": "bar",
-                    "var": "value"
-                }}, info)
-        (tmp_path / "test.html").write_text("hello")
-        job.config_testcase(str(tmp_path))
-        assert job._env_mod == dict(var="value", foo="bar")
-        assert job._testcase == os.path.join(job._tcroot, "test.html")
-        with open(job._testcase) as tc_fp:
-            assert tc_fp.read() == "hello"
-        assert job.result_code is None
-
-
-def test_run_01(tmp_path):
-    """single required testcase is reduced and reported"""
-    with TestReductionJob(tmp_path) as job:
-        (tmp_path / "tc").mkdir()
-        with open(str(tmp_path / "tc" / "test_info.json"), "w") as info:
-            json.dump({
-                "target": "test.html",
-                "env": {
-                    "foo": "bar",
-                    "var": "value"
-                }}, info)
-        (tmp_path / "tc" / "test.html").write_bytes(b"fluff\nrequired\n")
-        (tmp_path / "tc" / "prefs.js").write_bytes(b"some prefs")
-        job.config_testcase(str(tmp_path / "tc"))
-        report_data = {"num_reports": 0}
-
-        class FakeReporter(BaseFakeReporter):
-            def _submit_report(self, _report, test_cases):
-                assert len(test_cases) == 1, "too many test_cases: %r" % (test_cases,)
-                tc = test_cases[0]
-                assert len(tc._files.required) == 1, \
-                    "too many test_files: %r" % (tc._files.required,)
-                assert tc.landing_page == "test.html"
-                assert tc._files.required[0].data == b"required\n"
-                prefs_data = None
-                for meta_file in tc._files.meta:
-                    if meta_file.file_name == "prefs.js":
-                        prefs_data = meta_file.data
-                        break
-                assert prefs_data == b"some prefs"
-                assert tc.env_vars == dict(var="value", foo="bar")
-                assert self.quality == FuzzManagerReporter.QUAL_REDUCED_RESULT
-                assert self.force_report
-                report_data["num_reports"] += 1
-        job.set_reporter(FakeReporter())
-
-        assert job.run()
-        assert report_data["num_reports"] == 1
-
-
-def test_run_02(tmp_path):
-    """other crashes are reported as unreduced crashes"""
-    with TestReductionJobAlt(tmp_path) as job:
-        (tmp_path / "tc").mkdir()
-        with open(str(tmp_path / "tc" / "test_info.json"), "w") as info:
-            json.dump({
-                "target": "test.html",
-                "env": {
-                    "foo": "bar",
-                    "var": "value"
-                }}, info)
-        (tmp_path / "tc" / "test.html").write_bytes(b"fluff\nrequired\n")
-        (tmp_path / "tc" / "prefs.js").write_bytes(b"some prefs")
-        job.config_testcase(str(tmp_path / "tc"))
-        report_data = {"num_reports": 0}
-
-        class FakeReporter(BaseFakeReporter):
-            def _submit_report(self, _report, test_cases):
-                assert len(test_cases) == 1, "too many test_cases: %r" % (test_cases,)
-                tc = test_cases[0]
-                assert len(tc._files.required) == 1, \
-                    "too many test_files: %r" % (tc._files.required,)
-                assert tc._files.required[0].data == b"required\n"
-                assert tc.landing_page == "test.html"
-                prefs_data = None
-                for meta_file in tc._files.meta:
-                    if meta_file.file_name == "prefs.js":
-                        prefs_data = meta_file.data
-                        break
-                assert prefs_data == b"some prefs"
-                assert tc.env_vars == dict(var="value", foo="bar")
-                assert self.quality == FuzzManagerReporter.QUAL_UNREDUCED
-                assert not self.force_report
-                report_data["num_reports"] += 1
-        job.set_reporter(FakeReporter())
-
-        assert not job.run()
-        assert report_data["num_reports"] == 1
-
-
-def test_run_03(tmp_path):
-    """other files in testcase are not reduced without DDBEGIN/END"""
-    with TestReductionJob(tmp_path) as job:
-        (tmp_path / "tc").mkdir()
-        (tmp_path / "tc" / "test_info.json").write_text("{\"target\":\"test.html\",\"env\":{}}")
-        (tmp_path / "tc" / "test.html").write_bytes(b"fluff\nrequired\n")
-        (tmp_path / "tc" / "test2.html").write_bytes(b"fluff\nrequired\n")
-        job.config_testcase(str(tmp_path / "tc"))
-        report_data = {"num_reports": 0}
-
-        class FakeReporter(BaseFakeReporter):
-            def _submit_report(self, _report, test_cases):
-                assert len(test_cases) == 1, "too many test_cases: %r" % (test_cases,)
-                tc = test_cases[0]
-                assert len(tc._files.required) == 1, \
-                    "expecting 1 test_file: %r" % ({f.file_name for f in tc._files.required},)
-                assert len(tc._files.optional) == 1, \
-                    "expecting 1 test_file: %r" % ({f.file_name for f in tc._files.optional},)
-                assert tc.landing_page == "test.html"
-                assert {x.file_name: x.data for x in tc._files.required} \
-                    == {"test.html": b"required\n"}
-                assert {x.file_name: x.data for x in tc._files.optional} \
-                    == {"test2.html": b"fluff\nrequired\n"}
-                assert self.quality == FuzzManagerReporter.QUAL_REDUCED_RESULT
-                assert self.force_report
-                report_data["num_reports"] += 1
-        job.set_reporter(FakeReporter())
-
-        assert job.run()
-        assert report_data["num_reports"] == 1
-
-
-def test_run_04(tmp_path):
-    """other files in testcase are reduced with DDBEGIN/END"""
-    with TestReductionJob(tmp_path) as job:
-        (tmp_path / "tc").mkdir()
-        (tmp_path / "tc" / "test_info.json").write_text("{\"target\":\"test.html\",\"env\":{}}")
-        (tmp_path / "tc" / "test.html").write_bytes(b"fluff\nrequired\n")
-        (tmp_path / "tc" / "test2.html").write_bytes(b"DDBEGIN\nfluff\nrequired\nDDEND\n")
-        job.config_testcase(str(tmp_path / "tc"))
-        report_data = {"num_reports": 0}
-
-        class FakeReporter(BaseFakeReporter):
-            def _submit_report(self, _report, test_cases):
-                assert len(test_cases) == 1, "too many test_cases: %r" % (test_cases,)
-                tc = test_cases[0]
-                assert len(tc._files.required) == 1, \
-                    "expecting 1 test file: %r" % (tc._files.required,)
-                assert len(tc._files.optional) == 1, \
-                    "expecting 1 test file: %r" % (tc._files.optional,)
-                assert tc.landing_page == "test.html"
-                assert {x.file_name: x.data for x in tc._files.required} \
-                    == {"test.html": b"required\n"}
-                assert {x.file_name: x.data for x in tc._files.optional} \
-                    == {"test2.html": b"DDBEGIN\nrequired\nDDEND\n"}
-                assert self.quality == FuzzManagerReporter.QUAL_REDUCED_RESULT
-                assert self.force_report
-                report_data["num_reports"] += 1
-        job.set_reporter(FakeReporter())
-
-        assert job.run()
-        assert report_data["num_reports"] == 1
-
-
-def test_run_05(tmp_path):
-    """multiple testcases result in harness being reported"""
-    with TestReductionJobKeepHarness(tmp_path) as job:
-        (tmp_path / "tc").mkdir()
-        (tmp_path / "tc" / "-0").mkdir()
-        (tmp_path / "tc" / "-1").mkdir()
-        (tmp_path / "tc" / "-0" / "test_info.json").write_text("{\"target\":\"required.html\",\"env\":{}}")
-        (tmp_path / "tc" / "-0" / "required.html").write_bytes(b"DDBEGIN\nfluff\nrequired\nDDEND\n")
-        (tmp_path / "tc" / "-1" / "test_info.json").write_text("{\"target\":\"required.html\",\"env\":{}}")
-        (tmp_path / "tc" / "-1" / "required.html").write_bytes(b"DDBEGIN\nfluff\nrequired\nDDEND\n")
-        job.config_testcase(str(tmp_path / "tc"))
-        report_data = {"num_reports": 0}
-
-        class FakeReporter(BaseFakeReporter):
-            def _submit_report(self, _report, test_cases):
-                assert len(test_cases) == 1, "too many test_cases: %r" % (test_cases,)
-                tc = test_cases[0]
-                assert len(tc._files.required) == 1, \
-                    "expecting 1 test file: %r" % (tc._files.required,)
-                assert len(tc._files.optional) == 2, \
-                    "expecting 2 test files: %r" % (tc._files.optional,)
-                assert tc.landing_page.startswith("harness_")
-                assert tc.landing_page.endswith(".html")
-                assert {x.file_name: x.data for x in tc._files.optional} \
-                    == {os.path.join("-0", "required.html"): b"DDBEGIN\nrequired\nDDEND\n",
-                        os.path.join("-1", "required.html"): b"DDBEGIN\nrequired\nDDEND\n"}
-                assert self.quality == FuzzManagerReporter.QUAL_REDUCED_RESULT
-                assert self.force_report
-                report_data["num_reports"] += 1
-        job.set_reporter(FakeReporter())
-
-        assert job.run()
-        assert report_data["num_reports"] == 1
-
-
-def test_run_06(tmp_path):
-    """multiple testcases reducing to 1 file will have harness removed"""
-    with TestReductionJob(tmp_path) as job:
-        (tmp_path / "tc").mkdir()
-        (tmp_path / "tc" / "-0").mkdir()
-        (tmp_path / "tc" / "-1").mkdir()
-        (tmp_path / "tc" / "-0" / "test_info.json").write_text("{\"target\":\"test.html\",\"env\":{}}")
-        (tmp_path / "tc" / "-0" / "test.html").write_bytes(b"-0\nDDBEGIN\nfluff\nrequired\nDDEND\n")
-        (tmp_path / "tc" / "-1" / "test_info.json").write_text("{\"target\":\"required.html\",\"env\":{}}")
-        (tmp_path / "tc" / "-1" / "required.html").write_bytes(b"-1\nDDBEGIN\nfluff\nrequired\nDDEND\n")
-        job.config_testcase(str(tmp_path / "tc"))
-        report_data = {"num_reports": 0}
-
-        class FakeReporter(BaseFakeReporter):
-            def _submit_report(self, _report, test_cases):
-                assert len(test_cases) == 1, "too many test_cases: %r" % (test_cases,)
-                tc = test_cases[0]
-                assert len(tc._files.required) == 1, \
-                    "too many test_files: %r" % (tc._files.required,)
-                assert tc.landing_page == "required.html"
-                assert tc._files.required[0].data == b"-1\nDDBEGIN\nrequired\nDDEND\n"
-                assert self.quality == FuzzManagerReporter.QUAL_REDUCED_RESULT
-                assert self.force_report
-                report_data["num_reports"] += 1
-        job.set_reporter(FakeReporter())
-
-        assert job.run()
-        assert report_data["num_reports"] == 1
-
-
-@pytest.mark.skipif(not strategies.HAVE_JSBEAUTIFIER, reason="jsbeautifier required")
-def test_run_07(tmp_path):
-    """test that jsbeautifier stage works"""
-    with TestReductionJob(tmp_path) as job:
-        (tmp_path / "tc").mkdir()
-        (tmp_path / "tc" / "test_info.json").write_text("{\"target\":\"test.js\",\"env\":{}}")
-        (tmp_path / "tc" / "test.js").write_text("try{'fluff';'required'}catch(e){}\n")
-        job.config_testcase(str(tmp_path / "tc"))
-        report_data = {"num_reports": 0}
-
-        class FakeReporter(BaseFakeReporter):
-            def _submit_report(self, _report, test_cases):
-                assert len(test_cases) == 1, "too many test_cases: %r" % (test_cases,)
-                tc = test_cases[0]
-                assert len(tc._files.required) == 1, \
-                    "too many test_files: %r" % (tc._files.required,)
-                assert tc.landing_page == "test.js"
-                result = tc._files.required[0].data.decode("UTF-8").lstrip(" ")
-                assert result == "'required'%s" % (str(os.linesep),)
-                assert self.quality == FuzzManagerReporter.QUAL_REDUCED_RESULT
-                assert self.force_report
-                report_data["num_reports"] += 1
-        job.set_reporter(FakeReporter())
-
-        assert job.run()
-        assert report_data["num_reports"] == 1
-
-
-@pytest.mark.skipif(not strategies.HAVE_CSSBEAUTIFIER, reason="cssbeautifier required")
-def test_run_08(tmp_path):
-    """test that cssbeautifier stage works with .css file"""
-    with TestReductionJob(tmp_path) as job:
-        (tmp_path / "tc").mkdir()
-        (tmp_path / "tc" / "test_info.json").write_text("{\"target\":\"test.css\",\"env\":{}}")
-        (tmp_path / "tc" / "test.css").write_text("*,#a{fluff:0;required:1}\n")
-        job.config_testcase(str(tmp_path / "tc"))
-        report_data = {"num_reports": 0}
-
-        class FakeReporter(BaseFakeReporter):
-            def _submit_report(self, _report, test_cases):
-                assert len(test_cases) == 1, "too many test_cases: %r" % (test_cases,)
-                tc = test_cases[0]
-                assert len(tc._files.required) == 1, \
-                    "too many test_files: %r" % (tc._files.required,)
-                assert tc.landing_page == "test.css"
-                result = tc._files.required[0].data.decode("UTF-8").rstrip()
-                assert result == "  required: 1"
-                assert self.quality == FuzzManagerReporter.QUAL_REDUCED_RESULT
-                assert self.force_report
-                report_data["num_reports"] += 1
-        job.set_reporter(FakeReporter())
-
-        assert job.run()
-        assert report_data["num_reports"] == 1
-
-@pytest.mark.skipif(not strategies.HAVE_CSSBEAUTIFIER, reason="cssbeautifier required")
-def test_run_09(tmp_path):
-    """test that cssbeautifier stage works with .html file"""
-    # TODO: tests specifically targeting beautifiers should be created
-    with TestReductionJob(tmp_path) as job:
-        (tmp_path / "tc").mkdir()
-        (tmp_path / "tc" / "test_info.json").write_text("{\"target\":\"test.html\",\"env\":{}}")
-        (tmp_path / "tc" / "test.html").write_text("<style>*,#a{fluff:0;required:1}</style>\n")
-        job.config_testcase(str(tmp_path / "tc"))
-        report_data = {"num_reports": 0}
-
-        class FakeReporter(BaseFakeReporter):
-            def _submit_report(self, _report, test_cases):
-                assert len(test_cases) == 1, "too many test_cases: %r" % (test_cases,)
-                tc = test_cases[0]
-                assert len(tc._files.required) == 1, \
-                    "too many test_files: %r" % (tc._files.required,)
-                assert tc.landing_page == "test.html"
-                result = tc._files.required[0].data.decode("UTF-8").rstrip()
-                assert result == "  required: 1"
-                assert self.quality == FuzzManagerReporter.QUAL_REDUCED_RESULT
-                assert self.force_report
-                report_data["num_reports"] += 1
-        job.set_reporter(FakeReporter())
-
-        assert job.run()
-        assert report_data["num_reports"] == 1
-
-def test_run_10(tmp_path):
-    """test that jschar stage works"""
-    with TestReductionJob(tmp_path) as job:
-        (tmp_path / "tc").mkdir()
-        (tmp_path / "tc" / "test_info.json").write_bytes(b"{\"target\":\"test.js\",\"env\":{}}")
-        (tmp_path / "tc" / "test.js").write_bytes(b"var x = 'xrequiredx'\n")
-        job.config_testcase(str(tmp_path / "tc"))
-        report_data = {"num_reports": 0}
-
-        class FakeReporter(BaseFakeReporter):
-            def _submit_report(self, _report, test_cases):
-                assert len(test_cases) == 1, "too many test_cases: %r" % (test_cases,)
-                tc = test_cases[0]
-                assert len(tc._files.required) == 1, \
-                    "too many test_files: %r" % (tc._files.required,)
-                assert tc.landing_page == "test.js"
-                # strip() is required because jsbeautifier stage removes the newline (if installed)
-                result = tc._files.required[0].data.decode("UTF-8").strip()
-                assert result == "var x = 'required'"
-                assert self.quality == FuzzManagerReporter.QUAL_REDUCED_RESULT
-                assert self.force_report
-                report_data["num_reports"] += 1
-        job.set_reporter(FakeReporter())
-
-        assert job.run()
-        assert report_data["num_reports"] == 1
-
-
-def test_run_11(tmp_path):
-    """test that analyze stage works"""
-    with TestReductionJobSemiReliable(tmp_path, skip_analysis=False) as job:
-        (tmp_path / "tc").mkdir()
-        (tmp_path / "tc" / "test_info.json").write_text("{\"target\":\"test.html\",\"env\":{}}")
-        (tmp_path / "tc" / "test.html").write_text("fluff\nrequired\n")
-        (tmp_path / "tc" / "prefs.js").write_text("some prefs")
-        (tmp_path / "tc" / "env_vars.txt").write_text("var=value\nfoo=bar")
-        job.config_testcase(str(tmp_path / "tc"))
-
-        job.set_reporter(BaseFakeReporter())
-
-        # try a 50% reliable testcase
-        with job.analysis_mode() as params:
-            job.test_set_n(5)
-            job.run()
-            assert params.min_crashes == 2
-            assert params.repeat == 10
-            assert not params.no_harness
-
-        # try a 90% reliable testcase
-        with job.analysis_mode() as params:
-            job.test_set_n(9)
-            job.run()
-            assert params.min_crashes == 2
-            assert params.repeat == 4
-            assert not params.no_harness
-
-        # try a 100% reliable testcase that doesn't repro with the harness
-        with job.analysis_mode() as params:
-            job.test_set_n(11, require_no_harness=True)
-            job.run()
-            assert params.min_crashes == 2
-            assert params.repeat == 2
-            assert params.no_harness
-
-
-def test_run_12(tmp_path):
-    """test that analyze stage works with multiple testcases"""
-    with TestReductionJobSemiReliable(tmp_path, testcase_cache=True, skip_analysis=False) as job:
-        (tmp_path / "tc").mkdir()
-        (tmp_path / "tc" / "-0").mkdir()
-        (tmp_path / "tc" / "-1").mkdir()
-        (tmp_path / "tc" / "-0" / "test_info.json").write_text("{\"target\":\"test.html\",\"env\":{}}")
-        (tmp_path / "tc" / "-0" / "test.html").write_text("-0\nDDBEGIN\nfluff\nrequired\nDDEND\n")
-        (tmp_path / "tc" / "-1" / "test_info.json").write_text("{\"target\":\"required.html\",\"env\":{}}")
-        (tmp_path / "tc" / "-1" / "required.html").write_text("-1\nDDBEGIN\nfluff\nrequired\nDDEND\n")
-        job.config_testcase(str(tmp_path / "tc"))
-
-        job.set_reporter(BaseFakeReporter())
-
-        with job.analysis_mode() as params:
-            params.min_crashes = 1
-            params.repeat = 1
-            job.test_set_n(5)
-            job.run()
-            assert params.min_crashes == 2
-            assert params.repeat == 10
-            assert not params.no_harness
diff --git a/grizzly/replay/__init__.py b/grizzly/replay/__init__.py
index 840f40a5..5e1048db 100644
--- a/grizzly/replay/__init__.py
+++ b/grizzly/replay/__init__.py
@@ -3,7 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-__all__ = ("ReplayManager", "ReplayArgs")
+__all__ = ("ReplayManager", "ReplayArgs", "ReplayResult")
 
-from .replay import ReplayManager
+from .replay import ReplayManager, ReplayResult
 from .args import ReplayArgs
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 9705541d..dc0e2e3c 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -50,7 +50,6 @@ def __init__(self, ignore, server, target, any_crash=False, signature=None, use_
         self.target = target
         self._any_crash = any_crash
         self._harness = None
-        # TODO: make signature a property
         self._signature = signature
         if use_harness:
             with open(self.HARNESS_FILE, "rb") as in_fp:
@@ -65,6 +64,10 @@ def __enter__(self):
     def __exit__(self, *exc):
         self.cleanup()
 
+    @property
+    def signature(self):
+        return self._signature
+
     def cleanup(self):
         """Remove temporary files from disk.
 
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 6ad91bc4..1263b416 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -85,6 +85,15 @@ def __enter__(self):
     def __exit__(self, *exc):
         self.cleanup()
 
+    @property
+    def relaunch(self):
+        return self.rl_reset
+
+    @relaunch.setter
+    def relaunch(self, value):
+        self.rl_reset = value
+        self.rl_countdown = 0
+
     def add_abort_token(self, token):  # pylint: disable=no-self-use,unused-argument
         LOG.warning("add_abort_token() not implemented!")
 
diff --git a/setup.py b/setup.py
index d46c4108..e74705bc 100755
--- a/setup.py
+++ b/setup.py
@@ -10,7 +10,7 @@
 
 
 EXTRAS = {
-    'reduce': ['cssbeautifier', 'lithium-reducer<0.4', 'jsbeautifier'],
+    'reduce': ['cssbeautifier', 'lithium-reducer>=0.4', 'jsbeautifier'],
     's3': ['boto3'],
 }
 EXTRAS['all'] = list(set(chain.from_iterable(EXTRAS.values())))
@@ -41,6 +41,11 @@
             'grizzly_targets': [
                 'ffpuppet = grizzly.target.puppet_target:PuppetTarget',
             ],
+            'grizzly_reduce_strategies': [
+                'check = grizzly.reduce.strategies:Check',
+                'lines = grizzly.reduce.strategies:MinimizeLines',
+                'list = grizzly.reduce.strategies:MinimizeTestcaseList',
+            ],
         },
         extras_require=EXTRAS,
         install_requires=[
diff --git a/tox.ini b/tox.ini
index 33e367ce..fedec355 100644
--- a/tox.ini
+++ b/tox.ini
@@ -8,6 +8,7 @@ exclude_lines =
 omit =
     */__main__.py
     */test_*.py
+    */conftest.py
     grizzly/adapters/*/__init__.py
     setup.py
     dist/*
@@ -33,7 +34,7 @@ filterwarnings =
 log_level = DEBUG
 
 [testenv]
-commands = pytest -v --cache-clear --cov="{toxinidir}" --cov-report term-missing --basetemp="{envtmpdir}" {posargs}
+commands = pytest -o addopts= -v --cache-clear --cov="{toxinidir}" --cov-report term-missing --basetemp="{envtmpdir}" {posargs}
 extras =
     all
     test

From 51745679b3400582e561b1189e2db25986215e81 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 30 Sep 2020 14:25:44 -0400
Subject: [PATCH 056/531] Initial grizzly.reduce tests

---
 .pylintrc                    |   2 +
 grizzly/reduce/conftest.py   |  22 +++
 grizzly/reduce/reduce.py     |  21 +-
 grizzly/reduce/strategies.py |   8 +-
 grizzly/reduce/test_main.py  | 374 +++++++++++++++++++++++++++++++++++
 setup.py                     |   1 +
 6 files changed, 419 insertions(+), 9 deletions(-)
 create mode 100644 grizzly/reduce/conftest.py
 create mode 100644 grizzly/reduce/test_main.py

diff --git a/.pylintrc b/.pylintrc
index 546a2a9c..f20c1ccb 100644
--- a/.pylintrc
+++ b/.pylintrc
@@ -1,7 +1,9 @@
 [MESSAGES CONTROL]
 disable=
     duplicate-code,
+    fixme,
     missing-docstring,
+    super-with-arguments,
     too-few-public-methods,
     too-many-arguments,
     too-many-branches,
diff --git a/grizzly/reduce/conftest.py b/grizzly/reduce/conftest.py
new file mode 100644
index 00000000..11d32856
--- /dev/null
+++ b/grizzly/reduce/conftest.py
@@ -0,0 +1,22 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# pylint: disable=protected-access
+"""
+common unit test fixtures for grizzly.reduce
+"""
+
+import pytest
+from grizzly.common.reporter import FuzzManagerReporter
+
+
+@pytest.fixture
+def tmp_path_fm_config(tmp_path, mocker):
+    """Ensure fm config is always read from tmp_path so ~/.fuzzmanagerconf
+    can't be used by accident."""
+    mocker.patch.object(
+        FuzzManagerReporter,
+        "FM_CONFIG",
+        new=str(tmp_path / ".fuzzmanagerconf"),
+    )
diff --git a/grizzly/reduce/reduce.py b/grizzly/reduce/reduce.py
index 7aaeaf4e..5ad90de4 100644
--- a/grizzly/reduce/reduce.py
+++ b/grizzly/reduce/reduce.py
@@ -107,7 +107,7 @@ def run_reliability_analysis(self):
                         results = replay.run(self.testcases, repeat=1, min_results=1)
                     except (TargetLaunchError, TargetLaunchTimeout) as exc:
                         if isinstance(exc, TargetLaunchError) and exc.report:
-                            self.report([ReplayResult(exc.report, None, False)], self.testcases)
+                            self.report([ReplayResult(exc.report, None, [], False)], self.testcases)
                             exc.report.cleanup()
                         raise
                     try:
@@ -116,7 +116,7 @@ def run_reliability_analysis(self):
                         self.report([result for result in results if not result.expected], self.testcases)
                     finally:
                         for result in results:
-                            result.cleanup()
+                            result.report.cleanup()
                     if success and use_harness:
                         harness_crashes += 1
                     elif success:
@@ -155,6 +155,7 @@ def run_reliability_analysis(self):
         return (repeat, min_crashes)
 
     def run(self, repeat=1, min_results=1):
+        any_success = False
         last_reports = None
         for strategy_no, strategy in enumerate(self.strategies):
             LOG.info("Using strategy %s (%d/%d)", strategy, strategy_no + 1, len(self.strategies))
@@ -181,11 +182,15 @@ def run(self, repeat=1, min_results=1):
                                 results = replay.run(reduction, repeat=repeat, min_results=min_results)
                             except (TargetLaunchError, TargetLaunchTimeout) as exc:
                                 if isinstance(exc, TargetLaunchError) and exc.report:
-                                    self.report([ReplayResult(exc.report, None, False)], reduction)
+                                    self.report([ReplayResult(exc.report, None, [], False)], reduction)
                                     exc.report.cleanup()
                                 raise
                             success = any(report.expected for report in results)
                             strategy.update(success)
+                            if strategy.name == "check":
+                                if any_success and not success:
+                                    raise RuntimeError("Reduction broke")
+                            any_success = any_success or success
                             # if the reduction reproduced, update self.testcases (new best)
                             if success:
                                 LOG.info("Interesting")
@@ -195,7 +200,7 @@ def run(self, repeat=1, min_results=1):
                                 keep_reduction = True
                                 # cleanup old best results
                                 for result in best_results:
-                                    result.cleanup()
+                                    result.report.cleanup()
                                 # filter expected results out into `best_results`
                                 best_results = [result for result in results if result.expected]
                                 results = [result for result in results if not result.expected]
@@ -208,11 +213,11 @@ def run(self, repeat=1, min_results=1):
                                 for testcase in reduction:
                                     testcase.cleanup()
                             for result in results:
-                                result.cleanup()
+                                result.report.cleanup()
                     last_reports = self.report(best_results, self.testcases)
                 finally:
                     for result in best_results:
-                        result.cleanup()
+                        result.report.cleanup()
                 # if self._signature was already set, this will do nothing
                 # otherwise, ensure the first found signature is used throughout
                 self._signature = replay.signature
@@ -220,7 +225,7 @@ def run(self, repeat=1, min_results=1):
         if self._report_to_fuzzmanager and last_reports:
             for crash_id in last_reports:
                 change_quality(crash_id, FuzzManagerReporter.QUAL_REDUCED_RESULT)
-        return bool(last_reports)  # true if anything expected was reported in the last round
+        return any_success
 
     def report(self, results, tests):
         """Report results, either to fuzzmanager or to filesystem.
@@ -228,7 +233,7 @@ def report(self, results, tests):
         ret_values = []
         for result in results:
             if self._report_to_fuzzmanager:
-                reporter = FuzzManagerReporter(self.target.binary, self._report_tool)
+                reporter = FuzzManagerReporter(self._report_tool)
                 if result.expected:
                     reporter.force_report = True
             else:
diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index 558ce194..3228294d 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -14,7 +14,7 @@
 from types import MappingProxyType
 
 from lithium.strategies import CheckOnly, Minimize
-from lithium.testcases import TestcaseLine
+from lithium.testcases import TestcaseChar, TestcaseLine
 from pkg_resources import iter_entry_points
 
 from ..common.utils import grz_tmp
@@ -200,4 +200,10 @@ class MinimizeLines(_LithiumStrategy):
     testcase_cls = TestcaseLine
 
 
+class MinimizeChars(_LithiumStrategy):
+    name = "chars"
+    strategy_cls = Minimize
+    testcase_cls = TestcaseChar
+
+
 STRATEGIES = _load_strategies()
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
new file mode 100644
index 00000000..b1c7ed8d
--- /dev/null
+++ b/grizzly/reduce/test_main.py
@@ -0,0 +1,374 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# pylint: disable=protected-access
+"""
+unit tests for grizzly.reduce.main
+"""
+import functools
+from logging import getLogger
+from pathlib import Path
+
+import pytest
+from pytest import raises
+
+from sapphire import SERVED_ALL
+from ..common import TestCaseLoadFailure
+from ..target import Target, TargetLaunchError, TargetLaunchTimeout
+from ..reduce import ReduceManager
+from ..reduce.args import ReduceArgs
+
+
+LOG = getLogger(__name__)
+pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")  # pylint: disable=invalid-name
+
+
+def _fake_save_logs_foo(result_logs, meta=False):  # pylint: disable=unused-argument
+    """write fake log data to disk"""
+    (Path(result_logs) / "log_stderr.txt").write_text("STDERR log\n")
+    (Path(result_logs) / "log_stdout.txt").write_text("STDOUT log\n")
+    (Path(result_logs) / "log_asan_blah.txt").write_text(
+        "==1==ERROR: AddressSanitizer: "
+        "SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n"
+        "    #0 0xbad000 in foo /file1.c:123:234\n"
+        "    #1 0x1337dd in bar /file2.c:1806:19\n"
+    )
+
+
+def _fake_save_logs_bar(result_logs, meta=False):  # pylint: disable=unused-argument
+    """write fake log data to disk"""
+    (Path(result_logs) / "log_stderr.txt").write_text("STDERR log\n")
+    (Path(result_logs) / "log_stdout.txt").write_text("STDOUT log\n")
+    (Path(result_logs) / "log_asan_blah.txt").write_text(
+        "==1==ERROR: AddressSanitizer: "
+        "SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n"
+        "    #0 0xbad000 in bar /file1.c:123:234\n"
+        "    #1 0x1337dd in foo /file2.c:1806:19\n"
+    )
+
+
+def test_args_01(capsys, tmp_path):
+    """test parsing args"""
+    # missing args tests
+    with raises(SystemExit):
+        ReduceArgs().parse_args([])
+    # specified prefs.js missing
+    exe = tmp_path / "binary"
+    exe.touch()
+    inp = tmp_path / "input"
+    inp.mkdir()
+    (inp / "somefile").touch()
+    (inp / "test_info.json").touch()
+    with raises(SystemExit):
+        ReduceArgs().parse_args([str(exe), str(inp / "somefile"), "--prefs", "missing"])
+    assert "error: -p/--prefs not found 'missing'" in capsys.readouterr()[-1]
+    # test case directory
+    (inp / "prefs.js").touch()
+    ReduceArgs().parse_args([str(exe), str(inp)])
+    # test case file
+    ReduceArgs().parse_args([str(exe), str(inp / "somefile"), "--prefs", str(inp / "prefs.js")])
+    # test negative min-crashes value
+    with raises(SystemExit):
+        ReduceArgs().parse_args([str(exe), str(inp), "--min-crashes", "-1"])
+    assert "error: '--min-crashes' value must be positive" in capsys.readouterr()[-1]
+    # test negative repeat value
+    with raises(SystemExit):
+        ReduceArgs().parse_args([str(exe), str(inp), "--repeat", "-1"])
+    assert "error: '--repeat' value must be positive" in capsys.readouterr()[-1]
+    # test missing signature file
+    with raises(SystemExit):
+        ReduceArgs().parse_args([str(exe), str(inp), "--sig", "missing"])
+    assert "error: signature file not found" in capsys.readouterr()[-1]
+    # test any crash and signature
+    with raises(SystemExit):
+        ReduceArgs().parse_args([str(exe), str(inp), "--any-crash", "--sig", "x"])
+    assert "error: signature is ignored when running with '--any-crash'" in capsys.readouterr()[-1]
+
+    # above this line is copied from replay/test_main.py#test_args_01
+    # TODO: is there a way to make the test generic?
+
+    # test valid strategy
+    ReduceArgs().parse_args([str(exe), str(inp), "--strategy", "lines"])
+    # test invalid strategy
+    with raises(SystemExit):
+        ReduceArgs().parse_args([str(exe), str(inp), "--strategy", "cosmic_radiation"])
+    # test --logs must be dir
+    logs_file = tmp_path / "logs1"
+    logs_file.touch()
+    with raises(SystemExit):
+        ReduceArgs().parse_args([str(exe), str(inp), "--logs", str(logs_file)])
+    logs_dir = tmp_path / "logs2"
+    logs_dir.mkdir()
+    ReduceArgs().parse_args([str(exe), str(inp), "--logs", str(logs_dir)])
+    # test no-analysis
+    ReduceArgs().parse_args([str(exe), str(inp), "--no-analysis", "--repeat", "99", "--min-crashes", "99"])
+
+
+def test_main_01(mocker):
+    """test ReduceManager.main() failure cases"""
+    mocker.patch("grizzly.reduce.reduce.FuzzManagerReporter", autospec=True)
+    mocker.patch("grizzly.reduce.reduce.load_target", autospec=True)
+    mocker.patch("grizzly.reduce.reduce.Sapphire", autospec=True)
+    mocker.patch("grizzly.reduce.reduce.TestCase", autospec=True)
+    # setup args
+    args = mocker.Mock(
+        ignore=None,
+        input="test",
+        min_crashes=1,
+        prefs=None,
+        relaunch=1,
+        repeat=1,
+        sig=None)
+
+    mocker.patch("grizzly.reduce.reduce.ReduceManager.run", side_effect=TargetLaunchError("error", None))
+    assert ReduceManager.main(args) == 1
+
+    mocker.patch("grizzly.reduce.reduce.ReduceManager.run", side_effect=TargetLaunchTimeout)
+    assert ReduceManager.main(args) == 1
+
+    mocker.patch("grizzly.reduce.reduce.load_target", side_effect=KeyboardInterrupt)
+    assert ReduceManager.main(args) == 1
+
+    mocker.patch("grizzly.reduce.reduce.TestCase.load", side_effect=TestCaseLoadFailure)
+    assert ReduceManager.main(args) == 1
+
+    mocker.patch("grizzly.reduce.reduce.TestCase.load", return_value=list())
+    assert ReduceManager.main(args) == 1
+
+
+def ignore_arg(func):
+    """Function wrapper that simply ignores 1 argument"""
+    @functools.wraps(func)
+    def wrapped(_):
+        return func()
+    return wrapped
+
+
+@pytest.mark.parametrize(
+    "original, strategies, detect_failure, interesting_str, save_logs, launch_count, n_reports, reports, "
+    "n_other, other_reports",
+    [
+        # no repro
+        (
+            "123456\n",
+            ["check"],
+            lambda _: False,
+            "%r",
+            None,
+            1,
+            0,
+            None,
+            0,
+            None,
+        ),
+        # reproduces, one strategy, no reduction works
+        (
+            "1\n2\n3\n",
+            ["check", "lines"],
+            lambda contents: contents == "1\n2\n3\n",
+            "%r == '1\n2\n3\n'",
+            lambda _: _fake_save_logs_foo,
+            6,
+            1,
+            {"1\n2\n3\n"},
+            0,
+            None,
+        ),
+        # reproduces, one strategy, some reduction works
+        (
+            "odd\neven\n" * 3,
+            ["check", "lines"],
+            lambda contents: sum(1 for line in contents.splitlines() if line == "odd") == 3,
+            "%r contains 3x 'odd'",
+            lambda _: _fake_save_logs_foo,
+            8,
+            2,
+            {"odd\neven\n" * 3, "odd\n" * 3},
+            0,
+            None,
+        ),
+        # reproduces, one strategy, reduction only finds other
+        (
+            "1\n2\n3\n",
+            ["check", "lines"],
+            bool,
+            "%r != ''",
+            lambda contents: _fake_save_logs_foo if contents == "1\n2\n3\n" else \
+            (_fake_save_logs_bar if contents else None),
+            6,
+            1,
+            {"1\n2\n3\n"},
+            5,
+            {"1\n", "3\n", "1\n2\n", "1\n3\n", "2\n3\n"},
+        ),
+        # reproduces, 50% iterations work, 1 iteration produces other sig
+        (
+            "1\n2\n3\n4\n5\n6\n",
+            ["check", "lines"],
+            lambda contents: set(contents.splitlines()) >= set("135"),
+            "%r contains {'1', '3', '5'}",
+            lambda contents: _fake_save_logs_foo if contents == "1\n3\n5\n" else \
+            (_fake_save_logs_bar if contents else None),
+            13,
+            2,
+            {"1\n2\n3\n4\n5\n6\n", "1\n2\n3\n5\n"},
+            1,
+            {"1\n3\n5\n"},
+        ),
+        # reproduces, two strategies, 1st no reduction, 2nd 50% reduction
+        (
+            "A1\nA2\nA3\nA4\nA5\nA6\n",
+            ["check", "lines", "chars"],
+            lambda contents: len(contents.splitlines()) == 6 and set(contents.splitlines()) >= \
+            {"A1", "A3", "A5"},
+            "%r contains {'A1', 'A3', 'A5'} and len() == 6",
+            lambda _: _fake_save_logs_foo,
+            43,
+            # lines found nothing, only check and chars should report
+            2,
+            {"A1\nA2\nA3\nA4\nA5\nA6\n", "A1\n\nA3\n\nA5\nA"},
+            0,
+            None,
+        ),
+        # reproduces, two strategies, 1st 50% reduction, 2nd no reduction
+        (
+            "A1\nA2\nA3\nA4\nA5\nA6\n",
+            ["check", "lines", "chars"],
+            lambda contents: set(contents.splitlines(keepends=True)) >= {"A1\n", "A3\n", "A5\n"},
+            "%r contains {'A1\\n', 'A3\\n', 'A5\\n'}",
+            lambda _: _fake_save_logs_foo,
+            34,
+            # lines found nothing, only check and chars should report
+            2,
+            {"A1\nA2\nA3\nA4\nA5\nA6\n", "A1\nA3\nA5\n"},
+            0,
+            None,
+        ),
+        # reproduces, two strategies, reduce only produces other sig
+        (
+            "1\n2\n3\n",
+            ["check", "lines", "chars"],
+            bool,
+            "%r != ''",
+            lambda contents: _fake_save_logs_foo if contents == "1\n2\n3\n" else \
+            (_fake_save_logs_bar if contents else None),
+            16,
+            1,
+            {"1\n2\n3\n"},
+            15,
+            {"\n2\n3\n", "1\n", "1\n\n3\n", "1\n2\n", "1\n2\n\n", "1\n2\n3", "1\n23\n", "1\n3\n", "12\n3\n",
+             "2\n3\n", "3\n"}
+        ),
+        # reproduces, one strategy, testcase reduces to 0
+        (
+            "1\n2\n3\n",
+            ["check", "lines"],
+            lambda _: True,
+            "%r is anything, incl. empty",
+            lambda _: _fake_save_logs_foo,
+            3,
+            2,
+            {"1\n2\n3\n", ""},
+            0,
+            None,
+        ),
+        # reproduces, two strategies, 1st no reduce, 2nd testcase reduces to 0
+        (
+            "1\n2\n3\n",
+            ["check", "lines", "lines"],
+            ignore_arg(functools.partial([True, False, False, False, False, False, True, True].pop, 0)),
+            "%r is anything, only in second strategy",
+            lambda _: _fake_save_logs_foo,
+            8,
+            2,
+            {"1\n2\n3\n", ""},
+            0,
+            None,
+        ),
+    ]
+)
+def test_repro(mocker, tmp_path, original, strategies, detect_failure, interesting_str, save_logs,
+               launch_count, n_reports, reports, n_other, other_reports):
+    """test ReduceManager, difference scenarios produce correct expected/other results"""
+    last_path = [None]
+
+    def serve(path, **_kw):
+        LOG.debug("serving %r", path)
+        last_path[0] = path
+        return (SERVED_ALL, ["test.html"])
+    serve_path = mocker.patch("grizzly.reduce.reduce.Sapphire.serve_path", side_effect=serve)
+    # setup Target
+    load_target = mocker.patch("grizzly.reduce.reduce.load_target")
+    target = mocker.Mock(spec=Target, binary="bin", forced_close=True)
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
+    target.RESULT_IGNORED = Target.RESULT_IGNORED
+    target.RESULT_NONE = Target.RESULT_NONE
+
+    def _fake_save_logs(result_path, meta=False):
+        contents = (Path(last_path[0]) / "test.html").read_text()
+        return save_logs(contents)(result_path, meta)
+    target.save_logs = _fake_save_logs
+    target.relaunch = 1
+
+    def interesting(*_, **_kw):
+        contents = (Path(last_path[0]) / "test.html").read_text()
+        LOG.debug("interesting if " + interesting_str, contents)  # pylint: disable=logging-not-lazy
+        if detect_failure(contents):
+            return Target.RESULT_FAILURE
+        return Target.RESULT_NONE
+    target.detect_failure.side_effect = interesting
+    load_target.return_value.return_value = target
+
+    prefix = mocker.patch("grizzly.common.reporter.strftime")
+
+    def report_prefix(_):
+        return "%04d" % (prefix.call_count,)
+    prefix.side_effect = report_prefix
+
+    # setup args
+    args = mocker.Mock()
+    args.fuzzmanager = False
+    args.ignore = ["fake", "timeout"]
+    log_path = (tmp_path / "logs")
+    args.logs = str(log_path)
+    (tmp_path / "test.html").write_text(original)
+    args.input = str(tmp_path / "test.html")
+    args.min_crashes = 1
+    (tmp_path / "prefs.js").touch()
+    args.prefs = str(tmp_path / "prefs.js")
+    args.relaunch = 1
+    args.repeat = 1
+    args.any_crash = False
+    args.sig = None
+    args.timeout = 10
+    args.no_analysis = True
+    args.strategies = strategies
+    assert ReduceManager.main(args) == (0 if (n_reports or n_other) else 1)
+    assert target.forced_close
+    assert target.reverse.call_count == 1
+    assert target.launch.call_count == launch_count
+    assert target.step.call_count == launch_count
+    assert target.detect_failure.call_count == launch_count
+    assert serve_path.call_count == launch_count
+    assert load_target.call_count == 1
+    assert target.close.call_count == launch_count
+    assert target.cleanup.call_count == 1
+    assert target.check_relaunch.call_count == 0
+    expected_dirs = set()
+    if n_reports:
+        expected_dirs.add(log_path / "reports")
+    if n_other:
+        expected_dirs.add(log_path / "other_reports")
+    if expected_dirs:
+        assert set(log_path.iterdir()) == expected_dirs
+    if n_reports:
+        tests = {test.read_text() for test in log_path.glob("reports/*-0/test.html")}
+        assert tests == reports
+        assert len(list((log_path / "reports").iterdir())) \
+            == n_reports * 2, list((log_path / "reports").iterdir())
+    if n_other:
+        other_tests = {test.read_text() for test in log_path.glob("other_reports/*-0/test.html")}
+        assert other_tests == other_reports
+        assert len(list((log_path / "other_reports").iterdir())) \
+            == n_other * 2, list((log_path / "other_reports").iterdir())
diff --git a/setup.py b/setup.py
index e74705bc..02deb6e9 100755
--- a/setup.py
+++ b/setup.py
@@ -43,6 +43,7 @@
             ],
             'grizzly_reduce_strategies': [
                 'check = grizzly.reduce.strategies:Check',
+                'chars = grizzly.reduce.strategies:MinimizeChars',
                 'lines = grizzly.reduce.strategies:MinimizeLines',
                 'list = grizzly.reduce.strategies:MinimizeTestcaseList',
             ],

From 6e510e13be53935ca5ed76ace4b8515885de49bb Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 8 Oct 2020 16:27:53 -0400
Subject: [PATCH 057/531] Complete tests for grizzly.reduce.

Also some bug fixes found along the way through testing.
---
 grizzly/reduce/__init__.py            |   2 +-
 grizzly/reduce/__main__.py            |   2 +-
 grizzly/reduce/conftest.py            |  16 +-
 grizzly/reduce/{reduce.py => core.py} |  10 +-
 grizzly/reduce/strategies.py          |  10 +-
 grizzly/reduce/test_main.py           | 381 +++++------------------
 grizzly/reduce/test_reduce.py         | 418 ++++++++++++++++++++++++++
 grizzly/reduce/test_strategies.py     | 150 +++++++++
 8 files changed, 670 insertions(+), 319 deletions(-)
 rename grizzly/reduce/{reduce.py => core.py} (97%)
 create mode 100644 grizzly/reduce/test_reduce.py
 create mode 100644 grizzly/reduce/test_strategies.py

diff --git a/grizzly/reduce/__init__.py b/grizzly/reduce/__init__.py
index ac6ceed3..dde176a2 100644
--- a/grizzly/reduce/__init__.py
+++ b/grizzly/reduce/__init__.py
@@ -5,5 +5,5 @@
 
 __all__ = ("ReduceManager", "ReduceArgs")
 
-from .reduce import ReduceManager
+from .core import ReduceManager
 from .args import ReduceArgs
diff --git a/grizzly/reduce/__main__.py b/grizzly/reduce/__main__.py
index ab5d8aa9..6c2ca1d3 100644
--- a/grizzly/reduce/__main__.py
+++ b/grizzly/reduce/__main__.py
@@ -5,7 +5,7 @@
 import sys
 
 from .args import ReduceArgs
-from .reduce import ReduceManager
+from . import ReduceManager
 
 
 sys.exit(ReduceManager.main(ReduceArgs().parse_args()))
diff --git a/grizzly/reduce/conftest.py b/grizzly/reduce/conftest.py
index 11d32856..f92f2533 100644
--- a/grizzly/reduce/conftest.py
+++ b/grizzly/reduce/conftest.py
@@ -8,15 +8,23 @@
 """
 
 import pytest
-from grizzly.common.reporter import FuzzManagerReporter
 
 
 @pytest.fixture
 def tmp_path_fm_config(tmp_path, mocker):
     """Ensure fm config is always read from tmp_path so ~/.fuzzmanagerconf
     can't be used by accident."""
-    mocker.patch.object(
-        FuzzManagerReporter,
-        "FM_CONFIG",
+    mocker.patch(
+        "grizzly.reduce.core.FuzzManagerReporter.FM_CONFIG",
         new=str(tmp_path / ".fuzzmanagerconf"),
     )
+    (tmp_path / ".fuzzmanagerconf").touch()
+
+
+@pytest.fixture
+def reporter_sequential_strftime(mocker):
+    prefix = mocker.patch("grizzly.common.reporter.strftime")
+
+    def report_prefix(_):
+        return "%04d" % (prefix.call_count,)
+    prefix.side_effect = report_prefix
diff --git a/grizzly/reduce/reduce.py b/grizzly/reduce/core.py
similarity index 97%
rename from grizzly/reduce/reduce.py
rename to grizzly/reduce/core.py
index 5ad90de4..8f3f0243 100644
--- a/grizzly/reduce/reduce.py
+++ b/grizzly/reduce/core.py
@@ -47,7 +47,7 @@ def change_quality(crash_id, quality):
     url = "%s://%s:%d/crashmanager/rest/crashes/%d/" \
         % (coll.serverProtocol, coll.serverHost, coll.serverPort, crash_id)
     try:
-        Collector().patch(url, data={"testcase_quality": quality})
+        coll.patch(url, data={"testcase_quality": quality})
     except RuntimeError as exc:
         # let 404's go .. evidently the crash was deleted
         if str(exc) == "Unexpected HTTP response: 404":
@@ -93,15 +93,15 @@ def run_reliability_analysis(self):
         self.target.relaunch = self.ANALYSIS_ITERATIONS
 
         for use_harness in [True, False]:
-            if use_harness and self._original_use_harness:
+            if use_harness and not self._original_use_harness:
                 continue
-            if not use_harness and harness_crashes != self.ANALYSIS_ITERATIONS:
+            if not use_harness and harness_crashes == self.ANALYSIS_ITERATIONS:
                 continue
 
             with ReplayManager(self.ignore, self.server, self.target, any_crash=self._any_crash,
                                signature=self._signature, use_harness=use_harness) as replay:
                 LOG.info("Running for %d iterations to assess reliability %s harness.",
-                         "using" if use_harness else "without", self.ANALYSIS_ITERATIONS)
+                         self.ANALYSIS_ITERATIONS, "using" if use_harness else "without")
                 for _ in range(self.ANALYSIS_ITERATIONS):
                     try:
                         results = replay.run(self.testcases, repeat=1, min_results=1)
@@ -128,7 +128,7 @@ def run_reliability_analysis(self):
                 self._signature = replay.signature
 
         if harness_crashes == 0 and non_harness_crashes == 0:
-            raise RuntimeError("TODO: Did not reproduce during analysis")
+            raise RuntimeError("Did not reproduce during analysis")
 
         # should we use the harness? go with whichever crashed more
         self._use_harness = non_harness_crashes <= harness_crashes
diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index 3228294d..d3776e18 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -161,7 +161,7 @@ def __iter__(self):
                 if self._current_feedback:
                     # removal was success! find the testcase that matches timestamp,
                     # and remove it
-                    LOG.info("Removing testcase %d/%d was successful!", idx, n_testcases)
+                    LOG.info("Removing testcase %d/%d was successful!", idx + 1, n_testcases)
                     removed_path = None
                     for test_info in self._testcase_root.glob("*/test_info.json"):
                         info = json.loads(test_info.read_text())
@@ -178,7 +178,7 @@ def __iter__(self):
                     rmtree(str(removed_path.parent))
                     n_testcases -= 1
                 else:
-                    LOG.info("No result without testcase %d/%d", idx, n_testcases)
+                    LOG.info("No result without testcase %d/%d", idx + 1, n_testcases)
                     idx += 1
                 # reset
                 self._current_feedback = None
@@ -193,6 +193,12 @@ class Check(_LithiumStrategy):
     strategy_cls = CheckOnly
     testcase_cls = TestcaseLine
 
+    def __init__(self, *args, **kwds):
+        super().__init__(*args, **kwds)
+        # trim files_to_reduce, for check we don't need to run on every file
+        # just once per Grizzly TestCase set is enough.
+        self._files_to_reduce = self._files_to_reduce[:1]
+
 
 class MinimizeLines(_LithiumStrategy):
     name = "lines"
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index b1c7ed8d..a97f8c72 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -6,87 +6,38 @@
 """
 unit tests for grizzly.reduce.main
 """
-import functools
+import json
 from logging import getLogger
 from pathlib import Path
+from shutil import rmtree
 
 import pytest
 from pytest import raises
 
-from sapphire import SERVED_ALL
 from ..common import TestCaseLoadFailure
-from ..target import Target, TargetLaunchError, TargetLaunchTimeout
-from ..reduce import ReduceManager
-from ..reduce.args import ReduceArgs
+from ..target import TargetLaunchError, TargetLaunchTimeout
+from .args import ReduceArgs
+from . import ReduceManager
 
 
 LOG = getLogger(__name__)
 pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")  # pylint: disable=invalid-name
 
 
-def _fake_save_logs_foo(result_logs, meta=False):  # pylint: disable=unused-argument
-    """write fake log data to disk"""
-    (Path(result_logs) / "log_stderr.txt").write_text("STDERR log\n")
-    (Path(result_logs) / "log_stdout.txt").write_text("STDOUT log\n")
-    (Path(result_logs) / "log_asan_blah.txt").write_text(
-        "==1==ERROR: AddressSanitizer: "
-        "SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n"
-        "    #0 0xbad000 in foo /file1.c:123:234\n"
-        "    #1 0x1337dd in bar /file2.c:1806:19\n"
-    )
-
-
-def _fake_save_logs_bar(result_logs, meta=False):  # pylint: disable=unused-argument
-    """write fake log data to disk"""
-    (Path(result_logs) / "log_stderr.txt").write_text("STDERR log\n")
-    (Path(result_logs) / "log_stdout.txt").write_text("STDOUT log\n")
-    (Path(result_logs) / "log_asan_blah.txt").write_text(
-        "==1==ERROR: AddressSanitizer: "
-        "SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n"
-        "    #0 0xbad000 in bar /file1.c:123:234\n"
-        "    #1 0x1337dd in foo /file2.c:1806:19\n"
-    )
+def test_args_01(capsys, tmp_path, mocker):
+    """test args in common with grizzly.replay"""
+    from ..replay.test_main import test_args_01 as real_test  # pylint: disable=import-outside-toplevel
+    mocker.patch("grizzly.replay.test_main.ReplayArgs", new=ReduceArgs)
+    real_test(capsys, tmp_path)
 
 
-def test_args_01(capsys, tmp_path):
-    """test parsing args"""
-    # missing args tests
-    with raises(SystemExit):
-        ReduceArgs().parse_args([])
-    # specified prefs.js missing
+def test_args_02(tmp_path):
+    """test parsing args specific to grizzly.reduce"""
     exe = tmp_path / "binary"
     exe.touch()
     inp = tmp_path / "input"
     inp.mkdir()
     (inp / "somefile").touch()
-    (inp / "test_info.json").touch()
-    with raises(SystemExit):
-        ReduceArgs().parse_args([str(exe), str(inp / "somefile"), "--prefs", "missing"])
-    assert "error: -p/--prefs not found 'missing'" in capsys.readouterr()[-1]
-    # test case directory
-    (inp / "prefs.js").touch()
-    ReduceArgs().parse_args([str(exe), str(inp)])
-    # test case file
-    ReduceArgs().parse_args([str(exe), str(inp / "somefile"), "--prefs", str(inp / "prefs.js")])
-    # test negative min-crashes value
-    with raises(SystemExit):
-        ReduceArgs().parse_args([str(exe), str(inp), "--min-crashes", "-1"])
-    assert "error: '--min-crashes' value must be positive" in capsys.readouterr()[-1]
-    # test negative repeat value
-    with raises(SystemExit):
-        ReduceArgs().parse_args([str(exe), str(inp), "--repeat", "-1"])
-    assert "error: '--repeat' value must be positive" in capsys.readouterr()[-1]
-    # test missing signature file
-    with raises(SystemExit):
-        ReduceArgs().parse_args([str(exe), str(inp), "--sig", "missing"])
-    assert "error: signature file not found" in capsys.readouterr()[-1]
-    # test any crash and signature
-    with raises(SystemExit):
-        ReduceArgs().parse_args([str(exe), str(inp), "--any-crash", "--sig", "x"])
-    assert "error: signature is ignored when running with '--any-crash'" in capsys.readouterr()[-1]
-
-    # above this line is copied from replay/test_main.py#test_args_01
-    # TODO: is there a way to make the test generic?
 
     # test valid strategy
     ReduceArgs().parse_args([str(exe), str(inp), "--strategy", "lines"])
@@ -103,17 +54,20 @@ def test_args_01(capsys, tmp_path):
     ReduceArgs().parse_args([str(exe), str(inp), "--logs", str(logs_dir)])
     # test no-analysis
     ReduceArgs().parse_args([str(exe), str(inp), "--no-analysis", "--repeat", "99", "--min-crashes", "99"])
+    # these should both log a warning that the args will be ignored due to analysis
+    ReduceArgs().parse_args([str(exe), str(inp), "--repeat", "99"])
+    ReduceArgs().parse_args([str(exe), str(inp), "--min-crashes", "99"])
 
 
 def test_main_01(mocker):
     """test ReduceManager.main() failure cases"""
-    mocker.patch("grizzly.reduce.reduce.FuzzManagerReporter", autospec=True)
-    mocker.patch("grizzly.reduce.reduce.load_target", autospec=True)
-    mocker.patch("grizzly.reduce.reduce.Sapphire", autospec=True)
-    mocker.patch("grizzly.reduce.reduce.TestCase", autospec=True)
+    mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
+    mocker.patch("grizzly.reduce.core.load_target", autospec=True)
+    mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
+    mocker.patch("grizzly.reduce.core.TestCase", autospec=True)
     # setup args
     args = mocker.Mock(
-        ignore=None,
+        ignore=["fake"],
         input="test",
         min_crashes=1,
         prefs=None,
@@ -121,254 +75,69 @@ def test_main_01(mocker):
         repeat=1,
         sig=None)
 
-    mocker.patch("grizzly.reduce.reduce.ReduceManager.run", side_effect=TargetLaunchError("error", None))
+    mocker.patch("grizzly.reduce.core.ReduceManager.run", side_effect=TargetLaunchError("error", None))
     assert ReduceManager.main(args) == 1
 
-    mocker.patch("grizzly.reduce.reduce.ReduceManager.run", side_effect=TargetLaunchTimeout)
+    mocker.patch("grizzly.reduce.core.ReduceManager.run", side_effect=TargetLaunchTimeout)
     assert ReduceManager.main(args) == 1
 
-    mocker.patch("grizzly.reduce.reduce.load_target", side_effect=KeyboardInterrupt)
+    mocker.patch("grizzly.reduce.core.load_target", side_effect=KeyboardInterrupt)
     assert ReduceManager.main(args) == 1
 
-    mocker.patch("grizzly.reduce.reduce.TestCase.load", side_effect=TestCaseLoadFailure)
+    mocker.patch("grizzly.reduce.core.TestCase.load", side_effect=TestCaseLoadFailure)
     assert ReduceManager.main(args) == 1
 
-    mocker.patch("grizzly.reduce.reduce.TestCase.load", return_value=list())
+    mocker.patch("grizzly.reduce.core.TestCase.load", return_value=list())
     assert ReduceManager.main(args) == 1
 
 
-def ignore_arg(func):
-    """Function wrapper that simply ignores 1 argument"""
-    @functools.wraps(func)
-    def wrapped(_):
-        return func()
-    return wrapped
-
-
-@pytest.mark.parametrize(
-    "original, strategies, detect_failure, interesting_str, save_logs, launch_count, n_reports, reports, "
-    "n_other, other_reports",
-    [
-        # no repro
-        (
-            "123456\n",
-            ["check"],
-            lambda _: False,
-            "%r",
-            None,
-            1,
-            0,
-            None,
-            0,
-            None,
-        ),
-        # reproduces, one strategy, no reduction works
-        (
-            "1\n2\n3\n",
-            ["check", "lines"],
-            lambda contents: contents == "1\n2\n3\n",
-            "%r == '1\n2\n3\n'",
-            lambda _: _fake_save_logs_foo,
-            6,
-            1,
-            {"1\n2\n3\n"},
-            0,
-            None,
-        ),
-        # reproduces, one strategy, some reduction works
-        (
-            "odd\neven\n" * 3,
-            ["check", "lines"],
-            lambda contents: sum(1 for line in contents.splitlines() if line == "odd") == 3,
-            "%r contains 3x 'odd'",
-            lambda _: _fake_save_logs_foo,
-            8,
-            2,
-            {"odd\neven\n" * 3, "odd\n" * 3},
-            0,
-            None,
-        ),
-        # reproduces, one strategy, reduction only finds other
-        (
-            "1\n2\n3\n",
-            ["check", "lines"],
-            bool,
-            "%r != ''",
-            lambda contents: _fake_save_logs_foo if contents == "1\n2\n3\n" else \
-            (_fake_save_logs_bar if contents else None),
-            6,
-            1,
-            {"1\n2\n3\n"},
-            5,
-            {"1\n", "3\n", "1\n2\n", "1\n3\n", "2\n3\n"},
-        ),
-        # reproduces, 50% iterations work, 1 iteration produces other sig
-        (
-            "1\n2\n3\n4\n5\n6\n",
-            ["check", "lines"],
-            lambda contents: set(contents.splitlines()) >= set("135"),
-            "%r contains {'1', '3', '5'}",
-            lambda contents: _fake_save_logs_foo if contents == "1\n3\n5\n" else \
-            (_fake_save_logs_bar if contents else None),
-            13,
-            2,
-            {"1\n2\n3\n4\n5\n6\n", "1\n2\n3\n5\n"},
-            1,
-            {"1\n3\n5\n"},
-        ),
-        # reproduces, two strategies, 1st no reduction, 2nd 50% reduction
-        (
-            "A1\nA2\nA3\nA4\nA5\nA6\n",
-            ["check", "lines", "chars"],
-            lambda contents: len(contents.splitlines()) == 6 and set(contents.splitlines()) >= \
-            {"A1", "A3", "A5"},
-            "%r contains {'A1', 'A3', 'A5'} and len() == 6",
-            lambda _: _fake_save_logs_foo,
-            43,
-            # lines found nothing, only check and chars should report
-            2,
-            {"A1\nA2\nA3\nA4\nA5\nA6\n", "A1\n\nA3\n\nA5\nA"},
-            0,
-            None,
-        ),
-        # reproduces, two strategies, 1st 50% reduction, 2nd no reduction
-        (
-            "A1\nA2\nA3\nA4\nA5\nA6\n",
-            ["check", "lines", "chars"],
-            lambda contents: set(contents.splitlines(keepends=True)) >= {"A1\n", "A3\n", "A5\n"},
-            "%r contains {'A1\\n', 'A3\\n', 'A5\\n'}",
-            lambda _: _fake_save_logs_foo,
-            34,
-            # lines found nothing, only check and chars should report
-            2,
-            {"A1\nA2\nA3\nA4\nA5\nA6\n", "A1\nA3\nA5\n"},
-            0,
-            None,
-        ),
-        # reproduces, two strategies, reduce only produces other sig
-        (
-            "1\n2\n3\n",
-            ["check", "lines", "chars"],
-            bool,
-            "%r != ''",
-            lambda contents: _fake_save_logs_foo if contents == "1\n2\n3\n" else \
-            (_fake_save_logs_bar if contents else None),
-            16,
-            1,
-            {"1\n2\n3\n"},
-            15,
-            {"\n2\n3\n", "1\n", "1\n\n3\n", "1\n2\n", "1\n2\n\n", "1\n2\n3", "1\n23\n", "1\n3\n", "12\n3\n",
-             "2\n3\n", "3\n"}
-        ),
-        # reproduces, one strategy, testcase reduces to 0
-        (
-            "1\n2\n3\n",
-            ["check", "lines"],
-            lambda _: True,
-            "%r is anything, incl. empty",
-            lambda _: _fake_save_logs_foo,
-            3,
-            2,
-            {"1\n2\n3\n", ""},
-            0,
-            None,
-        ),
-        # reproduces, two strategies, 1st no reduce, 2nd testcase reduces to 0
-        (
-            "1\n2\n3\n",
-            ["check", "lines", "lines"],
-            ignore_arg(functools.partial([True, False, False, False, False, False, True, True].pop, 0)),
-            "%r is anything, only in second strategy",
-            lambda _: _fake_save_logs_foo,
-            8,
-            2,
-            {"1\n2\n3\n", ""},
-            0,
-            None,
-        ),
-    ]
-)
-def test_repro(mocker, tmp_path, original, strategies, detect_failure, interesting_str, save_logs,
-               launch_count, n_reports, reports, n_other, other_reports):
-    """test ReduceManager, difference scenarios produce correct expected/other results"""
-    last_path = [None]
-
-    def serve(path, **_kw):
-        LOG.debug("serving %r", path)
-        last_path[0] = path
-        return (SERVED_ALL, ["test.html"])
-    serve_path = mocker.patch("grizzly.reduce.reduce.Sapphire.serve_path", side_effect=serve)
-    # setup Target
-    load_target = mocker.patch("grizzly.reduce.reduce.load_target")
-    target = mocker.Mock(spec=Target, binary="bin", forced_close=True)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.RESULT_IGNORED = Target.RESULT_IGNORED
-    target.RESULT_NONE = Target.RESULT_NONE
-
-    def _fake_save_logs(result_path, meta=False):
-        contents = (Path(last_path[0]) / "test.html").read_text()
-        return save_logs(contents)(result_path, meta)
-    target.save_logs = _fake_save_logs
-    target.relaunch = 1
-
-    def interesting(*_, **_kw):
-        contents = (Path(last_path[0]) / "test.html").read_text()
-        LOG.debug("interesting if " + interesting_str, contents)  # pylint: disable=logging-not-lazy
-        if detect_failure(contents):
-            return Target.RESULT_FAILURE
-        return Target.RESULT_NONE
-    target.detect_failure.side_effect = interesting
-    load_target.return_value.return_value = target
-
-    prefix = mocker.patch("grizzly.common.reporter.strftime")
-
-    def report_prefix(_):
-        return "%04d" % (prefix.call_count,)
-    prefix.side_effect = report_prefix
-
-    # setup args
-    args = mocker.Mock()
-    args.fuzzmanager = False
-    args.ignore = ["fake", "timeout"]
-    log_path = (tmp_path / "logs")
-    args.logs = str(log_path)
-    (tmp_path / "test.html").write_text(original)
-    args.input = str(tmp_path / "test.html")
-    args.min_crashes = 1
-    (tmp_path / "prefs.js").touch()
-    args.prefs = str(tmp_path / "prefs.js")
-    args.relaunch = 1
-    args.repeat = 1
-    args.any_crash = False
-    args.sig = None
-    args.timeout = 10
-    args.no_analysis = True
-    args.strategies = strategies
-    assert ReduceManager.main(args) == (0 if (n_reports or n_other) else 1)
-    assert target.forced_close
-    assert target.reverse.call_count == 1
-    assert target.launch.call_count == launch_count
-    assert target.step.call_count == launch_count
-    assert target.detect_failure.call_count == launch_count
-    assert serve_path.call_count == launch_count
-    assert load_target.call_count == 1
-    assert target.close.call_count == launch_count
-    assert target.cleanup.call_count == 1
-    assert target.check_relaunch.call_count == 0
-    expected_dirs = set()
-    if n_reports:
-        expected_dirs.add(log_path / "reports")
-    if n_other:
-        expected_dirs.add(log_path / "other_reports")
-    if expected_dirs:
-        assert set(log_path.iterdir()) == expected_dirs
-    if n_reports:
-        tests = {test.read_text() for test in log_path.glob("reports/*-0/test.html")}
-        assert tests == reports
-        assert len(list((log_path / "reports").iterdir())) \
-            == n_reports * 2, list((log_path / "reports").iterdir())
-    if n_other:
-        other_tests = {test.read_text() for test in log_path.glob("other_reports/*-0/test.html")}
-        assert other_tests == other_reports
-        assert len(list((log_path / "other_reports").iterdir())) \
-            == n_other * 2, list((log_path / "other_reports").iterdir())
+def test_force_closed(mocker, tmp_path):
+    """test that `forced_close` in testcase metadata is respected"""
+    load_target = mocker.patch("grizzly.reduce.core.load_target")
+    mocker.patch("grizzly.reduce.core.ReduceManager.run", autospec=True)
+    mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
+    (tmp_path / "test.html").touch()
+    (tmp_path / "test_info.json").write_text(
+        json.dumps({"timestamp": 1, "target": "test.html", "env": {"GRZ_FORCED_CLOSE": "0"}})
+    )
+    args = mocker.Mock(
+        fuzzmanager=False,
+        ignore=[],
+        input=str(tmp_path),
+        min_crashes=1,
+        prefs=None,
+        repeat=1,
+        sig=None,
+    )
+    ReduceManager.main(args)
+    assert load_target.return_value.return_value.forced_close is False
+
+
+@pytest.mark.parametrize("result", ["testprefs", "argprefs"])
+def test_testcase_prefs(mocker, tmp_path, result):
+    """test that prefs from testcase are used if --prefs not specified and --prefs overrides"""
+    load_target = mocker.patch("grizzly.reduce.core.load_target")
+    mocker.patch("grizzly.reduce.core.ReduceManager.run", autospec=True)
+    mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
+    rmtree_mock = mocker.patch("grizzly.reduce.core.rmtree", autospec=True)
+    (tmp_path / "test.html").touch()
+    (tmp_path / "prefs.js").write_text("testprefs")
+    args = mocker.Mock(
+        fuzzmanager=False,
+        ignore=[],
+        input=str(tmp_path / "test.html"),
+        min_crashes=1,
+        prefs=None,
+        repeat=1,
+        sig=None,
+    )
+    if result == "argprefs":
+        (tmp_path / "args.js").write_text("argprefs")
+        args.prefs = str(tmp_path / "args.js")
+
+    try:
+        ReduceManager.main(args)
+        assert Path(load_target.return_value.return_value.prefs).read_text() == result
+    finally:
+        for call in rmtree_mock.call_args_list:
+            rmtree(*call.args, **call.kwargs)
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
new file mode 100644
index 00000000..4ae7dd50
--- /dev/null
+++ b/grizzly/reduce/test_reduce.py
@@ -0,0 +1,418 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# pylint: disable=protected-access
+"""
+unit tests for grizzly.reduce.reduce
+"""
+from collections import namedtuple
+import functools
+from logging import getLogger
+from pathlib import Path
+
+import pytest
+from pytest import raises
+
+from sapphire import Sapphire
+from ..common import TestCase, Report
+from ..replay import ReplayResult
+from ..target import Target, TargetLaunchError, TargetLaunchTimeout
+from . import ReduceManager
+
+
+LOG = getLogger(__name__)
+pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")  # pylint: disable=invalid-name
+
+
+def _fake_save_logs_foo(result_logs, meta=False):  # pylint: disable=unused-argument
+    """write fake log data to disk"""
+    (Path(result_logs) / "log_stderr.txt").write_text("STDERR log\n")
+    (Path(result_logs) / "log_stdout.txt").write_text("STDOUT log\n")
+    (Path(result_logs) / "log_asan_blah.txt").write_text(
+        "==1==ERROR: AddressSanitizer: "
+        "SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n"
+        "    #0 0xbad000 in foo /file1.c:123:234\n"
+        "    #1 0x1337dd in bar /file2.c:1806:19\n"
+    )
+
+
+def _fake_save_logs_bar(result_logs, meta=False):  # pylint: disable=unused-argument
+    """write fake log data to disk"""
+    (Path(result_logs) / "log_stderr.txt").write_text("STDERR log\n")
+    (Path(result_logs) / "log_stdout.txt").write_text("STDOUT log\n")
+    (Path(result_logs) / "log_asan_blah.txt").write_text(
+        "==1==ERROR: AddressSanitizer: "
+        "SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n"
+        "    #0 0xbad000 in bar /file1.c:123:234\n"
+        "    #1 0x1337dd in foo /file2.c:1806:19\n"
+    )
+
+
+AnalysisTestParams = namedtuple(
+    "AnalysisTestParams",
+    "crashes, expected_repeat, expected_min_crashes, use_harness, result_harness"
+)
+
+
+@pytest.mark.parametrize(
+    AnalysisTestParams._fields,
+    [
+        # perfect with harness
+        AnalysisTestParams([True] * 11, 2, 2, True, True),
+        # perfect without harness
+        AnalysisTestParams([False] * 11 + [True] * 11, 2, 2, True, False),
+        # perfect, use_harness=False
+        AnalysisTestParams([True] * 11, 2, 2, False, False),
+        # better without harness
+        AnalysisTestParams([True] + [False] * 19 + [True] * 2, 30, 2, True, False),
+        # better with harness
+        AnalysisTestParams([True] * 2 + [False] * 19 + [True], 30, 2, True, True),
+        # same with both, prefer harness
+        AnalysisTestParams([True] * 2 + [False] * 18 + [True] * 2, 30, 2, True, True),
+    ]
+)
+def test_analysis(mocker, tmp_path, crashes, expected_repeat, expected_min_crashes, use_harness,
+                  result_harness):
+    """test that analysis sets reasonable params"""
+    replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    expected_iters = len(crashes)
+
+    def replay_run(_, **_kw):
+        LOG.debug("interesting: %r", crashes[0])
+        if crashes.pop(0):
+            log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+            log_path.mkdir()
+            _fake_save_logs_foo(log_path)
+            report = Report(str(log_path), "bin")
+            return [ReplayResult(report, ["test.html"], [], True)]
+        return []
+    replayer.return_value.__enter__.return_value.run.side_effect = replay_run
+
+    test = TestCase("test.html", None, "test-adapter")
+    test.add_from_data("", "test.html")
+    tests = [test]
+    log_path = tmp_path / "logs"
+
+    try:
+        mgr = ReduceManager(None, mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target), tests, None,
+                            log_path, use_harness=use_harness)
+        repeat, min_crashes = mgr.run_reliability_analysis()
+    finally:
+        for test in tests:
+            test.cleanup()
+
+    assert replayer.return_value.__enter__.return_value.run.call_count == expected_iters
+    assert repeat == expected_repeat
+    assert min_crashes == expected_min_crashes
+    assert mgr._use_harness == result_harness
+
+
+def _ignore_arg(func):
+    """Function wrapper that simply ignores 1 argument"""
+    @functools.wraps(func)
+    def wrapped(_):
+        return func()
+    return wrapped
+
+
+ReproTestParams = namedtuple(
+    "ReproTestParams",
+    "original, strategies, detect_failure, interesting_str, is_expected, expected_run_calls, n_reports,"
+    "reports, n_other, other_reports, result"
+)
+
+
+@pytest.mark.parametrize(
+    ReproTestParams._fields,
+    [
+        # no repro
+        ReproTestParams(
+            original="123456\n",
+            strategies=["check"],
+            detect_failure=lambda _: False,
+            interesting_str="%r",
+            is_expected=None,
+            expected_run_calls=1,
+            n_reports=0,
+            reports=None,
+            n_other=0,
+            other_reports=None,
+            result=False,
+        ),
+        # reproduces, one strategy, no reduction works
+        ReproTestParams(
+            original="1\n2\n3\n",
+            strategies=["check", "lines"],
+            detect_failure=lambda contents: contents == "1\n2\n3\n",
+            interesting_str="%r == '1\n2\n3\n'",
+            is_expected=lambda _: True,
+            expected_run_calls=6,
+            n_reports=1,
+            reports={"1\n2\n3\n"},
+            n_other=0,
+            other_reports=None,
+            result=True,
+        ),
+        # reproduces, one strategy, some reduction works
+        ReproTestParams(
+            original="odd\neven\n" * 3,
+            strategies=["check", "lines"],
+            detect_failure=lambda contents: sum(1 for line in contents.splitlines() if line == "odd") == 3,
+            interesting_str="%r contains 3x 'odd'",
+            is_expected=lambda _: True,
+            expected_run_calls=8,
+            n_reports=2,
+            reports={"odd\neven\n" * 3, "odd\n" * 3},
+            n_other=0,
+            other_reports=None,
+            result=True,
+        ),
+        # reproduces, one strategy, reduction only finds other
+        ReproTestParams(
+            original="1\n2\n3\n",
+            strategies=["check", "lines"],
+            detect_failure=bool,
+            interesting_str="%r != ''",
+            is_expected=lambda contents: contents == "1\n2\n3\n",
+            expected_run_calls=6,
+            n_reports=1,
+            reports={"1\n2\n3\n"},
+            n_other=5,
+            other_reports={"1\n", "3\n", "1\n2\n", "1\n3\n", "2\n3\n"},
+            result=True,
+        ),
+        # reproduces, 50% iterations work, 1 iteration produces other sig
+        ReproTestParams(
+            original="1\n2\n3\n4\n5\n6\n",
+            strategies=["check", "lines"],
+            detect_failure=lambda contents: set(contents.splitlines()) >= set("135"),
+            interesting_str="%r contains {'1', '3', '5'}",
+            is_expected=lambda contents: contents != "1\n3\n5\n",
+            expected_run_calls=13,
+            n_reports=2,
+            reports={"1\n2\n3\n4\n5\n6\n", "1\n2\n3\n5\n"},
+            n_other=1,
+            other_reports={"1\n3\n5\n"},
+            result=True,
+        ),
+        # reproduces, two strategies, 1st no reduction, 2nd 50% reduction
+        ReproTestParams(
+            original="A1\nA2\nA3\nA4\nA5\nA6\n",
+            strategies=["check", "lines", "chars"],
+            detect_failure=(
+                lambda contents: (
+                    len(contents.splitlines()) == 6 and set(contents.splitlines()) >= {"A1", "A3", "A5"})),
+            interesting_str="%r contains {'A1', 'A3', 'A5'} and len() == 6",
+            is_expected=lambda _: True,
+            expected_run_calls=43,
+            # lines found nothing, only check and chars should report
+            n_reports=2,
+            reports={"A1\nA2\nA3\nA4\nA5\nA6\n", "A1\n\nA3\n\nA5\nA"},
+            n_other=0,
+            other_reports=None,
+            result=True,
+        ),
+        # reproduces, two strategies, 1st 50% reduction, 2nd no reduction
+        ReproTestParams(
+            original="A1\nA2\nA3\nA4\nA5\nA6\n",
+            strategies=["check", "lines", "chars"],
+            detect_failure=(
+                lambda contents: set(contents.splitlines(keepends=True)) >= {"A1\n", "A3\n", "A5\n"}),
+            interesting_str="%r contains {'A1\\n', 'A3\\n', 'A5\\n'}",
+            is_expected=lambda _: True,
+            expected_run_calls=34,
+            # lines found nothing, only check and chars should report
+            n_reports=2,
+            reports={"A1\nA2\nA3\nA4\nA5\nA6\n", "A1\nA3\nA5\n"},
+            n_other=0,
+            other_reports=None,
+            result=True,
+        ),
+        # reproduces, two strategies, reduce only produces other sig
+        ReproTestParams(
+            original="1\n2\n3\n",
+            strategies=["check", "lines", "chars"],
+            detect_failure=bool,
+            interesting_str="%r != ''",
+            is_expected=lambda contents: contents == "1\n2\n3\n",
+            expected_run_calls=16,
+            n_reports=1,
+            reports={"1\n2\n3\n"},
+            n_other=15,
+            other_reports={"\n2\n3\n", "1\n", "1\n\n3\n", "1\n2\n", "1\n2\n\n", "1\n2\n3", "1\n23\n",
+                           "1\n3\n", "12\n3\n", "2\n3\n", "3\n"},
+            result=True,
+        ),
+        # reproduces, one strategy, testcase reduces to 0
+        ReproTestParams(
+            original="1\n2\n3\n",
+            strategies=["check", "lines"],
+            detect_failure=lambda _: True,
+            interesting_str="%r is anything, incl. empty",
+            is_expected=lambda _: True,
+            expected_run_calls=3,
+            n_reports=2,
+            reports={"1\n2\n3\n", ""},
+            n_other=0,
+            other_reports=None,
+            result=True,
+        ),
+        # reproduces, two strategies, 1st no reduce, 2nd testcase reduces to 0
+        ReproTestParams(
+            original="1\n2\n3\n",
+            strategies=["check", "lines", "lines"],
+            detect_failure=_ignore_arg(
+                functools.partial([True, False, False, False, False, False, True, True].pop, 0)),
+            interesting_str="%r is anything, only in second strategy",
+            is_expected=lambda _: True,
+            expected_run_calls=8,
+            n_reports=2,
+            reports={"1\n2\n3\n", ""},
+            n_other=0,
+            other_reports=None,
+            result=True,
+        ),
+    ]
+)
+@pytest.mark.usefixtures("reporter_sequential_strftime")
+def test_repro(mocker, tmp_path, original, strategies, detect_failure, interesting_str, is_expected,
+               expected_run_calls, n_reports, reports, n_other, other_reports, result):
+    """test ReduceManager, difference scenarios produce correct expected/other results"""
+    replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+
+    def replay_run(testcases, **_):
+        for test in testcases:
+            contents = test.get_file("test.html").data.decode("ascii")
+            LOG.debug("interesting if " + interesting_str, contents)  # pylint: disable=logging-not-lazy
+            if detect_failure(contents):
+                log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+                log_path.mkdir()
+                expected = is_expected(contents)
+                if expected:
+                    _fake_save_logs_foo(log_path)
+                else:
+                    _fake_save_logs_bar(log_path)
+                report = Report(str(log_path), "bin")
+                return [ReplayResult(report, ["test.html"], [], expected)]
+        return []
+    replayer.return_value.run.side_effect = replay_run
+
+    test = TestCase("test.html", None, "test-adapter")
+    test.add_from_data(original, "test.html")
+    tests = [test]
+    log_path = tmp_path / "logs"
+
+    target = mocker.Mock(spec=Target)
+    target.relaunch = 1
+    try:
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies, log_path,
+                            use_analysis=False)
+        assert mgr.run() == result
+    finally:
+        for test in tests:
+            test.cleanup()
+
+    assert replayer.return_value.run.call_count == expected_run_calls
+    expected_dirs = set()
+    if n_reports:
+        expected_dirs.add(log_path / "reports")
+    if n_other:
+        expected_dirs.add(log_path / "other_reports")
+    if expected_dirs:
+        assert set(log_path.iterdir()) == expected_dirs
+    if n_reports:
+        tests = {test.read_text() for test in log_path.glob("reports/*-0/test.html")}
+        assert tests == reports
+        assert len(list((log_path / "reports").iterdir())) \
+            == n_reports * 2, list((log_path / "reports").iterdir())
+    if n_other:
+        other_tests = {test.read_text() for test in log_path.glob("other_reports/*-0/test.html")}
+        assert other_tests == other_reports
+        assert len(list((log_path / "other_reports").iterdir())) \
+            == n_other * 2, list((log_path / "other_reports").iterdir())
+
+
+def test_quality_update(mocker, tmp_path):
+    """test that the final result gets changed to Q0 with --fuzzmanager"""
+    replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+
+    def replay_run(_, **_kw):
+        log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+        log_path.mkdir()
+        _fake_save_logs_foo(log_path)
+        report = Report(str(log_path), "bin")
+        return [ReplayResult(report, ["test.html"], [], True)]
+    replayer.return_value.run.side_effect = replay_run
+
+    (tmp_path / "test.html").touch()
+    testcases = TestCase.load(str(tmp_path / "test.html"), False)
+    assert testcases
+    log_path = tmp_path / "logs"
+
+    mocker.patch("grizzly.common.reporter.Collector")
+    reporter = mocker.patch("grizzly.reduce.core.FuzzManagerReporter")
+    update_coll = mocker.patch("grizzly.reduce.core.Collector")
+    target = mocker.Mock(spec=Target)
+    target.relaunch = 1
+    try:
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, testcases, ["check"], log_path,
+                            use_analysis=False, report_to_fuzzmanager=True)
+        assert mgr.run()
+    finally:
+        for test in testcases:
+            test.cleanup()
+
+    assert reporter.return_value.submit.call_count == 1
+    report_args = reporter.return_value.submit.call_args.args
+    assert len(report_args) == 1
+    assert isinstance(report_args[0], list)
+    assert len(report_args[0]) == 1
+    assert isinstance(report_args[0][0], TestCase)
+    report_kwds = reporter.return_value.submit.call_args.kwargs
+    assert report_kwds.keys() == {"report"}
+    assert update_coll.call_count == 1
+    assert update_coll.return_value.patch.call_count == 1
+    assert update_coll.return_value.patch.call_args.kwargs == {
+        "data": {"testcase_quality": reporter.QUAL_REDUCED_RESULT},
+    }
+
+
+@pytest.mark.parametrize("use_analysis", [True, False])
+@pytest.mark.parametrize("exc_type", [TargetLaunchError, TargetLaunchTimeout])
+def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
+    """test that launch errors are reported"""
+    report_fcn = mocker.patch("grizzly.reduce.core.ReduceManager.report", autospec=True)
+    replay_mock = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    if exc_type is TargetLaunchError:
+        report_obj = mocker.Mock(spec=Report)
+        replay_mock.return_value.__enter__.return_value.run.side_effect = TargetLaunchError("msg", report_obj)
+        replay_mock.return_value.run.side_effect = TargetLaunchError("msg", report_obj)
+    else:
+        replay_mock.return_value.__enter__.return_value.run.side_effect = TargetLaunchTimeout("msg")
+        replay_mock.return_value.run.side_effect = TargetLaunchTimeout("msg")
+
+    (tmp_path / "test.html").touch()
+    testcases = TestCase.load(str(tmp_path / "test.html"), False)
+    assert testcases
+
+    target_obj = mocker.Mock(spec=Target)
+    target_obj.relaunch = 1
+    mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target_obj, testcases, ["check"], None,
+                        use_analysis=use_analysis)
+    with raises(exc_type):
+        mgr.run()
+    if exc_type is TargetLaunchError:
+        assert report_fcn.call_count == 1
+        _mgr, reports, reported_testcases = report_fcn.call_args.args
+        if use_analysis:
+            assert reported_testcases == testcases
+        else:
+            # should be testcases reported, but from the strategy, not the original
+            assert reported_testcases
+            assert reported_testcases != testcases
+        assert len(reports) == 1
+        assert reports[0].report == report_obj
+        assert report_obj.cleanup.call_count == 1
+    else:
+        assert report_fcn.call_count == 0
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
new file mode 100644
index 00000000..67e9a8ec
--- /dev/null
+++ b/grizzly/reduce/test_strategies.py
@@ -0,0 +1,150 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# pylint: disable=protected-access
+"""
+unit tests for grizzly.reduce.strategies
+"""
+from collections import namedtuple
+from logging import getLogger
+from pathlib import Path
+
+import pytest
+from pytest import raises
+
+from sapphire import Sapphire
+from ..common import TestCase, Report
+from ..replay import ReplayResult
+from ..target import Target
+from .strategies import _load_strategies
+from . import ReduceManager
+
+
+LOG = getLogger(__name__)
+pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")  # pylint: disable=invalid-name
+
+
+def _fake_save_logs_foo(result_logs):
+    """write fake log data to disk"""
+    (Path(result_logs) / "log_stderr.txt").write_text("STDERR log\n")
+    (Path(result_logs) / "log_stdout.txt").write_text("STDOUT log\n")
+    (Path(result_logs) / "log_asan_blah.txt").write_text(
+        "==1==ERROR: AddressSanitizer: "
+        "SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n"
+        "    #0 0xbad000 in foo /file1.c:123:234\n"
+        "    #1 0x1337dd in bar /file2.c:1806:19\n"
+    )
+
+
+def test_strategy_load_fail(mocker):
+    """test that a broken strategy doesn't block other strategies"""
+    class _GoodStrategy(object):
+        name = "good"
+        @classmethod
+        def load(cls):
+            return cls
+
+    class _BadStrategy(object):
+        name = "bad"
+        @classmethod
+        def load(cls):
+            raise RuntimeError("oops")
+
+    def entries(_):
+        yield _BadStrategy
+        yield _GoodStrategy
+
+    mocker.patch("grizzly.reduce.strategies.iter_entry_points", side_effect=entries)
+    mocker.patch("grizzly.reduce.strategies.DEFAULT_STRATEGIES", new=("good",))
+    result = _load_strategies()
+    assert result == {"good": _GoodStrategy}
+
+    # missing strategy in defaults should raise
+    mocker.patch("grizzly.reduce.strategies.DEFAULT_STRATEGIES", new=("good", "bad"))
+    with raises(AssertionError):
+        _load_strategies()
+
+
+ListStrategyParams = namedtuple(
+    "ListStrategyParams",
+    "test_data, strategies, required_first, expected_run_calls, expected_results, expected_num_reports"
+)
+
+
+@pytest.mark.parametrize(
+    ListStrategyParams._fields,
+    [
+        # "list" is a no-op with a single testcase
+        ListStrategyParams(
+            test_data=["123"],
+            strategies=["check", "list"],
+            required_first=False,
+            expected_run_calls=1,
+            expected_results={"123"},
+            expected_num_reports=2,
+        ),
+        # "list" reduces a list of testcases down to one required
+        ListStrategyParams(
+            test_data=["", "", "123", ""],
+            strategies=["list"],
+            required_first=False,
+            expected_run_calls=4,
+            expected_results={"123"},
+            expected_num_reports=2,
+        ),
+        # "list" reduces a list of testcases down to two required
+        ListStrategyParams(
+            test_data=["", "required", "123", ""],
+            strategies=["list"],
+            required_first=True,
+            expected_run_calls=4,
+            expected_results={"required", "123"},
+            expected_num_reports=3,
+        ),
+    ]
+)
+def test_list(mocker, tmp_path, test_data, strategies, required_first, expected_run_calls, expected_results,
+              expected_num_reports):
+    """test that "list" is a no-op with a single testcase"""
+    replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+
+    def replay_run(testcases, **_):
+        required_seen = False
+        for test in testcases:
+            contents = test.get_file("test.html").data.decode("ascii")
+            LOG.debug("interesting if %r == '123'", contents)
+            if contents == "required" and required_first:
+                required_seen = True
+            elif contents == "123" and (required_seen or not required_first):
+                log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+                log_path.mkdir()
+                _fake_save_logs_foo(log_path)
+                report = Report(str(log_path), "bin")
+                return [ReplayResult(report, ["test.html"], [], True)]
+        return []
+    replayer.return_value.run.side_effect = replay_run
+
+    tests = []
+    for data in test_data:
+        test = TestCase("test.html", None, "test-adapter")
+        test.add_from_data(data, "test.html")
+        tests.append(test)
+    log_path = tmp_path / "logs"
+
+    target = mocker.Mock(spec=Target)
+    target.relaunch = 1
+    try:
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies, log_path,
+                            use_analysis=False)
+        assert mgr.run()
+    finally:
+        for test in tests:
+            test.cleanup()
+
+    assert replayer.return_value.run.call_count == expected_run_calls
+    assert set(log_path.iterdir()) == {log_path / "reports"}
+    tests = {test.read_text() for test in log_path.glob("reports/*-*/test.html")}
+    assert tests == expected_results
+    assert len(list((log_path / "reports").iterdir())) == expected_num_reports, \
+        list((log_path / "reports").iterdir())

From 9779a10df7e12bc58cc8ffe696dbd4c87ff7b295 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 14 Oct 2020 14:37:51 -0400
Subject: [PATCH 058/531] Add remaining strategies.

---
 grizzly/reduce/strategies.py      | 227 ++++++++++++++++++++++++++----
 grizzly/reduce/test_strategies.py | 104 +++++++++++++-
 setup.py                          |   6 +-
 3 files changed, 306 insertions(+), 31 deletions(-)

diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index d3776e18..f73b92f1 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -9,17 +9,29 @@
 import json
 from logging import getLogger
 from pathlib import Path
+import re
 from shutil import rmtree
 from tempfile import mkdtemp
 from types import MappingProxyType
 
-from lithium.strategies import CheckOnly, Minimize
-from lithium.testcases import TestcaseChar, TestcaseLine
+from lithium.strategies import CheckOnly, CollapseEmptyBraces as LithCollapseEmptyBraces, Minimize
+from lithium.testcases import TestcaseChar, TestcaseJsStr, TestcaseLine
 from pkg_resources import iter_entry_points
 
 from ..common.utils import grz_tmp
 from ..common.storage import TestCase
 
+try:
+    import cssbeautifier
+    HAVE_CSSBEAUTIFIER = True
+except ImportError:
+    HAVE_CSSBEAUTIFIER = False
+try:
+    import jsbeautifier
+    HAVE_JSBEAUTIFIER = True
+except ImportError:
+    HAVE_JSBEAUTIFIER = False
+
 
 LOG = getLogger(__name__)
 
@@ -27,6 +39,9 @@
 DEFAULT_STRATEGIES = (
     "list",
     "lines",
+    "cssbeautify",
+    "jsbeautify",
+    "collapsebraces",
 )
 
 
@@ -56,6 +71,11 @@ def _load_strategies():
 
 
 class Strategy(ABC):
+    """Implementors must define these class attributes:
+
+    Attributes:
+        name (str): The strategy name.
+    """
     def __init__(self, testcases):
         self._testcase_root = Path(mkdtemp(prefix="tc_", dir=grz_tmp("reduce")))
         for idx, testcase in enumerate(testcases):
@@ -81,9 +101,105 @@ def cleanup(self):
         rmtree(str(self._testcase_root))
 
 
+class _BeautifyStrategy(Strategy, ABC):
+    """Implementors must define these class attributes:
+
+    Attributes:
+        all_extensions (set(str)): Set of all file extensions to beautify.
+        import_available (bool): Whether or not the beautify module was imported.
+        import_name (str): The name of the beautify module imported (for error reporting).
+        name (str): The strategy name.
+        native_extension (str): The native file extension for this type.
+        tag_name (str): Tag name to search for in other (non-native) extensions.
+    """
+    blacklist_files = {"test_info.json", "prefs.js"}
+
+    def __init__(self, *args, **kwds):
+        super().__init__(*args, **kwds)
+        self._files_to_reduce = []
+        for path in self._testcase_root.glob("**/*"):
+            if (path.is_file() and path.suffix in self.all_extensions  # pylint: disable=no-member
+                    and path.name not in self.blacklist_files):
+                self._files_to_reduce.append(path)
+        self._current_feedback = None
+        tag_bytes = self.tag_name.encode("ascii")  # pylint: disable=no-member
+        self._re_tag = re.compile(br"(<" + tag_bytes + br".*?>)(.*?)(</\s*" + tag_bytes + br"\s*>)",
+                                  flags=re.DOTALL | re.IGNORECASE)
+        self._re_tag_start = re.compile(br"<" + tag_bytes + br".*?>\s*$", flags=re.DOTALL | re.IGNORECASE)
+        self._re_tag_end = re.compile(br"^\s*</\s*" + tag_bytes + br"\s*>", flags=re.IGNORECASE)
+
+    def update(self, success):
+        assert self._current_feedback is None
+        self._current_feedback = success
+
+    @classmethod
+    @abstractmethod
+    def beautify_bytes(cls, data):
+        pass
+
+    def __iter__(self):
+        if not self.import_available:  # pylint: disable=no-member
+            LOG.warning("%s not available, skipping strategy.", self.import_name)  # pylint: disable=no-member
+            return
+
+        LOG.info("Beautifying %d files", len(self._files_to_reduce))
+        for file_no, file in enumerate(self._files_to_reduce):
+            LOG.info("Beautifying %s (file %d/%d)", file.relative_to(self._testcase_root), file_no + 1,
+                     len(self._files_to_reduce))
+
+            # Use Lithium just to split the file at DDBEGIN/END.
+            # Lithium already has the right logic for DDBEGIN/END and line endings.
+            lith_tc = TestcaseLine()
+            lith_tc.load(file)
+            to_reduce = b"".join(lith_tc.parts)
+            # check if the DDBEGIN/END were right inside a <script> or <style> tag
+            in_tag_already = (self._re_tag_start.match(lith_tc.before) is not None
+                              and self._re_tag_end.match(lith_tc.after) is not None)
+
+            if file.suffix == self.native_extension or in_tag_already:  # pylint: disable=no-member
+                with file.open("wb") as testcase_fp:
+                    testcase_fp.write(lith_tc.before)
+                    testcase_fp.write(self.beautify_bytes(to_reduce))
+                    testcase_fp.write(lith_tc.after)
+            else:
+                # handle html files
+                pos = 0
+                with file.open("wb") as testcase_fp:
+                    testcase_fp.write(lith_tc.before)
+                    for match in self._re_tag.finditer(to_reduce):
+                        testcase_fp.write(to_reduce[pos:match.start(2)])
+                        beautified = self.beautify_bytes(match.group(2))
+                        if beautified:
+                            if not to_reduce[pos:match.start(2)].endswith(b"\n"):
+                                testcase_fp.write(b"\n")
+                            testcase_fp.write(beautified)
+                            if not beautified.endswith(b"\n"):
+                                testcase_fp.write(b"\n")
+                        pos = match.end(2)
+                    testcase_fp.write(to_reduce[pos:])
+                    testcase_fp.write(lith_tc.after)
+                if pos == 0:
+                    LOG.warning("<%s> tags not found, skipping", self.tag_name)  # pylint: disable=no-member
+                    continue
+
+            yield TestCase.load(str(self._testcase_root), False)
+
+            assert self._current_feedback is not None, "No feedback for last iteration"
+            if self._current_feedback:
+                LOG.info("%s was successful", self.name)  # pylint: disable=no-member
+            else:
+                LOG.warning("%s failed (reverting)", self.name)  # pylint: disable=no-member
+                lith_tc.dump(file)
+            self._current_feedback = None
+
+
 class _LithiumStrategy(Strategy, ABC):
-    """Must define name, testcase_cls (lithium.testcases.Testcase), and
-    strategy_cls (lithium.strategies.Strategy).
+    """Implementors must define these class attributes:
+
+    Attributes:
+        name (str): The strategy name.
+        strategy_cls (lithium.strategies.Strategy): Lithium strategy type.
+        testcase_cls (lithium.testcases.Testcase): Lithium testcase type.
     """
     def __init__(self, *args, **kwds):
         super().__init__(*args, **kwds)
@@ -113,6 +229,85 @@ def __iter__(self):
             self._current_reducer = None
 
 
+class Check(_LithiumStrategy):
+    name = "check"
+    strategy_cls = CheckOnly
+    testcase_cls = TestcaseLine
+
+    def __init__(self, *args, **kwds):
+        super().__init__(*args, **kwds)
+        # trim files_to_reduce, for check we don't need to run on every file
+        # just once per Grizzly TestCase set is enough.
+        self._files_to_reduce = self._files_to_reduce[:1]
+
+
+class CollapseEmptyBraces(_LithiumStrategy):
+    name = "collapsebraces"
+    strategy_cls = LithCollapseEmptyBraces
+    testcase_cls = TestcaseLine
+
+
+class CSSBeautify(_BeautifyStrategy):
+    all_extensions = {".css", ".htm", ".html", ".xhtml"}
+    import_available = HAVE_CSSBEAUTIFIER
+    import_name = "cssbeautifier"
+    name = "cssbeautify"
+    native_extension = ".css"
+    opts = (
+        ('end_with_newline', False),
+        ('indent_size', 2),
+        ('newline_between_rules', False),
+        ('preserve_newlines', False),
+    )
+    tag_name = "style"
+
+    @classmethod
+    def beautify_bytes(cls, data):
+        assert cls.import_available
+        data = data.decode("utf-8", errors="surrogateescape")
+        return cssbeautifier.beautify(data, cls.opts).encode("utf-8", errors="surrogateescape")
+
+
+class JSBeautify(_BeautifyStrategy):
+    all_extensions = {".js", ".htm", ".html", ".xhtml"}
+    import_available = HAVE_JSBEAUTIFIER
+    import_name = "jsbeautifier"
+    name = "jsbeautify"
+    native_extension = ".js"
+    opts = None
+    tag_name = "script"
+    try_catch_re = re.compile(r"(\s*try {)\n\s*(.*)\n\s*(}\s*catch.*)")
+
+    @classmethod
+    def beautify_bytes(cls, data):
+        assert HAVE_JSBEAUTIFIER
+        data = data.decode("utf-8", errors="surrogateescape")
+
+        beautified = jsbeautifier.beautify(data, cls.opts)
+        # All try/catch pairs will be expanded on their own lines
+        # Collapse these pairs when only a single instruction is contained within
+        beautified = cls.try_catch_re.sub(r"\1 \2 \3", beautified)
+        return beautified.encode("utf-8", errors="surrogateescape")
+
+
+class MinimizeChars(_LithiumStrategy):
+    name = "chars"
+    strategy_cls = Minimize
+    testcase_cls = TestcaseChar
+
+
+class MinimizeJSChars(_LithiumStrategy):
+    name = "jschars"
+    strategy_cls = Minimize
+    testcase_cls = TestcaseJsStr
+
+
+class MinimizeLines(_LithiumStrategy):
+    name = "lines"
+    strategy_cls = Minimize
+    testcase_cls = TestcaseLine
+
+
 class MinimizeTestcaseList(Strategy):
     """Try removing testcases from a list of sequential testcases (eg. Grizzly result
     cache). The strategy favours testcases at the tail of the list, so for a list of
@@ -188,28 +383,4 @@ def __iter__(self):
                     testcase.cleanup()
 
 
-class Check(_LithiumStrategy):
-    name = "check"
-    strategy_cls = CheckOnly
-    testcase_cls = TestcaseLine
-
-    def __init__(self, *args, **kwds):
-        super().__init__(*args, **kwds)
-        # trim files_to_reduce, for check we don't need to run on every file
-        # just once per Grizzly TestCase set is enough.
-        self._files_to_reduce = self._files_to_reduce[:1]
-
-
-class MinimizeLines(_LithiumStrategy):
-    name = "lines"
-    strategy_cls = Minimize
-    testcase_cls = TestcaseLine
-
-
-class MinimizeChars(_LithiumStrategy):
-    name = "chars"
-    strategy_cls = Minimize
-    testcase_cls = TestcaseChar
-
-
 STRATEGIES = _load_strategies()
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 67e9a8ec..225485ea 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -17,7 +17,7 @@
 from ..common import TestCase, Report
 from ..replay import ReplayResult
 from ..target import Target
-from .strategies import _load_strategies
+from .strategies import _load_strategies, HAVE_CSSBEAUTIFIER, HAVE_JSBEAUTIFIER
 from . import ReduceManager
 
 
@@ -106,7 +106,7 @@ def entries(_):
 )
 def test_list(mocker, tmp_path, test_data, strategies, required_first, expected_run_calls, expected_results,
               expected_num_reports):
-    """test that "list" is a no-op with a single testcase"""
+    """tests for the "list" strategy"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
 
     def replay_run(testcases, **_):
@@ -148,3 +148,103 @@ def replay_run(testcases, **_):
     assert tests == expected_results
     assert len(list((log_path / "reports").iterdir())) == expected_num_reports, \
         list((log_path / "reports").iterdir())
+
+
+BeautifyStrategyParams = namedtuple(
+    "BeautifyStrategyParams",
+    "test_data, test_name, expected_run_calls, expected_results, expected_num_reports, strategies"
+)
+
+
+@pytest.mark.parametrize(
+    BeautifyStrategyParams._fields,
+    [
+        # test beautify a .js file
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="try{'fluff';'required'}catch(e){}\n",
+                test_name="test.js",
+                expected_run_calls=6,
+                expected_results={"'required'"},
+                expected_num_reports=2,
+                strategies=["jsbeautify", "lines"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+        ),
+        # test beautify js embedded in html
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="<script>try{'fluff';'required'}catch(e){}</script>\n",
+                test_name="test.html",
+                expected_run_calls=7,
+                expected_results={"'required'"},
+                expected_num_reports=2,
+                strategies=["jsbeautify", "lines"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+        ),
+        # test beautify a .css file
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="*,#a{fluff:0;required:1}\n",
+                test_name="test.css",
+                expected_run_calls=8,
+                expected_results={"required: 1"},
+                expected_num_reports=2,
+                strategies=["cssbeautify", "lines"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"),
+        ),
+        # test beautify css embedded in html
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="<style>*,#a{fluff:0;required:1}</style>\n",
+                test_name="test.html",
+                expected_run_calls=6,
+                expected_results={"required: 1"},
+                expected_num_reports=2,
+                strategies=["cssbeautify", "lines"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"),
+        ),
+    ]
+)
+def test_beautifier(mocker, tmp_path, test_data, test_name, expected_run_calls, expected_results,
+                    expected_num_reports, strategies):
+    """test for the "beautify" strategies"""
+    replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+
+    def replay_run(testcases, **_):
+        for test in testcases:
+            contents = test.get_file(test_name).data.decode("ascii")
+            LOG.debug("interesting if 'required' in %r", contents)
+            if "required" in contents:
+                log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+                log_path.mkdir()
+                _fake_save_logs_foo(log_path)
+                report = Report(str(log_path), "bin")
+                return [ReplayResult(report, [test_name], [], True)]
+        return []
+    replayer.return_value.run.side_effect = replay_run
+
+    test = TestCase(test_name, None, "test-adapter")
+    test.add_from_data(test_data, test_name)
+    tests = [test]
+    log_path = tmp_path / "logs"
+
+    target = mocker.Mock(spec=Target)
+    target.relaunch = 1
+    try:
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies, log_path,
+                            use_analysis=False)
+        assert mgr.run()
+    finally:
+        for test in tests:
+            test.cleanup()
+
+    assert replayer.return_value.run.call_count == expected_run_calls
+    assert set(log_path.iterdir()) == {log_path / "reports"}
+    tests = {test.read_text().strip() for test in log_path.glob("reports/*-*/" + test_name)}
+    assert tests == expected_results
+    assert len(list((log_path / "reports").iterdir())) == expected_num_reports, \
+        list((log_path / "reports").iterdir())
diff --git a/setup.py b/setup.py
index 02deb6e9..35a2007b 100755
--- a/setup.py
+++ b/setup.py
@@ -42,8 +42,12 @@
                 'ffpuppet = grizzly.target.puppet_target:PuppetTarget',
             ],
             'grizzly_reduce_strategies': [
-                'check = grizzly.reduce.strategies:Check',
                 'chars = grizzly.reduce.strategies:MinimizeChars',
+                'check = grizzly.reduce.strategies:Check',
+                'collapsebraces = grizzly.reduce.strategies:CollapseEmptyBraces',
+                'cssbeautify = grizzly.reduce.strategies:CSSBeautify',
+                'jsbeautify = grizzly.reduce.strategies:JSBeautify',
+                'jschars = grizzly.reduce.strategies:MinimizeJSChars',
                 'lines = grizzly.reduce.strategies:MinimizeLines',
                 'list = grizzly.reduce.strategies:MinimizeTestcaseList',
             ],

From ec8e8f10885f0bb037acaa987bf9d5ce7adc1cef Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 14 Oct 2020 15:56:58 -0400
Subject: [PATCH 059/531] Implement sanity checking for abstract attributes
 required by the reduction strategy classes.

---
 grizzly/reduce/strategies.py      | 56 ++++++++++++++++++++++++-------
 grizzly/reduce/test_strategies.py |  4 +++
 2 files changed, 48 insertions(+), 12 deletions(-)

diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index f73b92f1..cee25310 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -14,8 +14,9 @@
 from tempfile import mkdtemp
 from types import MappingProxyType
 
-from lithium.strategies import CheckOnly, CollapseEmptyBraces as LithCollapseEmptyBraces, Minimize
-from lithium.testcases import TestcaseChar, TestcaseJsStr, TestcaseLine
+from lithium.strategies import CheckOnly, CollapseEmptyBraces as LithCollapseEmptyBraces, Minimize, \
+    Strategy as LithStrategy
+from lithium.testcases import TestcaseChar, TestcaseJsStr, TestcaseLine, Testcase as LithTestcase
 from pkg_resources import iter_entry_points
 
 from ..common.utils import grz_tmp
@@ -52,6 +53,7 @@ def _load_strategies():
     for entry_point in iter_entry_points("grizzly_reduce_strategies"):
         try:
             strategy_cls = entry_point.load()
+            strategy_cls.sanity_check_impl()
             assert (
                 strategy_cls.name == entry_point.name
             ), "entry_point name mismatch, check setup.py and %s.name" % (
@@ -76,6 +78,8 @@ class Strategy(ABC):
     Attributes:
         name (str): The strategy name.
     """
+    name = None
+
     def __init__(self, testcases):
         self._testcase_root = Path(mkdtemp(prefix="tc_", dir=grz_tmp("reduce")))
         for idx, testcase in enumerate(testcases):
@@ -83,6 +87,10 @@ def __init__(self, testcases):
             testpath = self._testcase_root / ("%03d" % (idx,))
             testcase.dump(str(testpath), include_details=True)
 
+    @classmethod
+    def sanity_check_impl(cls):
+        assert isinstance(cls.name, str)
+
     @abstractmethod
     def __iter__(self):
         pass
@@ -112,22 +120,37 @@ class _BeautifyStrategy(Strategy, ABC):
         native_extension (str): The native file extension for this type.
         tag_name (str): Tag name to search for in other (non-native) extensions.
     """
+    all_extensions = None
     blacklist_files = {"test_info.json", "prefs.js"}
+    import_available = None
+    import_name = None
+    native_extension = None
+    tag_name = None
 
     def __init__(self, *args, **kwds):
         super().__init__(*args, **kwds)
         self._files_to_reduce = []
         for path in self._testcase_root.glob("**/*"):
-            if (path.is_file() and path.suffix in self.all_extensions  # pylint: disable=no-member
+            if (path.is_file() and path.suffix in self.all_extensions
                     and path.name not in self.blacklist_files):
                 self._files_to_reduce.append(path)
         self._current_feedback = None
-        tag_bytes = self.tag_name.encode("ascii")  # pylint: disable=no-member
+        tag_bytes = self.tag_name.encode("ascii")
         self._re_tag = re.compile(br"(<" + tag_bytes + br".*?>)(.*?)(</\s*" + tag_bytes + br"\s*>)",
                                   flags=re.DOTALL | re.IGNORECASE)
         self._re_tag_start = re.compile(br"<" + tag_bytes + br".*?>\s*$", flags=re.DOTALL | re.IGNORECASE)
         self._re_tag_end = re.compile(br"^\s*</\s*" + tag_bytes + br"\s*>", flags=re.IGNORECASE)
 
+    @classmethod
+    def sanity_check_impl(cls):
+        super().sanity_check_impl()
+        assert isinstance(cls.all_extensions, set)
+        assert all(isinstance(ext, str) for ext in cls.all_extensions)
+        assert isinstance(cls.import_available, bool)
+        assert isinstance(cls.import_name, str)
+        assert isinstance(cls.native_extension, str)
+        assert isinstance(cls.tag_name, str)
+
     def update(self, success):
         assert self._current_feedback is None
         self._current_feedback = success
@@ -138,8 +161,8 @@ def beautify_bytes(cls, data):
         pass
 
     def __iter__(self):
-        if not self.import_available:  # pylint: disable=no-member
-            LOG.warning("%s not available, skipping strategy.", self.import_name)  # pylint: disable=no-member
+        if not self.import_available:
+            LOG.warning("%s not available, skipping strategy.", self.import_name)
             return
 
         LOG.info("Beautifying %d files", len(self._files_to_reduce))
@@ -156,7 +179,7 @@ def __iter__(self):
             in_tag_already = (self._re_tag_start.match(lith_tc.before) is not None
                               and self._re_tag_end.match(lith_tc.after) is not None)
 
-            if file.suffix == self.native_extension or in_tag_already:  # pylint: disable=no-member
+            if file.suffix == self.native_extension or in_tag_already:
                 with file.open("wb") as testcase_fp:
                     testcase_fp.write(lith_tc.before)
                     testcase_fp.write(self.beautify_bytes(to_reduce))
@@ -179,16 +202,16 @@ def __iter__(self):
                     testcase_fp.write(to_reduce[pos:])
                     testcase_fp.write(lith_tc.after)
                 if pos == 0:
-                    LOG.warning("<%s> tags not found, skipping", self.tag_name)  # pylint: disable=no-member
+                    LOG.warning("<%s> tags not found, skipping", self.tag_name)
                     continue
 
             yield TestCase.load(str(self._testcase_root), False)
 
             assert self._current_feedback is not None, "No feedback for last iteration"
             if self._current_feedback:
-                LOG.info("%s was successful", self.name)  # pylint: disable=no-member
+                LOG.info("%s was successful", self.name)
             else:
-                LOG.warning("%s failed (reverting)", self.name)  # pylint: disable=no-member
+                LOG.warning("%s failed (reverting)", self.name)
                 lith_tc.dump(file)
             self._current_feedback = None
 
@@ -201,6 +224,9 @@ class _LithiumStrategy(Strategy, ABC):
         strategy_cls (lithium.strategies.Strategy): Lithium strategy type.
         testcase_cls (lithium.testcases.Testcase): Lithium testcase type.
     """
+    strategy_cls = None
+    testcase_cls = None
+
     def __init__(self, *args, **kwds):
         super().__init__(*args, **kwds)
         self._current_reducer = None
@@ -209,6 +235,12 @@ def __init__(self, *args, **kwds):
             if path.is_file() and path.name not in {"test_info.json", "prefs.js"}:
                 self._files_to_reduce.append(path)
 
+    @classmethod
+    def sanity_check_impl(cls):
+        super().sanity_check_impl()
+        assert issubclass(cls.strategy_cls, LithStrategy)
+        assert issubclass(cls.testcase_cls, LithTestcase)
+
     def update(self, success):
         assert self._current_reducer is not None
         self._current_reducer.feedback(success)
@@ -217,9 +249,9 @@ def __iter__(self):
         LOG.info("Reducing %d files", len(self._files_to_reduce))
         for file_no, file in enumerate(self._files_to_reduce):
             LOG.info("Reducing %s (file %d/%d)", file, file_no + 1, len(self._files_to_reduce))
-            lithium_testcase = self.testcase_cls()  # pylint: disable=no-member
+            lithium_testcase = self.testcase_cls()  # pylint: disable=not-callable
             lithium_testcase.load(file)
-            # pylint: disable=no-member
+            # pylint: disable=not-callable
             self._current_reducer = self.strategy_cls().reduce(lithium_testcase)
             for reduction in self._current_reducer:
                 reduction.dump()
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 225485ea..ca9b8f0d 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -41,6 +41,10 @@ def test_strategy_load_fail(mocker):
     """test that a broken strategy doesn't block other strategies"""
     class _GoodStrategy(object):
         name = "good"
+        @classmethod
+        def sanity_check_impl(cls):
+            pass
+
         @classmethod
         def load(cls):
             return cls

From 4e0e774341a50864232dbfde5f66e48bfa4f44f2 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 15 Oct 2020 09:42:36 -0400
Subject: [PATCH 060/531] Fix JS/CSS Beautifier strategies.

They should work now for any <script>/<style> tags, and DDBEGIN/DDEND are
respected regardless of where they appear.
---
 grizzly/reduce/strategies.py      | 123 ++++++++++++++-------
 grizzly/reduce/test_strategies.py | 173 +++++++++++++++++++++++++++---
 2 files changed, 244 insertions(+), 52 deletions(-)

diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index cee25310..74a42f35 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -129,17 +129,15 @@ class _BeautifyStrategy(Strategy, ABC):
 
     def __init__(self, *args, **kwds):
         super().__init__(*args, **kwds)
-        self._files_to_reduce = []
+        self._files_to_beautify = []
         for path in self._testcase_root.glob("**/*"):
             if (path.is_file() and path.suffix in self.all_extensions
                     and path.name not in self.blacklist_files):
-                self._files_to_reduce.append(path)
+                self._files_to_beautify.append(path)
         self._current_feedback = None
         tag_bytes = self.tag_name.encode("ascii")
-        self._re_tag = re.compile(br"(<" + tag_bytes + br".*?>)(.*?)(</\s*" + tag_bytes + br"\s*>)",
-                                  flags=re.DOTALL | re.IGNORECASE)
-        self._re_tag_start = re.compile(br"<" + tag_bytes + br".*?>\s*$", flags=re.DOTALL | re.IGNORECASE)
-        self._re_tag_end = re.compile(br"^\s*</\s*" + tag_bytes + br"\s*>", flags=re.IGNORECASE)
+        self._re_tag_start = re.compile(br"<\s*" + tag_bytes + br".*?>", flags=re.DOTALL | re.IGNORECASE)
+        self._re_tag_end = re.compile(br"</\s*" + tag_bytes + br"\s*>", flags=re.IGNORECASE)
 
     @classmethod
     def sanity_check_impl(cls):
@@ -160,48 +158,99 @@ def update(self, success):
     def beautify_bytes(cls, data):
         pass
 
+    def _chunks_to_beautify(self, before, to_beautify, file):
+        """Iterate over `to_beautify` and find chunks of style/script to beautify.
+
+        Arguments:
+            before (bytes): The data preceding `to_beautify`. Used to check whether `to_beautify` is
+                            already in an open <script> or <style> tag.
+            to_beautify (bytes): The data to beautify.
+            file (Path): The input file (used only to check if this is a .css/.js file)
+
+        Yields:
+            tuple (int,int): Slices of `to_beautify` that should be beautified.
+        """
+        # native extension, there's no need to search for tags
+        if file.suffix == self.native_extension:
+            yield (0, len(to_beautify))
+            return
+
+        # find the last <tag> preceding DDBEGIN
+        last_tag_start = None
+        for match in self._re_tag_start.finditer(before):
+            last_tag_start = match
+        in_tag_already = (
+            # there was an open <tag>
+            last_tag_start is not None
+            # and it isn't followed by a closing </tag>
+            and self._re_tag_end.search(before[last_tag_start.end(0):]) is None
+        )
+        if in_tag_already:
+            tag_end = self._re_tag_end.search(to_beautify)
+            if tag_end is None:
+                # similar to native case. DDBEGIN/END occurred inside the tag, so
+                # no need to look further
+                yield (0, len(to_beautify))
+                return
+            yield (0, tag_end.start(0))
+            search_start = tag_end.end(0)
+        else:
+            search_start = 0
+
+        # scan for <tag></tag> (with </tag> being optional for the last match)
+        while True:
+            tag_start = self._re_tag_start.search(to_beautify[search_start:])
+            if tag_start is None:
+                break
+            chunk_start = search_start + tag_start.end(0)
+            tag_end = self._re_tag_end.search(to_beautify[chunk_start:])
+            if tag_end is None:
+                # last </tag> was missing, stop looking
+                yield (chunk_start, len(to_beautify))
+                break
+            yield (chunk_start, chunk_start + tag_end.start(0))
+            search_start = chunk_start + tag_end.end(0)
+
     def __iter__(self):
         if not self.import_available:
             LOG.warning("%s not available, skipping strategy.", self.import_name)
             return
 
-        LOG.info("Beautifying %d files", len(self._files_to_reduce))
-        for file_no, file in enumerate(self._files_to_reduce):
+        LOG.info("Beautifying %d files", len(self._files_to_beautify))
+        for file_no, file in enumerate(self._files_to_beautify):
             LOG.info("Beautifying %s (file %d/%d)", file.relative_to(self._testcase_root), file_no + 1,
-                     len(self._files_to_reduce))
+                     len(self._files_to_beautify))
 
             # Use Lithium just to split the file at DDBEGIN/END.
             # Lithium already has the right logic for DDBEGIN/END and line endings.
             lith_tc = TestcaseLine()
             lith_tc.load(file)
-            to_reduce = b"".join(lith_tc.parts)
-            # check if the DDBEGIN/END were right inside a <script> or <style> tag
-            in_tag_already = (self._re_tag_start.match(lith_tc.before) is not None
-                              and self._re_tag_end.match(lith_tc.after) is not None)
-
-            if file.suffix == self.native_extension or in_tag_already:
-                with file.open("wb") as testcase_fp:
-                    testcase_fp.write(lith_tc.before)
-                    testcase_fp.write(self.beautify_bytes(to_reduce))
-                    testcase_fp.write(lith_tc.after)
-            else:
-                # handle html files
-                pos = 0
-                with file.open("wb") as testcase_fp:
-                    testcase_fp.write(lith_tc.before)
-                    for match in self._re_tag.finditer(to_reduce):
-                        testcase_fp.write(to_reduce[pos:match.start(2)])
-                        beautified = self.beautify_bytes(match.group(2))
-                        if beautified:
-                            if not to_reduce[pos:match.start(2)].endswith(b"\n"):
-                                testcase_fp.write(b"\n")
-                            testcase_fp.write(beautified)
-                            if not beautified.endswith(b"\n"):
-                                testcase_fp.write(b"\n")
-                        pos = match.end(2)
-                    testcase_fp.write(to_reduce[pos:])
-                    testcase_fp.write(lith_tc.after)
-                if pos == 0:
+            raw = b"".join(lith_tc.parts)
+
+            with file.open("wb") as testcase_fp:
+                last = 0
+                testcase_fp.write(lith_tc.before)
+                for start, end in self._chunks_to_beautify(lith_tc.before, raw, file):
+                    before = raw[last:start]
+                    testcase_fp.write(before)
+                    to_beautify = raw[start:end]
+                    beautified = self.beautify_bytes(to_beautify)
+                    if beautified:
+                        if before and not before.endswith(b"\n"):
+                            testcase_fp.write(b"\n")
+                        testcase_fp.write(beautified)
+                        if not beautified.endswith(b"\n"):
+                            testcase_fp.write(b"\n")
+                    elif to_beautify.strip():  # pragma: no cover
+                        # this should never happen, but just in case...
+                        # pragma: no cover
+                        LOG.warning("No output from beautify! Writing %s unmodified.", self.tag_name)
+                        testcase_fp.write(to_beautify)  # pragma: no cover
+                    last = end
+                testcase_fp.write(raw[last:])
+                testcase_fp.write(lith_tc.after)
+
+                if last == 0:
                     LOG.warning("<%s> tags not found, skipping", self.tag_name)
                     continue
 
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index ca9b8f0d..4e3c368e 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -22,7 +22,8 @@
 
 
 LOG = getLogger(__name__)
-pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")  # pylint: disable=invalid-name
+# pylint: disable=invalid-name
+pytestmark = pytest.mark.usefixtures("tmp_path_fm_config", "reporter_sequential_strftime")
 
 
 def _fake_save_logs_foo(result_logs):
@@ -168,10 +169,10 @@ def replay_run(testcases, **_):
             *BeautifyStrategyParams(
                 test_data="try{'fluff';'required'}catch(e){}\n",
                 test_name="test.js",
-                expected_run_calls=6,
-                expected_results={"'required'"},
+                expected_run_calls=1,
+                expected_results={"try {\n    'fluff';\n    'required'\n} catch (e) {}\n"},
                 expected_num_reports=2,
-                strategies=["jsbeautify", "lines"],
+                strategies=["jsbeautify"],
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
         ),
@@ -180,10 +181,139 @@ def replay_run(testcases, **_):
             *BeautifyStrategyParams(
                 test_data="<script>try{'fluff';'required'}catch(e){}</script>\n",
                 test_name="test.html",
-                expected_run_calls=7,
-                expected_results={"'required'"},
+                expected_run_calls=1,
+                expected_results={"<script>\ntry {\n    'fluff';\n    'required'\n} catch (e) {}\n"
+                                  "</script>\n"},
                 expected_num_reports=2,
-                strategies=["jsbeautify", "lines"],
+                strategies=["jsbeautify"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+        ),
+        # test beautify multiple js embedded in html
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="<script>try{'fluff';'required'}catch(e){}</script>"
+                "<script>'fluff';'requisite'</script>\n",
+                test_name="test.html",
+                expected_run_calls=1,
+                expected_results={"<script>\ntry {\n    'fluff';\n    'required'\n} catch (e) {}\n</script>"
+                                  "<script>\n'fluff';\n'requisite'\n</script>\n"},
+                expected_num_reports=2,
+                strategies=["jsbeautify"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+        ),
+        # test beautify js embedded in html with no end
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="<script>try{'fluff';'required'}catch(e){}\n",
+                test_name="test.html",
+                expected_run_calls=1,
+                expected_results={"<script>\ntry {\n    'fluff';\n    'required'\n} catch (e) {}\n"},
+                expected_num_reports=2,
+                strategies=["jsbeautify"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+        ),
+        # test DDBEGIN/END respected in .js file
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="try{\n//DDBEGIN\n'fluff';'required'\n//DDEND\n}catch(e){}\n",
+                test_name="test.js",
+                expected_run_calls=1,
+                expected_results={"try{\n//DDBEGIN\n'fluff';\n'required'\n//DDEND\n}catch(e){}\n"},
+                expected_num_reports=2,
+                strategies=["jsbeautify"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+        ),
+        # test DDBEGIN/END respected for js embedded in html, DD outside <script>
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="<!--DDBEGIN-->\n<script>\ntry{'fluff';'required'}catch(e){}\n"
+                "</script><!--DDEND-->\n",
+                test_name="test.html",
+                expected_run_calls=1,
+                expected_results={"<!--DDBEGIN-->\n<script>\ntry {\n    'fluff';\n    'required'\n"
+                                  "} catch (e) {}\n</script><!--DDEND-->\n"},
+                expected_num_reports=2,
+                strategies=["jsbeautify"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+        ),
+        # test DDBEGIN/END respected for js embedded in html, DD inside <script>
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="<script>try{\n//DDBEGIN\n'fluff';'required'\n//DDEND\n}catch(e){}</script>\n",
+                test_name="test.html",
+                expected_run_calls=1,
+                expected_results={"<script>try{\n//DDBEGIN\n'fluff';\n'required'\n//DDEND\n}catch(e){}"
+                                  "</script>\n"},
+                expected_num_reports=2,
+                strategies=["jsbeautify"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+        ),
+        # test DDBEGIN/END respected for js embedded in html, DD straddle before <script>
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="<!--DDBEGIN-->\n<script>\ntry{'fluff';'required'}catch(e){}\n//DDEND\n",
+                test_name="test.html",
+                expected_run_calls=1,
+                expected_results={"<!--DDBEGIN-->\n<script>\ntry {\n    'fluff';\n    'required'\n"
+                                  "} catch (e) {}\n//DDEND\n"},
+                expected_num_reports=2,
+                strategies=["jsbeautify"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+        ),
+        # test DDBEGIN/END respected for js embedded in html, DD straddle after <script>
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="<script>\n//DDBEGIN\ntry{'fluff';'required'}catch(e){}\n//DDEND\n",
+                test_name="test.html",
+                expected_run_calls=1,
+                expected_results={"<script>\n//DDBEGIN\ntry {\n    'fluff';\n    'required'\n"
+                                  "} catch (e) {}\n//DDEND\n"},
+                expected_num_reports=2,
+                strategies=["jsbeautify"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+        ),
+        # test DDBEGIN/END respected for js embedded in html, DD straddle after </script>
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="<script>\n//DDBEGIN\ntry{'fluff';'required'}catch(e){}\n</script>\n<!--DDEND-->\n",
+                test_name="test.html",
+                expected_run_calls=1,
+                expected_results={"<script>\n//DDBEGIN\ntry {\n    'fluff';\n    'required'\n} catch (e) {}\n"
+                                  "</script>\n<!--DDEND-->\n"},
+                expected_num_reports=2,
+                strategies=["jsbeautify"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+        ),
+        # test beautify js embedded in html (no <script>)
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="try{'fluff';'required'}catch(e){}\n",
+                test_name="test.html",
+                expected_run_calls=1,
+                expected_results={"try{'fluff';'required'}catch(e){}\n"},
+                expected_num_reports=2,
+                strategies=["jsbeautify", "check"],  # no beautify performed, add check so the run succeeds
+            ),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+        ),
+        # test beautify js where beautification breaks
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="try{'fluff';'requi'+'red'}catch(e){}\n",
+                test_name="test.js",
+                expected_run_calls=2,
+                expected_results={"try{'fluff';'requi'+'red'}catch(e){}\n"},
+                expected_num_reports=2,
+                strategies=["jsbeautify", "check"],  # no beautify performed, add check so the run succeeds
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
         ),
@@ -192,10 +322,10 @@ def replay_run(testcases, **_):
             *BeautifyStrategyParams(
                 test_data="*,#a{fluff:0;required:1}\n",
                 test_name="test.css",
-                expected_run_calls=8,
-                expected_results={"required: 1"},
+                expected_run_calls=1,
+                expected_results={"*,\n#a {\n  fluff: 0;\n  required: 1\n}\n"},
                 expected_num_reports=2,
-                strategies=["cssbeautify", "lines"],
+                strategies=["cssbeautify"],
             ),
             marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"),
         ),
@@ -204,10 +334,22 @@ def replay_run(testcases, **_):
             *BeautifyStrategyParams(
                 test_data="<style>*,#a{fluff:0;required:1}</style>\n",
                 test_name="test.html",
-                expected_run_calls=6,
-                expected_results={"required: 1"},
+                expected_run_calls=1,
+                expected_results={"<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n</style>\n"},
+                expected_num_reports=2,
+                strategies=["cssbeautify"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"),
+        ),
+        # test beautify css embedded in html with no end
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="<style>*,#a{fluff:0;required:1}\n",
+                test_name="test.html",
+                expected_run_calls=1,
+                expected_results={"<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n"},
                 expected_num_reports=2,
-                strategies=["cssbeautify", "lines"],
+                strategies=["cssbeautify"],
             ),
             marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"),
         ),
@@ -222,7 +364,8 @@ def replay_run(testcases, **_):
         for test in testcases:
             contents = test.get_file(test_name).data.decode("ascii")
             LOG.debug("interesting if 'required' in %r", contents)
-            if "required" in contents:
+            if ("required" in contents and ("requisite" not in test_data or "requisite" in contents)) \
+                    or "'requi'+'red'" in contents:
                 log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
                 log_path.mkdir()
                 _fake_save_logs_foo(log_path)
@@ -248,7 +391,7 @@ def replay_run(testcases, **_):
 
     assert replayer.return_value.run.call_count == expected_run_calls
     assert set(log_path.iterdir()) == {log_path / "reports"}
-    tests = {test.read_text().strip() for test in log_path.glob("reports/*-*/" + test_name)}
+    tests = {test.read_text() for test in log_path.glob("reports/*-*/" + test_name)}
     assert tests == expected_results
     assert len(list((log_path / "reports").iterdir())) == expected_num_reports, \
         list((log_path / "reports").iterdir())

From d2f1bbf603e71aed6155671e54b6a9019c27f3eb Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 15 Oct 2020 16:46:55 -0400
Subject: [PATCH 061/531] Add support for adjusting idle_delay and Sapphire
 timeout based on test duration.

---
 grizzly/reduce/args.py        |   3 +
 grizzly/reduce/core.py        |  71 +++++++++++++++++++++--
 grizzly/reduce/test_reduce.py | 105 ++++++++++++++++++++++++++++++++++
 3 files changed, 175 insertions(+), 4 deletions(-)

diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 29afc0e4..e400397a 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -27,6 +27,9 @@ def __init__(self):
         reduce_args.add_argument(
             "--no-analysis", action="store_true",
             help="Disable analysis to auto-set --repeat/--min-crashes.")
+        reduce_args.add_argument(
+            "--static-timeout", action="store_true",
+            help="Disable automatically updating the iteration timeout.")
         reduce_args.add_argument(
             "--strategy", nargs="+", default=DEFAULT_STRATEGIES, metavar="STRATEGY",
             dest="strategies",
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 8f3f0243..608385e4 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -5,6 +5,7 @@
 """
 Given a build and testcase, try to reduce it using a set of strategies.
 """
+from itertools import chain
 from logging import getLogger
 from math import ceil, log
 from pathlib import Path
@@ -63,9 +64,20 @@ class ReduceManager(object):
     # to see the worst case, run the `repeat` calculation in run_reliability_analysis using
     # crashes_percent = 1.0/ANALYSIS_ITERATIONS
 
+    IDLE_DELAY_MIN = 10
+    IDLE_DELAY_DURATION_MULTIPLIER = 1.5
+    ITER_TIMEOUT_MIN = 10
+    ITER_TIMEOUT_DURATION_MULTIPLIER = 2
+
+    """
+    Args:
+        idle_delay (int): Number of seconds to wait before polling for idle.
+        idle_threshold (int): CPU usage threshold to mark the process as idle.
+    """
+
     def __init__(self, ignore, server, target, testcases, strategies, log_path, tool=None,
                  report_to_fuzzmanager=False, any_crash=False, signature=None, use_harness=True,
-                 use_analysis=True):
+                 use_analysis=True, static_timeout=False, idle_delay=0, idle_threshold=0):
         self.ignore = ignore
         self.server = server
         self.strategies = strategies
@@ -81,6 +93,39 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path, tool
         self._signature = signature
         self._use_analysis = use_analysis
         self._use_harness = use_harness
+        self._static_timeout = static_timeout
+        self._idle_delay = idle_delay
+        self._idle_threshold = idle_threshold
+
+    def update_timeout(self, results):
+        if self._static_timeout or self._any_crash or getattr(self.target, "use_valgrind", False):
+            # the amount of time it can take to replay a test case can vary
+            # when under Valgrind so do not update the timeout in that case
+
+            # when any_crash is given, crashes may be completely unrelated (all are expected), so
+            # lowering timeout or idle delay will only hide crashes
+            return
+
+        durations = list(chain.from_iterable(result.durations for result in results if result.expected))
+        if not durations:
+            # no expected results
+            return
+        run_time = max(durations)
+
+        # If `run_time * multiplier` is less than idle poll delay, update it
+        LOG.debug('Run time %r', run_time)
+        new_idle_delay = max(self.IDLE_DELAY_MIN, min(run_time * self.IDLE_DELAY_DURATION_MULTIPLIER,
+                                                      self._idle_delay))
+        if new_idle_delay < self._idle_delay:
+            LOG.info("Updating poll delay to: %r", new_idle_delay)
+            self._idle_delay = new_idle_delay
+        # If `run_time * multiplier` is less than iter_timeout, update it
+        # in other words, decrease the timeout if this ran in less than half the timeout
+        new_iter_timeout = max(self.ITER_TIMEOUT_MIN, min(run_time * self.ITER_TIMEOUT_DURATION_MULTIPLIER,
+                                                          self.server.timeout))
+        if new_iter_timeout < self.server.timeout:
+            LOG.info("Updating max timeout to: %r", new_iter_timeout)
+            self.server.timeout = new_iter_timeout
 
     def run_reliability_analysis(self):
         harness_crashes = 0
@@ -104,12 +149,14 @@ def run_reliability_analysis(self):
                          self.ANALYSIS_ITERATIONS, "using" if use_harness else "without")
                 for _ in range(self.ANALYSIS_ITERATIONS):
                     try:
-                        results = replay.run(self.testcases, repeat=1, min_results=1)
+                        results = replay.run(self.testcases, repeat=1, min_results=1,
+                                             idle_delay=self._idle_delay, idle_threshold=self._idle_threshold)
                     except (TargetLaunchError, TargetLaunchTimeout) as exc:
                         if isinstance(exc, TargetLaunchError) and exc.report:
                             self.report([ReplayResult(exc.report, None, [], False)], self.testcases)
                             exc.report.cleanup()
                         raise
+                    self.update_timeout(results)
                     try:
                         success = any(result.expected for result in results)
                         LOG.info("result: %s", "interesting." if success else "not interesting.")
@@ -155,6 +202,16 @@ def run_reliability_analysis(self):
         return (repeat, min_crashes)
 
     def run(self, repeat=1, min_results=1):
+        """Run testcase replay.
+
+        Args:
+            repeat (int): Maximum number of times to run the TestCase.
+            min_results (int): Minimum number of results needed before run can
+                               be considered successful.
+
+        Returns:
+            bool: Whether a crash was observed (whether or not reduction was successful).
+        """
         any_success = False
         last_reports = None
         for strategy_no, strategy in enumerate(self.strategies):
@@ -179,12 +236,15 @@ def run(self, repeat=1, min_results=1):
                         try:
                             try:
                                 # reduction is a new list of testcases to be replayed
-                                results = replay.run(reduction, repeat=repeat, min_results=min_results)
+                                results = replay.run(reduction, repeat=repeat, min_results=min_results,
+                                                     idle_delay=self._idle_delay,
+                                                     idle_threshold=self._idle_threshold)
                             except (TargetLaunchError, TargetLaunchTimeout) as exc:
                                 if isinstance(exc, TargetLaunchError) and exc.report:
                                     self.report([ReplayResult(exc.report, None, [], False)], reduction)
                                     exc.report.cleanup()
                                 raise
+                            self.update_timeout(results)
                             success = any(report.expected for report in results)
                             strategy.update(success)
                             if strategy.name == "check":
@@ -329,7 +389,10 @@ def main(cls, args):
                     any_crash=args.any_crash,
                     signature=signature,
                     use_harness=not args.no_harness,
-                    use_analysis=not args.no_analysis)
+                    use_analysis=not args.no_analysis,
+                    static_timeout=args.static_timeout,
+                    idle_delay=args.idle_delay,
+                    idle_threshold=args.idle_threshold)
                 success = mgr.run(repeat=args.repeat, min_results=args.min_crashes)
             return 0 if success else 1
 
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 4ae7dd50..2c4098dd 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -416,3 +416,108 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
         assert report_obj.cleanup.call_count == 1
     else:
         assert report_fcn.call_count == 0
+
+
+TimeoutTestParams = namedtuple(
+    "TimeoutTestParams",
+    "durations, interesting, static_timeout, idle_input, idle_output, iter_input, iter_output, result"
+)
+
+
+@pytest.mark.parametrize(
+    TimeoutTestParams._fields,
+    [
+        # 0 duration test sets both timeouts to minimum
+        TimeoutTestParams(
+            durations=[0],
+            interesting=True,
+            static_timeout=False,
+            idle_input=30,
+            idle_output=10,
+            iter_input=60,
+            iter_output=10,
+            result=True,
+        ),
+        # max duration is used
+        TimeoutTestParams(
+            durations=[0, 30],
+            interesting=True,
+            static_timeout=False,
+            idle_input=30,
+            idle_output=30,
+            iter_input=60,
+            iter_output=60,
+            result=True,
+        ),
+        # static timeout doesn't affect timeouts
+        TimeoutTestParams(
+            durations=[0],
+            interesting=True,
+            static_timeout=True,
+            idle_input=30,
+            idle_output=30,
+            iter_input=60,
+            iter_output=60,
+            result=True,
+        ),
+        # uninteresting result doesn't affect timeouts
+        TimeoutTestParams(
+            durations=[0],
+            interesting=False,
+            static_timeout=True,
+            idle_input=30,
+            idle_output=30,
+            iter_input=60,
+            iter_output=60,
+            result=False,
+        ),
+        # test duration affects timeouts
+        TimeoutTestParams(
+            durations=[10],
+            interesting=True,
+            static_timeout=False,
+            idle_input=30,
+            idle_output=15,
+            iter_input=60,
+            iter_output=20,
+            result=True,
+        ),
+    ]
+)
+def test_timeout_update(mocker, tmp_path, durations, interesting, static_timeout, idle_input, idle_output,
+                        iter_input, iter_output, result):
+    "timeout will be updated based on time to crash"
+    replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+
+    def replay_run(_testcases, **_):
+        LOG.debug("interesting true")
+        log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+        log_path.mkdir()
+        _fake_save_logs_foo(log_path)
+        report = Report(str(log_path), "bin")
+        return [ReplayResult(report, ["test.html"], durations, interesting)]
+    replayer.return_value.run.side_effect = replay_run
+
+    test = TestCase("test.html", None, "test-adapter")
+    test.add_from_data("123\n", "test.html")
+    tests = [test]
+    log_path = tmp_path / "logs"
+
+    target = mocker.Mock(spec=Target)
+    target.relaunch = 1
+    server = mocker.Mock(spec=Sapphire)
+    server.timeout = iter_input
+    try:
+        mgr = ReduceManager([], server, target, tests, ["check"], log_path,
+                            use_analysis=False, idle_delay=idle_input, static_timeout=static_timeout)
+        mgr.IDLE_DELAY_MIN = 10
+        mgr.IDLE_DELAY_DURATION_MULTIPLIER = 1.5
+        mgr.ITER_TIMEOUT_MIN = 10
+        mgr.ITER_TIMEOUT_DURATION_MULTIPLIER = 2
+        assert mgr.run() == result
+    finally:
+        for test in tests:
+            test.cleanup()
+
+    assert server.timeout == iter_output
+    assert mgr._idle_delay == idle_output

From c88fb240b708dd23eadc34e4cd725315a951ef69 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 16 Oct 2020 11:12:29 -0400
Subject: [PATCH 062/531] [reducer] Implement purging unserved files.

---
 grizzly/reduce/core.py            |   7 +-
 grizzly/reduce/strategies.py      | 156 +++++++++++++++++++++++++++---
 grizzly/reduce/test_reduce.py     |   8 +-
 grizzly/reduce/test_strategies.py | 140 ++++++++++++++++++++++++++-
 4 files changed, 289 insertions(+), 22 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 608385e4..2cfe114b 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -245,8 +245,11 @@ def run(self, repeat=1, min_results=1):
                                     exc.report.cleanup()
                                 raise
                             self.update_timeout(results)
-                            success = any(report.expected for report in results)
-                            strategy.update(success)
+                            # get the first expected result (if any), and update the strategy
+                            first_expected = next((report for report in results if report.expected), None)
+                            success = first_expected is not None
+                            served = first_expected.served if success and not self._any_crash else None
+                            strategy.update(success, served=served)
                             if strategy.name == "check":
                                 if any_success and not success:
                                     raise RuntimeError("Reduction broke")
diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index 74a42f35..1257c6e3 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -96,7 +96,7 @@ def __iter__(self):
         pass
 
     @abstractmethod
-    def update(self, success):
+    def update(self, success, served=None):
         pass
 
     def __enter__(self):
@@ -149,7 +149,9 @@ def sanity_check_impl(cls):
         assert isinstance(cls.native_extension, str)
         assert isinstance(cls.tag_name, str)
 
-    def update(self, success):
+    def update(self, success, served=None):
+        # beautify does nothing with served. it's unlikely a beautify operation alone would
+        # render a file unserved.
         assert self._current_feedback is None
         self._current_feedback = success
 
@@ -283,6 +285,8 @@ def __init__(self, *args, **kwds):
         for path in self._testcase_root.glob("**/*"):
             if path.is_file() and path.name not in {"test_info.json", "prefs.js"}:
                 self._files_to_reduce.append(path)
+        self._current_feedback = None
+        self._current_served = None
 
     @classmethod
     def sanity_check_impl(cls):
@@ -290,24 +294,119 @@ def sanity_check_impl(cls):
         assert issubclass(cls.strategy_cls, LithStrategy)
         assert issubclass(cls.testcase_cls, LithTestcase)
 
-    def update(self, success):
-        assert self._current_reducer is not None
-        self._current_reducer.feedback(success)
+    def update(self, success, served=None):
+        if self._current_reducer is not None:
+            self._current_reducer.feedback(success)
+        self._current_feedback = success
+        self._current_served = served
+
+    def _served_to_testcase_root_path(self, timestamps_in_order):
+        """The entries in `ReplayResult.served` are in the order of testcase timestamps as loaded by
+        `TestCase.load()`. We need to correlate that back to the original, which is the data on disk
+        in `self._testcase_root`.
+
+        Arguments:
+            timestamps_in_order (list[int]): `TestCase.timestamp` for each testcase as ordered by
+                                             `TestCase.load()`
+
+        Returns:
+            set{Path}: a flat set of all files served as they appear in `self._testcase_root`.
+        """
+        paths_in_order = [None] * len(timestamps_in_order)
+        for test_info in self._testcase_root.glob("*/test_info.json"):
+            info = json.loads(test_info.read_text())
+            idx = timestamps_in_order.index(info["timestamp"])
+            assert paths_in_order[idx] is None
+            paths_in_order[idx] = test_info.parent
+        assert all(path is not None for path in paths_in_order)
+        assert len(self._current_served) <= len(paths_in_order)
+        served_paths = set()
+        for root, served in zip(paths_in_order, self._current_served):
+            served_paths |= {root / path for path in served}
+        return served_paths
+
+    def _targets_by_path(self):
+        """Map testcase subfolders in `self._testcase_root` to `target` entries in their metadata.
+
+        Yields:
+            tuple(Path, str): mapping of testcase subfolders in `self._testcase_root` to `target` entries
+        """
+        for test_info in self._testcase_root.glob("*/test_info.json"):
+            info = json.loads(test_info.read_text())
+            yield (test_info.parent, info["target"])
 
     def __iter__(self):
         LOG.info("Reducing %d files", len(self._files_to_reduce))
-        for file_no, file in enumerate(self._files_to_reduce):
-            LOG.info("Reducing %s (file %d/%d)", file, file_no + 1, len(self._files_to_reduce))
+        file_no = 0
+        reduce_queue = self._files_to_reduce
+        reduce_queue.sort()  # not necessary, but helps make tests more predictable
+        reduced = set()
+        # indicates that self._testcase_root contains changes that haven't been yielded (if iteration ends,
+        # changes would be lost)
+        testcase_root_dirty = False
+        while reduce_queue:
+            LOG.debug("Reduce queue: %r", reduce_queue)
+            file = reduce_queue.pop(0)
+            reduced.add(file)
+            file_no += 1
+            LOG.info("Reducing %s (file %d/%d)", file, file_no, len(reduced) + len(reduce_queue))
             lithium_testcase = self.testcase_cls()  # pylint: disable=not-callable
             lithium_testcase.load(file)
             # pylint: disable=not-callable
             self._current_reducer = self.strategy_cls().reduce(lithium_testcase)
             for reduction in self._current_reducer:
                 reduction.dump()
-                yield TestCase.load(str(self._testcase_root), False)
-            # write out the best found testcase
-            self._current_reducer.testcase.dump()
+                testcases = TestCase.load(str(self._testcase_root), False)
+                ts_in_order = [testcase.timestamp for testcase in testcases]
+                yield testcases
+                if self._current_feedback:
+                    testcase_root_dirty = False
+                if self._current_feedback and self._current_served is not None:
+                    # check whether any files went unserved, and purge them
+                    served_paths = self._served_to_testcase_root_path(ts_in_order)
+                    files_in_play = set(reduce_queue) | reduced
+                    to_remove = files_in_play - served_paths
+                    current_reduction_invalid = False
+                    if to_remove:
+                        LOG.debug("files being reduced before: %r", list(files_in_play))
+                        for entry in to_remove:
+                            LOG.info("Testcase at %s was unserved, removing.",
+                                     entry.relative_to(self._testcase_root))
+                            files_in_play.remove(entry)
+                            current_reduction_invalid = current_reduction_invalid or file == entry
+                            entry.unlink()
+                            testcase_root_dirty = True
+                        # we've removed some files, now check if any whole folders
+                        # are unnecessary
+                        for root, target in self._targets_by_path():
+                            if root / target not in files_in_play:
+                                LOG.warning("target in %s is missing, directory will be removed",
+                                            root.relative_to(self._testcase_root))
+                                for entry in root.glob("**/*"):
+                                    LOG.debug(entry)
+                                    if not entry.is_file() or entry.name in {"test_info.json", "prefs.js"}:
+                                        continue
+                                    LOG.info("Removing unserved %s", entry.relative_to(self._testcase_root))
+                                    files_in_play.remove(entry)
+                                    current_reduction_invalid = current_reduction_invalid or file == entry
+                                rmtree(str(root))
+                                testcase_root_dirty = True
+                        LOG.debug("files being reduced after: %r", list(files_in_play))
+                        reduce_queue = list(sorted(files_in_play - reduced))
+                        reduced &= files_in_play
+                    if current_reduction_invalid:
+                        break
+            else:
+                # write out the best found testcase
+                self._current_reducer.testcase.dump()
             self._current_reducer = None
+        if testcase_root_dirty:
+            # purging unserved files enabled us to exit early from the loop.
+            # need to yield once more to set this trimmed version to the current best in ReduceManager
+            LOG.debug("purging changed the testcase root. one more iteration")
+            testcases = TestCase.load(str(self._testcase_root), False)
+            yield testcases
+            assert self._current_feedback, "Purging unserved files broke the testcase."
 
 
 class Check(_LithiumStrategy):
@@ -406,10 +505,13 @@ class MinimizeTestcaseList(Strategy):
     def __init__(self, *args, **kwds):
         super().__init__(*args, **kwds)
         self._current_feedback = None
+        self._last_served = None
 
-    def update(self, success):
+    def update(self, success, served=None):
         assert self._current_feedback is None
+        assert self._last_served is None
         self._current_feedback = success
+        self._last_served = served
 
     def __iter__(self):
         assert self._current_feedback is None
@@ -418,6 +520,9 @@ def __iter__(self):
         try:
             testcases = TestCase.load(str(self._testcase_root), False)
             n_testcases = len(testcases)
+            # indicates that self._testcase_root contains changes that haven't been yielded (if iteration
+            # ends, changes would be lost)
+            testcase_root_dirty = False
             while True:
                 if n_testcases <= 1:
                     LOG.info("Testcase list has length %d, not enough to reduce!", n_testcases)
@@ -431,14 +536,17 @@ def __iter__(self):
                     assert n_testcases == len(testcases)
                 removed_ts = testcases[idx].timestamp
                 testcases.pop(idx).cleanup()
+                ts_in_order = [testcase.timestamp for testcase in testcases]
                 yield testcases
                 testcases = None  # caller owns testcases now
                 assert self._current_feedback is not None, "no feedback received!"
                 if self._current_feedback:
+                    testcase_root_dirty = False
                     # removal was success! find the testcase that matches timestamp,
                     # and remove it
                     LOG.info("Removing testcase %d/%d was successful!", idx + 1, n_testcases)
                     removed_path = None
+                    unserved_paths = []
                     for test_info in self._testcase_root.glob("*/test_info.json"):
                         info = json.loads(test_info.read_text())
                         if removed_ts == info["timestamp"]:
@@ -447,17 +555,37 @@ def __iter__(self):
                             ), "Duplicate testcases found with timestamp %s" % (
                                 removed_ts,
                             )
-                            removed_path = test_info
+                            removed_path = test_info.parent
+                        elif self._last_served is not None:
+                            test_idx = ts_in_order.index(info["timestamp"])
+                            if test_idx >= len(self._last_served) or \
+                                    info["target"] not in self._last_served[test_idx]:
+                                LOG.info("Testcase at %s was unserved, removing.",
+                                         test_info.parent.relative_to(self._testcase_root))
+                                unserved_paths.append(test_info.parent)
                     assert (
                         removed_path is not None
                     ), "No testcase found with timestamp %s" % (removed_ts,)
-                    rmtree(str(removed_path.parent))
-                    n_testcases -= 1
+                    rmtree(str(removed_path))
+                    for unserved in unserved_paths:
+                        rmtree(str(unserved))
+                        testcase_root_dirty = True
+                    n_testcases -= 1 + len(unserved_paths)
                 else:
                     LOG.info("No result without testcase %d/%d", idx + 1, n_testcases)
                     idx += 1
                 # reset
                 self._current_feedback = None
+                self._last_served = None
+            if testcase_root_dirty:
+                # purging unserved files enabled us to exit early from the loop.
+                # need to yield once more to set this trimmed version to the current best in ReduceManager
+                LOG.debug("purging changed the testcase root. one more iteration")
+                testcases = TestCase.load(str(self._testcase_root), False)
+                assert n_testcases == len(testcases)
+                yield testcases
+                testcases = None  # caller owns testcases now
+                assert self._current_feedback, "Purging unserved files broke the testcase."
         finally:
             if testcases is not None:
                 for testcase in testcases:
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 2c4098dd..a8fd0463 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -85,7 +85,7 @@ def replay_run(_, **_kw):
             log_path.mkdir()
             _fake_save_logs_foo(log_path)
             report = Report(str(log_path), "bin")
-            return [ReplayResult(report, ["test.html"], [], True)]
+            return [ReplayResult(report, [["test.html"]], [], True)]
         return []
     replayer.return_value.__enter__.return_value.run.side_effect = replay_run
 
@@ -294,7 +294,7 @@ def replay_run(testcases, **_):
                 else:
                     _fake_save_logs_bar(log_path)
                 report = Report(str(log_path), "bin")
-                return [ReplayResult(report, ["test.html"], [], expected)]
+                return [ReplayResult(report, [["test.html"]], [], expected)]
         return []
     replayer.return_value.run.side_effect = replay_run
 
@@ -342,7 +342,7 @@ def replay_run(_, **_kw):
         log_path.mkdir()
         _fake_save_logs_foo(log_path)
         report = Report(str(log_path), "bin")
-        return [ReplayResult(report, ["test.html"], [], True)]
+        return [ReplayResult(report, [["test.html"]], [], True)]
     replayer.return_value.run.side_effect = replay_run
 
     (tmp_path / "test.html").touch()
@@ -495,7 +495,7 @@ def replay_run(_testcases, **_):
         log_path.mkdir()
         _fake_save_logs_foo(log_path)
         report = Report(str(log_path), "bin")
-        return [ReplayResult(report, ["test.html"], durations, interesting)]
+        return [ReplayResult(report, [["test.html"]], durations, interesting)]
     replayer.return_value.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 4e3c368e..3af587d6 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -126,7 +126,7 @@ def replay_run(testcases, **_):
                 log_path.mkdir()
                 _fake_save_logs_foo(log_path)
                 report = Report(str(log_path), "bin")
-                return [ReplayResult(report, ["test.html"], [], True)]
+                return [ReplayResult(report, [["test.html"]] * len(testcases), [], True)]
         return []
     replayer.return_value.run.side_effect = replay_run
 
@@ -370,7 +370,7 @@ def replay_run(testcases, **_):
                 log_path.mkdir()
                 _fake_save_logs_foo(log_path)
                 report = Report(str(log_path), "bin")
-                return [ReplayResult(report, [test_name], [], True)]
+                return [ReplayResult(report, [[test_name]], [], True)]
         return []
     replayer.return_value.run.side_effect = replay_run
 
@@ -395,3 +395,139 @@ def replay_run(testcases, **_):
     assert tests == expected_results
     assert len(list((log_path / "reports").iterdir())) == expected_num_reports, \
         list((log_path / "reports").iterdir())
+
+
+PurgeUnservedTestParams = namedtuple(
+    "PurgeUnservedTestParams",
+    "strategies, test_data, served, expected_results, expected_run_calls, expected_num_reports, "
+    "purging_breaks"
+)
+
+
+@pytest.mark.parametrize(
+    PurgeUnservedTestParams._fields,
+    [
+        # single test, first reduction uses 2 files, second uses only target file.
+        PurgeUnservedTestParams(
+            strategies=["chars"],
+            test_data=[{"test.html": "123", "opt.html": "456"}],
+            served=[[["test.html", "opt.html"]], [["test.html"]], [["test.html"]]],
+            expected_results={"1"},
+            expected_run_calls=5,
+            expected_num_reports=2,
+            purging_breaks=False,
+        ),
+        # single test, first reduction uses target only
+        PurgeUnservedTestParams(
+            strategies=["chars"],
+            test_data=[{"test.html": "123", "opt.html": "456"}],
+            served=[[["test.html"]], [["test.html"]]],
+            expected_results={"1"},
+            expected_run_calls=3,
+            expected_num_reports=2,
+            purging_breaks=False,
+        ),
+        # single test, first reduction uses 2 files, second uses only optional file. (no results -> Assertion)
+        PurgeUnservedTestParams(
+            strategies=["chars"],
+            test_data=[{"test.html": "123", "opt.html": "456"}],
+            served=[[["test.html", "opt.html"]], [["opt.html"]]],
+            expected_results=set(),
+            expected_run_calls=4,
+            expected_num_reports=None,
+            purging_breaks=True,
+        ),
+        # double test, first reduction uses all files, second uses only target file in second test.
+        PurgeUnservedTestParams(
+            strategies=["chars"],
+            test_data=[{"test.html": "123", "opt.html": "456"}, {"test.html": "789", "opt.html": "abc"}],
+            served=[[["test.html", "opt.html"], ["test.html", "opt.html"]],
+                    [["test.html", "opt.html"], ["test.html"]],
+                    [["test.html", "opt.html"], ["test.html"]]],
+            expected_results={"1", "4", "7"},
+            expected_run_calls=6,
+            expected_num_reports=3,
+            purging_breaks=False,
+        ),
+        # double test, first reduction uses all files, second uses only optional file (first test remains)
+        PurgeUnservedTestParams(
+            strategies=["chars"],
+            test_data=[{"test.html": "123", "opt.html": "456"}, {"test.html": "789", "opt.html": "abc"}],
+            served=[[["test.html", "opt.html"], ["test.html", "opt.html"]],
+                    [["test.html", "opt.html"], ["opt.html"]],
+                    [["test.html", "opt.html"]]],
+            expected_results={"1", "4"},
+            expected_run_calls=5,
+            expected_num_reports=2,
+            purging_breaks=False,
+        ),
+        # triple test, list strategy. first test gets reduced, third gets eliminated
+        PurgeUnservedTestParams(
+            strategies=["list"],
+            test_data=[{"test.html": "123"}, {"test.html": "456"}, {"test.html": "789"}],
+            served=[[["test.html"]],
+                    [["test.html"]],
+                    [["test.html"]]],
+            expected_results={"456"},
+            expected_run_calls=2,
+            expected_num_reports=2,
+            purging_breaks=False,
+        ),
+    ]
+)
+def test_purge_unserved(mocker, tmp_path, strategies, test_data, served, expected_results, expected_run_calls,
+                        expected_num_reports, purging_breaks):
+    """test purging unserved files"""
+    replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+
+    def replay_run(testcases, **_):
+        # test.html and opt.html should always contain one line.
+        # return [] (no result) if either of them exist and are empty
+        has_any = False
+        for test in testcases:
+            for file in ("test.html", "opt.html"):
+                if test.contains(file):
+                    LOG.debug("testcase contains %s", file)
+                    has_any = True
+                    contents = test.get_file(file).data.decode("ascii")
+                    if not contents.strip():
+                        return []
+        if not has_any:
+            return []
+        log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+        log_path.mkdir()
+        _fake_save_logs_foo(log_path)
+        report = Report(str(log_path), "bin")
+        return [ReplayResult(report, served.pop(0), [], True)]
+    replayer.return_value.run.side_effect = replay_run
+
+    tests = []
+    for testcase in test_data:
+        test = TestCase("test.html", None, "test-adapter")
+        for filename, data in testcase.items():
+            test.add_from_data(data, filename)
+        tests.append(test)
+    log_path = tmp_path / "logs"
+
+    target = mocker.Mock(spec=Target)
+    target.relaunch = 1
+    try:
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies, log_path,
+                            use_analysis=False)
+        if purging_breaks:
+            with raises(AssertionError):
+                mgr.run()
+        else:
+            assert mgr.run()
+    finally:
+        for test in tests:
+            test.cleanup()
+
+    assert replayer.return_value.run.call_count == expected_run_calls
+    if purging_breaks:
+        return
+    assert set(log_path.iterdir()) == {log_path / "reports"}
+    tests = {test.read_text() for test in log_path.glob("reports/*-*/*.html")}
+    assert tests == expected_results
+    assert len(list((log_path / "reports").iterdir())) == expected_num_reports, \
+        list((log_path / "reports").iterdir())

From a56e1bd97f3c8eb92e5e057697cc85e4801fba2d Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 16 Oct 2020 14:54:00 -0400
Subject: [PATCH 063/531] Add a TestCase.clone() method to make a deep copy of
 a TestCase and its TestFiles.

---
 grizzly/common/storage.py      | 23 ++++++++++++++++++++++-
 grizzly/common/test_storage.py | 23 +++++++++++++++++++++++
 2 files changed, 45 insertions(+), 1 deletion(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 3015c891..cb00b97e 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -187,6 +187,27 @@ def cleanup(self):
             for test_file in file_group:
                 test_file.close()
 
+    def clone(self):
+        """Make a copy of the TestCase.
+
+        Args:
+            None
+
+        Returns:
+            TestCase: A copy of the TestCase instance
+        """
+        result = type(self)(self.landing_page, self.redirect_page, self.adapter_name, self.input_fname,
+                            self.timestamp)
+        result.duration = self.duration
+        result.env_vars.update(self.env_vars)
+        for entry in self._files.meta:
+            result.add_meta(entry.clone())
+        for entry in self._files.optional:
+            result.add_file(entry.clone(), required=False)
+        for entry in self._files.required:
+            result.add_file(entry.clone(), required=True)
+        return result
+
     def contains(self, file_name):
         """Check TestCase contains the TestFile with name matching `file_name`.
 
@@ -489,7 +510,7 @@ def clone(self):
         Returns:
             TestFile: A copy of the TestFile instance
         """
-        cloned = TestFile(self._file_name)
+        cloned = type(self)(self._file_name)
         self._fp.seek(0)
         shutil.copyfileobj(self._fp, cloned._fp, self.XFER_BUF)  # pylint: disable=protected-access
         return cloned
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index aef61d1e..f7348e92 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -379,6 +379,29 @@ def test_testcase_18():
         assert src.get_file("missing") is None
         assert src.get_file("test.htm").data == b"test"
 
+def test_testcase_19(tmp_path):
+    """test TestCase.clone()"""
+    with TestCase("test.htm", "redirect.htm", "test-adaptor", "input.py") as src:
+        src.add_from_data("123", "test.htm")
+        src.add_from_data("456", "opt.htm", required=False)
+        src.add_meta(TestFile.from_data("pref", "prefs.js"))
+        src.add_environ_var("go", "away")
+        with src.clone() as tgt:
+            for prop in TestCase.__slots__:
+                if prop.startswith("_"):
+                    continue
+                assert getattr(src, prop) == getattr(tgt, prop)
+            assert src.data_size == tgt.data_size
+            for file, data in (("test.htm", b"123"), ("opt.htm", b"456"), ("prefs.js", b"pref")):
+                src.get_file(file).write(b"src")
+                tgt.get_file(file).write(b"tgt")
+                assert src.get_file(file).data == data + b"src"
+                assert tgt.get_file(file).data == data + b"tgt"
+            src.add_environ_var("foo", "bar")
+            tgt.add_environ_var("hello", "kitty")
+            assert src.env_vars == {"foo": "bar", "go": "away"}
+            assert tgt.env_vars == {"hello": "kitty", "go": "away"}
+
 def test_testfile_01():
     """test simple TestFile"""
     with TestFile("test_file.txt") as tfile:

From 03926a1c14969ea5eb3a9b0f2ffdf969d8a7c781 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 16 Oct 2020 16:17:06 -0400
Subject: [PATCH 064/531] [reducer] Call purge_optional before reporting any
 testcases.

---
 grizzly/reduce/core.py | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 2cfe114b..45ae62b8 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -304,7 +304,17 @@ def report(self, results, tests):
                 reporter = FilesystemReporter(
                     report_path=str(Path(self._log_path) / report_dir),
                     major_bucket=False)
-            ret_values.append(reporter.submit(tests, report=result.report))
+            # clone the tests so we can safely call purge_optional here for each report
+            # (report.served may be different for non-expected or any-crash results)
+            clones = [test.clone() for test in tests]
+            try:
+                for clone, served in zip(clones, result.served):
+                    if served is not None:
+                        clone.purge_optional(served)
+                ret_values.append(reporter.submit(clones, report=result.report))
+            finally:
+                for clone in clones:
+                    clone.cleanup()
         return ret_values
 
     @classmethod

From 74e71eb5af489c875c928bb514b984b557906ed3 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 16 Oct 2020 21:13:42 -0400
Subject: [PATCH 065/531] [reducer] Pass through the lithium reduction status
 to log

---
 grizzly/reduce/strategies.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index 1257c6e3..6d0bb410 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -358,6 +358,7 @@ def __iter__(self):
                 reduction.dump()
                 testcases = TestCase.load(str(self._testcase_root), False)
                 ts_in_order = [testcase.timestamp for testcase in testcases]
+                LOG.info(self._current_reducer.description)
                 yield testcases
                 if self._current_feedback:
                     testcase_root_dirty = False
@@ -403,8 +404,8 @@ def __iter__(self):
         if testcase_root_dirty:
             # purging unserved files enabled us to exit early from the loop.
             # need to yield once more to set this trimmed version to the current best in ReduceManager
-            LOG.debug("purging changed the testcase root. one more iteration")
             testcases = TestCase.load(str(self._testcase_root), False)
+            LOG.info("final iteration triggered by purge_optional")
             yield testcases
             assert self._current_feedback, "Purging unserved files broke the testcase."
 
@@ -580,9 +581,9 @@ def __iter__(self):
             if testcase_root_dirty:
                 # purging unserved files enabled us to exit early from the loop.
                 # need to yield once more to set this trimmed version to the current best in ReduceManager
-                LOG.debug("purging changed the testcase root. one more iteration")
                 testcases = TestCase.load(str(self._testcase_root), False)
                 assert n_testcases == len(testcases)
+                LOG.info("final iteration triggered by purge_optional")
                 yield testcases
                 testcases = None  # caller owns testcases now
                 assert self._current_feedback, "Purging unserved files broke the testcase."

From 84391789eb58206b121a12f9a05a0d819dd10814 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 16 Oct 2020 22:27:53 -0400
Subject: [PATCH 066/531] [reducer] Simplify purging by re-reading/dumping
 testcases from disk.

---
 grizzly/reduce/core.py       |   4 +-
 grizzly/reduce/strategies.py | 118 +++++++++++++----------------------
 2 files changed, 45 insertions(+), 77 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 45ae62b8..9922236f 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -256,7 +256,7 @@ def run(self, repeat=1, min_results=1):
                             any_success = any_success or success
                             # if the reduction reproduced, update self.testcases (new best)
                             if success:
-                                LOG.info("Interesting")
+                                LOG.info("Attempt succeeded")
                                 for testcase in self.testcases:
                                     testcase.cleanup()
                                 self.testcases = reduction
@@ -268,7 +268,7 @@ def run(self, repeat=1, min_results=1):
                                 best_results = [result for result in results if result.expected]
                                 results = [result for result in results if not result.expected]
                             else:
-                                LOG.info("Uninteresting")
+                                LOG.info("Attempt failed")
                             # if the reduction found other crashes, report those immediately
                             self.report(results, reduction)
                         finally:  # noqa pylint: disable=bare-except
diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index 6d0bb410..912379e6 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -82,6 +82,9 @@ class Strategy(ABC):
 
     def __init__(self, testcases):
         self._testcase_root = Path(mkdtemp(prefix="tc_", dir=grz_tmp("reduce")))
+        self.dump_testcases(testcases)
+
+    def dump_testcases(self, testcases):
         for idx, testcase in enumerate(testcases):
             LOG.debug("Extracting testcase %d/%d", idx + 1, len(testcases))
             testpath = self._testcase_root / ("%03d" % (idx,))
@@ -282,11 +285,15 @@ def __init__(self, *args, **kwds):
         super().__init__(*args, **kwds)
         self._current_reducer = None
         self._files_to_reduce = []
+        self.rescan_files_to_reduce()
+        self._current_feedback = None
+        self._current_served = None
+
+    def rescan_files_to_reduce(self):
+        self._files_to_reduce.clear()
         for path in self._testcase_root.glob("**/*"):
             if path.is_file() and path.name not in {"test_info.json", "prefs.js"}:
                 self._files_to_reduce.append(path)
-        self._current_feedback = None
-        self._current_served = None
 
     @classmethod
     def sanity_check_impl(cls):
@@ -300,56 +307,19 @@ def update(self, success, served=None):
         self._current_feedback = success
         self._current_served = served
 
-    def _served_to_testcase_root_path(self, timestamps_in_order):
-        """The entries in `ReplayResult.served` are in the order of testcase timestamps as loaded by
-        `TestCase.load()`. We need to correlate that back to the original, which is the data on disk
-        in `self._testcase_root`.
-
-        Arguments:
-            timestamps_in_order (list[int]): `TestCase.timestamp` for each testcase as ordered by
-                                             `TestCase.load()`
-
-        Returns:
-            set{Path}: a flat set of all files served as they appear in `self._testcase_root`.
-        """
-        paths_in_order = [None] * len(timestamps_in_order)
-        for test_info in self._testcase_root.glob("*/test_info.json"):
-            info = json.loads(test_info.read_text())
-            idx = timestamps_in_order.index(info["timestamp"])
-            assert paths_in_order[idx] is None
-            paths_in_order[idx] = test_info.parent
-        assert all(path is not None for path in paths_in_order)
-        assert len(self._current_served) <= len(paths_in_order)
-        served_paths = set()
-        for root, served in zip(paths_in_order, self._current_served):
-            served_paths |= {root / path for path in served}
-        return served_paths
-
-    def _targets_by_path(self):
-        """Map testcase subfolders in `self._testcase_root` to `target` entries in their metadata.
-
-        Yields:
-            tuple(Path, str): mapping of testcase subfolders in `self._testcase_root` to `target` entries
-        """
-        for test_info in self._testcase_root.glob("*/test_info.json"):
-            info = json.loads(test_info.read_text())
-            yield (test_info.parent, info["target"])
-
     def __iter__(self):
         LOG.info("Reducing %d files", len(self._files_to_reduce))
         file_no = 0
-        reduce_queue = self._files_to_reduce
+        reduce_queue = self._files_to_reduce.copy()
         reduce_queue.sort()  # not necessary, but helps make tests more predictable
-        reduced = set()
         # indicates that self._testcase_root contains changes that haven't been yielded (if iteration ends,
         # changes would be lost)
         testcase_root_dirty = False
         while reduce_queue:
             LOG.debug("Reduce queue: %r", reduce_queue)
             file = reduce_queue.pop(0)
-            reduced.add(file)
             file_no += 1
-            LOG.info("Reducing %s (file %d/%d)", file, file_no, len(reduced) + len(reduce_queue))
+            LOG.info("Reducing %s (file %d/%d)", file, file_no, len(self._files_to_reduce))
             lithium_testcase = self.testcase_cls()  # pylint: disable=not-callable
             lithium_testcase.load(file)
             # pylint: disable=not-callable
@@ -357,45 +327,43 @@ def __iter__(self):
             for reduction in self._current_reducer:
                 reduction.dump()
                 testcases = TestCase.load(str(self._testcase_root), False)
-                ts_in_order = [testcase.timestamp for testcase in testcases]
                 LOG.info(self._current_reducer.description)
                 yield testcases
                 if self._current_feedback:
                     testcase_root_dirty = False
                 if self._current_feedback and self._current_served is not None:
-                    # check whether any files went unserved, and purge them
-                    served_paths = self._served_to_testcase_root_path(ts_in_order)
-                    files_in_play = set(reduce_queue) | reduced
-                    to_remove = files_in_play - served_paths
-                    current_reduction_invalid = False
-                    if to_remove:
-                        LOG.debug("files being reduced before: %r", list(files_in_play))
-                        for entry in to_remove:
-                            LOG.info("Testcase at %s was unserved, removing.",
-                                     entry.relative_to(self._testcase_root))
-                            files_in_play.remove(entry)
-                            current_reduction_invalid = current_reduction_invalid or file == entry
-                            entry.unlink()
-                            testcase_root_dirty = True
-                        # we've removed some files, now check if any whole folders
-                        # are unnecessary
-                        for root, target in self._targets_by_path():
-                            if root / target not in files_in_play:
-                                LOG.warning("target in %s is missing, directory will be removed",
-                                            root.relative_to(self._testcase_root))
-                                for entry in root.glob("**/*"):
-                                    LOG.debug(entry)
-                                    if not entry.is_file() or entry.name in {"test_info.json", "prefs.js"}:
-                                        continue
-                                    LOG.info("Removing unserved %s", entry.relative_to(self._testcase_root))
-                                    files_in_play.remove(entry)
-                                    current_reduction_invalid = current_reduction_invalid or file == entry
-                                rmtree(str(root))
-                                testcase_root_dirty = True
-                        LOG.debug("files being reduced after: %r", list(files_in_play))
-                        reduce_queue = list(sorted(files_in_play - reduced))
-                        reduced &= files_in_play
-                    if current_reduction_invalid:
+                    testcases = TestCase.load(str(self._testcase_root), False)
+                    try:
+                        LOG.debug("purging from %d testcases", len(testcases))
+                        while len(self._current_served) < len(testcases):
+                            LOG.debug("not all %d testcases served (%d served), popping one", len(testcases),
+                                      len(self._current_served))
+                            testcases.pop().cleanup()
+                        remove_testcases = []
+                        for idx, (testcase, served) in enumerate(zip(testcases, self._current_served)):
+                            LOG.debug("testcase %d served %r", idx, served)
+                            if testcase.landing_page not in served:
+                                LOG.debug("landing page %r not served", testcase.landing_page)
+                                remove_testcases.append(idx)
+                            else:
+                                testcase.purge_optional(served)
+                        for idx in reversed(remove_testcases):
+                            testcases.pop(idx).cleanup()
+                        rmtree(str(self._testcase_root))
+                        self._testcase_root.mkdir()
+                        self.dump_testcases(testcases)
+                        num_files_before = len(self._files_to_reduce)
+                        LOG.debug("files being reduced before: %r", self._files_to_reduce)
+                        self.rescan_files_to_reduce()
+                        LOG.debug("files being reduced after: %r", self._files_to_reduce)
+                    finally:
+                        for testcase in testcases:
+                            testcase.cleanup()
+                    files_to_reduce = set(self._files_to_reduce)
+                    reduce_queue = list(sorted(set(reduce_queue) & files_to_reduce))
+                    testcase_root_dirty = len(self._files_to_reduce) != num_files_before
+                    if file not in files_to_reduce:
+                        # current reduction was for a purged file
                         break
             else:
                 # write out the best found testcase

From f1d7072a8c3726a06483402dd62ffba190aae9a7 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 19 Oct 2020 11:50:08 -0400
Subject: [PATCH 067/531] [reduce] Fix tests for python < 3.8.

---
 grizzly/reduce/core.py            |  6 ++++--
 grizzly/reduce/test_main.py       |  4 ++--
 grizzly/reduce/test_reduce.py     | 20 +++++++++-----------
 grizzly/reduce/test_strategies.py |  7 +++----
 4 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 9922236f..00445e7f 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -84,7 +84,9 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path, tool
         self.target = target
         self.testcases = testcases
         self._any_crash = any_crash
-        self._log_path = log_path
+        # only coerce `log_path` to `Path` if it's a string
+        # this caution is only necessary in python3.5 where pytest uses pathlib2 rather than pathlib
+        self._log_path = Path(log_path) if isinstance(log_path, str) else log_path
         # these parameters may be overwritten during analysis, so keep a copy of them
         self._original_relaunch = target.relaunch
         self._original_use_harness = use_harness
@@ -302,7 +304,7 @@ def report(self, results, tests):
             else:
                 report_dir = "reports" if result.expected else "other_reports"
                 reporter = FilesystemReporter(
-                    report_path=str(Path(self._log_path) / report_dir),
+                    report_path=str(self._log_path / report_dir),
                     major_bucket=False)
             # clone the tests so we can safely call purge_optional here for each report
             # (report.served may be different for non-expected or any-crash results)
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index a97f8c72..7ff3d4ec 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -139,5 +139,5 @@ def test_testcase_prefs(mocker, tmp_path, result):
         ReduceManager.main(args)
         assert Path(load_target.return_value.return_value.prefs).read_text() == result
     finally:
-        for call in rmtree_mock.call_args_list:
-            rmtree(*call.args, **call.kwargs)
+        for rm_args, rm_kwds in rmtree_mock.call_args_list:
+            rmtree(*rm_args, **rm_kwds)
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index a8fd0463..3c4080a1 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -9,7 +9,6 @@
 from collections import namedtuple
 import functools
 from logging import getLogger
-from pathlib import Path
 
 import pytest
 from pytest import raises
@@ -27,9 +26,9 @@
 
 def _fake_save_logs_foo(result_logs, meta=False):  # pylint: disable=unused-argument
     """write fake log data to disk"""
-    (Path(result_logs) / "log_stderr.txt").write_text("STDERR log\n")
-    (Path(result_logs) / "log_stdout.txt").write_text("STDOUT log\n")
-    (Path(result_logs) / "log_asan_blah.txt").write_text(
+    (result_logs / "log_stderr.txt").write_text("STDERR log\n")
+    (result_logs / "log_stdout.txt").write_text("STDOUT log\n")
+    (result_logs / "log_asan_blah.txt").write_text(
         "==1==ERROR: AddressSanitizer: "
         "SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n"
         "    #0 0xbad000 in foo /file1.c:123:234\n"
@@ -39,9 +38,9 @@ def _fake_save_logs_foo(result_logs, meta=False):  # pylint: disable=unused-argu
 
 def _fake_save_logs_bar(result_logs, meta=False):  # pylint: disable=unused-argument
     """write fake log data to disk"""
-    (Path(result_logs) / "log_stderr.txt").write_text("STDERR log\n")
-    (Path(result_logs) / "log_stdout.txt").write_text("STDOUT log\n")
-    (Path(result_logs) / "log_asan_blah.txt").write_text(
+    (result_logs / "log_stderr.txt").write_text("STDERR log\n")
+    (result_logs / "log_stdout.txt").write_text("STDOUT log\n")
+    (result_logs / "log_asan_blah.txt").write_text(
         "==1==ERROR: AddressSanitizer: "
         "SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n"
         "    #0 0xbad000 in bar /file1.c:123:234\n"
@@ -364,16 +363,15 @@ def replay_run(_, **_kw):
             test.cleanup()
 
     assert reporter.return_value.submit.call_count == 1
-    report_args = reporter.return_value.submit.call_args.args
+    report_args, report_kwds = reporter.return_value.submit.call_args
     assert len(report_args) == 1
     assert isinstance(report_args[0], list)
     assert len(report_args[0]) == 1
     assert isinstance(report_args[0][0], TestCase)
-    report_kwds = reporter.return_value.submit.call_args.kwargs
     assert report_kwds.keys() == {"report"}
     assert update_coll.call_count == 1
     assert update_coll.return_value.patch.call_count == 1
-    assert update_coll.return_value.patch.call_args.kwargs == {
+    assert update_coll.return_value.patch.call_args[1] == {
         "data": {"testcase_quality": reporter.QUAL_REDUCED_RESULT},
     }
 
@@ -404,7 +402,7 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
         mgr.run()
     if exc_type is TargetLaunchError:
         assert report_fcn.call_count == 1
-        _mgr, reports, reported_testcases = report_fcn.call_args.args
+        _mgr, reports, reported_testcases = report_fcn.call_args[0]
         if use_analysis:
             assert reported_testcases == testcases
         else:
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 3af587d6..ffe5ea19 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -8,7 +8,6 @@
 """
 from collections import namedtuple
 from logging import getLogger
-from pathlib import Path
 
 import pytest
 from pytest import raises
@@ -28,9 +27,9 @@
 
 def _fake_save_logs_foo(result_logs):
     """write fake log data to disk"""
-    (Path(result_logs) / "log_stderr.txt").write_text("STDERR log\n")
-    (Path(result_logs) / "log_stdout.txt").write_text("STDOUT log\n")
-    (Path(result_logs) / "log_asan_blah.txt").write_text(
+    (result_logs / "log_stderr.txt").write_text("STDERR log\n")
+    (result_logs / "log_stdout.txt").write_text("STDOUT log\n")
+    (result_logs / "log_asan_blah.txt").write_text(
         "==1==ERROR: AddressSanitizer: "
         "SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n"
         "    #0 0xbad000 in foo /file1.c:123:234\n"

From b60c143ee6600a2efe030f3fefdc3474460a472d Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 19 Oct 2020 11:56:35 -0400
Subject: [PATCH 068/531] [reduce] Save intermediate reduction if Ctrl+C is
 given.

---
 grizzly/reduce/core.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 00445e7f..3e761bb6 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -280,6 +280,11 @@ def run(self, repeat=1, min_results=1):
                             for result in results:
                                 result.report.cleanup()
                     last_reports = self.report(best_results, self.testcases)
+                except KeyboardInterrupt:
+                    if best_results:
+                        last_reports = self.report(best_results, self.testcases)
+                        LOG.warning("Ctrl+C detected, best reduction so far reported as %r", last_reports)
+                    raise
                 finally:
                     for result in best_results:
                         result.report.cleanup()

From 46a9c63c4001e963f2644c89789e5b1fa8746d66 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 19 Oct 2020 21:25:34 -0400
Subject: [PATCH 069/531] [reduce] Factor out purge unserved code to share
 between lithium strategies and "list" strategy.

---
 grizzly/reduce/core.py            |   4 +-
 grizzly/reduce/strategies.py      | 128 ++++++++++++++++--------------
 grizzly/reduce/test_strategies.py |  10 +++
 3 files changed, 82 insertions(+), 60 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 3e761bb6..6c268f83 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -315,8 +315,8 @@ def report(self, results, tests):
             # (report.served may be different for non-expected or any-crash results)
             clones = [test.clone() for test in tests]
             try:
-                for clone, served in zip(clones, result.served):
-                    if served is not None:
+                if result.served is not None:
+                    for clone, served in zip(clones, result.served):
                         clone.purge_optional(served)
                 ret_values.append(reporter.submit(clones, report=result.report))
             finally:
diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index 912379e6..dae163ee 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -84,7 +84,19 @@ def __init__(self, testcases):
         self._testcase_root = Path(mkdtemp(prefix="tc_", dir=grz_tmp("reduce")))
         self.dump_testcases(testcases)
 
-    def dump_testcases(self, testcases):
+    def dump_testcases(self, testcases, recreate_tcroot=False):
+        """Dump a testcase list to testcase root on disk.
+
+        Arguments:
+            testcases (list(grizzly.common.storage.TestCase)): list of testcases to dump
+            recreate_tcroot (bool): if True, delete testcase root and recreate it before dumping
+
+        Returns:
+            None
+        """
+        if recreate_tcroot:
+            rmtree(str(self._testcase_root))
+            self._testcase_root.mkdir()
         for idx, testcase in enumerate(testcases):
             LOG.debug("Extracting testcase %d/%d", idx + 1, len(testcases))
             testpath = self._testcase_root / ("%03d" % (idx,))
@@ -111,6 +123,40 @@ def __exit__(self, *args, **kwds):
     def cleanup(self):
         rmtree(str(self._testcase_root))
 
+    def purge_unserved(self, testcases, served):
+        """Given the testcase list yielded and list of what was served, purge
+        everything in testcase root to hold only what was served.
+
+        Arguments:
+            testcases (list(grizzly.common.storage.TestCase): testcases last replayed
+            served (list(list(str))): list of files served for each testcase.
+
+        Returns:
+            bool: True if anything was purged
+        """
+        LOG.debug("purging from %d testcases", len(testcases))
+        anything_purged = False
+        while len(served) < len(testcases):
+            LOG.debug("not all %d testcases served (%d served), popping one", len(testcases),
+                      len(served))
+            testcases.pop().cleanup()
+            anything_purged = True
+        remove_testcases = []
+        for idx, (testcase, served) in enumerate(zip(testcases, served)):
+            LOG.debug("testcase %d served %r", idx, served)
+            if testcase.landing_page not in served:
+                LOG.debug("landing page %r not served", testcase.landing_page)
+                remove_testcases.append(idx)
+                anything_purged = True
+            else:
+                size_before = testcase.data_size
+                testcase.purge_optional(served)
+                anything_purged = anything_purged or testcase.data_size != size_before
+        for idx in reversed(remove_testcases):
+            testcases.pop(idx).cleanup()
+        self.dump_testcases(testcases, recreate_tcroot=True)
+        return anything_purged
+
 
 class _BeautifyStrategy(Strategy, ABC):
     """Implementors must define these class attributes:
@@ -334,31 +380,14 @@ def __iter__(self):
                 if self._current_feedback and self._current_served is not None:
                     testcases = TestCase.load(str(self._testcase_root), False)
                     try:
-                        LOG.debug("purging from %d testcases", len(testcases))
-                        while len(self._current_served) < len(testcases):
-                            LOG.debug("not all %d testcases served (%d served), popping one", len(testcases),
-                                      len(self._current_served))
-                            testcases.pop().cleanup()
-                        remove_testcases = []
-                        for idx, (testcase, served) in enumerate(zip(testcases, self._current_served)):
-                            LOG.debug("testcase %d served %r", idx, served)
-                            if testcase.landing_page not in served:
-                                LOG.debug("landing page %r not served", testcase.landing_page)
-                                remove_testcases.append(idx)
-                            else:
-                                testcase.purge_optional(served)
-                        for idx in reversed(remove_testcases):
-                            testcases.pop(idx).cleanup()
-                        rmtree(str(self._testcase_root))
-                        self._testcase_root.mkdir()
-                        self.dump_testcases(testcases)
-                        num_files_before = len(self._files_to_reduce)
-                        LOG.debug("files being reduced before: %r", self._files_to_reduce)
-                        self.rescan_files_to_reduce()
-                        LOG.debug("files being reduced after: %r", self._files_to_reduce)
+                        self.purge_unserved(testcases, self._current_served)
                     finally:
                         for testcase in testcases:
                             testcase.cleanup()
+                    num_files_before = len(self._files_to_reduce)
+                    LOG.debug("files being reduced before: %r", self._files_to_reduce)
+                    self.rescan_files_to_reduce()
+                    LOG.debug("files being reduced after: %r", self._files_to_reduce)
                     files_to_reduce = set(self._files_to_reduce)
                     reduce_queue = list(sorted(set(reduce_queue) & files_to_reduce))
                     testcase_root_dirty = len(self._files_to_reduce) != num_files_before
@@ -474,13 +503,13 @@ class MinimizeTestcaseList(Strategy):
     def __init__(self, *args, **kwds):
         super().__init__(*args, **kwds)
         self._current_feedback = None
-        self._last_served = None
+        self._current_served = None
 
     def update(self, success, served=None):
         assert self._current_feedback is None
-        assert self._last_served is None
+        assert self._current_served is None
         self._current_feedback = success
-        self._last_served = served
+        self._current_served = served
 
     def __iter__(self):
         assert self._current_feedback is None
@@ -503,54 +532,37 @@ def __iter__(self):
                 if testcases is None:
                     testcases = TestCase.load(str(self._testcase_root), False)
                     assert n_testcases == len(testcases)
-                removed_ts = testcases[idx].timestamp
                 testcases.pop(idx).cleanup()
-                ts_in_order = [testcase.timestamp for testcase in testcases]
                 yield testcases
                 testcases = None  # caller owns testcases now
                 assert self._current_feedback is not None, "no feedback received!"
+
                 if self._current_feedback:
                     testcase_root_dirty = False
-                    # removal was success! find the testcase that matches timestamp,
-                    # and remove it
                     LOG.info("Removing testcase %d/%d was successful!", idx + 1, n_testcases)
-                    removed_path = None
-                    unserved_paths = []
-                    for test_info in self._testcase_root.glob("*/test_info.json"):
-                        info = json.loads(test_info.read_text())
-                        if removed_ts == info["timestamp"]:
-                            assert (
-                                removed_path is None
-                            ), "Duplicate testcases found with timestamp %s" % (
-                                removed_ts,
-                            )
-                            removed_path = test_info.parent
-                        elif self._last_served is not None:
-                            test_idx = ts_in_order.index(info["timestamp"])
-                            if test_idx >= len(self._last_served) or \
-                                    info["target"] not in self._last_served[test_idx]:
-                                LOG.info("Testcase at %s was unserved, removing.",
-                                         test_info.parent.relative_to(self._testcase_root))
-                                unserved_paths.append(test_info.parent)
-                    assert (
-                        removed_path is not None
-                    ), "No testcase found with timestamp %s" % (removed_ts,)
-                    rmtree(str(removed_path))
-                    for unserved in unserved_paths:
-                        rmtree(str(unserved))
-                        testcase_root_dirty = True
-                    n_testcases -= 1 + len(unserved_paths)
+                    testcases = TestCase.load(str(self._testcase_root), False)
+                    try:
+                        # remove the actual testcase we were reducing
+                        testcases.pop(idx).cleanup()
+                        if testcases and self._current_served is not None:
+                            testcase_root_dirty = self.purge_unserved(testcases, self._current_served)
+                        else:
+                            self.dump_testcases(testcases, recreate_tcroot=True)
+                    finally:
+                        for testcase in testcases:
+                            testcase.cleanup()
+                    testcases = TestCase.load(str(self._testcase_root), False)
+                    n_testcases = len(testcases)
                 else:
                     LOG.info("No result without testcase %d/%d", idx + 1, n_testcases)
                     idx += 1
                 # reset
                 self._current_feedback = None
-                self._last_served = None
+                self._current_served = None
             if testcase_root_dirty:
                 # purging unserved files enabled us to exit early from the loop.
                 # need to yield once more to set this trimmed version to the current best in ReduceManager
                 testcases = TestCase.load(str(self._testcase_root), False)
-                assert n_testcases == len(testcases)
                 LOG.info("final iteration triggered by purge_optional")
                 yield testcases
                 testcases = None  # caller owns testcases now
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index ffe5ea19..29f675de 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -472,6 +472,16 @@ def replay_run(testcases, **_):
             expected_num_reports=2,
             purging_breaks=False,
         ),
+        # triple test, list strategy. None for served still eliminates first two tests
+        PurgeUnservedTestParams(
+            strategies=["list"],
+            test_data=[{"test.html": "123"}, {"test.html": "456"}, {"test.html": "789"}],
+            served=[None, None, None],
+            expected_results={"789"},
+            expected_run_calls=2,
+            expected_num_reports=2,
+            purging_breaks=False,
+        ),
     ]
 )
 def test_purge_unserved(mocker, tmp_path, strategies, test_data, served, expected_results, expected_run_calls,

From 69fe4c80290b812c97605fb8edcaef9280f4bea0 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Tue, 20 Oct 2020 16:34:11 -0400
Subject: [PATCH 070/531] [reduce] Add docstrings to all files.

Reformat everything to 88 columns to make transition to black easier.
---
 .pylintrc                         |   1 +
 grizzly/reduce/__init__.py        |   2 +
 grizzly/reduce/__main__.py        |   3 +
 grizzly/reduce/args.py            |  16 ++
 grizzly/reduce/conftest.py        |   9 +-
 grizzly/reduce/core.py            | 238 ++++++++++++++-----
 grizzly/reduce/strategies.py      | 379 +++++++++++++++++++++++++-----
 grizzly/reduce/test_main.py       |  26 +-
 grizzly/reduce/test_reduce.py     |  84 ++++---
 grizzly/reduce/test_strategies.py | 209 ++++++++++------
 10 files changed, 721 insertions(+), 246 deletions(-)

diff --git a/.pylintrc b/.pylintrc
index f20c1ccb..f0ff07d9 100644
--- a/.pylintrc
+++ b/.pylintrc
@@ -16,3 +16,4 @@ disable=
 
 [FORMAT]
 max-line-length=110
+const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__)|pytestmark)$
diff --git a/grizzly/reduce/__init__.py b/grizzly/reduce/__init__.py
index dde176a2..87f67339 100644
--- a/grizzly/reduce/__init__.py
+++ b/grizzly/reduce/__init__.py
@@ -2,6 +2,8 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Grizzly reducer module.
+"""
 
 __all__ = ("ReduceManager", "ReduceArgs")
 
diff --git a/grizzly/reduce/__main__.py b/grizzly/reduce/__main__.py
index 6c2ca1d3..cf65162b 100644
--- a/grizzly/reduce/__main__.py
+++ b/grizzly/reduce/__main__.py
@@ -2,6 +2,9 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Grizzly reducer CLI.
+"""
+
 import sys
 
 from .args import ReduceArgs
diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index e400397a..1b02d94a 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -2,6 +2,8 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""CLI argument parsing for Grizzly reduction.
+"""
 from logging import getLogger
 from pathlib import Path
 
@@ -13,8 +15,14 @@
 
 
 class ReduceArgs(ReplayArgs):
+    """Argument parser for `grizzly.reduce`.
+
+    Takes all arguments defined for `grizzly.replay`, and a few specific to reduction.
+    """
 
     def __init__(self):
+        """Initialize argument parser.
+        """
         super().__init__()
 
         # these arguments have other defaults vs how they are defined in ReplayArgs
@@ -37,6 +45,14 @@ def __init__(self):
             % (" ".join(sorted(STRATEGIES)), " ".join(DEFAULT_STRATEGIES)))
 
     def sanity_check(self, args):
+        """Sanity check reducer args.
+
+        Arguments:
+            args (argparse.Namespace): Result from `parse_args()`.
+
+        Raises:
+            SystemExit: on error, `ArgumentParser.error()` is called, which will exit.
+        """
         super().sanity_check(args)
 
         # if logs is specified, we need it to be a directory (whether existent or not)
diff --git a/grizzly/reduce/conftest.py b/grizzly/reduce/conftest.py
index f92f2533..990bf2ac 100644
--- a/grizzly/reduce/conftest.py
+++ b/grizzly/reduce/conftest.py
@@ -3,8 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
-"""
-common unit test fixtures for grizzly.reduce
+"""Common unit test fixtures for `grizzly.reduce`.
 """
 
 import pytest
@@ -13,7 +12,8 @@
 @pytest.fixture
 def tmp_path_fm_config(tmp_path, mocker):
     """Ensure fm config is always read from tmp_path so ~/.fuzzmanagerconf
-    can't be used by accident."""
+    can't be used by accident.
+    """
     mocker.patch(
         "grizzly.reduce.core.FuzzManagerReporter.FM_CONFIG",
         new=str(tmp_path / ".fuzzmanagerconf"),
@@ -23,6 +23,9 @@ def tmp_path_fm_config(tmp_path, mocker):
 
 @pytest.fixture
 def reporter_sequential_strftime(mocker):
+    """Make `strftime` in `FilesystemReporter` return sequential values.
+    This ensures ever report gets a unique folder and won't overwrite another.
+    """
     prefix = mocker.patch("grizzly.common.reporter.strftime")
 
     def report_prefix(_):
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 6c268f83..d3af4160 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -2,8 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-"""
-Given a build and testcase, try to reduce it using a set of strategies.
+"""`ReduceManager` finds the smallest testcase(s) to reproduce an issue.
 """
 from itertools import chain
 from logging import getLogger
@@ -33,16 +32,22 @@
 
 
 def change_quality(crash_id, quality):
-    """Update a FuzzManager crash entry quality.
+    """Update a FuzzManager crash entry quality (if the crash entry exists).
+
+    Missing crash entries are ignored with a warning.
 
     Args:
         crash_id (int): Crash ID on FuzzManager server
         quality (int): Quality constant defined in FuzzManagerReporter.QUAL_*
 
+    Raises:
+        RuntimeError: Error communicating with FuzzManager server.
+
     Returns:
         None
     """
-    LOG.info("Updating crash %d to quality %s", crash_id, FuzzManagerReporter.quality_name(quality))
+    LOG.info("Updating crash %d to quality %s", crash_id,
+             FuzzManagerReporter.quality_name(quality))
     coll = Collector()
 
     url = "%s://%s:%d/crashmanager/rest/crashes/%d/" \
@@ -58,26 +63,60 @@ def change_quality(crash_id, quality):
 
 
 class ReduceManager(object):
+    """Manage reduction of one or more testcases to find the smallest testcase
+    that reproduces a given issue.
+
+    Attributes:
+        ignore (list(str)): Classes of results to ignore (see `--ignore`).
+        server (sapphire.Sapphire): Server instance to serve testcases.
+        strategies (list(str)): List of strategies to use for reducing
+                                testcases (in order).
+        target (grizzly.target.Target): Target instance to run testcases.
+        testcases (list(grizzly.common.storage.TestCase)): List of one or more Grizzly
+                                                           testcases to reduce.
+    """
     ANALYSIS_ITERATIONS = 11  # number of iterations to analyze
     ANALYSIS_MIN_CRASHES = 2  # --min-crashes value when analysis is used
-    ANALYSIS_TARGET_PROBABILITY = 0.95  # probability that successful reduction will observe the crash
-    # to see the worst case, run the `repeat` calculation in run_reliability_analysis using
-    # crashes_percent = 1.0/ANALYSIS_ITERATIONS
+    # probability that successful reduction will observe the crash
+    ANALYSIS_TARGET_PROBABILITY = 0.95
+    # to see the worst case, run the `repeat` calculation in run_reliability_analysis
+    # using `crashes_percent = 1.0/ANALYSIS_ITERATIONS`
 
     IDLE_DELAY_MIN = 10
     IDLE_DELAY_DURATION_MULTIPLIER = 1.5
     ITER_TIMEOUT_MIN = 10
     ITER_TIMEOUT_DURATION_MULTIPLIER = 2
 
-    """
-    Args:
-        idle_delay (int): Number of seconds to wait before polling for idle.
-        idle_threshold (int): CPU usage threshold to mark the process as idle.
-    """
+    def __init__(self, ignore, server, target, testcases, strategies, log_path,
+                 tool=None, report_to_fuzzmanager=False, any_crash=False,
+                 signature=None, use_harness=True, use_analysis=True,
+                 static_timeout=False, idle_delay=0, idle_threshold=0):
+        """Initialize reduction manager. Many arguments are common with `ReplayManager`.
 
-    def __init__(self, ignore, server, target, testcases, strategies, log_path, tool=None,
-                 report_to_fuzzmanager=False, any_crash=False, signature=None, use_harness=True,
-                 use_analysis=True, static_timeout=False, idle_delay=0, idle_threshold=0):
+        Args:
+            ignore (list(str)): Value for `self.ignore` attribute.
+            server (sapphire.Sapphire): Value for `self.server` attribute.
+            target (grizzly.target.Target): Value for `self.target` attribute.
+            testcases (list(grizzly.common.storage.TestCase)):
+                Value for `self.testcases` attribute.
+            strategies (list(str)): Value for `self.strategies` attribute.
+            log_path (Path or str): Path to save results when reporting to filesystem.
+            tool (str or None): Override tool when reporting to FuzzManager.
+            report_to_fuzzmanager (bool): Report to FuzzManager rather than filesystem.
+            any_crash (bool): Accept any crash when reducing, not just those matching
+                              the specified or first observed signature.
+            signature (FTB.Signatures.CrashInfo.CrashSignature or None):
+                Signature for accepting crashes.
+            use_harness (bool): Whether to allow use of harness when navigating
+                                between testcases.
+            use_analysis (bool): Analyse reliability of testcase before running each
+                                 reduction strategy.
+            static_timeout (bool): Use only specified timeouts (`--timeout` and
+                                   `--idle-delay`), even if testcase appears to need
+                                   less time.
+            idle_delay (int): Number of seconds to wait before polling for idle.
+            idle_threshold (int): CPU usage threshold to mark the process as idle.
+        """
         self.ignore = ignore
         self.server = server
         self.strategies = strategies
@@ -85,7 +124,8 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path, tool
         self.testcases = testcases
         self._any_crash = any_crash
         # only coerce `log_path` to `Path` if it's a string
-        # this caution is only necessary in python3.5 where pytest uses pathlib2 rather than pathlib
+        # this caution is only necessary in python3.5 where pytest uses
+        # pathlib2 rather than pathlib
         self._log_path = Path(log_path) if isinstance(log_path, str) else log_path
         # these parameters may be overwritten during analysis, so keep a copy of them
         self._original_relaunch = target.relaunch
@@ -100,15 +140,35 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path, tool
         self._idle_threshold = idle_threshold
 
     def update_timeout(self, results):
-        if self._static_timeout or self._any_crash or getattr(self.target, "use_valgrind", False):
+        """Tune idle/server timeout values based on actual duration of expected results.
+
+        Expected durations will be updated if the actual duration is much lower.
+
+        Timeouts are not updated in three cases:
+
+            - `static_timeout=True` is passed to constructor (`--static-timeout`),
+            - `any_crash=True` is passed to constructor (`--any-crash`),
+            - Target is running under valgrind (`--valgrind`).
+
+        Arguments:
+            results (grizzly.replay.ReplayResult):
+                Observed results. Any given expected results may affect the idle delay
+                and sapphire timeout.
+
+        Returns:
+            None
+        """
+        if (self._static_timeout or self._any_crash or
+                getattr(self.target, "use_valgrind", False)):
             # the amount of time it can take to replay a test case can vary
             # when under Valgrind so do not update the timeout in that case
 
-            # when any_crash is given, crashes may be completely unrelated (all are expected), so
-            # lowering timeout or idle delay will only hide crashes
+            # when any_crash is given, crashes may be completely unrelated (all are
+            # expected), so lowering timeout or idle delay will only hide crashes
             return
 
-        durations = list(chain.from_iterable(result.durations for result in results if result.expected))
+        durations = list(chain.from_iterable(result.durations
+                                             for result in results if result.expected))
         if not durations:
             # no expected results
             return
@@ -116,27 +176,42 @@ def update_timeout(self, results):
 
         # If `run_time * multiplier` is less than idle poll delay, update it
         LOG.debug('Run time %r', run_time)
-        new_idle_delay = max(self.IDLE_DELAY_MIN, min(run_time * self.IDLE_DELAY_DURATION_MULTIPLIER,
-                                                      self._idle_delay))
+        new_idle_delay = max(self.IDLE_DELAY_MIN,
+                             min(run_time * self.IDLE_DELAY_DURATION_MULTIPLIER,
+                                 self._idle_delay))
         if new_idle_delay < self._idle_delay:
             LOG.info("Updating poll delay to: %r", new_idle_delay)
             self._idle_delay = new_idle_delay
         # If `run_time * multiplier` is less than iter_timeout, update it
         # in other words, decrease the timeout if this ran in less than half the timeout
-        new_iter_timeout = max(self.ITER_TIMEOUT_MIN, min(run_time * self.ITER_TIMEOUT_DURATION_MULTIPLIER,
-                                                          self.server.timeout))
+        new_iter_timeout = max(self.ITER_TIMEOUT_MIN,
+                               min(run_time * self.ITER_TIMEOUT_DURATION_MULTIPLIER,
+                                   self.server.timeout))
         if new_iter_timeout < self.server.timeout:
             LOG.info("Updating max timeout to: %r", new_iter_timeout)
             self.server.timeout = new_iter_timeout
 
     def run_reliability_analysis(self):
+        """Run several analysis passes of the current testcase to find `run` parameters.
+
+        The number of repetitions and minimum number of crashes are calculated to
+        maximize the chances of observing the expected crash.
+
+        Arguments:
+            None
+
+        Returns:
+            tuple(int, int): Values for `repeat` and `min_crashes` resulting from
+                             analysis.
+        """
         harness_crashes = 0
         non_harness_crashes = 0
 
         # Reset parameters.
-        # Use repeat=1 & relaunch=ITERATIONS because this is closer to how we will run post-analysis.
-        # We're only using repeat=1 instead of repeat=ITERATIONS so we can get feedback on every
-        #   call to interesting.
+        # Use repeat=1 & relaunch=ITERATIONS because this is closer to how we will run
+        #   post-analysis.
+        # We're only using repeat=1 instead of repeat=ITERATIONS so we can get feedback
+        #   on every call to interesting.
         self.target.relaunch = self.ANALYSIS_ITERATIONS
 
         for use_harness in [True, False]:
@@ -145,24 +220,31 @@ def run_reliability_analysis(self):
             if not use_harness and harness_crashes == self.ANALYSIS_ITERATIONS:
                 continue
 
-            with ReplayManager(self.ignore, self.server, self.target, any_crash=self._any_crash,
-                               signature=self._signature, use_harness=use_harness) as replay:
+            with ReplayManager(self.ignore, self.server, self.target,
+                               any_crash=self._any_crash, signature=self._signature,
+                               use_harness=use_harness) as replay:
                 LOG.info("Running for %d iterations to assess reliability %s harness.",
-                         self.ANALYSIS_ITERATIONS, "using" if use_harness else "without")
+                         self.ANALYSIS_ITERATIONS,
+                         "using" if use_harness else "without")
                 for _ in range(self.ANALYSIS_ITERATIONS):
                     try:
                         results = replay.run(self.testcases, repeat=1, min_results=1,
-                                             idle_delay=self._idle_delay, idle_threshold=self._idle_threshold)
+                                             idle_delay=self._idle_delay,
+                                             idle_threshold=self._idle_threshold)
                     except (TargetLaunchError, TargetLaunchTimeout) as exc:
                         if isinstance(exc, TargetLaunchError) and exc.report:
-                            self.report([ReplayResult(exc.report, None, [], False)], self.testcases)
+                            self.report([ReplayResult(exc.report, None, [], False)],
+                                        self.testcases)
                             exc.report.cleanup()
                         raise
                     self.update_timeout(results)
                     try:
                         success = any(result.expected for result in results)
-                        LOG.info("result: %s", "interesting." if success else "not interesting.")
-                        self.report([result for result in results if not result.expected], self.testcases)
+                        LOG.info("result: %s",
+                                 "interesting." if success else "not interesting.")
+                        self.report(
+                            [result for result in results if not result.expected],
+                            self.testcases)
                     finally:
                         for result in results:
                             result.report.cleanup()
@@ -171,7 +253,8 @@ def run_reliability_analysis(self):
                     elif success:
                         non_harness_crashes += 1
                 LOG.info("Testcase was interesting %0.1f%% of %d attempts %s harness.",
-                         100.0 * harness_crashes / self.ANALYSIS_ITERATIONS, self.ANALYSIS_ITERATIONS,
+                         100.0 * harness_crashes / self.ANALYSIS_ITERATIONS,
+                         self.ANALYSIS_ITERATIONS,
                          "using" if use_harness else "without")
                 # ensure same signature is always used
                 self._signature = replay.signature
@@ -183,17 +266,20 @@ def run_reliability_analysis(self):
         self._use_harness = non_harness_crashes <= harness_crashes
 
         # this is max 99.9% to avoid domain errors in the calculation below
-        crashes_percent = min(1.0 * max(non_harness_crashes, harness_crashes) / self.ANALYSIS_ITERATIONS,
-                              0.999)
+        crashes_percent = min(
+            1.0 * max(non_harness_crashes, harness_crashes) / self.ANALYSIS_ITERATIONS,
+            0.999)
 
         # adjust repeat/min-crashes depending on how reliable the testcase was
         min_crashes = self.ANALYSIS_MIN_CRASHES
-        repeat = int(ceil(log(1 - self.ANALYSIS_TARGET_PROBABILITY, 1 - crashes_percent))
-                     * self.ANALYSIS_MIN_CRASHES)
+        repeat = int(
+            ceil(log(1 - self.ANALYSIS_TARGET_PROBABILITY, 1 - crashes_percent))
+            * self.ANALYSIS_MIN_CRASHES)
 
         LOG.info("Analysis results:")
         if harness_crashes == self.ANALYSIS_ITERATIONS:
-            LOG.info("* testcase was perfectly reliable with the harness (--no-harness not assessed)")
+            LOG.info("* testcase was perfectly reliable with the harness (--no-harness "
+                     "not assessed)")
         elif harness_crashes == non_harness_crashes:
             LOG.info("* testcase was equally reliable with/without the harness")
         elif not self._original_use_harness:
@@ -212,19 +298,21 @@ def run(self, repeat=1, min_results=1):
                                be considered successful.
 
         Returns:
-            bool: Whether a crash was observed (whether or not reduction was successful).
+            bool: Whether a crash was observed (ie. reduction was successful).
         """
         any_success = False
         last_reports = None
         for strategy_no, strategy in enumerate(self.strategies):
-            LOG.info("Using strategy %s (%d/%d)", strategy, strategy_no + 1, len(self.strategies))
+            LOG.info("Using strategy %s (%d/%d)", strategy, strategy_no + 1,
+                     len(self.strategies))
             if self._use_analysis:
                 repeat, min_results = self.run_reliability_analysis()
             self.target.relaunch = min(self._original_relaunch, repeat)
             LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
                      repeat, min_results, self.target.relaunch)
-            replay = ReplayManager(self.ignore, self.server, self.target, any_crash=self._any_crash,
-                                   signature=self._signature, use_harness=self._use_harness)
+            replay = ReplayManager(self.ignore, self.server, self.target,
+                                   any_crash=self._any_crash, signature=self._signature,
+                                   use_harness=self._use_harness)
             strategy = STRATEGIES[strategy](self.testcases)
             with replay, strategy:
                 best_results = []
@@ -238,25 +326,33 @@ def run(self, repeat=1, min_results=1):
                         try:
                             try:
                                 # reduction is a new list of testcases to be replayed
-                                results = replay.run(reduction, repeat=repeat, min_results=min_results,
-                                                     idle_delay=self._idle_delay,
-                                                     idle_threshold=self._idle_threshold)
+                                results = replay.run(
+                                    reduction, repeat=repeat, min_results=min_results,
+                                    idle_delay=self._idle_delay,
+                                    idle_threshold=self._idle_threshold)
                             except (TargetLaunchError, TargetLaunchTimeout) as exc:
                                 if isinstance(exc, TargetLaunchError) and exc.report:
-                                    self.report([ReplayResult(exc.report, None, [], False)], reduction)
+                                    self.report(
+                                        [ReplayResult(exc.report, None, [], False)],
+                                        reduction)
                                     exc.report.cleanup()
                                 raise
                             self.update_timeout(results)
-                            # get the first expected result (if any), and update the strategy
-                            first_expected = next((report for report in results if report.expected), None)
+                            # get the first expected result (if any),
+                            #   and update the strategy
+                            first_expected = next((report for report in results
+                                                   if report.expected), None)
                             success = first_expected is not None
-                            served = first_expected.served if success and not self._any_crash else None
+                            served = None
+                            if success and not self._any_crash:
+                                served = first_expected.served
                             strategy.update(success, served=served)
                             if strategy.name == "check":
                                 if any_success and not success:
                                     raise RuntimeError("Reduction broke")
                             any_success = any_success or success
-                            # if the reduction reproduced, update self.testcases (new best)
+                            # if the reduction reproduced,
+                            #   update self.testcases (new best)
                             if success:
                                 LOG.info("Attempt succeeded")
                                 for testcase in self.testcases:
@@ -267,11 +363,14 @@ def run(self, repeat=1, min_results=1):
                                 for result in best_results:
                                     result.report.cleanup()
                                 # filter expected results out into `best_results`
-                                best_results = [result for result in results if result.expected]
-                                results = [result for result in results if not result.expected]
+                                best_results = [result for result in results
+                                                if result.expected]
+                                results = [result for result in results
+                                           if not result.expected]
                             else:
                                 LOG.info("Attempt failed")
-                            # if the reduction found other crashes, report those immediately
+                            # if the reduction found other crashes,
+                            #   report those immediately
                             self.report(results, reduction)
                         finally:  # noqa pylint: disable=bare-except
                             if not keep_reduction:
@@ -283,7 +382,8 @@ def run(self, repeat=1, min_results=1):
                 except KeyboardInterrupt:
                     if best_results:
                         last_reports = self.report(best_results, self.testcases)
-                        LOG.warning("Ctrl+C detected, best reduction so far reported as %r", last_reports)
+                        LOG.warning("Ctrl+C detected, best reduction so far reported "
+                                    "as %r", last_reports)
                     raise
                 finally:
                     for result in best_results:
@@ -297,8 +397,17 @@ def run(self, repeat=1, min_results=1):
                 change_quality(crash_id, FuzzManagerReporter.QUAL_REDUCED_RESULT)
         return any_success
 
-    def report(self, results, tests):
-        """Report results, either to fuzzmanager or to filesystem.
+    def report(self, results, testcases):
+        """Report results, either to FuzzManager or to filesystem.
+
+        Arguments:
+            results (list(grizzly.replay.ReplayResult)):
+                Results observed during reduction.
+            testcases (list(grizzly.common.storage.TestCase)):
+                Testcases used to trigger results.
+
+        Returns:
+            list(*): List of return values from `reporter.submit()`.
         """
         ret_values = []
         for result in results:
@@ -313,7 +422,7 @@ def report(self, results, tests):
                     major_bucket=False)
             # clone the tests so we can safely call purge_optional here for each report
             # (report.served may be different for non-expected or any-crash results)
-            clones = [test.clone() for test in tests]
+            clones = [test.clone() for test in testcases]
             try:
                 if result.served is not None:
                     for clone, served in zip(clones, result.served):
@@ -326,6 +435,14 @@ def report(self, results, tests):
 
     @classmethod
     def main(cls, args):
+        """CLI for `grizzly.replay`.
+
+        Arguments:
+            args (argparse.Namespace): Result from `ReduceArgs.parse_args`.
+
+        Returns:
+            int: 0 for success. non-0 indicates a problem.
+        """
         configure_logging(args.log_level)
         if args.fuzzmanager:
             FuzzManagerReporter.sanity_check(args.binary)
@@ -384,7 +501,8 @@ def main(cls, args):
                 for testcase in testcases:
                     prefs_tf = testcase.get_file("prefs.js")
                     if prefs_tf:
-                        tmp_prefs = Path(mkdtemp(prefix="prefs_", dir=grz_tmp("replay")))
+                        tmp_prefs = Path(mkdtemp(prefix="prefs_",
+                                                 dir=grz_tmp("replay")))
                         prefs_tf.dump(str(tmp_prefs))
                         LOG.info("Using prefs.js from testcase")
                         target.prefs = str(tmp_prefs / "prefs.js")
diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index dae163ee..5c3bf9c5 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -2,11 +2,21 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-"""
-Grizzly Reducer strategy definitions
+"""Grizzly reducer strategy definitions.
+
+Each class defined here is an iterator yielding *potential* reductions. The caller
+should evaluate each set of testcases, and keep the best one. The caller is responsible
+for cleaning up all testcases that are yielded.
+
+Constants:
+    DEFAULT_STRATEGIES (list(str)): List of strategy names run by default if none are
+                                    specified.
+    STRATEGIES (dict{str: Strategy}): Mapping of available strategy names to
+                                      implementing class.
+    HAVE_CSSBEAUTIFIER (bool): True if `cssbeautifier` module is available.
+    HAVE_JSBEAUTIFIER (bool): True if `jsbeautifier` module is available.
 """
 from abc import ABC, abstractmethod
-import json
 from logging import getLogger
 from pathlib import Path
 import re
@@ -14,9 +24,10 @@
 from tempfile import mkdtemp
 from types import MappingProxyType
 
-from lithium.strategies import CheckOnly, CollapseEmptyBraces as LithCollapseEmptyBraces, Minimize, \
-    Strategy as LithStrategy
-from lithium.testcases import TestcaseChar, TestcaseJsStr, TestcaseLine, Testcase as LithTestcase
+from lithium.strategies import CheckOnly, \
+    CollapseEmptyBraces as LithCollapseEmptyBraces, Minimize, Strategy as LithStrategy
+from lithium.testcases import TestcaseChar, TestcaseJsStr, TestcaseLine, \
+    Testcase as LithTestcase
 from pkg_resources import iter_entry_points
 
 from ..common.utils import grz_tmp
@@ -48,12 +59,15 @@
 
 def _load_strategies():
     """STRATEGIES is created at the end of this file.
+
+    Returns:
+        mapping: A mapping of strategy names to strategy class.
     """
     strategies = {}
     for entry_point in iter_entry_points("grizzly_reduce_strategies"):
         try:
             strategy_cls = entry_point.load()
-            strategy_cls.sanity_check_impl()
+            strategy_cls.sanity_check_cls_attrs()
             assert (
                 strategy_cls.name == entry_point.name
             ), "entry_point name mismatch, check setup.py and %s.name" % (
@@ -73,23 +87,34 @@ def _load_strategies():
 
 
 class Strategy(ABC):
-    """Implementors must define these class attributes:
+    """A strategy is a procedure for repeatedly running a testcase to find the smallest
+    equivalent test.
 
-    Attributes:
+    Implementors must define these class attributes:
+
+    Class Attributes:
         name (str): The strategy name.
     """
     name = None
 
     def __init__(self, testcases):
+        """Initialize strategy instance.
+
+        Arguments:
+            testcases (list(grizzly.common.storage.TestCase)):
+                List of testcases to reduce. The object does not take ownership of the
+                testcases.
+        """
         self._testcase_root = Path(mkdtemp(prefix="tc_", dir=grz_tmp("reduce")))
         self.dump_testcases(testcases)
 
     def dump_testcases(self, testcases, recreate_tcroot=False):
-        """Dump a testcase list to testcase root on disk.
+        """Dump a testcase list to the testcase root on disk.
 
         Arguments:
             testcases (list(grizzly.common.storage.TestCase)): list of testcases to dump
-            recreate_tcroot (bool): if True, delete testcase root and recreate it before dumping
+            recreate_tcroot (bool): if True, delete testcase root and recreate it before
+                                    dumping
 
         Returns:
             None
@@ -103,24 +128,72 @@ def dump_testcases(self, testcases, recreate_tcroot=False):
             testcase.dump(str(testpath), include_details=True)
 
     @classmethod
-    def sanity_check_impl(cls):
+    def sanity_check_cls_attrs(cls):
+        """Sanity check the strategy class implementation.
+
+        This should assert that any required class attributes are defined and correct.
+
+        Raises:
+            AssertionError: Any required class attributes are missing or wrong type.
+
+        Returns:
+            None
+        """
         assert isinstance(cls.name, str)
 
     @abstractmethod
     def __iter__(self):
-        pass
+        """Iterate over potential reductions of testcases according to this strategy.
+
+        The caller should evaluate each reduction yielded, and call `update` with the
+        result. The caller owns the testcases yielded, and should call `cleanup` for
+        each.
+
+        Yields:
+            list(grizzly.common.storage.TestCase): list of testcases with reduction
+                                                   applied
+        """
 
     @abstractmethod
     def update(self, success, served=None):
-        pass
+        """Inform the strategy whether or not the last reduction yielded was good.
+
+        Arguments:
+            success (bool): Whether or not the last reduction was acceptable.
+            served (list(list(str))): The list of served files for each testcase in the
+                                      last reduction.
+
+        Returns:
+            None
+        """
 
     def __enter__(self):
+        """Enter a runtime context that will automatically call `cleanup` on exit.
+
+        Returns:
+            Strategy: self
+        """
         return self
 
-    def __exit__(self, *args, **kwds):
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit the runtime context. `cleanup` is called.
+
+        Arguments:
+            exc_type (type or None): Type of exception object currently raised.
+            exc_val (Exception or None): Exception object currently raised.
+            exc_tb (traceback or None): Traceback for currently raised exception.
+
+        Returns:
+            None
+        """
         self.cleanup()
 
     def cleanup(self):
+        """Destroy all resources held by the strategy.
+
+        Returns:
+            None
+        """
         rmtree(str(self._testcase_root))
 
     def purge_unserved(self, testcases, served):
@@ -137,20 +210,20 @@ def purge_unserved(self, testcases, served):
         LOG.debug("purging from %d testcases", len(testcases))
         anything_purged = False
         while len(served) < len(testcases):
-            LOG.debug("not all %d testcases served (%d served), popping one", len(testcases),
-                      len(served))
+            LOG.debug("not all %d testcases served (%d served), popping one",
+                      len(testcases), len(served))
             testcases.pop().cleanup()
             anything_purged = True
         remove_testcases = []
-        for idx, (testcase, served) in enumerate(zip(testcases, served)):
-            LOG.debug("testcase %d served %r", idx, served)
-            if testcase.landing_page not in served:
+        for idx, (testcase, tc_served) in enumerate(zip(testcases, served)):
+            LOG.debug("testcase %d served %r", idx, tc_served)
+            if testcase.landing_page not in tc_served:
                 LOG.debug("landing page %r not served", testcase.landing_page)
                 remove_testcases.append(idx)
                 anything_purged = True
             else:
                 size_before = testcase.data_size
-                testcase.purge_optional(served)
+                testcase.purge_optional(tc_served)
                 anything_purged = anything_purged or testcase.data_size != size_before
         for idx in reversed(remove_testcases):
             testcases.pop(idx).cleanup()
@@ -159,12 +232,15 @@ def purge_unserved(self, testcases, served):
 
 
 class _BeautifyStrategy(Strategy, ABC):
-    """Implementors must define these class attributes:
+    """A strategy that beautifies code in the testcase to make it more reducible.
+
+    Implementors must define these class attributes:
 
-    Attributes:
+    Class attributes:
         all_extensions (set(str)): Set of all file extensions to beautify.
         import_available (bool): Whether or not the beautify module was imported.
-        import_name (str): The name of the beautify module imported (for error reporting).
+        import_name (str): The name of the beautify module imported (for error
+                           reporting).
         name (str): The strategy name.
         native_extension (str): The native file extension for this type.
         tag_name (str): Tag name to search for in other (non-native) extensions.
@@ -176,8 +252,15 @@ class _BeautifyStrategy(Strategy, ABC):
     native_extension = None
     tag_name = None
 
-    def __init__(self, *args, **kwds):
-        super().__init__(*args, **kwds)
+    def __init__(self, testcases):
+        """Initialize beautification strategy instance.
+
+        Arguments:
+            testcases (list(grizzly.common.storage.TestCase)):
+                List of testcases to reduce. The object does not take ownership of the
+                testcases.
+        """
+        super().__init__(testcases)
         self._files_to_beautify = []
         for path in self._testcase_root.glob("**/*"):
             if (path.is_file() and path.suffix in self.all_extensions
@@ -185,12 +268,22 @@ def __init__(self, *args, **kwds):
                 self._files_to_beautify.append(path)
         self._current_feedback = None
         tag_bytes = self.tag_name.encode("ascii")
-        self._re_tag_start = re.compile(br"<\s*" + tag_bytes + br".*?>", flags=re.DOTALL | re.IGNORECASE)
-        self._re_tag_end = re.compile(br"</\s*" + tag_bytes + br"\s*>", flags=re.IGNORECASE)
+        self._re_tag_start = re.compile(br"<\s*" + tag_bytes + br".*?>",
+                                        flags=re.DOTALL | re.IGNORECASE)
+        self._re_tag_end = re.compile(br"</\s*" + tag_bytes + br"\s*>",
+                                      flags=re.IGNORECASE)
 
     @classmethod
-    def sanity_check_impl(cls):
-        super().sanity_check_impl()
+    def sanity_check_cls_attrs(cls):
+        """Sanity check the strategy class implementation.
+
+        Raises:
+            AssertionError: Required class attributes are missing or wrong type.
+
+        Returns:
+            None
+        """
+        super().sanity_check_cls_attrs()
         assert isinstance(cls.all_extensions, set)
         assert all(isinstance(ext, str) for ext in cls.all_extensions)
         assert isinstance(cls.import_available, bool)
@@ -199,22 +292,39 @@ def sanity_check_impl(cls):
         assert isinstance(cls.tag_name, str)
 
     def update(self, success, served=None):
-        # beautify does nothing with served. it's unlikely a beautify operation alone would
-        # render a file unserved.
+        """Inform the strategy whether or not the last beautification yielded was good.
+
+        Arguments:
+            success (bool): Whether or not the last beautification was acceptable.
+            served (list(list(str))): The list of served files for each testcase in the
+                                      last beautification.
+
+        Returns:
+            None
+        """
+        # beautify does nothing with served. it's unlikely a beautify operation alone
+        # would render a file unserved.
         assert self._current_feedback is None
         self._current_feedback = success
 
     @classmethod
     @abstractmethod
     def beautify_bytes(cls, data):
-        pass
+        """Perform beautification on a code buffer.
+
+        Arguments:
+            data (bytes): The code data to be beautified.
+
+        Returns:
+            bytes: The beautified result.
+        """
 
     def _chunks_to_beautify(self, before, to_beautify, file):
         """Iterate over `to_beautify` and find chunks of style/script to beautify.
 
         Arguments:
-            before (bytes): The data preceding `to_beautify`. Used to check whether `to_beautify` is
-                            already in an open <script> or <style> tag.
+            before (bytes): The data preceding `to_beautify`. Used to check whether
+                            `to_beautify` is already in an open <script> or <style> tag.
             to_beautify (bytes): The data to beautify.
             file (Path): The input file (used only to check if this is a .css/.js file)
 
@@ -263,13 +373,25 @@ def _chunks_to_beautify(self, before, to_beautify, file):
             search_start = chunk_start + tag_end.end(0)
 
     def __iter__(self):
+        """Iterate over potential beautifications of testcases according to this
+        strategy.
+
+        The caller should evaluate each testcase set yielded, and call `update` with the
+        result. The caller owns the testcases yielded, and should call `cleanup` for
+        each.
+
+        Yields:
+            list(grizzly.common.storage.TestCase): list of testcases with beautification
+                                                   applied
+        """
         if not self.import_available:
             LOG.warning("%s not available, skipping strategy.", self.import_name)
             return
 
         LOG.info("Beautifying %d files", len(self._files_to_beautify))
         for file_no, file in enumerate(self._files_to_beautify):
-            LOG.info("Beautifying %s (file %d/%d)", file.relative_to(self._testcase_root), file_no + 1,
+            LOG.info("Beautifying %s (file %d/%d)",
+                     file.relative_to(self._testcase_root), file_no + 1,
                      len(self._files_to_beautify))
 
             # Use Lithium just to split the file at DDBEGIN/END.
@@ -295,7 +417,8 @@ def __iter__(self):
                     elif to_beautify.strip():  # pragma: no cover
                         # this should never happen, but just in case...
                         # pragma: no cover
-                        LOG.warning("No output from beautify! Writing %s unmodified.", self.tag_name)
+                        LOG.warning("No output from beautify! Writing %s unmodified.",
+                                    self.tag_name)
                         testcase_fp.write(to_beautify)  # pragma: no cover
                     last = end
                 testcase_fp.write(raw[last:])
@@ -317,9 +440,12 @@ def __iter__(self):
 
 
 class _LithiumStrategy(Strategy, ABC):
-    """Implementors must define these class attributes:
+    """Use a Lithium `Strategy`/`Testcase` pair to reduce the given Grizzly `TestCase`
+    set.
+
+    Implementors must define these class attributes:
 
-    Attributes:
+    Class attributes:
         name (str): The strategy name.
         strategy_cls (lithium.strategies.Strategy): Lithium strategy type.
         testcase_cls (lithium.testcases.Testcase): Lithium testcase type.
@@ -327,8 +453,15 @@ class _LithiumStrategy(Strategy, ABC):
     strategy_cls = None
     testcase_cls = None
 
-    def __init__(self, *args, **kwds):
-        super().__init__(*args, **kwds)
+    def __init__(self, testcases):
+        """Initialize strategy instance.
+
+        Arguments:
+            testcases (list(grizzly.common.storage.TestCase)):
+                List of testcases to reduce. The object does not take ownership of the
+                testcases.
+        """
+        super().__init__(testcases)
         self._current_reducer = None
         self._files_to_reduce = []
         self.rescan_files_to_reduce()
@@ -336,36 +469,71 @@ def __init__(self, *args, **kwds):
         self._current_served = None
 
     def rescan_files_to_reduce(self):
+        """Repopulate the private `files_to_reduce` attribute by scanning the testcase
+        root.
+
+        Returns:
+            None
+        """
         self._files_to_reduce.clear()
         for path in self._testcase_root.glob("**/*"):
             if path.is_file() and path.name not in {"test_info.json", "prefs.js"}:
                 self._files_to_reduce.append(path)
 
     @classmethod
-    def sanity_check_impl(cls):
-        super().sanity_check_impl()
+    def sanity_check_cls_attrs(cls):
+        """Sanity check the strategy class implementation.
+
+        Raises:
+            AssertionError: Required class attributes are missing or wrong type.
+
+        Returns:
+            None
+        """
+        super().sanity_check_cls_attrs()
         assert issubclass(cls.strategy_cls, LithStrategy)
         assert issubclass(cls.testcase_cls, LithTestcase)
 
     def update(self, success, served=None):
+        """Inform the strategy whether or not the last reduction yielded was good.
+
+        Arguments:
+            success (bool): Whether or not the last reduction was acceptable.
+            served (list(list(str))): The list of served files for each testcase in the
+                                      last reduction.
+
+        Returns:
+            None
+        """
         if self._current_reducer is not None:
             self._current_reducer.feedback(success)
         self._current_feedback = success
         self._current_served = served
 
     def __iter__(self):
+        """Iterate over potential reductions of testcases according to this strategy.
+
+        The caller should evaluate each testcase set yielded, and call `update` with the
+        result. The caller owns the testcases yielded, and should call `cleanup` for
+        each.
+
+        Yields:
+            list(grizzly.common.storage.TestCase): list of testcases with reduction
+                                                   applied
+        """
         LOG.info("Reducing %d files", len(self._files_to_reduce))
         file_no = 0
         reduce_queue = self._files_to_reduce.copy()
         reduce_queue.sort()  # not necessary, but helps make tests more predictable
-        # indicates that self._testcase_root contains changes that haven't been yielded (if iteration ends,
-        # changes would be lost)
+        # indicates that self._testcase_root contains changes that haven't been yielded
+        # (if iteration ends, changes would be lost)
         testcase_root_dirty = False
         while reduce_queue:
             LOG.debug("Reduce queue: %r", reduce_queue)
             file = reduce_queue.pop(0)
             file_no += 1
-            LOG.info("Reducing %s (file %d/%d)", file, file_no, len(self._files_to_reduce))
+            LOG.info("Reducing %s (file %d/%d)", file, file_no,
+                     len(self._files_to_reduce))
             lithium_testcase = self.testcase_cls()  # pylint: disable=not-callable
             lithium_testcase.load(file)
             # pylint: disable=not-callable
@@ -400,7 +568,8 @@ def __iter__(self):
             self._current_reducer = None
         if testcase_root_dirty:
             # purging unserved files enabled us to exit early from the loop.
-            # need to yield once more to set this trimmed version to the current best in ReduceManager
+            # need to yield once more to set this trimmed version to the current best
+            # in ReduceManager
             testcases = TestCase.load(str(self._testcase_root), False)
             LOG.info("final iteration triggered by purge_optional")
             yield testcases
@@ -408,6 +577,11 @@ def __iter__(self):
 
 
 class Check(_LithiumStrategy):
+    """Check whether the testcase is reproducible.
+
+    This strategy does no reduction, and only yields once. It is intended to provide a
+    pass/fail result in a reduction pipeline.
+    """
     name = "check"
     strategy_cls = CheckOnly
     testcase_cls = TestcaseLine
@@ -420,12 +594,24 @@ def __init__(self, *args, **kwds):
 
 
 class CollapseEmptyBraces(_LithiumStrategy):
+    """Minimize lines, but collapse empty curly braces between each iteration.
+
+    During reduction, the contents of a block may be reduced away entirely, but removing
+    the starting brace or ending brace alone will break the syntax of the test file.
+    This strategy tries to collapse empty braces onto the same line between each
+    iteration, so that empty blocks can be removed if otherwise possible.
+    """
     name = "collapsebraces"
     strategy_cls = LithCollapseEmptyBraces
     testcase_cls = TestcaseLine
 
 
 class CSSBeautify(_BeautifyStrategy):
+    """Run CSS beautification on all CSS files and `<style>` tags.
+
+    This should make the CSS more reducible if there are long lines with compound
+    definitions.
+    """
     all_extensions = {".css", ".htm", ".html", ".xhtml"}
     import_available = HAVE_CSSBEAUTIFIER
     import_name = "cssbeautifier"
@@ -441,12 +627,27 @@ class CSSBeautify(_BeautifyStrategy):
 
     @classmethod
     def beautify_bytes(cls, data):
+        """Perform CSS beautification on a code buffer.
+
+        Arguments:
+            data (bytes): The code data to be beautified.
+
+        Returns:
+            bytes: The beautified result.
+        """
         assert cls.import_available
         data = data.decode("utf-8", errors="surrogateescape")
-        return cssbeautifier.beautify(data, cls.opts).encode("utf-8", errors="surrogateescape")
+        return (cssbeautifier
+                .beautify(data, cls.opts)
+                .encode("utf-8", errors="surrogateescape"))
 
 
 class JSBeautify(_BeautifyStrategy):
+    """Run JS beautification on all JS files and `<script>` tags.
+
+    This should make the javascript more reducible if there are long lines with
+    compound statements.
+    """
     all_extensions = {".js", ".htm", ".html", ".xhtml"}
     import_available = HAVE_JSBEAUTIFIER
     import_name = "jsbeautifier"
@@ -458,6 +659,14 @@ class JSBeautify(_BeautifyStrategy):
 
     @classmethod
     def beautify_bytes(cls, data):
+        """Perform JS beautification on a code buffer.
+
+        Arguments:
+            data (bytes): The code data to be beautified.
+
+        Returns:
+            bytes: The beautified result.
+        """
         assert HAVE_JSBEAUTIFIER
         data = data.decode("utf-8", errors="surrogateescape")
 
@@ -469,18 +678,28 @@ def beautify_bytes(cls, data):
 
 
 class MinimizeChars(_LithiumStrategy):
+    """Minimize all bytes in the testcase.
+    """
     name = "chars"
     strategy_cls = Minimize
     testcase_cls = TestcaseChar
 
 
 class MinimizeJSChars(_LithiumStrategy):
+    """Minimize all bytes contained in javascript strings.
+
+    This works the same as MinimizeChars, but only operates if it can identify what
+    looks like a quoted string. It also treats escaped characters as a single token
+    for reduction.
+    """
     name = "jschars"
     strategy_cls = Minimize
     testcase_cls = TestcaseJsStr
 
 
 class MinimizeLines(_LithiumStrategy):
+    """Minimize all lines in the testcase.
+    """
     name = "lines"
     strategy_cls = Minimize
     testcase_cls = TestcaseLine
@@ -490,40 +709,68 @@ class MinimizeTestcaseList(Strategy):
     """Try removing testcases from a list of sequential testcases (eg. Grizzly result
     cache). The strategy favours testcases at the tail of the list, so for a list of
     five testcases:
-                        testcases
-                0       1 2 3 4 5
-    iteration   1         2 3 4 5
-                2       1   3 4 5
-                3       1 2   4 5
-                4       1 2 3   5
-                5       1 2 3 4
+                            testcases
+                    0       1 2 3 4 5
+        iteration   1         2 3 4 5
+                    2       1   3 4 5
+                    3       1 2   4 5
+                    4       1 2 3   5
+                    5       1 2 3 4
     """
     name = "list"
 
-    def __init__(self, *args, **kwds):
-        super().__init__(*args, **kwds)
+    def __init__(self, testcases):
+        """Initialize strategy instance.
+
+        Arguments:
+            testcases (list(grizzly.common.storage.TestCase)):
+                List of testcases to reduce. The object does not take ownership of the
+                testcases.
+        """
+        super().__init__(testcases)
         self._current_feedback = None
         self._current_served = None
 
     def update(self, success, served=None):
+        """Inform the strategy whether or not the last reduction yielded was good.
+
+        Arguments:
+            success (bool): Whether or not the last reduction was acceptable.
+            served (list(list(str))): The list of served files for each testcase in the
+                                      last reduction.
+
+        Returns:
+            None
+        """
         assert self._current_feedback is None
         assert self._current_served is None
         self._current_feedback = success
         self._current_served = served
 
     def __iter__(self):
+        """Iterate over potential reductions of testcases according to this strategy.
+
+        The caller should evaluate each testcase set yielded, and call `update` with the
+        result. The caller owns the testcases yielded, and should call `cleanup` for
+        each.
+
+        Yields:
+            list(grizzly.common.storage.TestCase): list of testcases with reduction
+                                                   applied
+        """
         assert self._current_feedback is None
         idx = 0
         testcases = None
         try:
             testcases = TestCase.load(str(self._testcase_root), False)
             n_testcases = len(testcases)
-            # indicates that self._testcase_root contains changes that haven't been yielded (if iteration
-            # ends, changes would be lost)
+            # indicates that self._testcase_root contains changes that haven't been
+            # yielded (if iteration ends, changes would be lost)
             testcase_root_dirty = False
             while True:
                 if n_testcases <= 1:
-                    LOG.info("Testcase list has length %d, not enough to reduce!", n_testcases)
+                    LOG.info("Testcase list has length %d, not enough to reduce!",
+                             n_testcases)
                     break
                 if idx >= n_testcases:
                     LOG.info("Attempted to remove every single testcase")
@@ -539,13 +786,15 @@ def __iter__(self):
 
                 if self._current_feedback:
                     testcase_root_dirty = False
-                    LOG.info("Removing testcase %d/%d was successful!", idx + 1, n_testcases)
+                    LOG.info("Removing testcase %d/%d was successful!", idx + 1,
+                             n_testcases)
                     testcases = TestCase.load(str(self._testcase_root), False)
                     try:
                         # remove the actual testcase we were reducing
                         testcases.pop(idx).cleanup()
                         if testcases and self._current_served is not None:
-                            testcase_root_dirty = self.purge_unserved(testcases, self._current_served)
+                            testcase_root_dirty = \
+                                self.purge_unserved(testcases, self._current_served)
                         else:
                             self.dump_testcases(testcases, recreate_tcroot=True)
                     finally:
@@ -561,12 +810,14 @@ def __iter__(self):
                 self._current_served = None
             if testcase_root_dirty:
                 # purging unserved files enabled us to exit early from the loop.
-                # need to yield once more to set this trimmed version to the current best in ReduceManager
+                # need to yield once more to set this trimmed version to the current
+                # best in ReduceManager
                 testcases = TestCase.load(str(self._testcase_root), False)
                 LOG.info("final iteration triggered by purge_optional")
                 yield testcases
                 testcases = None  # caller owns testcases now
-                assert self._current_feedback, "Purging unserved files broke the testcase."
+                assert self._current_feedback, \
+                    "Purging unserved files broke the testcase."
         finally:
             if testcases is not None:
                 for testcase in testcases:
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 7ff3d4ec..61aa45e4 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -3,8 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
-"""
-unit tests for grizzly.reduce.main
+"""Unit tests for `grizzly.reduce.main`.
 """
 import json
 from logging import getLogger
@@ -21,12 +20,13 @@
 
 
 LOG = getLogger(__name__)
-pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")  # pylint: disable=invalid-name
+pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")
 
 
 def test_args_01(capsys, tmp_path, mocker):
     """test args in common with grizzly.replay"""
-    from ..replay.test_main import test_args_01 as real_test  # pylint: disable=import-outside-toplevel
+    # pylint: disable=import-outside-toplevel
+    from ..replay.test_main import test_args_01 as real_test
     mocker.patch("grizzly.replay.test_main.ReplayArgs", new=ReduceArgs)
     real_test(capsys, tmp_path)
 
@@ -53,7 +53,8 @@ def test_args_02(tmp_path):
     logs_dir.mkdir()
     ReduceArgs().parse_args([str(exe), str(inp), "--logs", str(logs_dir)])
     # test no-analysis
-    ReduceArgs().parse_args([str(exe), str(inp), "--no-analysis", "--repeat", "99", "--min-crashes", "99"])
+    ReduceArgs().parse_args([str(exe), str(inp), "--no-analysis", "--repeat", "99",
+                             "--min-crashes", "99"])
     # these should both log a warning that the args will be ignored due to analysis
     ReduceArgs().parse_args([str(exe), str(inp), "--repeat", "99"])
     ReduceArgs().parse_args([str(exe), str(inp), "--min-crashes", "99"])
@@ -75,10 +76,12 @@ def test_main_01(mocker):
         repeat=1,
         sig=None)
 
-    mocker.patch("grizzly.reduce.core.ReduceManager.run", side_effect=TargetLaunchError("error", None))
+    mocker.patch("grizzly.reduce.core.ReduceManager.run",
+                 side_effect=TargetLaunchError("error", None))
     assert ReduceManager.main(args) == 1
 
-    mocker.patch("grizzly.reduce.core.ReduceManager.run", side_effect=TargetLaunchTimeout)
+    mocker.patch("grizzly.reduce.core.ReduceManager.run",
+                 side_effect=TargetLaunchTimeout)
     assert ReduceManager.main(args) == 1
 
     mocker.patch("grizzly.reduce.core.load_target", side_effect=KeyboardInterrupt)
@@ -98,7 +101,11 @@ def test_force_closed(mocker, tmp_path):
     mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
     (tmp_path / "test.html").touch()
     (tmp_path / "test_info.json").write_text(
-        json.dumps({"timestamp": 1, "target": "test.html", "env": {"GRZ_FORCED_CLOSE": "0"}})
+        json.dumps({
+            "timestamp": 1,
+            "target": "test.html",
+            "env": {"GRZ_FORCED_CLOSE": "0"}
+        })
     )
     args = mocker.Mock(
         fuzzmanager=False,
@@ -115,7 +122,8 @@ def test_force_closed(mocker, tmp_path):
 
 @pytest.mark.parametrize("result", ["testprefs", "argprefs"])
 def test_testcase_prefs(mocker, tmp_path, result):
-    """test that prefs from testcase are used if --prefs not specified and --prefs overrides"""
+    """test that prefs from testcase are used if --prefs not specified and --prefs
+    overrides"""
     load_target = mocker.patch("grizzly.reduce.core.load_target")
     mocker.patch("grizzly.reduce.core.ReduceManager.run", autospec=True)
     mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 3c4080a1..a0b5031c 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -3,8 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
-"""
-unit tests for grizzly.reduce.reduce
+"""Unit tests for `grizzly.reduce.reduce`.
 """
 from collections import namedtuple
 import functools
@@ -21,7 +20,7 @@
 
 
 LOG = getLogger(__name__)
-pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")  # pylint: disable=invalid-name
+pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")
 
 
 def _fake_save_logs_foo(result_logs, meta=False):  # pylint: disable=unused-argument
@@ -71,8 +70,8 @@ def _fake_save_logs_bar(result_logs, meta=False):  # pylint: disable=unused-argu
         AnalysisTestParams([True] * 2 + [False] * 18 + [True] * 2, 30, 2, True, True),
     ]
 )
-def test_analysis(mocker, tmp_path, crashes, expected_repeat, expected_min_crashes, use_harness,
-                  result_harness):
+def test_analysis(mocker, tmp_path, crashes, expected_repeat, expected_min_crashes,
+                  use_harness, result_harness):
     """test that analysis sets reasonable params"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     expected_iters = len(crashes)
@@ -80,7 +79,9 @@ def test_analysis(mocker, tmp_path, crashes, expected_repeat, expected_min_crash
     def replay_run(_, **_kw):
         LOG.debug("interesting: %r", crashes[0])
         if crashes.pop(0):
-            log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+            log_path = tmp_path / (
+                "crash%d_logs" % (replayer.return_value.run.call_count,)
+            )
             log_path.mkdir()
             _fake_save_logs_foo(log_path)
             report = Report(str(log_path), "bin")
@@ -94,8 +95,8 @@ def replay_run(_, **_kw):
     log_path = tmp_path / "logs"
 
     try:
-        mgr = ReduceManager(None, mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target), tests, None,
-                            log_path, use_harness=use_harness)
+        mgr = ReduceManager(None, mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target),
+                            tests, None, log_path, use_harness=use_harness)
         repeat, min_crashes = mgr.run_reliability_analysis()
     finally:
         for test in tests:
@@ -117,8 +118,8 @@ def wrapped(_):
 
 ReproTestParams = namedtuple(
     "ReproTestParams",
-    "original, strategies, detect_failure, interesting_str, is_expected, expected_run_calls, n_reports,"
-    "reports, n_other, other_reports, result"
+    "original, strategies, detect_failure, interesting_str, is_expected,"
+    "expected_run_calls, n_reports, reports, n_other, other_reports, result"
 )
 
 
@@ -157,7 +158,8 @@ def wrapped(_):
         ReproTestParams(
             original="odd\neven\n" * 3,
             strategies=["check", "lines"],
-            detect_failure=lambda contents: sum(1 for line in contents.splitlines() if line == "odd") == 3,
+            detect_failure=lambda contents: sum(1 for line in contents.splitlines()
+                                                if line == "odd") == 3,
             interesting_str="%r contains 3x 'odd'",
             is_expected=lambda _: True,
             expected_run_calls=8,
@@ -201,7 +203,8 @@ def wrapped(_):
             strategies=["check", "lines", "chars"],
             detect_failure=(
                 lambda contents: (
-                    len(contents.splitlines()) == 6 and set(contents.splitlines()) >= {"A1", "A3", "A5"})),
+                    len(contents.splitlines()) == 6
+                    and set(contents.splitlines()) >= {"A1", "A3", "A5"})),
             interesting_str="%r contains {'A1', 'A3', 'A5'} and len() == 6",
             is_expected=lambda _: True,
             expected_run_calls=43,
@@ -217,7 +220,8 @@ def wrapped(_):
             original="A1\nA2\nA3\nA4\nA5\nA6\n",
             strategies=["check", "lines", "chars"],
             detect_failure=(
-                lambda contents: set(contents.splitlines(keepends=True)) >= {"A1\n", "A3\n", "A5\n"}),
+                lambda contents: (set(contents.splitlines(keepends=True))
+                                  >= {"A1\n", "A3\n", "A5\n"})),
             interesting_str="%r contains {'A1\\n', 'A3\\n', 'A5\\n'}",
             is_expected=lambda _: True,
             expected_run_calls=34,
@@ -239,8 +243,8 @@ def wrapped(_):
             n_reports=1,
             reports={"1\n2\n3\n"},
             n_other=15,
-            other_reports={"\n2\n3\n", "1\n", "1\n\n3\n", "1\n2\n", "1\n2\n\n", "1\n2\n3", "1\n23\n",
-                           "1\n3\n", "12\n3\n", "2\n3\n", "3\n"},
+            other_reports={"\n2\n3\n", "1\n", "1\n\n3\n", "1\n2\n", "1\n2\n\n",
+                           "1\n2\n3", "1\n23\n", "1\n3\n", "12\n3\n", "2\n3\n", "3\n"},
             result=True,
         ),
         # reproduces, one strategy, testcase reduces to 0
@@ -262,7 +266,8 @@ def wrapped(_):
             original="1\n2\n3\n",
             strategies=["check", "lines", "lines"],
             detect_failure=_ignore_arg(
-                functools.partial([True, False, False, False, False, False, True, True].pop, 0)),
+                functools.partial(
+                    [True, False, False, False, False, False, True, True].pop, 0)),
             interesting_str="%r is anything, only in second strategy",
             is_expected=lambda _: True,
             expected_run_calls=8,
@@ -275,17 +280,22 @@ def wrapped(_):
     ]
 )
 @pytest.mark.usefixtures("reporter_sequential_strftime")
-def test_repro(mocker, tmp_path, original, strategies, detect_failure, interesting_str, is_expected,
-               expected_run_calls, n_reports, reports, n_other, other_reports, result):
-    """test ReduceManager, difference scenarios produce correct expected/other results"""
+def test_repro(mocker, tmp_path, original, strategies, detect_failure, interesting_str,
+               is_expected, expected_run_calls, n_reports, reports, n_other,
+               other_reports, result):
+    """test ReduceManager, difference scenarios produce correct expected/other
+    results"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
 
     def replay_run(testcases, **_):
         for test in testcases:
             contents = test.get_file("test.html").data.decode("ascii")
-            LOG.debug("interesting if " + interesting_str, contents)  # pylint: disable=logging-not-lazy
+            # pylint: disable=logging-not-lazy
+            LOG.debug("interesting if " + interesting_str, contents)
             if detect_failure(contents):
-                log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+                log_path = tmp_path / (
+                    "crash%d_logs" % (replayer.return_value.run.call_count,)
+                )
                 log_path.mkdir()
                 expected = is_expected(contents)
                 if expected:
@@ -305,8 +315,8 @@ def replay_run(testcases, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies, log_path,
-                            use_analysis=False)
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies,
+                            log_path, use_analysis=False)
         assert mgr.run() == result
     finally:
         for test in tests:
@@ -326,7 +336,8 @@ def replay_run(testcases, **_):
         assert len(list((log_path / "reports").iterdir())) \
             == n_reports * 2, list((log_path / "reports").iterdir())
     if n_other:
-        other_tests = {test.read_text() for test in log_path.glob("other_reports/*-0/test.html")}
+        other_tests = {test.read_text()
+                       for test in log_path.glob("other_reports/*-0/test.html")}
         assert other_tests == other_reports
         assert len(list((log_path / "other_reports").iterdir())) \
             == n_other * 2, list((log_path / "other_reports").iterdir())
@@ -355,8 +366,9 @@ def replay_run(_, **_kw):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, testcases, ["check"], log_path,
-                            use_analysis=False, report_to_fuzzmanager=True)
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, testcases,
+                            ["check"], log_path, use_analysis=False,
+                            report_to_fuzzmanager=True)
         assert mgr.run()
     finally:
         for test in testcases:
@@ -384,10 +396,12 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
     replay_mock = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     if exc_type is TargetLaunchError:
         report_obj = mocker.Mock(spec=Report)
-        replay_mock.return_value.__enter__.return_value.run.side_effect = TargetLaunchError("msg", report_obj)
+        replay_mock.return_value.__enter__.return_value.run.side_effect = \
+            TargetLaunchError("msg", report_obj)
         replay_mock.return_value.run.side_effect = TargetLaunchError("msg", report_obj)
     else:
-        replay_mock.return_value.__enter__.return_value.run.side_effect = TargetLaunchTimeout("msg")
+        replay_mock.return_value.__enter__.return_value.run.side_effect = \
+            TargetLaunchTimeout("msg")
         replay_mock.return_value.run.side_effect = TargetLaunchTimeout("msg")
 
     (tmp_path / "test.html").touch()
@@ -396,8 +410,8 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
 
     target_obj = mocker.Mock(spec=Target)
     target_obj.relaunch = 1
-    mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target_obj, testcases, ["check"], None,
-                        use_analysis=use_analysis)
+    mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target_obj, testcases,
+                        ["check"], None, use_analysis=use_analysis)
     with raises(exc_type):
         mgr.run()
     if exc_type is TargetLaunchError:
@@ -418,7 +432,8 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
 
 TimeoutTestParams = namedtuple(
     "TimeoutTestParams",
-    "durations, interesting, static_timeout, idle_input, idle_output, iter_input, iter_output, result"
+    "durations, interesting, static_timeout, idle_input, idle_output, iter_input,"
+    "iter_output, result"
 )
 
 
@@ -482,8 +497,8 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
         ),
     ]
 )
-def test_timeout_update(mocker, tmp_path, durations, interesting, static_timeout, idle_input, idle_output,
-                        iter_input, iter_output, result):
+def test_timeout_update(mocker, tmp_path, durations, interesting, static_timeout,
+                        idle_input, idle_output, iter_input, iter_output, result):
     "timeout will be updated based on time to crash"
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
 
@@ -507,7 +522,8 @@ def replay_run(_testcases, **_):
     server.timeout = iter_input
     try:
         mgr = ReduceManager([], server, target, tests, ["check"], log_path,
-                            use_analysis=False, idle_delay=idle_input, static_timeout=static_timeout)
+                            use_analysis=False, idle_delay=idle_input,
+                            static_timeout=static_timeout)
         mgr.IDLE_DELAY_MIN = 10
         mgr.IDLE_DELAY_DURATION_MULTIPLIER = 1.5
         mgr.ITER_TIMEOUT_MIN = 10
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 29f675de..6ab1e29a 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -3,8 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
-"""
-unit tests for grizzly.reduce.strategies
+"""Unit tests for `grizzly.reduce.strategies`.
 """
 from collections import namedtuple
 from logging import getLogger
@@ -21,8 +20,8 @@
 
 
 LOG = getLogger(__name__)
-# pylint: disable=invalid-name
-pytestmark = pytest.mark.usefixtures("tmp_path_fm_config", "reporter_sequential_strftime")
+pytestmark = pytest.mark.usefixtures("tmp_path_fm_config",
+                                     "reporter_sequential_strftime")
 
 
 def _fake_save_logs_foo(result_logs):
@@ -42,7 +41,7 @@ def test_strategy_load_fail(mocker):
     class _GoodStrategy(object):
         name = "good"
         @classmethod
-        def sanity_check_impl(cls):
+        def sanity_check_cls_attrs(cls):
             pass
 
         @classmethod
@@ -72,7 +71,8 @@ def entries(_):
 
 ListStrategyParams = namedtuple(
     "ListStrategyParams",
-    "test_data, strategies, required_first, expected_run_calls, expected_results, expected_num_reports"
+    "test_data, strategies, required_first, expected_run_calls, expected_results,"
+    "expected_num_reports"
 )
 
 
@@ -108,8 +108,8 @@ def entries(_):
         ),
     ]
 )
-def test_list(mocker, tmp_path, test_data, strategies, required_first, expected_run_calls, expected_results,
-              expected_num_reports):
+def test_list(mocker, tmp_path, test_data, strategies, required_first,
+              expected_run_calls, expected_results, expected_num_reports):
     """tests for the "list" strategy"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
 
@@ -121,11 +121,14 @@ def replay_run(testcases, **_):
             if contents == "required" and required_first:
                 required_seen = True
             elif contents == "123" and (required_seen or not required_first):
-                log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+                log_path = tmp_path / (
+                    "crash%d_logs" % (replayer.return_value.run.call_count,)
+                )
                 log_path.mkdir()
                 _fake_save_logs_foo(log_path)
                 report = Report(str(log_path), "bin")
-                return [ReplayResult(report, [["test.html"]] * len(testcases), [], True)]
+                return [ReplayResult(report, [["test.html"]] * len(testcases), [],
+                                     True)]
         return []
     replayer.return_value.run.side_effect = replay_run
 
@@ -139,8 +142,8 @@ def replay_run(testcases, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies, log_path,
-                            use_analysis=False)
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies,
+                            log_path, use_analysis=False)
         assert mgr.run()
     finally:
         for test in tests:
@@ -156,7 +159,8 @@ def replay_run(testcases, **_):
 
 BeautifyStrategyParams = namedtuple(
     "BeautifyStrategyParams",
-    "test_data, test_name, expected_run_calls, expected_results, expected_num_reports, strategies"
+    "test_data, test_name, expected_run_calls, expected_results, expected_num_reports,"
+    "strategies"
 )
 
 
@@ -169,11 +173,14 @@ def replay_run(testcases, **_):
                 test_data="try{'fluff';'required'}catch(e){}\n",
                 test_name="test.js",
                 expected_run_calls=1,
-                expected_results={"try {\n    'fluff';\n    'required'\n} catch (e) {}\n"},
+                expected_results={
+                    "try {\n    'fluff';\n    'required'\n} catch (e) {}\n"
+                },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
+                                     reason="jsbeautifier required"),
         ),
         # test beautify js embedded in html
         pytest.param(
@@ -181,12 +188,13 @@ def replay_run(testcases, **_):
                 test_data="<script>try{'fluff';'required'}catch(e){}</script>\n",
                 test_name="test.html",
                 expected_run_calls=1,
-                expected_results={"<script>\ntry {\n    'fluff';\n    'required'\n} catch (e) {}\n"
-                                  "</script>\n"},
+                expected_results={"<script>\ntry {\n    'fluff';\n    'required'\n} "
+                                  "catch (e) {}\n</script>\n"},
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
+                                     reason="jsbeautifier required"),
         ),
         # test beautify multiple js embedded in html
         pytest.param(
@@ -195,12 +203,14 @@ def replay_run(testcases, **_):
                 "<script>'fluff';'requisite'</script>\n",
                 test_name="test.html",
                 expected_run_calls=1,
-                expected_results={"<script>\ntry {\n    'fluff';\n    'required'\n} catch (e) {}\n</script>"
-                                  "<script>\n'fluff';\n'requisite'\n</script>\n"},
+                expected_results={"<script>\ntry {\n    'fluff';\n    'required'\n} "
+                                  "catch (e) {}\n</script><script>\n'fluff';\n'"
+                                  "requisite'\n</script>\n"},
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
+                                     reason="jsbeautifier required"),
         ),
         # test beautify js embedded in html with no end
         pytest.param(
@@ -208,11 +218,14 @@ def replay_run(testcases, **_):
                 test_data="<script>try{'fluff';'required'}catch(e){}\n",
                 test_name="test.html",
                 expected_run_calls=1,
-                expected_results={"<script>\ntry {\n    'fluff';\n    'required'\n} catch (e) {}\n"},
+                expected_results={
+                    "<script>\ntry {\n    'fluff';\n    'required'\n} catch (e) {}\n"
+                },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
+                                     reason="jsbeautifier required"),
         ),
         # test DDBEGIN/END respected in .js file
         pytest.param(
@@ -220,77 +233,101 @@ def replay_run(testcases, **_):
                 test_data="try{\n//DDBEGIN\n'fluff';'required'\n//DDEND\n}catch(e){}\n",
                 test_name="test.js",
                 expected_run_calls=1,
-                expected_results={"try{\n//DDBEGIN\n'fluff';\n'required'\n//DDEND\n}catch(e){}\n"},
+                expected_results={
+                    "try{\n//DDBEGIN\n'fluff';\n'required'\n//DDEND\n}catch(e){}\n"
+                },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
+                                     reason="jsbeautifier required"),
         ),
         # test DDBEGIN/END respected for js embedded in html, DD outside <script>
         pytest.param(
             *BeautifyStrategyParams(
-                test_data="<!--DDBEGIN-->\n<script>\ntry{'fluff';'required'}catch(e){}\n"
-                "</script><!--DDEND-->\n",
+                test_data="<!--DDBEGIN-->\n<script>\ntry{'fluff';'required'}"
+                          "catch(e){}\n</script><!--DDEND-->\n",
                 test_name="test.html",
                 expected_run_calls=1,
-                expected_results={"<!--DDBEGIN-->\n<script>\ntry {\n    'fluff';\n    'required'\n"
-                                  "} catch (e) {}\n</script><!--DDEND-->\n"},
+                expected_results={
+                    "<!--DDBEGIN-->\n<script>\ntry {\n    'fluff';\n    'required'\n} "
+                    "catch (e) {}\n</script><!--DDEND-->\n"
+                },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
+                                     reason="jsbeautifier required"),
         ),
         # test DDBEGIN/END respected for js embedded in html, DD inside <script>
         pytest.param(
             *BeautifyStrategyParams(
-                test_data="<script>try{\n//DDBEGIN\n'fluff';'required'\n//DDEND\n}catch(e){}</script>\n",
+                test_data="<script>try{\n//DDBEGIN\n'fluff';'required'\n//DDEND\n}"
+                          "catch(e){}</script>\n",
                 test_name="test.html",
                 expected_run_calls=1,
-                expected_results={"<script>try{\n//DDBEGIN\n'fluff';\n'required'\n//DDEND\n}catch(e){}"
-                                  "</script>\n"},
+                expected_results={
+                    "<script>try{\n//DDBEGIN\n'fluff';\n'required'\n//DDEND\n}"
+                    "catch(e){}</script>\n"
+                },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
+                                     reason="jsbeautifier required"),
         ),
-        # test DDBEGIN/END respected for js embedded in html, DD straddle before <script>
+        # test DDBEGIN/END respected for js embedded in html, DD straddle before
+        # <script>
         pytest.param(
             *BeautifyStrategyParams(
-                test_data="<!--DDBEGIN-->\n<script>\ntry{'fluff';'required'}catch(e){}\n//DDEND\n",
+                test_data="<!--DDBEGIN-->\n<script>\ntry{'fluff';'required'}catch(e){}"
+                          "\n//DDEND\n",
                 test_name="test.html",
                 expected_run_calls=1,
-                expected_results={"<!--DDBEGIN-->\n<script>\ntry {\n    'fluff';\n    'required'\n"
-                                  "} catch (e) {}\n//DDEND\n"},
+                expected_results={
+                    "<!--DDBEGIN-->\n<script>\ntry {\n    'fluff';\n    'required'\n} "
+                    "catch (e) {}\n//DDEND\n"
+                },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
+                                     reason="jsbeautifier required"),
         ),
         # test DDBEGIN/END respected for js embedded in html, DD straddle after <script>
         pytest.param(
             *BeautifyStrategyParams(
-                test_data="<script>\n//DDBEGIN\ntry{'fluff';'required'}catch(e){}\n//DDEND\n",
+                test_data="<script>\n//DDBEGIN\ntry{'fluff';'required'}catch(e){}\n"
+                          "//DDEND\n",
                 test_name="test.html",
                 expected_run_calls=1,
-                expected_results={"<script>\n//DDBEGIN\ntry {\n    'fluff';\n    'required'\n"
-                                  "} catch (e) {}\n//DDEND\n"},
+                expected_results={
+                    "<script>\n//DDBEGIN\ntry {\n    'fluff';\n    'required'\n} "
+                    "catch (e) {}\n//DDEND\n"
+                },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
+                                     reason="jsbeautifier required"),
         ),
-        # test DDBEGIN/END respected for js embedded in html, DD straddle after </script>
+        # test DDBEGIN/END respected for js embedded in html, DD straddle after
+        # </script>
         pytest.param(
             *BeautifyStrategyParams(
-                test_data="<script>\n//DDBEGIN\ntry{'fluff';'required'}catch(e){}\n</script>\n<!--DDEND-->\n",
+                test_data="<script>\n//DDBEGIN\ntry{'fluff';'required'}catch(e){}\n"
+                          "</script>\n<!--DDEND-->\n",
                 test_name="test.html",
                 expected_run_calls=1,
-                expected_results={"<script>\n//DDBEGIN\ntry {\n    'fluff';\n    'required'\n} catch (e) {}\n"
-                                  "</script>\n<!--DDEND-->\n"},
+                expected_results={
+                    "<script>\n//DDBEGIN\ntry {\n    'fluff';\n    'required'\n} "
+                    "catch (e) {}\n</script>\n<!--DDEND-->\n"
+                },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
+                                     reason="jsbeautifier required"),
         ),
         # test beautify js embedded in html (no <script>)
         pytest.param(
@@ -300,9 +337,11 @@ def replay_run(testcases, **_):
                 expected_run_calls=1,
                 expected_results={"try{'fluff';'required'}catch(e){}\n"},
                 expected_num_reports=2,
-                strategies=["jsbeautify", "check"],  # no beautify performed, add check so the run succeeds
+                # no beautify performed, add check so the run succeeds
+                strategies=["jsbeautify", "check"],
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
+                                     reason="jsbeautifier required"),
         ),
         # test beautify js where beautification breaks
         pytest.param(
@@ -312,9 +351,11 @@ def replay_run(testcases, **_):
                 expected_run_calls=2,
                 expected_results={"try{'fluff';'requi'+'red'}catch(e){}\n"},
                 expected_num_reports=2,
-                strategies=["jsbeautify", "check"],  # no beautify performed, add check so the run succeeds
+                # no beautify performed, add check so the run succeeds
+                strategies=["jsbeautify", "check"],
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
+                                     reason="jsbeautifier required"),
         ),
         # test beautify a .css file
         pytest.param(
@@ -326,7 +367,8 @@ def replay_run(testcases, **_):
                 expected_num_reports=2,
                 strategies=["cssbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
+                                     reason="cssbeautifier required"),
         ),
         # test beautify css embedded in html
         pytest.param(
@@ -334,11 +376,14 @@ def replay_run(testcases, **_):
                 test_data="<style>*,#a{fluff:0;required:1}</style>\n",
                 test_name="test.html",
                 expected_run_calls=1,
-                expected_results={"<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n</style>\n"},
+                expected_results={
+                    "<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n</style>\n"
+                },
                 expected_num_reports=2,
                 strategies=["cssbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
+                                     reason="cssbeautifier required"),
         ),
         # test beautify css embedded in html with no end
         pytest.param(
@@ -350,12 +395,13 @@ def replay_run(testcases, **_):
                 expected_num_reports=2,
                 strategies=["cssbeautify"],
             ),
-            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"),
+            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
+                                     reason="cssbeautifier required"),
         ),
     ]
 )
-def test_beautifier(mocker, tmp_path, test_data, test_name, expected_run_calls, expected_results,
-                    expected_num_reports, strategies):
+def test_beautifier(mocker, tmp_path, test_data, test_name, expected_run_calls,
+                    expected_results, expected_num_reports, strategies):
     """test for the "beautify" strategies"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
 
@@ -363,9 +409,12 @@ def replay_run(testcases, **_):
         for test in testcases:
             contents = test.get_file(test_name).data.decode("ascii")
             LOG.debug("interesting if 'required' in %r", contents)
-            if ("required" in contents and ("requisite" not in test_data or "requisite" in contents)) \
-                    or "'requi'+'red'" in contents:
-                log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+            if (("required" in contents and
+                    ("requisite" not in test_data or "requisite" in contents))
+                    or "'requi'+'red'" in contents):
+                log_path = tmp_path / (
+                    "crash%d_logs" % (replayer.return_value.run.call_count,)
+                )
                 log_path.mkdir()
                 _fake_save_logs_foo(log_path)
                 report = Report(str(log_path), "bin")
@@ -381,8 +430,8 @@ def replay_run(testcases, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies, log_path,
-                            use_analysis=False)
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies,
+                            log_path, use_analysis=False)
         assert mgr.run()
     finally:
         for test in tests:
@@ -398,8 +447,8 @@ def replay_run(testcases, **_):
 
 PurgeUnservedTestParams = namedtuple(
     "PurgeUnservedTestParams",
-    "strategies, test_data, served, expected_results, expected_run_calls, expected_num_reports, "
-    "purging_breaks"
+    "strategies, test_data, served, expected_results, expected_run_calls,"
+    "expected_num_reports, purging_breaks"
 )
 
 
@@ -426,7 +475,8 @@ def replay_run(testcases, **_):
             expected_num_reports=2,
             purging_breaks=False,
         ),
-        # single test, first reduction uses 2 files, second uses only optional file. (no results -> Assertion)
+        # single test, first reduction uses 2 files, second uses only optional file.
+        # (no results -> Assertion)
         PurgeUnservedTestParams(
             strategies=["chars"],
             test_data=[{"test.html": "123", "opt.html": "456"}],
@@ -436,10 +486,12 @@ def replay_run(testcases, **_):
             expected_num_reports=None,
             purging_breaks=True,
         ),
-        # double test, first reduction uses all files, second uses only target file in second test.
+        # double test, first reduction uses all files, second uses only target file in
+        # second test.
         PurgeUnservedTestParams(
             strategies=["chars"],
-            test_data=[{"test.html": "123", "opt.html": "456"}, {"test.html": "789", "opt.html": "abc"}],
+            test_data=[{"test.html": "123", "opt.html": "456"},
+                       {"test.html": "789", "opt.html": "abc"}],
             served=[[["test.html", "opt.html"], ["test.html", "opt.html"]],
                     [["test.html", "opt.html"], ["test.html"]],
                     [["test.html", "opt.html"], ["test.html"]]],
@@ -448,10 +500,12 @@ def replay_run(testcases, **_):
             expected_num_reports=3,
             purging_breaks=False,
         ),
-        # double test, first reduction uses all files, second uses only optional file (first test remains)
+        # double test, first reduction uses all files, second uses only optional file
+        # (first test remains)
         PurgeUnservedTestParams(
             strategies=["chars"],
-            test_data=[{"test.html": "123", "opt.html": "456"}, {"test.html": "789", "opt.html": "abc"}],
+            test_data=[{"test.html": "123", "opt.html": "456"},
+                       {"test.html": "789", "opt.html": "abc"}],
             served=[[["test.html", "opt.html"], ["test.html", "opt.html"]],
                     [["test.html", "opt.html"], ["opt.html"]],
                     [["test.html", "opt.html"]]],
@@ -463,7 +517,8 @@ def replay_run(testcases, **_):
         # triple test, list strategy. first test gets reduced, third gets eliminated
         PurgeUnservedTestParams(
             strategies=["list"],
-            test_data=[{"test.html": "123"}, {"test.html": "456"}, {"test.html": "789"}],
+            test_data=[{"test.html": "123"}, {"test.html": "456"},
+                       {"test.html": "789"}],
             served=[[["test.html"]],
                     [["test.html"]],
                     [["test.html"]]],
@@ -475,7 +530,8 @@ def replay_run(testcases, **_):
         # triple test, list strategy. None for served still eliminates first two tests
         PurgeUnservedTestParams(
             strategies=["list"],
-            test_data=[{"test.html": "123"}, {"test.html": "456"}, {"test.html": "789"}],
+            test_data=[{"test.html": "123"}, {"test.html": "456"},
+                       {"test.html": "789"}],
             served=[None, None, None],
             expected_results={"789"},
             expected_run_calls=2,
@@ -484,8 +540,9 @@ def replay_run(testcases, **_):
         ),
     ]
 )
-def test_purge_unserved(mocker, tmp_path, strategies, test_data, served, expected_results, expected_run_calls,
-                        expected_num_reports, purging_breaks):
+def test_purge_unserved(mocker, tmp_path, strategies, test_data, served,
+                        expected_results, expected_run_calls, expected_num_reports,
+                        purging_breaks):
     """test purging unserved files"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
 
@@ -521,8 +578,8 @@ def replay_run(testcases, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies, log_path,
-                            use_analysis=False)
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies,
+                            log_path, use_analysis=False)
         if purging_breaks:
             with raises(AssertionError):
                 mgr.run()

From be5b8692e232120b5d9bdf82c00867c8bbca0390 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 29 Oct 2020 09:45:36 -0400
Subject: [PATCH 071/531] [reduce] Use replay `exit_early` to simplify
 analysis.

---
 grizzly/reduce/core.py        | 60 +++++++++++++++++------------------
 grizzly/reduce/test_reduce.py | 31 ++++++++++--------
 2 files changed, 48 insertions(+), 43 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index d3af4160..7cf6bfe4 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -220,40 +220,40 @@ def run_reliability_analysis(self):
             if not use_harness and harness_crashes == self.ANALYSIS_ITERATIONS:
                 continue
 
-            with ReplayManager(self.ignore, self.server, self.target,
-                               any_crash=self._any_crash, signature=self._signature,
-                               use_harness=use_harness) as replay:
+            with ReplayManager(
+                self.ignore, self.server, self.target, any_crash=self._any_crash,
+                signature=self._signature, use_harness=use_harness,
+            ) as replay:
                 LOG.info("Running for %d iterations to assess reliability %s harness.",
                          self.ANALYSIS_ITERATIONS,
                          "using" if use_harness else "without")
-                for _ in range(self.ANALYSIS_ITERATIONS):
-                    try:
-                        results = replay.run(self.testcases, repeat=1, min_results=1,
-                                             idle_delay=self._idle_delay,
-                                             idle_threshold=self._idle_threshold)
-                    except (TargetLaunchError, TargetLaunchTimeout) as exc:
-                        if isinstance(exc, TargetLaunchError) and exc.report:
-                            self.report([ReplayResult(exc.report, None, [], False)],
-                                        self.testcases)
-                            exc.report.cleanup()
-                        raise
+                try:
+                    results = replay.run(
+                        self.testcases, repeat=self.ANALYSIS_ITERATIONS, min_results=1,
+                        exit_early=False, idle_delay=self._idle_delay,
+                        idle_threshold=self._idle_threshold,
+                    )
+                except (TargetLaunchError, TargetLaunchTimeout) as exc:
+                    if isinstance(exc, TargetLaunchError) and exc.report:
+                        self.report([ReplayResult(exc.report, None, [], False)],
+                                    self.testcases)
+                        exc.report.cleanup()
+                    raise
+                try:
                     self.update_timeout(results)
-                    try:
-                        success = any(result.expected for result in results)
-                        LOG.info("result: %s",
-                                 "interesting." if success else "not interesting.")
-                        self.report(
-                            [result for result in results if not result.expected],
-                            self.testcases)
-                    finally:
-                        for result in results:
-                            result.report.cleanup()
-                    if success and use_harness:
-                        harness_crashes += 1
-                    elif success:
-                        non_harness_crashes += 1
+                    crashes = sum(x.count for x in results if x.expected)
+                    self.report(
+                        [result for result in results if not result.expected],
+                        self.testcases)
+                    if crashes and use_harness:
+                        harness_crashes = crashes
+                    elif crashes:
+                        non_harness_crashes = crashes
+                finally:
+                    for result in results:
+                        result.report.cleanup()
                 LOG.info("Testcase was interesting %0.1f%% of %d attempts %s harness.",
-                         100.0 * harness_crashes / self.ANALYSIS_ITERATIONS,
+                         100.0 * crashes / self.ANALYSIS_ITERATIONS,
                          self.ANALYSIS_ITERATIONS,
                          "using" if use_harness else "without")
                 # ensure same signature is always used
@@ -290,7 +290,7 @@ def run_reliability_analysis(self):
         return (repeat, min_crashes)
 
     def run(self, repeat=1, min_results=1):
-        """Run testcase replay.
+        """Run testcase reduction.
 
         Args:
             repeat (int): Maximum number of times to run the TestCase.
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index a0b5031c..c5993fb1 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -74,19 +74,24 @@ def test_analysis(mocker, tmp_path, crashes, expected_repeat, expected_min_crash
                   use_harness, result_harness):
     """test that analysis sets reasonable params"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
-    expected_iters = len(crashes)
-
-    def replay_run(_, **_kw):
-        LOG.debug("interesting: %r", crashes[0])
-        if crashes.pop(0):
-            log_path = tmp_path / (
-                "crash%d_logs" % (replayer.return_value.run.call_count,)
-            )
-            log_path.mkdir()
-            _fake_save_logs_foo(log_path)
-            report = Report(str(log_path), "bin")
-            return [ReplayResult(report, [["test.html"]], [], True)]
-        return []
+    expected_iters = len(crashes) / 11
+
+    def replay_run(_, **kw):
+        results = []
+        repeat = kw["repeat"]
+        assert repeat <= len(crashes)
+        assert not kw["exit_early"]
+        for _ in range(repeat):
+            LOG.debug("interesting: %r", crashes[0])
+            if crashes.pop(0):
+                log_path = tmp_path / (
+                    "crash%d_logs" % (replayer.return_value.run.call_count,)
+                )
+                log_path.mkdir(exist_ok=True)
+                _fake_save_logs_foo(log_path)
+                report = Report(str(log_path), "bin")
+                results.append(ReplayResult(report, [["test.html"]], [], True))
+        return results
     replayer.return_value.__enter__.return_value.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")

From c17208d5d14029a446bb6e973881d0e16f236818 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 29 Oct 2020 09:54:29 -0400
Subject: [PATCH 072/531] [reducer] Add "try" testcase caching between
 files/strategies.

Previously, caching only worked within lithium so identical attempts on
the same file & strategy would not be repeated. This change makes the
cache work across all files and between strategies in Lithium.
---
 grizzly/reduce/core.py            |  8 ++++
 grizzly/reduce/strategies.py      | 76 ++++++++++++++++++++++++++++++-
 grizzly/reduce/test_strategies.py | 30 ++++++++++--
 setup.py                          |  2 +-
 4 files changed, 110 insertions(+), 6 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 7cf6bfe4..2507ef91 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -302,6 +302,7 @@ def run(self, repeat=1, min_results=1):
         """
         any_success = False
         last_reports = None
+        last_tried = None
         for strategy_no, strategy in enumerate(self.strategies):
             LOG.info("Using strategy %s (%d/%d)", strategy, strategy_no + 1,
                      len(self.strategies))
@@ -314,6 +315,9 @@ def run(self, repeat=1, min_results=1):
                                    any_crash=self._any_crash, signature=self._signature,
                                    use_harness=self._use_harness)
             strategy = STRATEGIES[strategy](self.testcases)
+            if last_tried is not None:
+                strategy.update_tried(last_tried)
+                last_tried = None
             with replay, strategy:
                 best_results = []
                 attempt_no = 0
@@ -391,6 +395,10 @@ def run(self, repeat=1, min_results=1):
                 # if self._signature was already set, this will do nothing
                 # otherwise, ensure the first found signature is used throughout
                 self._signature = replay.signature
+
+            # store "tried" cache to pass to next strategy
+            last_tried = strategy.get_tried()
+
         # if we complete all strategies, mark the last reported crashes as reduced
         if self._report_to_fuzzmanager and last_reports:
             for crash_id in last_reports:
diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index 5c3bf9c5..e1f59f4e 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -17,7 +17,8 @@
     HAVE_JSBEAUTIFIER (bool): True if `jsbeautifier` module is available.
 """
 from abc import ABC, abstractmethod
-from logging import getLogger
+from hashlib import sha512
+from logging import DEBUG, getLogger
 from pathlib import Path
 import re
 from shutil import rmtree
@@ -105,9 +106,59 @@ def __init__(self, testcases):
                 List of testcases to reduce. The object does not take ownership of the
                 testcases.
         """
+        self._tried = set()  # set of tuple(tuple(str(Path), SHA512))
         self._testcase_root = Path(mkdtemp(prefix="tc_", dir=grz_tmp("reduce")))
         self.dump_testcases(testcases)
 
+    def _calculate_testcase_hash(self):
+        """Calculate hashes of all files in testcase root.
+
+        Returns:
+            tuple(tuple(str, str)): A tuple of 2-tuples mapping str(Path) to SHA-512 of each
+                                    file in testcase root.
+        """
+        result = []
+        for path in self._testcase_root.glob("**/*"):
+            if path.is_file():
+                tf_hash = sha512()
+                tf_hash.update(path.read_bytes())
+                result.append(
+                    (str(path.relative_to(self._testcase_root)), tf_hash.digest())
+                )
+        result = tuple(sorted(result))
+
+        if LOG.getEffectiveLevel() == DEBUG:
+            print_hash = sha512()
+            print_hash.update(repr(result).encode("utf-8", errors="surrogateescape"))
+            in_tried = result in self._tried
+            LOG.debug(
+                "Testcase hash: %s (%sin cache)",
+                print_hash.hexdigest()[:32], "" if in_tried else "not "
+            )
+
+        return result
+
+    def update_tried(self, tried):
+        """Update the list of tried testcase/hash sets. Testcases are hashed with
+        SHA-512 and digested to bytes (`hashlib.sha512(testcase).digest()`)
+
+        Arguments:
+            tried (iterable(tuple(tuple(str, str)))): Set of already tried testcase hashes.
+
+        Returns:
+            None
+        """
+        self._tried.update(frozenset(tried))
+
+    def get_tried(self):
+        """Return the set of tried testcase hashes. Testcases are hashed with SHA-512
+        and digested to bytes (`hashlib.sha512(testcase).digest()`)
+
+        Returns:
+            frozenset(tuple(tuple(str, str))): Testcase hashes.
+        """
+        return frozenset(self._tried)
+
     def dump_testcases(self, testcases, recreate_tcroot=False):
         """Dump a testcase list to the testcase root on disk.
 
@@ -428,6 +479,12 @@ def __iter__(self):
                     LOG.warning("<%s> tags not found, skipping", self.tag_name)
                     continue
 
+            tc_hash = self._calculate_testcase_hash()
+            if tc_hash in self._tried:
+                LOG.info("cache hit, reverting")
+                lith_tc.dump(file)
+                continue
+
             yield TestCase.load(str(self._testcase_root), False)
 
             assert self._current_feedback is not None, "No feedback for last iteration"
@@ -436,6 +493,7 @@ def __iter__(self):
             else:
                 LOG.warning("%s failed (reverting)", self.name)
                 lith_tc.dump(file)
+                self._tried.add(tc_hash)
             self._current_feedback = None
 
 
@@ -538,6 +596,20 @@ def __iter__(self):
             lithium_testcase.load(file)
             # pylint: disable=not-callable
             self._current_reducer = self.strategy_cls().reduce(lithium_testcase)
+
+            # populate the lithium strategy "tried" cache
+            # use all cache values where all hashes other than the current file match
+            # the current testcase_root state.
+            current_tc_hash_map = dict(self._calculate_testcase_hash())
+            del current_tc_hash_map[str(file.relative_to(self._testcase_root))]
+            this_tc_tried = set()
+            for tried in self._tried:
+                tried = dict(tried)
+                tc_tried = tried.pop(str(file.relative_to(self._testcase_root)))
+                if tried == current_tc_hash_map:
+                    this_tc_tried.add(tc_tried)
+            self._current_reducer.update_tried(this_tc_tried)
+
             for reduction in self._current_reducer:
                 reduction.dump()
                 testcases = TestCase.load(str(self._testcase_root), False)
@@ -545,6 +617,8 @@ def __iter__(self):
                 yield testcases
                 if self._current_feedback:
                     testcase_root_dirty = False
+                else:
+                    self._tried.add(self._calculate_testcase_hash())
                 if self._current_feedback and self._current_served is not None:
                     testcases = TestCase.load(str(self._testcase_root), False)
                     try:
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 6ab1e29a..65eb2e02 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -398,6 +398,22 @@ def replay_run(testcases, **_):
             marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
                                      reason="cssbeautifier required"),
         ),
+        # test almost beautified css (any change breaks test, beautify only removes an extra blank line,
+        # so `lines` will have already tried it, and this will hit the cache)
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="<style nochange=true>\n/*DDBEGIN*/\n\nrequisite {\n  required: 1\n}\n/*DDEND*/\n</style>\n",
+                test_name="test.html",
+                expected_run_calls=8,
+                expected_results={
+                    "<style nochange=true>\n/*DDBEGIN*/\n\nrequisite {\n  required: 1\n}\n/*DDEND*/\n</style>\n"
+                },
+                expected_num_reports=2,
+                strategies=["check", "lines", "cssbeautify"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
+                                     reason="cssbeautifier required"),
+        ),
     ]
 )
 def test_beautifier(mocker, tmp_path, test_data, test_name, expected_run_calls,
@@ -408,10 +424,16 @@ def test_beautifier(mocker, tmp_path, test_data, test_name, expected_run_calls,
     def replay_run(testcases, **_):
         for test in testcases:
             contents = test.get_file(test_name).data.decode("ascii")
-            LOG.debug("interesting if 'required' in %r", contents)
-            if (("required" in contents and
-                    ("requisite" not in test_data or "requisite" in contents))
-                    or "'requi'+'red'" in contents):
+            if "nochange" in test_data:
+                LOG.debug("interesting if test unchanged")
+                interesting = test_data == contents
+            elif "requisite" in test_data:
+                LOG.debug("interesting if ('requisite' and 'required') or 'requi'+'red' in %r", contents)
+                interesting = ("required" in contents and "requisite" in contents) or "'requi'+'red'" in contents
+            else:
+                LOG.debug("interesting if 'required' or 'requi'+'red' in %r", contents)
+                interesting = "required" in contents or "'requi'+'red'" in contents
+            if interesting:
                 log_path = tmp_path / (
                     "crash%d_logs" % (replayer.return_value.run.call_count,)
                 )
diff --git a/setup.py b/setup.py
index 35a2007b..352a1de7 100755
--- a/setup.py
+++ b/setup.py
@@ -10,7 +10,7 @@
 
 
 EXTRAS = {
-    'reduce': ['cssbeautifier', 'lithium-reducer>=0.4', 'jsbeautifier'],
+    'reduce': ['cssbeautifier', 'lithium-reducer>=0.4.3', 'jsbeautifier'],
     's3': ['boto3'],
 }
 EXTRAS['all'] = list(set(chain.from_iterable(EXTRAS.values())))

From 79deda7ab48e6b86f8e13290f427efba8e31e6c1 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 29 Oct 2020 10:07:52 -0400
Subject: [PATCH 073/531] [reducer] Only run "beautify" attempt if it had
 altered the file.

---
 grizzly/reduce/strategies.py      | 18 +++++++++++++++---
 grizzly/reduce/test_strategies.py | 15 +++++++++++++++
 2 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index e1f59f4e..5919af27 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -453,18 +453,26 @@ def __iter__(self):
 
             with file.open("wb") as testcase_fp:
                 last = 0
+                any_beautified = False
                 testcase_fp.write(lith_tc.before)
                 for start, end in self._chunks_to_beautify(lith_tc.before, raw, file):
                     before = raw[last:start]
                     testcase_fp.write(before)
                     to_beautify = raw[start:end]
+                    LOG.debug("before: %r", to_beautify)
                     beautified = self.beautify_bytes(to_beautify)
+                    LOG.debug("after: %r", beautified)
                     if beautified:
                         if before and not before.endswith(b"\n"):
-                            testcase_fp.write(b"\n")
-                        testcase_fp.write(beautified)
+                            beautified = b"\n" + beautified
                         if not beautified.endswith(b"\n"):
-                            testcase_fp.write(b"\n")
+                            beautified = beautified + b"\n"
+
+                        testcase_fp.write(beautified)
+                        if beautified == to_beautify:
+                            LOG.warning("Beautify had no effect!")
+                        else:
+                            any_beautified = True
                     elif to_beautify.strip():  # pragma: no cover
                         # this should never happen, but just in case...
                         # pragma: no cover
@@ -479,6 +487,10 @@ def __iter__(self):
                     LOG.warning("<%s> tags not found, skipping", self.tag_name)
                     continue
 
+                if not any_beautified:
+                    LOG.warning("Beautify had no effect on the file, skipping")
+                    continue
+
             tc_hash = self._calculate_testcase_hash()
             if tc_hash in self._tried:
                 LOG.info("cache hit, reverting")
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 65eb2e02..2141d4a4 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -398,6 +398,21 @@ def replay_run(testcases, **_):
             marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
                                      reason="cssbeautifier required"),
         ),
+        # test already beautified css (beautify does nothing)
+        pytest.param(
+            *BeautifyStrategyParams(
+                test_data="<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n</style>\n",
+                test_name="test.html",
+                expected_run_calls=1,
+                expected_results={
+                    "<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n</style>\n"
+                },
+                expected_num_reports=2,
+                strategies=["check", "cssbeautify"],
+            ),
+            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
+                                     reason="cssbeautifier required"),
+        ),
         # test almost beautified css (any change breaks test, beautify only removes an extra blank line,
         # so `lines` will have already tried it, and this will hit the cache)
         pytest.param(

From 2d75a61fbf85642eb768dd535efb4eca78a6b3a9 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 29 Oct 2020 11:55:39 -0400
Subject: [PATCH 074/531] [reducer] Record and stats per-stage and report them
 to the console.

---
 grizzly/reduce/core.py        | 204 +++++++++++++++++++++++++++++++---
 grizzly/reduce/test_reduce.py |   5 +-
 2 files changed, 195 insertions(+), 14 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 2507ef91..73ebb5f6 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -4,12 +4,17 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """`ReduceManager` finds the smallest testcase(s) to reproduce an issue.
 """
-from itertools import chain
+from collections import namedtuple
+from functools import partial
+from itertools import chain, zip_longest
+from locale import LC_ALL, setlocale
 from logging import getLogger
 from math import ceil, log
 from pathlib import Path
+import re
 from shutil import rmtree
 from tempfile import mkdtemp
+from time import gmtime, strftime, time
 
 from Collector.Collector import Collector
 from FTB.Signatures.CrashInfo import CrashSignature
@@ -62,6 +67,59 @@ def change_quality(crash_id, quality):
             raise
 
 
+ReductionStat = namedtuple("ReductionStat", "name, duration, iterations, size")
+
+
+class _FormatTable(object):
+    """Format tabular data in a table.
+    """
+    def __init__(self, columns, formatters, vsep=" | ", hsep="-"):
+        """Initialize a FormatTable instance.
+
+        Arguments:
+            columns (iterable(str)): List of column names for the table header.
+            formatters (iterable(callable)): List of format functions for each column.
+            vsep (str): Vertical separation between columns.
+            hsep (str): Horizontal separation between header and data.
+        """
+        assert len(columns) == len(formatters)
+        self._columns = columns
+        self._formatters = formatters
+        self._vsep = vsep
+        self._hsep = hsep
+
+    def format_rows(self, rows):
+        """Format rows as a table and return a line generator.
+
+        Arguments:
+            rows (list(list(str))): Tabular data. Each row must be the same length as
+                                    `columns` passed to `__init__`.
+
+        Yields:
+            str: Each line of formatted tabular data.
+        """
+        max_width = [len(col) for col in self._columns]
+        formatted = []
+        for row in rows:
+            assert len(row) == len(self._columns)
+            formatted.append([])
+            for idx, (data, formatter) in enumerate(zip(row, self._formatters)):
+                data = formatter(data)
+                max_width[idx] = max(max_width[idx], len(data))
+                formatted[-1].append(data)
+
+        # build a format_str to space out the columns with separators using `max_width`
+        # the first column is left-aligned, and other fields are right-aligned.
+        format_str = self._vsep.join(
+            field % (width,)
+            for field, width in zip_longest(["%%-%ds"], max_width, fillvalue="%%%ds")
+        )
+        yield format_str % self._columns
+        yield self._hsep * (len(self._vsep) * (len(self._columns) - 1) + sum(max_width))
+        for row in formatted:
+            yield format_str % tuple(row)
+
+
 class ReduceManager(object):
     """Manage reduction of one or more testcases to find the smallest testcase
     that reproduces a given issue.
@@ -138,6 +196,7 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
         self._static_timeout = static_timeout
         self._idle_delay = idle_delay
         self._idle_threshold = idle_threshold
+        self._stats = []
 
     def update_timeout(self, results):
         """Tune idle/server timeout values based on actual duration of expected results.
@@ -191,14 +250,15 @@ def update_timeout(self, results):
             LOG.info("Updating max timeout to: %r", new_iter_timeout)
             self.server.timeout = new_iter_timeout
 
-    def run_reliability_analysis(self):
+    def run_reliability_analysis(self, stats):
         """Run several analysis passes of the current testcase to find `run` parameters.
 
         The number of repetitions and minimum number of crashes are calculated to
         maximize the chances of observing the expected crash.
 
         Arguments:
-            None
+            stats (object): Opaque stats object. Increment the ".iters" attribute with the
+                            number of iterations performed.
 
         Returns:
             tuple(int, int): Values for `repeat` and `min_crashes` resulting from
@@ -240,6 +300,7 @@ def run_reliability_analysis(self):
                         exc.report.cleanup()
                     raise
                 try:
+                    stats.iters += self.ANALYSIS_ITERATIONS
                     self.update_timeout(results)
                     crashes = sum(x.count for x in results if x.expected)
                     self.report(
@@ -289,6 +350,78 @@ def run_reliability_analysis(self):
                      "more" if harness_crashes > non_harness_crashes else "less")
         return (repeat, min_crashes)
 
+    def record_stat_milestone(self, name, elapsed=None, iters=None):
+        """Record reduction stats for a given point in time:
+
+        - name of the milestone (eg. init, strategy name completed)
+        - current testcase size (bytes)
+        - elapsed time (seconds)
+        - # of iterations
+
+        Arguments:
+            name (str): name of milestone
+            elapsed (float or None): seconds elapsed for period recorded
+            iters (int or None): # of iterations performed
+
+        Returns:
+            None
+        """
+        testcase_size = sum(tc.data_size for tc in self.testcases)
+        self._stats.append(
+            ReductionStat(
+                name=name,
+                size=testcase_size,
+                duration=elapsed,
+                iterations=iters,
+            )
+        )
+
+    def time_stat_milestone(self, name):
+        """Time and record the period leading up to a reduction milestone.
+        eg. a strategy being run.
+
+        Arguments:
+            name (str): name of milestone
+
+        Returns:
+            context: Timer context for the period being recorded up to the milestone.
+
+                     Attributes:
+                        iters (int): # of iterations performed during period
+        """
+        # pylint: disable=no-self-argument
+        class _MilestoneTimer(object):
+            def __init__(sub):
+                sub._start = None
+                sub.iters = 0
+
+            def __enter__(sub):
+                sub._start = time()
+                return sub
+
+            def __exit__(sub, exc_type, exc_value, traceback):
+                elapsed = time() - sub._start
+                self.record_stat_milestone(name, elapsed=elapsed, iters=sub.iters)
+        return _MilestoneTimer()
+
+    def calculate_stat_total(self, name):
+        """Calculate a "total" by summing the time and iterations in the stats table.
+
+        Arguments:
+            name (str): name of milestone (eg. final, total)
+
+        Returns:
+            None
+        """
+        duration = 0
+        iters = 0
+        for stat in self._stats:
+            if stat.duration is not None:
+                duration += stat.duration
+            if stat.iterations is not None:
+                iters += stat.iterations
+        self.record_stat_milestone(name, elapsed=duration, iters=iters)
+
     def run(self, repeat=1, min_results=1):
         """Run testcase reduction.
 
@@ -303,14 +436,17 @@ def run(self, repeat=1, min_results=1):
         any_success = False
         last_reports = None
         last_tried = None
+        self.record_stat_milestone("init")
+        if self._use_analysis:
+            with self.time_stat_milestone("analysis") as stats:
+                repeat, min_results = self.run_reliability_analysis(stats)
+        self.target.relaunch = min(self._original_relaunch, repeat)
+        LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
+                 repeat, min_results, self.target.relaunch)
         for strategy_no, strategy in enumerate(self.strategies):
+            LOG.info("")
             LOG.info("Using strategy %s (%d/%d)", strategy, strategy_no + 1,
                      len(self.strategies))
-            if self._use_analysis:
-                repeat, min_results = self.run_reliability_analysis()
-            self.target.relaunch = min(self._original_relaunch, repeat)
-            LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
-                     repeat, min_results, self.target.relaunch)
             replay = ReplayManager(self.ignore, self.server, self.target,
                                    any_crash=self._any_crash, signature=self._signature,
                                    use_harness=self._use_harness)
@@ -318,13 +454,11 @@ def run(self, repeat=1, min_results=1):
             if last_tried is not None:
                 strategy.update_tried(last_tried)
                 last_tried = None
-            with replay, strategy:
+            with replay, strategy, self.time_stat_milestone(strategy.name) as stats:
                 best_results = []
-                attempt_no = 0
                 try:
                     for reduction in strategy:
-                        attempt_no += 1
-                        LOG.info("Attempt #%d", attempt_no)
+                        stats.iters += 1
                         keep_reduction = False
                         results = []
                         try:
@@ -358,7 +492,7 @@ def run(self, repeat=1, min_results=1):
                             # if the reduction reproduced,
                             #   update self.testcases (new best)
                             if success:
-                                LOG.info("Attempt succeeded")
+                                LOG.info("Reduction succeeded")
                                 for testcase in self.testcases:
                                     testcase.cleanup()
                                 self.testcases = reduction
@@ -403,6 +537,49 @@ def run(self, repeat=1, min_results=1):
         if self._report_to_fuzzmanager and last_reports:
             for crash_id in last_reports:
                 change_quality(crash_id, FuzzManagerReporter.QUAL_REDUCED_RESULT)
+
+        # log a summary of what was done.
+        self.calculate_stat_total("final")
+
+        def _format_duration(duration, total=0):
+            result = ""
+            if duration is not None:
+                if total == 0:
+                    percent = 0
+                else:
+                    percent = int(100 * duration / total)
+                # format H:M:S, and then remove all leading zeros with regex
+                result = re.sub("^[0:]*", "", strftime("%H:%M:%S", gmtime(duration)))
+                # if the result is all zeroes, ensure one zero is output
+                if not result:
+                    result = "0"
+                result += " (%3d%%)" % (percent,)
+            return result
+
+        def _format_number(number, total=0):
+            result = ""
+            if number is not None:
+                if total == 0:
+                    percent = 0
+                else:
+                    percent = int(100 * number / total)
+                result = "{:n} ({:3d}%)".format(number, percent)
+            return result
+
+        tabulator = _FormatTable(
+            ReductionStat._fields,
+            ReductionStat(
+                name=str,
+                # duration and iterations are % of total (last), size % of init (first)
+                duration=partial(_format_duration, total=self._stats[-1].duration),
+                iterations=partial(_format_number, total=self._stats[-1].iterations),
+                size=partial(_format_number, total=self._stats[0].size),
+            )
+        )
+        LOG.info("Reduction summary:")
+        for row in tabulator.format_rows(self._stats):
+            LOG.info(row)
+
         return any_success
 
     def report(self, results, testcases):
@@ -452,6 +629,7 @@ def main(cls, args):
             int: 0 for success. non-0 indicates a problem.
         """
         configure_logging(args.log_level)
+        setlocale(LC_ALL, "")
         if args.fuzzmanager:
             FuzzManagerReporter.sanity_check(args.binary)
 
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index c5993fb1..febeffe6 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -99,10 +99,13 @@ def replay_run(_, **kw):
     tests = [test]
     log_path = tmp_path / "logs"
 
+    class _ReduceStats:
+        iters = 0
+
     try:
         mgr = ReduceManager(None, mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target),
                             tests, None, log_path, use_harness=use_harness)
-        repeat, min_crashes = mgr.run_reliability_analysis()
+        repeat, min_crashes = mgr.run_reliability_analysis(_ReduceStats)
     finally:
         for test in tests:
             test.cleanup()

From 1a5dcb4dacdb62247f7606c3e827f8589ad1aaaf Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 29 Oct 2020 13:43:14 -0400
Subject: [PATCH 075/531] [reducer] Record stats total using a separate timer,
 so any time between strategies is still captured in the total.

---
 grizzly/reduce/core.py | 229 ++++++++++++++++++++---------------------
 1 file changed, 110 insertions(+), 119 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 73ebb5f6..7621794c 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -257,8 +257,8 @@ def run_reliability_analysis(self, stats):
         maximize the chances of observing the expected crash.
 
         Arguments:
-            stats (object): Opaque stats object. Increment the ".iters" attribute with the
-                            number of iterations performed.
+            stats (object): Opaque stats object. Increment the ".iters" attribute with
+                            the number of iterations performed.
 
         Returns:
             tuple(int, int): Values for `repeat` and `min_crashes` resulting from
@@ -404,24 +404,6 @@ def __exit__(sub, exc_type, exc_value, traceback):
                 self.record_stat_milestone(name, elapsed=elapsed, iters=sub.iters)
         return _MilestoneTimer()
 
-    def calculate_stat_total(self, name):
-        """Calculate a "total" by summing the time and iterations in the stats table.
-
-        Arguments:
-            name (str): name of milestone (eg. final, total)
-
-        Returns:
-            None
-        """
-        duration = 0
-        iters = 0
-        for stat in self._stats:
-            if stat.duration is not None:
-                duration += stat.duration
-            if stat.iterations is not None:
-                iters += stat.iterations
-        self.record_stat_milestone(name, elapsed=duration, iters=iters)
-
     def run(self, repeat=1, min_results=1):
         """Run testcase reduction.
 
@@ -437,110 +419,119 @@ def run(self, repeat=1, min_results=1):
         last_reports = None
         last_tried = None
         self.record_stat_milestone("init")
-        if self._use_analysis:
-            with self.time_stat_milestone("analysis") as stats:
-                repeat, min_results = self.run_reliability_analysis(stats)
-        self.target.relaunch = min(self._original_relaunch, repeat)
-        LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
-                 repeat, min_results, self.target.relaunch)
-        for strategy_no, strategy in enumerate(self.strategies):
-            LOG.info("")
-            LOG.info("Using strategy %s (%d/%d)", strategy, strategy_no + 1,
-                     len(self.strategies))
-            replay = ReplayManager(self.ignore, self.server, self.target,
-                                   any_crash=self._any_crash, signature=self._signature,
-                                   use_harness=self._use_harness)
-            strategy = STRATEGIES[strategy](self.testcases)
-            if last_tried is not None:
-                strategy.update_tried(last_tried)
-                last_tried = None
-            with replay, strategy, self.time_stat_milestone(strategy.name) as stats:
-                best_results = []
-                try:
-                    for reduction in strategy:
-                        stats.iters += 1
-                        keep_reduction = False
-                        results = []
-                        try:
+        # record total_stats overall so that any time missed by individual milestones
+        # will still be included in the total
+        with self.time_stat_milestone("final") as total_stats:
+            if self._use_analysis:
+                with self.time_stat_milestone("analysis") as stats:
+                    repeat, min_results = self.run_reliability_analysis(stats)
+                    total_stats.iters += stats.iters
+            self.target.relaunch = min(self._original_relaunch, repeat)
+            LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
+                     repeat, min_results, self.target.relaunch)
+            for strategy_no, strategy in enumerate(self.strategies):
+                LOG.info("")
+                LOG.info("Using strategy %s (%d/%d)", strategy, strategy_no + 1,
+                         len(self.strategies))
+                replay = ReplayManager(self.ignore, self.server, self.target,
+                                       any_crash=self._any_crash,
+                                       signature=self._signature,
+                                       use_harness=self._use_harness)
+                strategy = STRATEGIES[strategy](self.testcases)
+                if last_tried is not None:
+                    strategy.update_tried(last_tried)
+                    last_tried = None
+                with replay, strategy, self.time_stat_milestone(strategy.name) as stats:
+                    best_results = []
+                    try:
+                        for reduction in strategy:
+                            stats.iters += 1
+                            total_stats.iters += 1
+                            keep_reduction = False
+                            results = []
                             try:
-                                # reduction is a new list of testcases to be replayed
-                                results = replay.run(
-                                    reduction, repeat=repeat, min_results=min_results,
-                                    idle_delay=self._idle_delay,
-                                    idle_threshold=self._idle_threshold)
-                            except (TargetLaunchError, TargetLaunchTimeout) as exc:
-                                if isinstance(exc, TargetLaunchError) and exc.report:
-                                    self.report(
-                                        [ReplayResult(exc.report, None, [], False)],
-                                        reduction)
-                                    exc.report.cleanup()
-                                raise
-                            self.update_timeout(results)
-                            # get the first expected result (if any),
-                            #   and update the strategy
-                            first_expected = next((report for report in results
-                                                   if report.expected), None)
-                            success = first_expected is not None
-                            served = None
-                            if success and not self._any_crash:
-                                served = first_expected.served
-                            strategy.update(success, served=served)
-                            if strategy.name == "check":
-                                if any_success and not success:
-                                    raise RuntimeError("Reduction broke")
-                            any_success = any_success or success
-                            # if the reduction reproduced,
-                            #   update self.testcases (new best)
-                            if success:
-                                LOG.info("Reduction succeeded")
-                                for testcase in self.testcases:
-                                    testcase.cleanup()
-                                self.testcases = reduction
-                                keep_reduction = True
-                                # cleanup old best results
-                                for result in best_results:
+                                try:
+                                    # reduction is a new list of testcases to be
+                                    # replayed
+                                    results = replay.run(
+                                        reduction, repeat=repeat,
+                                        min_results=min_results,
+                                        idle_delay=self._idle_delay,
+                                        idle_threshold=self._idle_threshold)
+                                except (TargetLaunchError, TargetLaunchTimeout) as exc:
+                                    if (
+                                        isinstance(exc, TargetLaunchError)
+                                        and exc.report
+                                    ):
+                                        self.report(
+                                            [ReplayResult(exc.report, None, [], False)],
+                                            reduction)
+                                        exc.report.cleanup()
+                                    raise
+                                self.update_timeout(results)
+                                # get the first expected result (if any),
+                                #   and update the strategy
+                                first_expected = next((report for report in results
+                                                       if report.expected), None)
+                                success = first_expected is not None
+                                served = None
+                                if success and not self._any_crash:
+                                    served = first_expected.served
+                                strategy.update(success, served=served)
+                                if strategy.name == "check":
+                                    if any_success and not success:
+                                        raise RuntimeError("Reduction broke")
+                                any_success = any_success or success
+                                # if the reduction reproduced,
+                                #   update self.testcases (new best)
+                                if success:
+                                    LOG.info("Reduction succeeded")
+                                    for testcase in self.testcases:
+                                        testcase.cleanup()
+                                    self.testcases = reduction
+                                    keep_reduction = True
+                                    # cleanup old best results
+                                    for result in best_results:
+                                        result.report.cleanup()
+                                    # filter expected results out into `best_results`
+                                    best_results = [result for result in results
+                                                    if result.expected]
+                                    results = [result for result in results
+                                               if not result.expected]
+                                else:
+                                    LOG.info("Attempt failed")
+                                # if the reduction found other crashes,
+                                #   report those immediately
+                                self.report(results, reduction)
+                            finally:  # noqa pylint: disable=bare-except
+                                if not keep_reduction:
+                                    for testcase in reduction:
+                                        testcase.cleanup()
+                                for result in results:
                                     result.report.cleanup()
-                                # filter expected results out into `best_results`
-                                best_results = [result for result in results
-                                                if result.expected]
-                                results = [result for result in results
-                                           if not result.expected]
-                            else:
-                                LOG.info("Attempt failed")
-                            # if the reduction found other crashes,
-                            #   report those immediately
-                            self.report(results, reduction)
-                        finally:  # noqa pylint: disable=bare-except
-                            if not keep_reduction:
-                                for testcase in reduction:
-                                    testcase.cleanup()
-                            for result in results:
-                                result.report.cleanup()
-                    last_reports = self.report(best_results, self.testcases)
-                except KeyboardInterrupt:
-                    if best_results:
                         last_reports = self.report(best_results, self.testcases)
-                        LOG.warning("Ctrl+C detected, best reduction so far reported "
-                                    "as %r", last_reports)
-                    raise
-                finally:
-                    for result in best_results:
-                        result.report.cleanup()
-                # if self._signature was already set, this will do nothing
-                # otherwise, ensure the first found signature is used throughout
-                self._signature = replay.signature
-
-            # store "tried" cache to pass to next strategy
-            last_tried = strategy.get_tried()
-
-        # if we complete all strategies, mark the last reported crashes as reduced
-        if self._report_to_fuzzmanager and last_reports:
-            for crash_id in last_reports:
-                change_quality(crash_id, FuzzManagerReporter.QUAL_REDUCED_RESULT)
+                    except KeyboardInterrupt:
+                        if best_results:
+                            last_reports = self.report(best_results, self.testcases)
+                            LOG.warning("Ctrl+C detected, best reduction so far "
+                                        "reported as %r", last_reports)
+                        raise
+                    finally:
+                        for result in best_results:
+                            result.report.cleanup()
+                    # if self._signature was already set, this will do nothing
+                    # otherwise, ensure the first found signature is used throughout
+                    self._signature = replay.signature
+
+                # store "tried" cache to pass to next strategy
+                last_tried = strategy.get_tried()
+
+            # if we complete all strategies, mark the last reported crashes as reduced
+            if self._report_to_fuzzmanager and last_reports:
+                for crash_id in last_reports:
+                    change_quality(crash_id, FuzzManagerReporter.QUAL_REDUCED_RESULT)
 
         # log a summary of what was done.
-        self.calculate_stat_total("final")
-
         def _format_duration(duration, total=0):
             result = ""
             if duration is not None:

From ab9087f2c181d12e261bae0d8a5e56628a213cbb Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 29 Oct 2020 14:08:43 -0400
Subject: [PATCH 076/531] [reducer] Return a FuzzManagerReporter quality value
 rather than 0/1.

QUAL_REDUCED_RESULT (0) still indicates success.
---
 grizzly/reduce/core.py            | 17 ++++++++++----
 grizzly/reduce/test_main.py       | 37 ++++++++++++++++---------------
 grizzly/reduce/test_reduce.py     | 30 ++++++++++++-------------
 grizzly/reduce/test_strategies.py |  6 ++---
 4 files changed, 50 insertions(+), 40 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 7621794c..2f4992d2 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -413,7 +413,7 @@ def run(self, repeat=1, min_results=1):
                                be considered successful.
 
         Returns:
-            bool: Whether a crash was observed (ie. reduction was successful).
+            int: One of the `FuzzManagerReporter.QUAL_*` constants.
         """
         any_success = False
         last_reports = None
@@ -571,7 +571,9 @@ def _format_number(number, total=0):
         for row in tabulator.format_rows(self._stats):
             LOG.info(row)
 
-        return any_success
+        if any_success:
+            return FuzzManagerReporter.QUAL_REDUCED_RESULT
+        return FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE
 
     def report(self, results, testcases):
         """Report results, either to FuzzManager or to filesystem.
@@ -708,8 +710,15 @@ def main(cls, args):
                     static_timeout=args.static_timeout,
                     idle_delay=args.idle_delay,
                     idle_threshold=args.idle_threshold)
-                success = mgr.run(repeat=args.repeat, min_results=args.min_crashes)
-            return 0 if success else 1
+                try:
+                    return_code = mgr.run(
+                        repeat=args.repeat,
+                        min_results=args.min_crashes
+                    )
+                except Exception:  # pylint: disable=broad-except
+                    LOG.exception("Exception during reduction!")
+                    return FuzzManagerReporter.QUAL_REDUCER_ERROR
+            return return_code
 
         except (KeyboardInterrupt, TargetLaunchError, TargetLaunchTimeout):
             return 1
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 61aa45e4..4bae65af 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -60,9 +60,24 @@ def test_args_02(tmp_path):
     ReduceArgs().parse_args([str(exe), str(inp), "--min-crashes", "99"])
 
 
-def test_main_01(mocker):
+@pytest.mark.parametrize(
+    "patch_func, side_effect, return_value, result",
+    [
+        (
+            "grizzly.reduce.core.ReduceManager.run",
+            TargetLaunchError("error", None), None, 9
+        ),
+        ("grizzly.reduce.core.ReduceManager.run", TargetLaunchTimeout, None, 9),
+        ("grizzly.reduce.core.load_target", KeyboardInterrupt, None, 1),
+        ("grizzly.reduce.core.TestCase.load", TestCaseLoadFailure, None, 1),
+        ("grizzly.reduce.core.TestCase.load", None, [], 1),
+    ]
+)
+def test_main_01(mocker, patch_func, side_effect, return_value, result):
     """test ReduceManager.main() failure cases"""
-    mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
+    mocker.patch(
+        "grizzly.reduce.core.FuzzManagerReporter", autospec=True,
+        QUAL_REDUCER_ERROR=9)
     mocker.patch("grizzly.reduce.core.load_target", autospec=True)
     mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
     mocker.patch("grizzly.reduce.core.TestCase", autospec=True)
@@ -76,22 +91,8 @@ def test_main_01(mocker):
         repeat=1,
         sig=None)
 
-    mocker.patch("grizzly.reduce.core.ReduceManager.run",
-                 side_effect=TargetLaunchError("error", None))
-    assert ReduceManager.main(args) == 1
-
-    mocker.patch("grizzly.reduce.core.ReduceManager.run",
-                 side_effect=TargetLaunchTimeout)
-    assert ReduceManager.main(args) == 1
-
-    mocker.patch("grizzly.reduce.core.load_target", side_effect=KeyboardInterrupt)
-    assert ReduceManager.main(args) == 1
-
-    mocker.patch("grizzly.reduce.core.TestCase.load", side_effect=TestCaseLoadFailure)
-    assert ReduceManager.main(args) == 1
-
-    mocker.patch("grizzly.reduce.core.TestCase.load", return_value=list())
-    assert ReduceManager.main(args) == 1
+    mocker.patch(patch_func, side_effect=side_effect, return_value=return_value)
+    assert ReduceManager.main(args) == result
 
 
 def test_force_closed(mocker, tmp_path):
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index febeffe6..2d3b3721 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -146,7 +146,7 @@ def wrapped(_):
             reports=None,
             n_other=0,
             other_reports=None,
-            result=False,
+            result=10,
         ),
         # reproduces, one strategy, no reduction works
         ReproTestParams(
@@ -160,7 +160,7 @@ def wrapped(_):
             reports={"1\n2\n3\n"},
             n_other=0,
             other_reports=None,
-            result=True,
+            result=0,
         ),
         # reproduces, one strategy, some reduction works
         ReproTestParams(
@@ -175,7 +175,7 @@ def wrapped(_):
             reports={"odd\neven\n" * 3, "odd\n" * 3},
             n_other=0,
             other_reports=None,
-            result=True,
+            result=0,
         ),
         # reproduces, one strategy, reduction only finds other
         ReproTestParams(
@@ -189,7 +189,7 @@ def wrapped(_):
             reports={"1\n2\n3\n"},
             n_other=5,
             other_reports={"1\n", "3\n", "1\n2\n", "1\n3\n", "2\n3\n"},
-            result=True,
+            result=0,
         ),
         # reproduces, 50% iterations work, 1 iteration produces other sig
         ReproTestParams(
@@ -203,7 +203,7 @@ def wrapped(_):
             reports={"1\n2\n3\n4\n5\n6\n", "1\n2\n3\n5\n"},
             n_other=1,
             other_reports={"1\n3\n5\n"},
-            result=True,
+            result=0,
         ),
         # reproduces, two strategies, 1st no reduction, 2nd 50% reduction
         ReproTestParams(
@@ -221,7 +221,7 @@ def wrapped(_):
             reports={"A1\nA2\nA3\nA4\nA5\nA6\n", "A1\n\nA3\n\nA5\nA"},
             n_other=0,
             other_reports=None,
-            result=True,
+            result=0,
         ),
         # reproduces, two strategies, 1st 50% reduction, 2nd no reduction
         ReproTestParams(
@@ -238,7 +238,7 @@ def wrapped(_):
             reports={"A1\nA2\nA3\nA4\nA5\nA6\n", "A1\nA3\nA5\n"},
             n_other=0,
             other_reports=None,
-            result=True,
+            result=0,
         ),
         # reproduces, two strategies, reduce only produces other sig
         ReproTestParams(
@@ -253,7 +253,7 @@ def wrapped(_):
             n_other=15,
             other_reports={"\n2\n3\n", "1\n", "1\n\n3\n", "1\n2\n", "1\n2\n\n",
                            "1\n2\n3", "1\n23\n", "1\n3\n", "12\n3\n", "2\n3\n", "3\n"},
-            result=True,
+            result=0,
         ),
         # reproduces, one strategy, testcase reduces to 0
         ReproTestParams(
@@ -267,7 +267,7 @@ def wrapped(_):
             reports={"1\n2\n3\n", ""},
             n_other=0,
             other_reports=None,
-            result=True,
+            result=0,
         ),
         # reproduces, two strategies, 1st no reduce, 2nd testcase reduces to 0
         ReproTestParams(
@@ -283,7 +283,7 @@ def wrapped(_):
             reports={"1\n2\n3\n", ""},
             n_other=0,
             other_reports=None,
-            result=True,
+            result=0,
         ),
     ]
 )
@@ -457,7 +457,7 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
             idle_output=10,
             iter_input=60,
             iter_output=10,
-            result=True,
+            result=0,
         ),
         # max duration is used
         TimeoutTestParams(
@@ -468,7 +468,7 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
             idle_output=30,
             iter_input=60,
             iter_output=60,
-            result=True,
+            result=0,
         ),
         # static timeout doesn't affect timeouts
         TimeoutTestParams(
@@ -479,7 +479,7 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
             idle_output=30,
             iter_input=60,
             iter_output=60,
-            result=True,
+            result=0,
         ),
         # uninteresting result doesn't affect timeouts
         TimeoutTestParams(
@@ -490,7 +490,7 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
             idle_output=30,
             iter_input=60,
             iter_output=60,
-            result=False,
+            result=10,
         ),
         # test duration affects timeouts
         TimeoutTestParams(
@@ -501,7 +501,7 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
             idle_output=15,
             iter_input=60,
             iter_output=20,
-            result=True,
+            result=0,
         ),
     ]
 )
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 2141d4a4..08986810 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -144,7 +144,7 @@ def replay_run(testcases, **_):
     try:
         mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies,
                             log_path, use_analysis=False)
-        assert mgr.run()
+        assert mgr.run() == 0
     finally:
         for test in tests:
             test.cleanup()
@@ -469,7 +469,7 @@ def replay_run(testcases, **_):
     try:
         mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies,
                             log_path, use_analysis=False)
-        assert mgr.run()
+        assert mgr.run() == 0
     finally:
         for test in tests:
             test.cleanup()
@@ -621,7 +621,7 @@ def replay_run(testcases, **_):
             with raises(AssertionError):
                 mgr.run()
         else:
-            assert mgr.run()
+            assert mgr.run() == 0
     finally:
         for test in tests:
             test.cleanup()

From 8365af3e8a89d06b28c15a13d2a0420e0d0bd1e0 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 29 Oct 2020 21:01:56 -0400
Subject: [PATCH 077/531] [reduce] Clean up reduction stats implementation.

Save reduction stats in report.
---
 grizzly/reduce/core.py        | 277 ++++++++++------------------------
 grizzly/reduce/stats.py       | 213 ++++++++++++++++++++++++++
 grizzly/reduce/test_reduce.py |   9 +-
 3 files changed, 298 insertions(+), 201 deletions(-)
 create mode 100644 grizzly/reduce/stats.py

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 2f4992d2..8311a873 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -4,17 +4,13 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """`ReduceManager` finds the smallest testcase(s) to reproduce an issue.
 """
-from collections import namedtuple
-from functools import partial
-from itertools import chain, zip_longest
+from itertools import chain
 from locale import LC_ALL, setlocale
 from logging import getLogger
 from math import ceil, log
 from pathlib import Path
-import re
 from shutil import rmtree
 from tempfile import mkdtemp
-from time import gmtime, strftime, time
 
 from Collector.Collector import Collector
 from FTB.Signatures.CrashInfo import CrashSignature
@@ -26,6 +22,7 @@
 from ..main import configure_logging
 from ..replay import ReplayManager, ReplayResult
 from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
+from .stats import ReductionStats
 from .strategies import STRATEGIES
 
 
@@ -67,59 +64,6 @@ def change_quality(crash_id, quality):
             raise
 
 
-ReductionStat = namedtuple("ReductionStat", "name, duration, iterations, size")
-
-
-class _FormatTable(object):
-    """Format tabular data in a table.
-    """
-    def __init__(self, columns, formatters, vsep=" | ", hsep="-"):
-        """Initialize a FormatTable instance.
-
-        Arguments:
-            columns (iterable(str)): List of column names for the table header.
-            formatters (iterable(callable)): List of format functions for each column.
-            vsep (str): Vertical separation between columns.
-            hsep (str): Horizontal separation between header and data.
-        """
-        assert len(columns) == len(formatters)
-        self._columns = columns
-        self._formatters = formatters
-        self._vsep = vsep
-        self._hsep = hsep
-
-    def format_rows(self, rows):
-        """Format rows as a table and return a line generator.
-
-        Arguments:
-            rows (list(list(str))): Tabular data. Each row must be the same length as
-                                    `columns` passed to `__init__`.
-
-        Yields:
-            str: Each line of formatted tabular data.
-        """
-        max_width = [len(col) for col in self._columns]
-        formatted = []
-        for row in rows:
-            assert len(row) == len(self._columns)
-            formatted.append([])
-            for idx, (data, formatter) in enumerate(zip(row, self._formatters)):
-                data = formatter(data)
-                max_width[idx] = max(max_width[idx], len(data))
-                formatted[-1].append(data)
-
-        # build a format_str to space out the columns with separators using `max_width`
-        # the first column is left-aligned, and other fields are right-aligned.
-        format_str = self._vsep.join(
-            field % (width,)
-            for field, width in zip_longest(["%%-%ds"], max_width, fillvalue="%%%ds")
-        )
-        yield format_str % self._columns
-        yield self._hsep * (len(self._vsep) * (len(self._columns) - 1) + sum(max_width))
-        for row in formatted:
-            yield format_str % tuple(row)
-
-
 class ReduceManager(object):
     """Manage reduction of one or more testcases to find the smallest testcase
     that reproduces a given issue.
@@ -196,7 +140,7 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
         self._static_timeout = static_timeout
         self._idle_delay = idle_delay
         self._idle_threshold = idle_threshold
-        self._stats = []
+        self._stats = ReductionStats()
 
     def update_timeout(self, results):
         """Tune idle/server timeout values based on actual duration of expected results.
@@ -257,8 +201,8 @@ def run_reliability_analysis(self, stats):
         maximize the chances of observing the expected crash.
 
         Arguments:
-            stats (object): Opaque stats object. Increment the ".iters" attribute with
-                            the number of iterations performed.
+            stats (list(object)): Opaque stats object. Increment the ".iters" attribute
+                                  with the number of iterations performed.
 
         Returns:
             tuple(int, int): Values for `repeat` and `min_crashes` resulting from
@@ -296,16 +240,17 @@ def run_reliability_analysis(self, stats):
                 except (TargetLaunchError, TargetLaunchTimeout) as exc:
                     if isinstance(exc, TargetLaunchError) and exc.report:
                         self.report([ReplayResult(exc.report, None, [], False)],
-                                    self.testcases)
+                                    self.testcases, self._stats.copy(stats))
                         exc.report.cleanup()
                     raise
                 try:
-                    stats.iters += self.ANALYSIS_ITERATIONS
+                    for stat in stats:
+                        stat.iters += self.ANALYSIS_ITERATIONS
                     self.update_timeout(results)
                     crashes = sum(x.count for x in results if x.expected)
                     self.report(
                         [result for result in results if not result.expected],
-                        self.testcases)
+                        self.testcases, self._stats.copy(stats))
                     if crashes and use_harness:
                         harness_crashes = crashes
                     elif crashes:
@@ -350,59 +295,13 @@ def run_reliability_analysis(self, stats):
                      "more" if harness_crashes > non_harness_crashes else "less")
         return (repeat, min_crashes)
 
-    def record_stat_milestone(self, name, elapsed=None, iters=None):
-        """Record reduction stats for a given point in time:
-
-        - name of the milestone (eg. init, strategy name completed)
-        - current testcase size (bytes)
-        - elapsed time (seconds)
-        - # of iterations
-
-        Arguments:
-            name (str): name of milestone
-            elapsed (float or None): seconds elapsed for period recorded
-            iters (int or None): # of iterations performed
+    def testcase_size(self):
+        """Calculate the current testcase size.
 
         Returns:
-            None
-        """
-        testcase_size = sum(tc.data_size for tc in self.testcases)
-        self._stats.append(
-            ReductionStat(
-                name=name,
-                size=testcase_size,
-                duration=elapsed,
-                iterations=iters,
-            )
-        )
-
-    def time_stat_milestone(self, name):
-        """Time and record the period leading up to a reduction milestone.
-        eg. a strategy being run.
-
-        Arguments:
-            name (str): name of milestone
-
-        Returns:
-            context: Timer context for the period being recorded up to the milestone.
-
-                     Attributes:
-                        iters (int): # of iterations performed during period
+            int: Current size of the testcase(s).
         """
-        # pylint: disable=no-self-argument
-        class _MilestoneTimer(object):
-            def __init__(sub):
-                sub._start = None
-                sub.iters = 0
-
-            def __enter__(sub):
-                sub._start = time()
-                return sub
-
-            def __exit__(sub, exc_type, exc_value, traceback):
-                elapsed = time() - sub._start
-                self.record_stat_milestone(name, elapsed=elapsed, iters=sub.iters)
-        return _MilestoneTimer()
+        return sum(tc.data_size for tc in self.testcases)
 
     def run(self, repeat=1, min_results=1):
         """Run testcase reduction.
@@ -418,14 +317,14 @@ def run(self, repeat=1, min_results=1):
         any_success = False
         last_reports = None
         last_tried = None
-        self.record_stat_milestone("init")
-        # record total_stats overall so that any time missed by individual milestones
+        self._stats.add("init", self.testcase_size())
+        # record total stats overall so that any time missed by individual milestones
         # will still be included in the total
-        with self.time_stat_milestone("final") as total_stats:
+        with self._stats.add_timed("final", self.testcase_size) as total_stats:
             if self._use_analysis:
-                with self.time_stat_milestone("analysis") as stats:
-                    repeat, min_results = self.run_reliability_analysis(stats)
-                    total_stats.iters += stats.iters
+                with self._stats.add_timed("analysis", self.testcase_size) as stats:
+                    repeat, min_results = \
+                        self.run_reliability_analysis([stats, total_stats])
             self.target.relaunch = min(self._original_relaunch, repeat)
             LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
                      repeat, min_results, self.target.relaunch)
@@ -441,33 +340,24 @@ def run(self, repeat=1, min_results=1):
                 if last_tried is not None:
                     strategy.update_tried(last_tried)
                     last_tried = None
-                with replay, strategy, self.time_stat_milestone(strategy.name) as stats:
-                    best_results = []
-                    try:
+                strategy_stats = self._stats.add_timed(strategy.name, self.testcase_size)
+                best_results = []
+                try:
+                    with replay, strategy, strategy_stats:
                         for reduction in strategy:
-                            stats.iters += 1
+                            strategy_stats.iters += 1
                             total_stats.iters += 1
                             keep_reduction = False
                             results = []
                             try:
-                                try:
-                                    # reduction is a new list of testcases to be
-                                    # replayed
-                                    results = replay.run(
-                                        reduction, repeat=repeat,
-                                        min_results=min_results,
-                                        idle_delay=self._idle_delay,
-                                        idle_threshold=self._idle_threshold)
-                                except (TargetLaunchError, TargetLaunchTimeout) as exc:
-                                    if (
-                                        isinstance(exc, TargetLaunchError)
-                                        and exc.report
-                                    ):
-                                        self.report(
-                                            [ReplayResult(exc.report, None, [], False)],
-                                            reduction)
-                                        exc.report.cleanup()
-                                    raise
+                                # reduction is a new list of testcases to be
+                                # replayed
+                                results = replay.run(
+                                    reduction,
+                                    repeat=repeat,
+                                    min_results=min_results,
+                                    idle_delay=self._idle_delay,
+                                    idle_threshold=self._idle_threshold)
                                 self.update_timeout(results)
                                 # get the first expected result (if any),
                                 #   and update the strategy
@@ -502,26 +392,43 @@ def run(self, repeat=1, min_results=1):
                                     LOG.info("Attempt failed")
                                 # if the reduction found other crashes,
                                 #   report those immediately
-                                self.report(results, reduction)
-                            finally:  # noqa pylint: disable=bare-except
+                                self.report(
+                                    results, reduction,
+                                    self._stats.copy([strategy_stats, total_stats]))
+                            except TargetLaunchError as exc:
+                                if exc.report:
+                                    self.report(
+                                        [ReplayResult(exc.report, None, [], False)],
+                                        reduction,
+                                        self._stats.copy([strategy_stats, total_stats]))
+                                    exc.report.cleanup()
+                                raise
+                            finally:
                                 if not keep_reduction:
                                     for testcase in reduction:
                                         testcase.cleanup()
                                 for result in results:
                                     result.report.cleanup()
-                        last_reports = self.report(best_results, self.testcases)
-                    except KeyboardInterrupt:
-                        if best_results:
-                            last_reports = self.report(best_results, self.testcases)
-                            LOG.warning("Ctrl+C detected, best reduction so far "
-                                        "reported as %r", last_reports)
-                        raise
-                    finally:
-                        for result in best_results:
-                            result.report.cleanup()
-                    # if self._signature was already set, this will do nothing
-                    # otherwise, ensure the first found signature is used throughout
-                    self._signature = replay.signature
+
+                        # if self._signature was already set, this will do nothing
+                        # otherwise, ensure the first found signature is used throughout
+                        self._signature = replay.signature
+
+                    last_reports = self.report(
+                        best_results, self.testcases,
+                        self._stats.copy([total_stats]))
+
+                except KeyboardInterrupt:
+                    if best_results:
+                        last_reports = self.report(
+                            best_results, self.testcases,
+                            self._stats.copy([total_stats]))
+                        LOG.warning("Ctrl+C detected, best reduction so far "
+                                    "reported as %r", last_reports)
+                    raise
+                finally:
+                    for result in best_results:
+                        result.report.cleanup()
 
                 # store "tried" cache to pass to next strategy
                 last_tried = strategy.get_tried()
@@ -532,57 +439,22 @@ def run(self, repeat=1, min_results=1):
                     change_quality(crash_id, FuzzManagerReporter.QUAL_REDUCED_RESULT)
 
         # log a summary of what was done.
-        def _format_duration(duration, total=0):
-            result = ""
-            if duration is not None:
-                if total == 0:
-                    percent = 0
-                else:
-                    percent = int(100 * duration / total)
-                # format H:M:S, and then remove all leading zeros with regex
-                result = re.sub("^[0:]*", "", strftime("%H:%M:%S", gmtime(duration)))
-                # if the result is all zeroes, ensure one zero is output
-                if not result:
-                    result = "0"
-                result += " (%3d%%)" % (percent,)
-            return result
-
-        def _format_number(number, total=0):
-            result = ""
-            if number is not None:
-                if total == 0:
-                    percent = 0
-                else:
-                    percent = int(100 * number / total)
-                result = "{:n} ({:3d}%)".format(number, percent)
-            return result
-
-        tabulator = _FormatTable(
-            ReductionStat._fields,
-            ReductionStat(
-                name=str,
-                # duration and iterations are % of total (last), size % of init (first)
-                duration=partial(_format_duration, total=self._stats[-1].duration),
-                iterations=partial(_format_number, total=self._stats[-1].iterations),
-                size=partial(_format_number, total=self._stats[0].size),
-            )
-        )
         LOG.info("Reduction summary:")
-        for row in tabulator.format_rows(self._stats):
-            LOG.info(row)
+        for line in self._stats.format_lines():
+            LOG.info(line)
 
         if any_success:
             return FuzzManagerReporter.QUAL_REDUCED_RESULT
         return FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE
 
-    def report(self, results, testcases):
+    def report(self, results, testcases, stats=None):
         """Report results, either to FuzzManager or to filesystem.
 
         Arguments:
-            results (list(grizzly.replay.ReplayResult)):
-                Results observed during reduction.
-            testcases (list(grizzly.common.storage.TestCase)):
-                Testcases used to trigger results.
+            results (list(ReplayResult)): Results observed during reduction.
+            testcases (list(TestCase)): Testcases used to trigger results.
+            stats (ReductionStats): Statistics for reduction of these results.
+                                    (may be different than `self._stats`)
 
         Returns:
             list(*): List of return values from `reporter.submit()`.
@@ -598,6 +470,13 @@ def report(self, results, testcases):
                 reporter = FilesystemReporter(
                     report_path=str(self._log_path / report_dir),
                     major_bucket=False)
+            # write reduction stats
+            if stats is not None:
+                report_path = Path(result.report.path)
+                with (report_path / "reduce_stats.txt").open("w") as out:
+                    for line in stats.format_lines():
+                        print(line, file=out)
+                (report_path / "reduce_stats.json").write_text(stats.json())
             # clone the tests so we can safely call purge_optional here for each report
             # (report.served may be different for non-expected or any-crash results)
             clones = [test.clone() for test in testcases]
diff --git a/grizzly/reduce/stats.py b/grizzly/reduce/stats.py
new file mode 100644
index 00000000..24962eeb
--- /dev/null
+++ b/grizzly/reduce/stats.py
@@ -0,0 +1,213 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Keep statistics about reduction."""
+from collections import namedtuple
+from functools import partial
+from itertools import zip_longest
+import json
+import re
+from time import gmtime, strftime, time
+
+
+ReductionStat = namedtuple("ReductionStat", "name, duration, iterations, size")
+
+
+class _FormatTable(object):
+    """Format tabular data in a table.
+    """
+    def __init__(self, columns, formatters, vsep=" | ", hsep="-"):
+        """Initialize a FormatTable instance.
+
+        Arguments:
+            columns (iterable(str)): List of column names for the table header.
+            formatters (iterable(callable)): List of format functions for each column.
+            vsep (str): Vertical separation between columns.
+            hsep (str): Horizontal separation between header and data.
+        """
+        assert len(columns) == len(formatters)
+        self._columns = columns
+        self._formatters = formatters
+        self._vsep = vsep
+        self._hsep = hsep
+
+    def format_rows(self, rows):
+        """Format rows as a table and return a line generator.
+
+        Arguments:
+            rows (list(list(str))): Tabular data. Each row must be the same length as
+                                    `columns` passed to `__init__`.
+
+        Yields:
+            str: Each line of formatted tabular data.
+        """
+        max_width = [len(col) for col in self._columns]
+        formatted = []
+        for row in rows:
+            assert len(row) == len(self._columns)
+            formatted.append([])
+            for idx, (data, formatter) in enumerate(zip(row, self._formatters)):
+                data = formatter(data)
+                max_width[idx] = max(max_width[idx], len(data))
+                formatted[-1].append(data)
+
+        # build a format_str to space out the columns with separators using `max_width`
+        # the first column is left-aligned, and other fields are right-aligned.
+        format_str = self._vsep.join(
+            field % (width,)
+            for field, width in zip_longest(["%%-%ds"], max_width, fillvalue="%%%ds")
+        )
+        yield format_str % self._columns
+        yield self._hsep * (len(self._vsep) * (len(self._columns) - 1) + sum(max_width))
+        for row in formatted:
+            yield format_str % tuple(row)
+
+
+def _format_duration(duration, total=0):
+    result = ""
+    if duration is not None:
+        if total == 0:
+            percent = 0
+        else:
+            percent = int(100 * duration / total)
+        # format H:M:S, and then remove all leading zeros with regex
+        result = re.sub("^[0:]*", "", strftime("%H:%M:%S", gmtime(duration)))
+        # if the result is all zeroes, ensure one zero is output
+        if not result:
+            result = "0"
+        result += " (%3d%%)" % (percent,)
+    return result
+
+
+def _format_number(number, total=0):
+    result = ""
+    if number is not None:
+        if total == 0:
+            percent = 0
+        else:
+            percent = int(100 * number / total)
+        result = "{:n} ({:3d}%)".format(number, percent)
+    return result
+
+
+class ReductionStats(object):
+    """Statistics about reduction"""
+
+    def __init__(self):
+        """Initialize a ReductionStats instance."""
+        self._stats = []
+
+    def add(self, name, testcase_size, elapsed=None, iters=None):
+        """Record reduction stats for a given point in time:
+
+        - name of the milestone (eg. init, strategy name completed)
+        - current testcase size (bytes)
+        - elapsed time (seconds)
+        - # of iterations
+
+        Arguments:
+            name (str): name of milestone
+            testcase_size (int): size of testcase
+            elapsed (float or None): seconds elapsed for period recorded
+            iters (int or None): # of iterations performed
+
+        Returns:
+            None
+        """
+        self._stats.append(
+            ReductionStat(
+                name=name,
+                size=testcase_size,
+                duration=elapsed,
+                iterations=iters,
+            )
+        )
+
+    def add_timed(self, name, testcase_size_cb):
+        """Time and record the period leading up to a reduction milestone.
+        eg. a strategy being run.
+
+        Arguments:
+            name (str): name of milestone
+            testcase_size_cb (callable): callback to get testcase size when
+                                         context is exited.
+
+        Returns:
+            context: Timer context for the period being recorded up to the milestone.
+
+                     Attributes:
+                        iters (int): # of iterations performed during period
+        """
+        # pylint: disable=no-self-argument
+        class _MilestoneTimer(object):
+            def __init__(sub):
+                sub._start = None
+                sub.iters = 0
+
+            def __enter__(sub):
+                sub._start = time()
+                return sub
+
+            def _stop_early(sub, other):
+                """Clone and stop the timer. Add as a new stat to `other`.
+
+                Arguments:
+                    other (ReductionStats): The stats to add the clone to.
+
+                Returns:
+                    None
+                """
+                elapsed = time() - sub._start
+                other.add(
+                    name, testcase_size_cb(), elapsed=elapsed, iters=sub.iters
+                )
+
+            def __exit__(sub, exc_type, exc_value, traceback):
+                elapsed = time() - sub._start
+                self.add(name, testcase_size_cb(), elapsed=elapsed, iters=sub.iters)
+        return _MilestoneTimer()
+
+    def copy(self, stop_timers=None):
+        """Create a shallow copy of this instance.
+
+        Arguments:
+            stop_timers (list(`add_timed` context)):
+                In-progress `add_timed` calls that should be stopped and added to the
+                result.
+
+        Returns:
+            ReductionStats: Clone of self
+        """
+        result = type(self)()
+        result._stats = self._stats.copy()  # pylint: disable=protected-access
+        if stop_timers is not None:
+            for timer in stop_timers:
+                timer._stop_early(result)  # pylint: disable=protected-access
+        return result
+
+    def format_lines(self):
+        """Format the current stats in a table.
+
+        Yields:
+            str: Formatted lines to be output.
+        """
+        tabulator = _FormatTable(
+            ReductionStat._fields,
+            ReductionStat(
+                name=str,
+                # duration and iterations are % of total (last), size % of init (first)
+                duration=partial(_format_duration, total=self._stats[-1].duration),
+                iterations=partial(_format_number, total=self._stats[-1].iterations),
+                size=partial(_format_number, total=self._stats[0].size),
+            )
+        )
+        yield from tabulator.format_rows(self._stats)
+
+    def json(self):
+        """Serialize the stats using JSON.
+
+        Returns:
+            str: Stats as JSON.
+        """
+        return json.dumps(self._stats, indent=2)
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 2d3b3721..49c6ff39 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -102,10 +102,14 @@ def replay_run(_, **kw):
     class _ReduceStats:
         iters = 0
 
+        @staticmethod
+        def _stop_early(_):
+            pass
+
     try:
         mgr = ReduceManager(None, mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target),
                             tests, None, log_path, use_harness=use_harness)
-        repeat, min_crashes = mgr.run_reliability_analysis(_ReduceStats)
+        repeat, min_crashes = mgr.run_reliability_analysis([_ReduceStats])
     finally:
         for test in tests:
             test.cleanup()
@@ -114,6 +118,7 @@ class _ReduceStats:
     assert repeat == expected_repeat
     assert min_crashes == expected_min_crashes
     assert mgr._use_harness == result_harness
+    assert _ReduceStats.iters == expected_iters * 11
 
 
 def _ignore_arg(func):
@@ -424,7 +429,7 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
         mgr.run()
     if exc_type is TargetLaunchError:
         assert report_fcn.call_count == 1
-        _mgr, reports, reported_testcases = report_fcn.call_args[0]
+        _mgr, reports, reported_testcases, _stats = report_fcn.call_args[0]
         if use_analysis:
             assert reported_testcases == testcases
         else:

From ed3229d01d2f82fbb2fc00f6673a01209c53a7ae Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 2 Nov 2020 17:13:12 -0500
Subject: [PATCH 078/531] [reducer] Clean up exit codes.

---
 grizzly/common/reporter.py    |  2 +-
 grizzly/reduce/args.py        | 17 ++++++++++
 grizzly/reduce/core.py        | 61 +++++++++++++++++++----------------
 grizzly/reduce/exceptions.py  | 20 ++++++++++++
 grizzly/reduce/test_main.py   |  7 ++--
 grizzly/reduce/test_reduce.py | 17 +++++++---
 6 files changed, 89 insertions(+), 35 deletions(-)
 create mode 100644 grizzly/reduce/exceptions.py

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 6e723eee..c63fc43b 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -447,7 +447,7 @@ class FuzzManagerReporter(Reporter):
     # testcase quality values
     QUAL_REDUCED_RESULT = 0  # the final reduced testcase
     QUAL_REDUCED_ORIGINAL = 1  # the original used for successful reduction
-    QUAL_REPRODUCIBLE = 4  # the testcase was reproducible
+    QUAL_REDUCING = 4  # the testcase is currently being reduced
     QUAL_UNREDUCED = 5  # haven't attempted reduction yet (1st attempt, generic reducer)
     QUAL_REQUEST_SPECIFIC = 6  # platform specific reduction requested (2nd attempt)
     QUAL_NO_TESTCASE = 7  # no testcase was detected (could be the "testcase" is not a testcase)
diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 1b02d94a..06851c44 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -4,9 +4,13 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """CLI argument parsing for Grizzly reduction.
 """
+from argparse import ArgumentParser
 from logging import getLogger
 from pathlib import Path
+import sys
 
+from ..args import SortingHelpFormatter
+from ..common.reporter import FuzzManagerReporter
 from ..replay.args import ReplayArgs
 from .strategies import DEFAULT_STRATEGIES, STRATEGIES
 
@@ -14,6 +18,16 @@
 LOG = getLogger(__name__)
 
 
+class _ArgparserExitReducerError(ArgumentParser):
+    def exit(self, status=0, message=None):
+        if message is not None:
+            print(message, file=sys.stderr)
+        if status != 0:
+            LOG.debug("overriding original argparse exit code (%d)", status)
+            status = FuzzManagerReporter.QUAL_REDUCER_ERROR
+        sys.exit(status)
+
+
 class ReduceArgs(ReplayArgs):
     """Argument parser for `grizzly.reduce`.
 
@@ -23,6 +37,9 @@ class ReduceArgs(ReplayArgs):
     def __init__(self):
         """Initialize argument parser.
         """
+        self.parser = _ArgparserExitReducerError(
+                formatter_class=SortingHelpFormatter,
+                conflict_handler="resolve")
         super().__init__()
 
         # these arguments have other defaults vs how they are defined in ReplayArgs
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 8311a873..e842374f 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -22,6 +22,7 @@
 from ..main import configure_logging
 from ..replay import ReplayManager, ReplayResult
 from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
+from .exceptions import GrizzlyReduceBaseException, NotReproducible
 from .stats import ReductionStats
 from .strategies import STRATEGIES
 
@@ -266,7 +267,7 @@ def run_reliability_analysis(self, stats):
                 self._signature = replay.signature
 
         if harness_crashes == 0 and non_harness_crashes == 0:
-            raise RuntimeError("Did not reproduce during analysis")
+            raise NotReproducible("Did not reproduce during analysis")
 
         # should we use the harness? go with whichever crashed more
         self._use_harness = non_harness_crashes <= harness_crashes
@@ -325,6 +326,7 @@ def run(self, repeat=1, min_results=1):
                 with self._stats.add_timed("analysis", self.testcase_size) as stats:
                     repeat, min_results = \
                         self.run_reliability_analysis([stats, total_stats])
+                any_success = True  # analysis ran and didn't raise
             self.target.relaunch = min(self._original_relaunch, repeat)
             LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
                      repeat, min_results, self.target.relaunch)
@@ -368,9 +370,8 @@ def run(self, repeat=1, min_results=1):
                                 if success and not self._any_crash:
                                     served = first_expected.served
                                 strategy.update(success, served=served)
-                                if strategy.name == "check":
-                                    if any_success and not success:
-                                        raise RuntimeError("Reduction broke")
+                                if strategy.name == "check" and not success:
+                                    raise NotReproducible("Not reproducible at 'check'")
                                 any_success = any_success or success
                                 # if the reduction reproduced,
                                 #   update self.testcases (new best)
@@ -516,24 +517,29 @@ def main(cls, args):
         if args.rr:
             LOG.info("Running with RR")
 
-        if args.sig:
-            signature = CrashSignature.fromFile(args.sig)
-        else:
-            signature = None
-
-        LOG.debug("loading the TestCases")
-        try:
-            testcases = TestCase.load(args.input, args.prefs is None)
-            if not testcases:
-                raise TestCaseLoadFailure("Failed to load TestCases")
-        except TestCaseLoadFailure as exc:
-            LOG.error("Error: %s", str(exc))
-            return 1
-
         target = None
+        testcases = []
         tmp_prefs = None
         try:
+
+            if args.sig:
+                signature = CrashSignature.fromFile(args.sig)
+            else:
+                signature = None
+
+            LOG.debug("loading the TestCases")
+            try:
+                testcases = TestCase.load(args.input, args.prefs is None)
+                if not testcases:
+                    raise TestCaseLoadFailure("Failed to load TestCases")
+            except TestCaseLoadFailure as exc:
+                LOG.error("Error: %s", str(exc))
+                return FuzzManagerReporter.QUAL_NO_TESTCASE
+
             if args.no_harness:
+                if len(testcases) > 1:
+                    LOG.error("'--no-harness' cannot be used with multiple testcases")
+                    return FuzzManagerReporter.QUAL_REDUCER_ERROR
                 LOG.debug("--no-harness specified relaunch set to 1")
                 args.relaunch = 1
             args.repeat = max(args.min_crashes, args.repeat)
@@ -589,18 +595,19 @@ def main(cls, args):
                     static_timeout=args.static_timeout,
                     idle_delay=args.idle_delay,
                     idle_threshold=args.idle_threshold)
-                try:
-                    return_code = mgr.run(
-                        repeat=args.repeat,
-                        min_results=args.min_crashes
-                    )
-                except Exception:  # pylint: disable=broad-except
-                    LOG.exception("Exception during reduction!")
-                    return FuzzManagerReporter.QUAL_REDUCER_ERROR
+                return_code = mgr.run(repeat=args.repeat, min_results=args.min_crashes)
             return return_code
 
         except (KeyboardInterrupt, TargetLaunchError, TargetLaunchTimeout):
-            return 1
+            return FuzzManagerReporter.QUAL_REDUCER_ERROR
+
+        except GrizzlyReduceBaseException as exc:
+            LOG.error(exc.msg)
+            return exc.code
+
+        except Exception:  # noqa pylint: disable=broad-except
+            LOG.exception("Exception during reduction!")
+            return FuzzManagerReporter.QUAL_REDUCER_ERROR
 
         finally:
             LOG.warning("Shutting down...")
diff --git a/grizzly/reduce/exceptions.py b/grizzly/reduce/exceptions.py
new file mode 100644
index 00000000..b69fc08c
--- /dev/null
+++ b/grizzly/reduce/exceptions.py
@@ -0,0 +1,20 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Grizzly Reduction exceptions."""
+from ..common.reporter import FuzzManagerReporter
+
+
+class GrizzlyReduceBaseException(Exception):
+    """Base for other Grizzly Reducer specific exceptions."""
+    def __init__(self, msg, code=FuzzManagerReporter.QUAL_REDUCER_ERROR):
+        super().__init__()
+        self.msg = msg
+        self.code = code
+
+
+class NotReproducible(GrizzlyReduceBaseException):
+    """Crash was not observed when expected during reduction."""
+    def __init__(self, msg):
+        super().__init__(msg, code=FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE)
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 4bae65af..be641333 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -68,15 +68,16 @@ def test_args_02(tmp_path):
             TargetLaunchError("error", None), None, 9
         ),
         ("grizzly.reduce.core.ReduceManager.run", TargetLaunchTimeout, None, 9),
-        ("grizzly.reduce.core.load_target", KeyboardInterrupt, None, 1),
-        ("grizzly.reduce.core.TestCase.load", TestCaseLoadFailure, None, 1),
-        ("grizzly.reduce.core.TestCase.load", None, [], 1),
+        ("grizzly.reduce.core.load_target", KeyboardInterrupt, None, 9),
+        ("grizzly.reduce.core.TestCase.load", TestCaseLoadFailure, None, 7),
+        ("grizzly.reduce.core.TestCase.load", None, [], 7),
     ]
 )
 def test_main_01(mocker, patch_func, side_effect, return_value, result):
     """test ReduceManager.main() failure cases"""
     mocker.patch(
         "grizzly.reduce.core.FuzzManagerReporter", autospec=True,
+        QUAL_NO_TESTCASE=7,
         QUAL_REDUCER_ERROR=9)
     mocker.patch("grizzly.reduce.core.load_target", autospec=True)
     mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 49c6ff39..f0468285 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -17,6 +17,7 @@
 from ..replay import ReplayResult
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from . import ReduceManager
+from .exceptions import NotReproducible
 
 
 LOG = getLogger(__name__)
@@ -151,7 +152,7 @@ def wrapped(_):
             reports=None,
             n_other=0,
             other_reports=None,
-            result=10,
+            result=NotReproducible,
         ),
         # reproduces, one strategy, no reduction works
         ReproTestParams(
@@ -330,7 +331,11 @@ def replay_run(testcases, **_):
     try:
         mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies,
                             log_path, use_analysis=False)
-        assert mgr.run() == result
+        if isinstance(result, type) and issubclass(result, BaseException):
+            with raises(result):
+                mgr.run()
+        else:
+            assert mgr.run() == result
     finally:
         for test in tests:
             test.cleanup()
@@ -495,7 +500,7 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
             idle_output=30,
             iter_input=60,
             iter_output=60,
-            result=10,
+            result=NotReproducible,
         ),
         # test duration affects timeouts
         TimeoutTestParams(
@@ -541,7 +546,11 @@ def replay_run(_testcases, **_):
         mgr.IDLE_DELAY_DURATION_MULTIPLIER = 1.5
         mgr.ITER_TIMEOUT_MIN = 10
         mgr.ITER_TIMEOUT_DURATION_MULTIPLIER = 2
-        assert mgr.run() == result
+        if isinstance(result, type) and issubclass(result, BaseException):
+            with raises(result):
+                mgr.run()
+        else:
+            assert mgr.run() == result
     finally:
         for test in tests:
             test.cleanup()

From eca76e946f0d850fca3b0b6814f6b4ac22249ab5 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 2 Nov 2020 17:13:55 -0500
Subject: [PATCH 079/531] [reducer] Use actual iterations and not attempts.

---
 grizzly/reduce/core.py            |  6 +++---
 grizzly/reduce/test_reduce.py     | 28 ++++++++++++++++++----------
 grizzly/reduce/test_strategies.py | 24 +++++++++++++++---------
 3 files changed, 36 insertions(+), 22 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index e842374f..b3f383b5 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -246,7 +246,7 @@ def run_reliability_analysis(self, stats):
                     raise
                 try:
                     for stat in stats:
-                        stat.iters += self.ANALYSIS_ITERATIONS
+                        stat.iters += replay.status.iteration
                     self.update_timeout(results)
                     crashes = sum(x.count for x in results if x.expected)
                     self.report(
@@ -347,8 +347,8 @@ def run(self, repeat=1, min_results=1):
                 try:
                     with replay, strategy, strategy_stats:
                         for reduction in strategy:
-                            strategy_stats.iters += 1
-                            total_stats.iters += 1
+                            strategy_stats.iters += replay.status.iteration
+                            total_stats.iters += replay.status.iteration
                             keep_reduction = False
                             results = []
                             try:
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index f0468285..10c1dd06 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -75,6 +75,8 @@ def test_analysis(mocker, tmp_path, crashes, expected_repeat, expected_min_crash
                   use_harness, result_harness):
     """test that analysis sets reasonable params"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    replayer = replayer.return_value.__enter__.return_value
+    replayer.status.iteration = 11
     expected_iters = len(crashes) / 11
 
     def replay_run(_, **kw):
@@ -86,14 +88,14 @@ def replay_run(_, **kw):
             LOG.debug("interesting: %r", crashes[0])
             if crashes.pop(0):
                 log_path = tmp_path / (
-                    "crash%d_logs" % (replayer.return_value.run.call_count,)
+                    "crash%d_logs" % (replayer.run.call_count,)
                 )
                 log_path.mkdir(exist_ok=True)
                 _fake_save_logs_foo(log_path)
                 report = Report(str(log_path), "bin")
                 results.append(ReplayResult(report, [["test.html"]], [], True))
         return results
-    replayer.return_value.__enter__.return_value.run.side_effect = replay_run
+    replayer.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
     test.add_from_data("", "test.html")
@@ -115,7 +117,7 @@ def _stop_early(_):
         for test in tests:
             test.cleanup()
 
-    assert replayer.return_value.__enter__.return_value.run.call_count == expected_iters
+    assert replayer.run.call_count == expected_iters
     assert repeat == expected_repeat
     assert min_crashes == expected_min_crashes
     assert mgr._use_harness == result_harness
@@ -300,6 +302,8 @@ def test_repro(mocker, tmp_path, original, strategies, detect_failure, interesti
     """test ReduceManager, difference scenarios produce correct expected/other
     results"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    replayer = replayer.return_value
+    replayer.status.iteration = 1
 
     def replay_run(testcases, **_):
         for test in testcases:
@@ -308,7 +312,7 @@ def replay_run(testcases, **_):
             LOG.debug("interesting if " + interesting_str, contents)
             if detect_failure(contents):
                 log_path = tmp_path / (
-                    "crash%d_logs" % (replayer.return_value.run.call_count,)
+                    "crash%d_logs" % (replayer.run.call_count,)
                 )
                 log_path.mkdir()
                 expected = is_expected(contents)
@@ -319,7 +323,7 @@ def replay_run(testcases, **_):
                 report = Report(str(log_path), "bin")
                 return [ReplayResult(report, [["test.html"]], [], expected)]
         return []
-    replayer.return_value.run.side_effect = replay_run
+    replayer.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
     test.add_from_data(original, "test.html")
@@ -340,7 +344,7 @@ def replay_run(testcases, **_):
         for test in tests:
             test.cleanup()
 
-    assert replayer.return_value.run.call_count == expected_run_calls
+    assert replayer.run.call_count == expected_run_calls
     expected_dirs = set()
     if n_reports:
         expected_dirs.add(log_path / "reports")
@@ -364,14 +368,16 @@ def replay_run(testcases, **_):
 def test_quality_update(mocker, tmp_path):
     """test that the final result gets changed to Q0 with --fuzzmanager"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    replayer = replayer.return_value
+    replayer.status.iteration = 1
 
     def replay_run(_, **_kw):
-        log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+        log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
         log_path.mkdir()
         _fake_save_logs_foo(log_path)
         report = Report(str(log_path), "bin")
         return [ReplayResult(report, [["test.html"]], [], True)]
-    replayer.return_value.run.side_effect = replay_run
+    replayer.run.side_effect = replay_run
 
     (tmp_path / "test.html").touch()
     testcases = TestCase.load(str(tmp_path / "test.html"), False)
@@ -519,15 +525,17 @@ def test_timeout_update(mocker, tmp_path, durations, interesting, static_timeout
                         idle_input, idle_output, iter_input, iter_output, result):
     "timeout will be updated based on time to crash"
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    replayer = replayer.return_value
+    replayer.status.iteration = 1
 
     def replay_run(_testcases, **_):
         LOG.debug("interesting true")
-        log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+        log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
         log_path.mkdir()
         _fake_save_logs_foo(log_path)
         report = Report(str(log_path), "bin")
         return [ReplayResult(report, [["test.html"]], durations, interesting)]
-    replayer.return_value.run.side_effect = replay_run
+    replayer.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
     test.add_from_data("123\n", "test.html")
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 08986810..23ddb186 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -112,6 +112,8 @@ def test_list(mocker, tmp_path, test_data, strategies, required_first,
               expected_run_calls, expected_results, expected_num_reports):
     """tests for the "list" strategy"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    replayer = replayer.return_value
+    replayer.status.iteration = 1
 
     def replay_run(testcases, **_):
         required_seen = False
@@ -122,7 +124,7 @@ def replay_run(testcases, **_):
                 required_seen = True
             elif contents == "123" and (required_seen or not required_first):
                 log_path = tmp_path / (
-                    "crash%d_logs" % (replayer.return_value.run.call_count,)
+                    "crash%d_logs" % (replayer.run.call_count,)
                 )
                 log_path.mkdir()
                 _fake_save_logs_foo(log_path)
@@ -130,7 +132,7 @@ def replay_run(testcases, **_):
                 return [ReplayResult(report, [["test.html"]] * len(testcases), [],
                                      True)]
         return []
-    replayer.return_value.run.side_effect = replay_run
+    replayer.run.side_effect = replay_run
 
     tests = []
     for data in test_data:
@@ -149,7 +151,7 @@ def replay_run(testcases, **_):
         for test in tests:
             test.cleanup()
 
-    assert replayer.return_value.run.call_count == expected_run_calls
+    assert replayer.run.call_count == expected_run_calls
     assert set(log_path.iterdir()) == {log_path / "reports"}
     tests = {test.read_text() for test in log_path.glob("reports/*-*/test.html")}
     assert tests == expected_results
@@ -435,6 +437,8 @@ def test_beautifier(mocker, tmp_path, test_data, test_name, expected_run_calls,
                     expected_results, expected_num_reports, strategies):
     """test for the "beautify" strategies"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    replayer = replayer.return_value
+    replayer.status.iteration = 1
 
     def replay_run(testcases, **_):
         for test in testcases:
@@ -450,14 +454,14 @@ def replay_run(testcases, **_):
                 interesting = "required" in contents or "'requi'+'red'" in contents
             if interesting:
                 log_path = tmp_path / (
-                    "crash%d_logs" % (replayer.return_value.run.call_count,)
+                    "crash%d_logs" % (replayer.run.call_count,)
                 )
                 log_path.mkdir()
                 _fake_save_logs_foo(log_path)
                 report = Report(str(log_path), "bin")
                 return [ReplayResult(report, [[test_name]], [], True)]
         return []
-    replayer.return_value.run.side_effect = replay_run
+    replayer.run.side_effect = replay_run
 
     test = TestCase(test_name, None, "test-adapter")
     test.add_from_data(test_data, test_name)
@@ -474,7 +478,7 @@ def replay_run(testcases, **_):
         for test in tests:
             test.cleanup()
 
-    assert replayer.return_value.run.call_count == expected_run_calls
+    assert replayer.run.call_count == expected_run_calls
     assert set(log_path.iterdir()) == {log_path / "reports"}
     tests = {test.read_text() for test in log_path.glob("reports/*-*/" + test_name)}
     assert tests == expected_results
@@ -582,6 +586,8 @@ def test_purge_unserved(mocker, tmp_path, strategies, test_data, served,
                         purging_breaks):
     """test purging unserved files"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    replayer = replayer.return_value
+    replayer.status.iteration = 1
 
     def replay_run(testcases, **_):
         # test.html and opt.html should always contain one line.
@@ -597,12 +603,12 @@ def replay_run(testcases, **_):
                         return []
         if not has_any:
             return []
-        log_path = tmp_path / ("crash%d_logs" % (replayer.return_value.run.call_count,))
+        log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
         log_path.mkdir()
         _fake_save_logs_foo(log_path)
         report = Report(str(log_path), "bin")
         return [ReplayResult(report, served.pop(0), [], True)]
-    replayer.return_value.run.side_effect = replay_run
+    replayer.run.side_effect = replay_run
 
     tests = []
     for testcase in test_data:
@@ -626,7 +632,7 @@ def replay_run(testcases, **_):
         for test in tests:
             test.cleanup()
 
-    assert replayer.return_value.run.call_count == expected_run_calls
+    assert replayer.run.call_count == expected_run_calls
     if purging_breaks:
         return
     assert set(log_path.iterdir()) == {log_path / "reports"}

From 9816d20d22ca25293378bd4e3e243c4bf2d85de8 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 2 Nov 2020 17:14:38 -0500
Subject: [PATCH 080/531] [reducer] Print stage with reduction chunk messages.

---
 grizzly/reduce/strategies.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index 5919af27..69333a22 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -602,7 +602,8 @@ def __iter__(self):
             LOG.debug("Reduce queue: %r", reduce_queue)
             file = reduce_queue.pop(0)
             file_no += 1
-            LOG.info("Reducing %s (file %d/%d)", file, file_no,
+            LOG.info("[%s] Reducing %s (file %d/%d)", self.name,
+                     file.relative_to(self._testcase_root), file_no,
                      len(self._files_to_reduce))
             lithium_testcase = self.testcase_cls()  # pylint: disable=not-callable
             lithium_testcase.load(file)
@@ -625,7 +626,7 @@ def __iter__(self):
             for reduction in self._current_reducer:
                 reduction.dump()
                 testcases = TestCase.load(str(self._testcase_root), False)
-                LOG.info(self._current_reducer.description)
+                LOG.info("[%s] %s", self.name, self._current_reducer.description)
                 yield testcases
                 if self._current_feedback:
                     testcase_root_dirty = False
@@ -657,7 +658,7 @@ def __iter__(self):
             # need to yield once more to set this trimmed version to the current best
             # in ReduceManager
             testcases = TestCase.load(str(self._testcase_root), False)
-            LOG.info("final iteration triggered by purge_optional")
+            LOG.info("[%s] final iteration triggered by purge_optional", self.name)
             yield testcases
             assert self._current_feedback, "Purging unserved files broke the testcase."
 
@@ -899,7 +900,7 @@ def __iter__(self):
                 # need to yield once more to set this trimmed version to the current
                 # best in ReduceManager
                 testcases = TestCase.load(str(self._testcase_root), False)
-                LOG.info("final iteration triggered by purge_optional")
+                LOG.info("[%s] final iteration triggered by purge_optional", self.name)
                 yield testcases
                 testcases = None  # caller owns testcases now
                 assert self._current_feedback, \

From a2c8b2338e38be96a889333fbffaf74564930adf Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 4 Nov 2020 22:54:40 -0500
Subject: [PATCH 081/531] [reducer] Add more information to the ReducerStats:

- signature (whether given, any_crash, shortDescription)
- show successes and attempts instead of iterations
---
 grizzly/reduce/core.py        |  98 ++++++++++++++++-------
 grizzly/reduce/stats.py       | 143 ++++++++++++++++++++++++++--------
 grizzly/reduce/test_reduce.py |  11 ++-
 3 files changed, 190 insertions(+), 62 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index b3f383b5..86d49e34 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -5,9 +5,11 @@
 """`ReduceManager` finds the smallest testcase(s) to reproduce an issue.
 """
 from itertools import chain
+import json
 from locale import LC_ALL, setlocale
 from logging import getLogger
 from math import ceil, log
+import os
 from pathlib import Path
 from shutil import rmtree
 from tempfile import mkdtemp
@@ -93,7 +95,8 @@ class ReduceManager(object):
     def __init__(self, ignore, server, target, testcases, strategies, log_path,
                  tool=None, report_to_fuzzmanager=False, any_crash=False,
                  signature=None, use_harness=True, use_analysis=True,
-                 static_timeout=False, idle_delay=0, idle_threshold=0):
+                 static_timeout=False, idle_delay=0, idle_threshold=0,
+                 signature_desc=None):
         """Initialize reduction manager. Many arguments are common with `ReplayManager`.
 
         Args:
@@ -110,6 +113,7 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
                               the specified or first observed signature.
             signature (FTB.Signatures.CrashInfo.CrashSignature or None):
                 Signature for accepting crashes.
+            signature_desc (str): Short description of the given signature.
             use_harness (bool): Whether to allow use of harness when navigating
                                 between testcases.
             use_analysis (bool): Analyse reliability of testcase before running each
@@ -136,6 +140,7 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
         self._report_to_fuzzmanager = report_to_fuzzmanager
         self._report_tool = tool
         self._signature = signature
+        self._signature_desc = signature_desc
         self._use_analysis = use_analysis
         self._use_harness = use_harness
         self._static_timeout = static_timeout
@@ -202,15 +207,17 @@ def run_reliability_analysis(self, stats):
         maximize the chances of observing the expected crash.
 
         Arguments:
-            stats (list(object)): Opaque stats object. Increment the ".iters" attribute
-                                  with the number of iterations performed.
+            stats (object): Open stats timer (from `ReductionStats.add_timed`).
+                            Pass to `ReductionStats.copy` to properly terminate
+                            the timer for reporting.
 
         Returns:
-            tuple(int, int): Values for `repeat` and `min_crashes` resulting from
-                             analysis.
+            tuple(int, int, dict): Values for `repeat` and `min_crashes` resulting from
+                                   analysis, and info to include in stats.
         """
         harness_crashes = 0
         non_harness_crashes = 0
+        info = {}
 
         # Reset parameters.
         # Use repeat=1 & relaunch=ITERATIONS because this is closer to how we will run
@@ -245,10 +252,14 @@ def run_reliability_analysis(self, stats):
                         exc.report.cleanup()
                     raise
                 try:
-                    for stat in stats:
-                        stat.iters += replay.status.iteration
+                    stats.add_iterations(replay.status.iteration)
                     self.update_timeout(results)
                     crashes = sum(x.count for x in results if x.expected)
+                    if crashes and not self._any_crash and self._signature_desc is None:
+                        first_expected = next((report for report in results
+                                               if report.expected), None)
+                        self._signature_desc = (first_expected.report.crash_info
+                                                .createShortSignature())
                     self.report(
                         [result for result in results if not result.expected],
                         self.testcases, self._stats.copy(stats))
@@ -259,10 +270,11 @@ def run_reliability_analysis(self, stats):
                 finally:
                     for result in results:
                         result.report.cleanup()
-                LOG.info("Testcase was interesting %0.1f%% of %d attempts %s harness.",
-                         100.0 * crashes / self.ANALYSIS_ITERATIONS,
-                         self.ANALYSIS_ITERATIONS,
-                         "using" if use_harness else "without")
+                reliability = crashes / self.ANALYSIS_ITERATIONS
+                key = ("using" if use_harness else "without") + " harness"
+                LOG.info("Testcase was interesting %0.1f%% of %d attempts %s.",
+                         100.0 * reliability, self.ANALYSIS_ITERATIONS, key)
+                info[key] = reliability
                 # ensure same signature is always used
                 self._signature = replay.signature
 
@@ -294,7 +306,7 @@ def run_reliability_analysis(self, stats):
         else:
             LOG.info("* testcase was %s reliable with the harness",
                      "more" if harness_crashes > non_harness_crashes else "less")
-        return (repeat, min_crashes)
+        return (repeat, min_crashes, info)
 
     def testcase_size(self):
         """Calculate the current testcase size.
@@ -316,6 +328,7 @@ def run(self, repeat=1, min_results=1):
             int: One of the `FuzzManagerReporter.QUAL_*` constants.
         """
         any_success = False
+        sig_given = self._signature is not None
         last_reports = None
         last_tried = None
         self._stats.add("init", self.testcase_size())
@@ -323,13 +336,20 @@ def run(self, repeat=1, min_results=1):
         # will still be included in the total
         with self._stats.add_timed("final", self.testcase_size) as total_stats:
             if self._use_analysis:
-                with self._stats.add_timed("analysis", self.testcase_size) as stats:
-                    repeat, min_results = \
-                        self.run_reliability_analysis([stats, total_stats])
+                with total_stats.add_timed("analysis") as stats:
+                    repeat, min_results, reliability_info = \
+                        self.run_reliability_analysis(stats)
+                self._stats.add_info("Analysis", reliability_info)
                 any_success = True  # analysis ran and didn't raise
             self.target.relaunch = min(self._original_relaunch, repeat)
             LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
                      repeat, min_results, self.target.relaunch)
+            self._stats.add_info("Run Parameters", {
+                "Repeat": repeat,
+                "Min Crashes": min_results,
+                "Relaunch": self.target.relaunch,
+                "Harness": self._use_harness,
+            })
             for strategy_no, strategy in enumerate(self.strategies):
                 LOG.info("")
                 LOG.info("Using strategy %s (%d/%d)", strategy, strategy_no + 1,
@@ -342,13 +362,11 @@ def run(self, repeat=1, min_results=1):
                 if last_tried is not None:
                     strategy.update_tried(last_tried)
                     last_tried = None
-                strategy_stats = self._stats.add_timed(strategy.name, self.testcase_size)
+                strategy_stats = total_stats.add_timed(strategy.name)
                 best_results = []
                 try:
                     with replay, strategy, strategy_stats:
                         for reduction in strategy:
-                            strategy_stats.iters += replay.status.iteration
-                            total_stats.iters += replay.status.iteration
                             keep_reduction = False
                             results = []
                             try:
@@ -360,12 +378,24 @@ def run(self, repeat=1, min_results=1):
                                     min_results=min_results,
                                     idle_delay=self._idle_delay,
                                     idle_threshold=self._idle_threshold)
+                                strategy_stats.add_iterations(replay.status.iteration)
+                                strategy_stats.add_attempts(1)
                                 self.update_timeout(results)
                                 # get the first expected result (if any),
                                 #   and update the strategy
                                 first_expected = next((report for report in results
                                                        if report.expected), None)
                                 success = first_expected is not None
+                                if success:
+                                    strategy_stats.add_successes(1)
+                                    if (
+                                        not self._any_crash
+                                        and self._signature_desc is None
+                                    ):
+                                        self._signature_desc = (first_expected
+                                                                .report
+                                                                .crash_info
+                                                                .createShortSignature())
                                 served = None
                                 if success and not self._any_crash:
                                     served = first_expected.served
@@ -395,13 +425,13 @@ def run(self, repeat=1, min_results=1):
                                 #   report those immediately
                                 self.report(
                                     results, reduction,
-                                    self._stats.copy([strategy_stats, total_stats]))
+                                    self._stats.copy(strategy_stats))
                             except TargetLaunchError as exc:
                                 if exc.report:
                                     self.report(
                                         [ReplayResult(exc.report, None, [], False)],
                                         reduction,
-                                        self._stats.copy([strategy_stats, total_stats]))
+                                        self._stats.copy(strategy_stats))
                                     exc.report.cleanup()
                                 raise
                             finally:
@@ -417,13 +447,13 @@ def run(self, repeat=1, min_results=1):
 
                     last_reports = self.report(
                         best_results, self.testcases,
-                        self._stats.copy([total_stats]))
+                        self._stats.copy(total_stats))
 
                 except KeyboardInterrupt:
                     if best_results:
                         last_reports = self.report(
                             best_results, self.testcases,
-                            self._stats.copy([total_stats]))
+                            self._stats.copy(total_stats))
                         LOG.warning("Ctrl+C detected, best reduction so far "
                                     "reported as %r", last_reports)
                     raise
@@ -439,10 +469,18 @@ def run(self, repeat=1, min_results=1):
                 for crash_id in last_reports:
                     change_quality(crash_id, FuzzManagerReporter.QUAL_REDUCED_RESULT)
 
+        # it's possible we made it this far without ever setting signature_desc.
+        # this is only possible if --no-analysis is given
+        # just give None instead of trying to format the CrashSignature
+        self._stats.add_info("Signature", {
+            "given": sig_given,
+            "any": self._any_crash,
+            "description": self._signature_desc,
+        })
+
         # log a summary of what was done.
-        LOG.info("Reduction summary:")
-        for line in self._stats.format_lines():
-            LOG.info(line)
+        LOG.info("Reduction summary:%s%s", os.linesep,
+                 os.linesep.join(self._stats.format_lines()))
 
         if any_success:
             return FuzzManagerReporter.QUAL_REDUCED_RESULT
@@ -517,15 +555,18 @@ def main(cls, args):
         if args.rr:
             LOG.info("Running with RR")
 
+        signature = None
+        signature_desc = None
         target = None
         testcases = []
         tmp_prefs = None
         try:
-
             if args.sig:
                 signature = CrashSignature.fromFile(args.sig)
-            else:
-                signature = None
+                meta = Path(args.sig).with_suffix(".metadata")
+                if meta.is_file():
+                    meta = json.loads(meta.read_text())
+                    signature_desc = meta["shortDescription"]
 
             LOG.debug("loading the TestCases")
             try:
@@ -590,6 +631,7 @@ def main(cls, args):
                     report_to_fuzzmanager=args.fuzzmanager,
                     any_crash=args.any_crash,
                     signature=signature,
+                    signature_desc=signature_desc,
                     use_harness=not args.no_harness,
                     use_analysis=not args.no_analysis,
                     static_timeout=args.static_timeout,
diff --git a/grizzly/reduce/stats.py b/grizzly/reduce/stats.py
index 24962eeb..fc9d0257 100644
--- a/grizzly/reduce/stats.py
+++ b/grizzly/reduce/stats.py
@@ -4,6 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Keep statistics about reduction."""
 from collections import namedtuple
+from copy import deepcopy
 from functools import partial
 from itertools import zip_longest
 import json
@@ -11,7 +12,8 @@
 from time import gmtime, strftime, time
 
 
-ReductionStat = namedtuple("ReductionStat", "name, duration, iterations, size")
+ReductionStat = namedtuple(
+    "ReductionStat", "name, duration, successes, attempts, size, iterations")
 
 
 class _FormatTable(object):
@@ -23,11 +25,13 @@ def __init__(self, columns, formatters, vsep=" | ", hsep="-"):
         Arguments:
             columns (iterable(str)): List of column names for the table header.
             formatters (iterable(callable)): List of format functions for each column.
+                                             None will result in hiding that column.
             vsep (str): Vertical separation between columns.
             hsep (str): Horizontal separation between header and data.
         """
         assert len(columns) == len(formatters)
-        self._columns = columns
+        self._columns = tuple(column for (column, fmt) in zip(columns, formatters)
+                              if fmt is not None)
         self._formatters = formatters
         self._vsep = vsep
         self._hsep = hsep
@@ -45,11 +49,15 @@ def format_rows(self, rows):
         max_width = [len(col) for col in self._columns]
         formatted = []
         for row in rows:
-            assert len(row) == len(self._columns)
+            assert len(row) == len(self._formatters)
             formatted.append([])
+            offset = 0
             for idx, (data, formatter) in enumerate(zip(row, self._formatters)):
+                if formatter is None:
+                    offset += 1
+                    continue
                 data = formatter(data)
-                max_width[idx] = max(max_width[idx], len(data))
+                max_width[idx - offset] = max(max_width[idx - offset], len(data))
                 formatted[-1].append(data)
 
         # build a format_str to space out the columns with separators using `max_width`
@@ -96,34 +104,73 @@ class ReductionStats(object):
 
     def __init__(self):
         """Initialize a ReductionStats instance."""
-        self._stats = []
+        self._data = {"stats": []}
 
-    def add(self, name, testcase_size, elapsed=None, iters=None):
+    def __deepcopy__(self, memo):
+        """Return a deep copy of this instance."""
+        result = type(self)()
+        result._data = deepcopy(self._data, memo)  # pylint: disable=protected-access
+        return result
+
+    def add(self, name, testcase_size, elapsed=None, iterations=None, attempts=None,
+            successes=None):
         """Record reduction stats for a given point in time:
 
         - name of the milestone (eg. init, strategy name completed)
         - current testcase size (bytes)
         - elapsed time (seconds)
         - # of iterations
+        - # of total attempts
+        - # of successful attempts
 
         Arguments:
             name (str): name of milestone
             testcase_size (int): size of testcase
             elapsed (float or None): seconds elapsed for period recorded
-            iters (int or None): # of iterations performed
+            iterations (int or None): # of iterations performed
+            attempts (int or None): # of attempts performed
+            successes (int or None): # of attempts successful
 
         Returns:
             None
         """
-        self._stats.append(
+        self._data["stats"].append(
             ReductionStat(
                 name=name,
                 size=testcase_size,
                 duration=elapsed,
-                iterations=iters,
+                iterations=iterations,
+                attempts=attempts,
+                successes=successes,
             )
         )
 
+    def add_info(self, name, value):
+        """Add extra information to be added to the stats report.
+
+        Arguments:
+            name (str): key to identify the information
+            value (object): Any JSON serializable value.
+
+        Returns:
+            None
+        """
+        assert not self.has_info(name)
+        self._data[name] = value
+
+    def has_info(self, name):
+        """Check whether the extra information specified by "name"
+        already exists in this instance.
+
+        Arguments:
+            name (str): key to identify the information
+
+        Returns:
+            bool: Whether the named info already exists.
+        """
+        assert isinstance(name, str)
+        return name in self._data
+
     def add_timed(self, name, testcase_size_cb):
         """Time and record the period leading up to a reduction milestone.
         eg. a strategy being run.
@@ -137,18 +184,43 @@ def add_timed(self, name, testcase_size_cb):
             context: Timer context for the period being recorded up to the milestone.
 
                      Attributes:
-                        iters (int): # of iterations performed during period
+                        attempts (int): # of attempts performed during period
+                        iterations (int): # of iterations performed during period.
+                        successes (int): # of successful attempts during period
         """
         # pylint: disable=no-self-argument
         class _MilestoneTimer(object):
-            def __init__(sub):
+            def __init__(sub, sub_name, parent=None):
+                sub._name = sub_name
                 sub._start = None
-                sub.iters = 0
+                sub._attempts = 0
+                sub._iterations = 0
+                sub._successes = 0
+                sub._parent = parent
+
+            def add_attempts(sub, attempts):
+                sub._attempts += attempts
+                if sub._parent is not None:
+                    sub._parent.add_attempts(attempts)
+
+            def add_iterations(sub, iterations):
+                sub._iterations += iterations
+                if sub._parent is not None:
+                    sub._parent.add_iterations(iterations)
+
+            def add_successes(sub, successes):
+                sub._successes += successes
+                if sub._parent is not None:
+                    sub._parent.add_successes(successes)
 
             def __enter__(sub):
                 sub._start = time()
                 return sub
 
+            def add_timed(sub, sub_name):
+                """Create a new timed period linked to this one."""
+                return type(sub)(sub_name, parent=sub)
+
             def _stop_early(sub, other):
                 """Clone and stop the timer. Add as a new stat to `other`.
 
@@ -160,30 +232,32 @@ def _stop_early(sub, other):
                 """
                 elapsed = time() - sub._start
                 other.add(
-                    name, testcase_size_cb(), elapsed=elapsed, iters=sub.iters
-                )
+                    name, testcase_size_cb(), elapsed=elapsed, attempts=sub._attempts,
+                    successes=sub._successes, iterations=sub._iterations)
+                if sub._parent is not None:
+                    sub._parent._stop_early(other)  # pylint: disable=protected-access
 
             def __exit__(sub, exc_type, exc_value, traceback):
                 elapsed = time() - sub._start
-                self.add(name, testcase_size_cb(), elapsed=elapsed, iters=sub.iters)
-        return _MilestoneTimer()
+                self.add(sub._name, testcase_size_cb(), elapsed=elapsed,
+                         attempts=sub._attempts, successes=sub._successes,
+                         iterations=sub._iterations)
+        return _MilestoneTimer(name)
 
-    def copy(self, stop_timers=None):
-        """Create a shallow copy of this instance.
+    def copy(self, stop_timer=None):
+        """Create a deep copy of this instance.
 
         Arguments:
-            stop_timers (list(`add_timed` context)):
-                In-progress `add_timed` calls that should be stopped and added to the
+            stop_timer (`add_timed` context):
+                In-progress `add_timed` call that should be stopped and added to the
                 result.
 
         Returns:
             ReductionStats: Clone of self
         """
-        result = type(self)()
-        result._stats = self._stats.copy()  # pylint: disable=protected-access
-        if stop_timers is not None:
-            for timer in stop_timers:
-                timer._stop_early(result)  # pylint: disable=protected-access
+        result = deepcopy(self)
+        if stop_timer is not None:
+            stop_timer._stop_early(result)  # pylint: disable=protected-access
         return result
 
     def format_lines(self):
@@ -192,17 +266,24 @@ def format_lines(self):
         Yields:
             str: Formatted lines to be output.
         """
+        for key, value in self._data.items():
+            if key == "stats":
+                continue
+            yield "%s: %r" % (key, value)
+        stats = self._data["stats"]
         tabulator = _FormatTable(
             ReductionStat._fields,
             ReductionStat(
                 name=str,
-                # duration and iterations are % of total (last), size % of init (first)
-                duration=partial(_format_duration, total=self._stats[-1].duration),
-                iterations=partial(_format_number, total=self._stats[-1].iterations),
-                size=partial(_format_number, total=self._stats[0].size),
+                # duration and attempts are % of total (last), size % of init (first)
+                duration=partial(_format_duration, total=stats[-1].duration),
+                attempts=partial(_format_number, total=stats[-1].attempts),
+                successes=partial(_format_number, total=stats[-1].successes),
+                iterations=None,  # hide
+                size=partial(_format_number, total=stats[0].size),
             )
         )
-        yield from tabulator.format_rows(self._stats)
+        yield from tabulator.format_rows(stats)
 
     def json(self):
         """Serialize the stats using JSON.
@@ -210,4 +291,4 @@ def json(self):
         Returns:
             str: Stats as JSON.
         """
-        return json.dumps(self._stats, indent=2)
+        return json.dumps(self._data, indent=2)
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 10c1dd06..3797c1e4 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -103,16 +103,21 @@ def replay_run(_, **kw):
     log_path = tmp_path / "logs"
 
     class _ReduceStats:
-        iters = 0
+        def __init__(self):
+            self._iters = 0
+
+        def add_iterations(self, iters):
+            self._iters += iters
 
         @staticmethod
         def _stop_early(_):
             pass
 
+    stats = _ReduceStats()
     try:
         mgr = ReduceManager(None, mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target),
                             tests, None, log_path, use_harness=use_harness)
-        repeat, min_crashes = mgr.run_reliability_analysis([_ReduceStats])
+        repeat, min_crashes, _ = mgr.run_reliability_analysis(stats)
     finally:
         for test in tests:
             test.cleanup()
@@ -121,7 +126,7 @@ def _stop_early(_):
     assert repeat == expected_repeat
     assert min_crashes == expected_min_crashes
     assert mgr._use_harness == result_harness
-    assert _ReduceStats.iters == expected_iters * 11
+    assert stats._iters == expected_iters * 11
 
 
 def _ignore_arg(func):

From 24d6ed34cfd8e759dfe50183d7206d8e7e0ddc10 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 4 Nov 2020 22:56:26 -0500
Subject: [PATCH 082/531] [reducer] Change reliability analysis to work faster
 with less reliable testcases.

---
 grizzly/reduce/core.py        |  39 +++++---
 grizzly/reduce/test_reduce.py | 177 +++++++++++++++++++++++++++++++---
 2 files changed, 187 insertions(+), 29 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 86d49e34..1e8b49f7 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -81,7 +81,9 @@ class ReduceManager(object):
                                                            testcases to reduce.
     """
     ANALYSIS_ITERATIONS = 11  # number of iterations to analyze
-    ANALYSIS_MIN_CRASHES = 2  # --min-crashes value when analysis is used
+    # --min-crashes value when analysis is used and reliability is less than perfect
+    ANALYSIS_MIN_CRASHES = 1
+    ANALYSIS_PERFECT_MIN_CRASHES = 2  # --min-crashes when reliability is perfect
     # probability that successful reduction will observe the crash
     ANALYSIS_TARGET_PROBABILITY = 0.95
     # to see the worst case, run the `repeat` calculation in run_reliability_analysis
@@ -229,7 +231,7 @@ def run_reliability_analysis(self, stats):
         for use_harness in [True, False]:
             if use_harness and not self._original_use_harness:
                 continue
-            if not use_harness and harness_crashes == self.ANALYSIS_ITERATIONS:
+            if not use_harness and harness_crashes >= self.ANALYSIS_ITERATIONS / 2:
                 continue
 
             with ReplayManager(
@@ -281,24 +283,31 @@ def run_reliability_analysis(self, stats):
         if harness_crashes == 0 and non_harness_crashes == 0:
             raise NotReproducible("Did not reproduce during analysis")
 
-        # should we use the harness? go with whichever crashed more
-        self._use_harness = non_harness_crashes <= harness_crashes
+        # should we use the harness? go with harness unless no-harness crashed 50% more
+        self._use_harness = not (
+            non_harness_crashes > harness_crashes and (
+                harness_crashes == 0 or
+                (non_harness_crashes - harness_crashes) / harness_crashes >= 0.5
+            )
+        )
 
-        # this is max 99.9% to avoid domain errors in the calculation below
-        crashes_percent = min(
-            1.0 * max(non_harness_crashes, harness_crashes) / self.ANALYSIS_ITERATIONS,
-            0.999)
+        crashes_percent = (
+            harness_crashes if self._use_harness else non_harness_crashes
+        ) / self.ANALYSIS_ITERATIONS
 
         # adjust repeat/min-crashes depending on how reliable the testcase was
-        min_crashes = self.ANALYSIS_MIN_CRASHES
-        repeat = int(
-            ceil(log(1 - self.ANALYSIS_TARGET_PROBABILITY, 1 - crashes_percent))
-            * self.ANALYSIS_MIN_CRASHES)
+        if abs(crashes_percent - 1) < 0.01:
+            min_crashes = self.ANALYSIS_PERFECT_MIN_CRASHES
+        else:
+            min_crashes = self.ANALYSIS_MIN_CRASHES
+        # crashes_percent is max 99.9% to avoid domain errors
+        repeat = int(ceil(log(1 - self.ANALYSIS_TARGET_PROBABILITY,
+                              1 - min(crashes_percent, 0.9999))) * min_crashes)
 
         LOG.info("Analysis results:")
-        if harness_crashes == self.ANALYSIS_ITERATIONS:
-            LOG.info("* testcase was perfectly reliable with the harness (--no-harness "
-                     "not assessed)")
+        if harness_crashes >= self.ANALYSIS_ITERATIONS / 2:
+            LOG.info("* testcase was better than 50% reliable with the harness "
+                     "(--no-harness not assessed)")
         elif harness_crashes == non_harness_crashes:
             LOG.info("* testcase was equally reliable with/without the harness")
         elif not self._original_use_harness:
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 3797c1e4..c8d1e44e 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -50,7 +50,8 @@ def _fake_save_logs_bar(result_logs, meta=False):  # pylint: disable=unused-argu
 
 AnalysisTestParams = namedtuple(
     "AnalysisTestParams",
-    "crashes, expected_repeat, expected_min_crashes, use_harness, result_harness"
+    "harness_crashes, no_harness_crashes, expected_repeat, expected_min_crashes, "
+    "use_harness, result_harness"
 )
 
 
@@ -58,26 +59,174 @@ def _fake_save_logs_bar(result_logs, meta=False):  # pylint: disable=unused-argu
     AnalysisTestParams._fields,
     [
         # perfect with harness
-        AnalysisTestParams([True] * 11, 2, 2, True, True),
-        # perfect without harness
-        AnalysisTestParams([False] * 11 + [True] * 11, 2, 2, True, False),
+        AnalysisTestParams(11, None, 2, 2, True, True),
         # perfect, use_harness=False
-        AnalysisTestParams([True] * 11, 2, 2, False, False),
-        # better without harness
-        AnalysisTestParams([True] + [False] * 19 + [True] * 2, 30, 2, True, False),
-        # better with harness
-        AnalysisTestParams([True] * 2 + [False] * 19 + [True], 30, 2, True, True),
-        # same with both, prefer harness
-        AnalysisTestParams([True] * 2 + [False] * 18 + [True] * 2, 30, 2, True, True),
+        AnalysisTestParams(11, None, 2, 2, False, False),
+        # 10/11 with harness
+        AnalysisTestParams(10, None, 2, 1, True, True),
+        # 9/11 with harness
+        AnalysisTestParams(9, None, 2, 1, True, True),
+        # 8/11 with harness
+        AnalysisTestParams(8, None, 3, 1, True, True),
+        # 7/11 with harness
+        AnalysisTestParams(7, None, 3, 1, True, True),
+        # 6/11 with harness
+        AnalysisTestParams(6, None, 4, 1, True, True),
+        # 5/11 with harness
+        AnalysisTestParams(5, 0, 5, 1, True, True),
+        # 5/11 with harness, 1/11 without
+        AnalysisTestParams(5, 1, 5, 1, True, True),
+        # 5/11 with harness, 2/11 without
+        AnalysisTestParams(5, 2, 5, 1, True, True),
+        # 5/11 with harness, 3/11 without
+        AnalysisTestParams(5, 3, 5, 1, True, True),
+        # 5/11 with harness, 4/11 without
+        AnalysisTestParams(5, 4, 5, 1, True, True),
+        # 5/11 with harness, 5/11 without
+        AnalysisTestParams(5, 5, 5, 1, True, True),
+        # 5/11 with harness, 6/11 without
+        AnalysisTestParams(5, 6, 5, 1, True, True),
+        # 5/11 with harness, 7/11 without
+        AnalysisTestParams(5, 7, 5, 1, True, True),
+        # 5/11 with harness, 8/11 without
+        AnalysisTestParams(5, 8, 3, 1, True, False),
+        # 5/11 with harness, 9/11 without
+        AnalysisTestParams(5, 9, 2, 1, True, False),
+        # 5/11 with harness, 10/11 without
+        AnalysisTestParams(5, 10, 2, 1, True, False),
+        # 5/11 with harness, perfect without
+        AnalysisTestParams(5, 11, 2, 2, True, False),
+        # 4/11 with harness
+        AnalysisTestParams(4, 0, 7, 1, True, True),
+        # 4/11 with harness, 1/11 without
+        AnalysisTestParams(4, 1, 7, 1, True, True),
+        # 4/11 with harness, 2/11 without
+        AnalysisTestParams(4, 2, 7, 1, True, True),
+        # 4/11 with harness, 3/11 without
+        AnalysisTestParams(4, 3, 7, 1, True, True),
+        # 4/11 with harness, 4/11 without
+        AnalysisTestParams(4, 4, 7, 1, True, True),
+        # 4/11 with harness, 5/11 without
+        AnalysisTestParams(4, 5, 7, 1, True, True),
+        # 4/11 with harness, 6/11 without
+        AnalysisTestParams(4, 6, 4, 1, True, False),
+        # 4/11 with harness, 7/11 without
+        AnalysisTestParams(4, 7, 3, 1, True, False),
+        # 4/11 with harness, 8/11 without
+        AnalysisTestParams(4, 8, 3, 1, True, False),
+        # 4/11 with harness, 9/11 without
+        AnalysisTestParams(4, 9, 2, 1, True, False),
+        # 4/11 with harness, 10/11 without
+        AnalysisTestParams(4, 10, 2, 1, True, False),
+        # 4/11 with harness, perfect without
+        AnalysisTestParams(4, 11, 2, 2, True, False),
+        # 3/11 with harness
+        AnalysisTestParams(3, 0, 10, 1, True, True),
+        # 3/11 with harness, 1/11 without
+        AnalysisTestParams(3, 1, 10, 1, True, True),
+        # 3/11 with harness, 2/11 without
+        AnalysisTestParams(3, 2, 10, 1, True, True),
+        # 3/11 with harness, 3/11 without
+        AnalysisTestParams(3, 3, 10, 1, True, True),
+        # 3/11 with harness, 4/11 without
+        AnalysisTestParams(3, 4, 10, 1, True, True),
+        # 3/11 with harness, 5/11 without
+        AnalysisTestParams(3, 5, 5, 1, True, False),
+        # 3/11 with harness, 6/11 without
+        AnalysisTestParams(3, 6, 4, 1, True, False),
+        # 3/11 with harness, 7/11 without
+        AnalysisTestParams(3, 7, 3, 1, True, False),
+        # 3/11 with harness, 8/11 without
+        AnalysisTestParams(3, 8, 3, 1, True, False),
+        # 3/11 with harness, 9/11 without
+        AnalysisTestParams(3, 9, 2, 1, True, False),
+        # 3/11 with harness, 10/11 without
+        AnalysisTestParams(3, 10, 2, 1, True, False),
+        # 3/11 with harness, perfect without
+        AnalysisTestParams(3, 11, 2, 2, True, False),
+        # 2/11 with harness
+        AnalysisTestParams(2, 0, 15, 1, True, True),
+        # 2/11 with harness, 1/11 without
+        AnalysisTestParams(2, 1, 15, 1, True, True),
+        # 2/11 with harness, 2/11 without
+        AnalysisTestParams(2, 2, 15, 1, True, True),
+        # 2/11 with harness, 3/11 without
+        AnalysisTestParams(2, 3, 10, 1, True, False),
+        # 2/11 with harness, 4/11 without
+        AnalysisTestParams(2, 4, 7, 1, True, False),
+        # 2/11 with harness, 5/11 without
+        AnalysisTestParams(2, 5, 5, 1, True, False),
+        # 2/11 with harness, 6/11 without
+        AnalysisTestParams(2, 6, 4, 1, True, False),
+        # 2/11 with harness, 7/11 without
+        AnalysisTestParams(2, 7, 3, 1, True, False),
+        # 2/11 with harness, 8/11 without
+        AnalysisTestParams(2, 8, 3, 1, True, False),
+        # 2/11 with harness, 9/11 without
+        AnalysisTestParams(2, 9, 2, 1, True, False),
+        # 2/11 with harness, 10/11 without
+        AnalysisTestParams(2, 10, 2, 1, True, False),
+        # 2/11 with harness, perfect without
+        AnalysisTestParams(2, 11, 2, 2, True, False),
+        # 1/11 with harness
+        AnalysisTestParams(1, 0, 32, 1, True, True),
+        # 1/11 with harness, 1/11 without
+        AnalysisTestParams(1, 1, 32, 1, True, True),
+        # 1/11 with harness, 2/11 without
+        AnalysisTestParams(1, 2, 15, 1, True, False),
+        # 1/11 with harness, 3/11 without
+        AnalysisTestParams(1, 3, 10, 1, True, False),
+        # 1/11 with harness, 4/11 without
+        AnalysisTestParams(1, 4, 7, 1, True, False),
+        # 1/11 with harness, 5/11 without
+        AnalysisTestParams(1, 5, 5, 1, True, False),
+        # 1/11 with harness, 6/11 without
+        AnalysisTestParams(1, 6, 4, 1, True, False),
+        # 1/11 with harness, 7/11 without
+        AnalysisTestParams(1, 7, 3, 1, True, False),
+        # 1/11 with harness, 8/11 without
+        AnalysisTestParams(1, 8, 3, 1, True, False),
+        # 1/11 with harness, 9/11 without
+        AnalysisTestParams(1, 9, 2, 1, True, False),
+        # 1/11 with harness, 10/11 without
+        AnalysisTestParams(1, 10, 2, 1, True, False),
+        # 1/11 with harness, perfect without
+        AnalysisTestParams(1, 11, 2, 2, True, False),
+        # perfect without harness
+        AnalysisTestParams(0, 11, 2, 2, True, False),
+        # 10/11 without harness
+        AnalysisTestParams(0, 10, 2, 1, True, False),
+        # 9/11 without harness
+        AnalysisTestParams(0, 9, 2, 1, True, False),
+        # 8/11 without harness
+        AnalysisTestParams(0, 8, 3, 1, True, False),
+        # 7/11 without harness
+        AnalysisTestParams(0, 7, 3, 1, True, False),
+        # 6/11 without harness
+        AnalysisTestParams(0, 6, 4, 1, True, False),
+        # 5/11 without harness
+        AnalysisTestParams(0, 5, 5, 1, True, False),
+        # 4/11 without harness
+        AnalysisTestParams(0, 4, 7, 1, True, False),
+        # 3/11 without harness
+        AnalysisTestParams(0, 3, 10, 1, True, False),
+        # 2/11 without harness
+        AnalysisTestParams(0, 2, 15, 1, True, False),
+        # 1/11 without harness
+        AnalysisTestParams(0, 1, 32, 1, True, False),
     ]
 )
-def test_analysis(mocker, tmp_path, crashes, expected_repeat, expected_min_crashes,
-                  use_harness, result_harness):
+def test_analysis(mocker, tmp_path, harness_crashes, no_harness_crashes,
+                  expected_repeat, expected_min_crashes, use_harness, result_harness):
     """test that analysis sets reasonable params"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value.__enter__.return_value
     replayer.status.iteration = 11
-    expected_iters = len(crashes) / 11
+    expected_iters = 1
+    crashes = [True] * harness_crashes + [False] * (11 - harness_crashes)
+    if no_harness_crashes is not None:
+        crashes += [False] * (11 - no_harness_crashes) + [True] * no_harness_crashes
+        expected_iters += 1
 
     def replay_run(_, **kw):
         results = []

From d26eb2b3cf0c538f3f53ca7c6716ba5c845c21ec Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 5 Nov 2020 00:01:04 -0500
Subject: [PATCH 083/531] [reducer] Add support for '--test-index'

---
 grizzly/reduce/core.py      | 37 ++++++++++++++++----
 grizzly/reduce/test_main.py | 69 ++++++++++++++++++++++++++++++++-----
 2 files changed, 92 insertions(+), 14 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 1e8b49f7..fa7d80db 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -241,16 +241,21 @@ def run_reliability_analysis(self, stats):
                 LOG.info("Running for %d iterations to assess reliability %s harness.",
                          self.ANALYSIS_ITERATIONS,
                          "using" if use_harness else "without")
+                testcases = self.testcases
+                if not use_harness and len(testcases) > 1:
+                    LOG.warning("Only the last testcase of %d given will be used to "
+                                "assess reliability without harness.", len(testcases))
+                    testcases = [testcases[-1]]
                 try:
                     results = replay.run(
-                        self.testcases, repeat=self.ANALYSIS_ITERATIONS, min_results=1,
+                        testcases, repeat=self.ANALYSIS_ITERATIONS, min_results=1,
                         exit_early=False, idle_delay=self._idle_delay,
                         idle_threshold=self._idle_threshold,
                     )
                 except (TargetLaunchError, TargetLaunchTimeout) as exc:
                     if isinstance(exc, TargetLaunchError) and exc.report:
                         self.report([ReplayResult(exc.report, None, [], False)],
-                                    self.testcases, self._stats.copy(stats))
+                                    testcases, self._stats.copy(stats))
                         exc.report.cleanup()
                     raise
                 try:
@@ -264,7 +269,7 @@ def run_reliability_analysis(self, stats):
                                                 .createShortSignature())
                     self.report(
                         [result for result in results if not result.expected],
-                        self.testcases, self._stats.copy(stats))
+                        testcases, self._stats.copy(stats))
                     if crashes and use_harness:
                         harness_crashes = crashes
                     elif crashes:
@@ -291,6 +296,13 @@ def run_reliability_analysis(self, stats):
             )
         )
 
+        if not self._use_harness and len(self.testcases) > 1:
+            LOG.warning("Last testcase without harness was selected, other %d "
+                        "testcases in the original will be ignored.",
+                        len(self.testcases) - 1)
+            while len(self.testcases) > 1:
+                self.testcases.pop(0).cleanup()
+
         crashes_percent = (
             harness_crashes if self._use_harness else non_harness_crashes
         ) / self.ANALYSIS_ITERATIONS
@@ -586,10 +598,23 @@ def main(cls, args):
                 LOG.error("Error: %s", str(exc))
                 return FuzzManagerReporter.QUAL_NO_TESTCASE
 
+            if args.test_index is not None or (args.no_harness and len(testcases) > 1):
+                if args.test_index is None:
+                    LOG.warning("'--no-harness' given with %d testcases and without "
+                                "'--test-index', defaulting to last testcase",
+                                len(testcases))
+                    args.test_index = -1
+                LOG.debug("using TestCase with index %d", args.test_index)
+                try:
+                    selected = testcases.pop(args.test_index)
+                except IndexError:
+                    LOG.error("Error: Invalid '--test-index'")
+                    return FuzzManagerReporter.QUAL_NO_TESTCASE
+                for test in testcases:
+                    test.cleanup()
+                testcases = [selected]
+
             if args.no_harness:
-                if len(testcases) > 1:
-                    LOG.error("'--no-harness' cannot be used with multiple testcases")
-                    return FuzzManagerReporter.QUAL_REDUCER_ERROR
                 LOG.debug("--no-harness specified relaunch set to 1")
                 args.relaunch = 1
             args.repeat = max(args.min_crashes, args.repeat)
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index be641333..d87e8e1f 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -9,14 +9,17 @@
 from logging import getLogger
 from pathlib import Path
 from shutil import rmtree
+from unittest.mock import Mock
 
 import pytest
 from pytest import raises
 
 from ..common import TestCaseLoadFailure
+from ..common.storage import TestCase
 from ..target import TargetLaunchError, TargetLaunchTimeout
 from .args import ReduceArgs
 from . import ReduceManager
+from .exceptions import GrizzlyReduceBaseException
 
 
 LOG = getLogger(__name__)
@@ -61,19 +64,27 @@ def test_args_02(tmp_path):
 
 
 @pytest.mark.parametrize(
-    "patch_func, side_effect, return_value, result",
+    "patch_func, side_effect, return_value, kwargs, result",
     [
         (
             "grizzly.reduce.core.ReduceManager.run",
-            TargetLaunchError("error", None), None, 9
+            TargetLaunchError("error", None), None, {}, 9
+        ),
+        ("grizzly.reduce.core.ReduceManager.run", TargetLaunchTimeout, None, {}, 9),
+        ("grizzly.reduce.core.load_target", KeyboardInterrupt, None, {}, 9),
+        (
+            "grizzly.reduce.core.load_target",
+            GrizzlyReduceBaseException(""), None, {}, 9
+        ),
+        ("grizzly.reduce.core.TestCase.load", TestCaseLoadFailure, None, {}, 7),
+        ("grizzly.reduce.core.TestCase.load", None, [], {}, 7),
+        (
+            "grizzly.reduce.core.TestCase.load", None, [Mock(), Mock()],
+            {"test_index": 100}, 7
         ),
-        ("grizzly.reduce.core.ReduceManager.run", TargetLaunchTimeout, None, 9),
-        ("grizzly.reduce.core.load_target", KeyboardInterrupt, None, 9),
-        ("grizzly.reduce.core.TestCase.load", TestCaseLoadFailure, None, 7),
-        ("grizzly.reduce.core.TestCase.load", None, [], 7),
     ]
 )
-def test_main_01(mocker, patch_func, side_effect, return_value, result):
+def test_main_01(mocker, patch_func, side_effect, return_value, kwargs, result):
     """test ReduceManager.main() failure cases"""
     mocker.patch(
         "grizzly.reduce.core.FuzzManagerReporter", autospec=True,
@@ -90,12 +101,52 @@ def test_main_01(mocker, patch_func, side_effect, return_value, result):
         prefs=None,
         relaunch=1,
         repeat=1,
-        sig=None)
+        sig=None,
+        **kwargs)
 
     mocker.patch(patch_func, side_effect=side_effect, return_value=return_value)
     assert ReduceManager.main(args) == result
 
 
+@pytest.mark.parametrize("test_index", [0, 1, 2, -1, None])
+def test_main_02(mocker, test_index):
+    """test Reducemanager.main() testcases with --test-index"""
+    mocker.patch(
+        "grizzly.reduce.core.FuzzManagerReporter", autospec=True,
+        QUAL_NO_TESTCASE=7,
+        QUAL_REDUCER_ERROR=9)
+    mgr = mocker.patch("grizzly.reduce.core.ReduceManager", autospec=True)
+    mgr.return_value.run.return_value = 0
+    mocker.patch("grizzly.reduce.core.load_target", autospec=True)
+    mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
+    mocker.patch("grizzly.reduce.core.TestCase", autospec=True)
+    # setup args
+    tests = [mocker.Mock(spec=TestCase) for _ in range(3)]
+    LOG.debug("test mocks: %r", tests)
+    args = mocker.Mock(
+        ignore=["fake"],
+        input="test",
+        min_crashes=1,
+        prefs=None,
+        relaunch=1,
+        repeat=1,
+        sig=None,
+        no_harness=True,
+        test_index=test_index)
+
+    mocker.patch("grizzly.reduce.core.TestCase.load", return_value=tests.copy())
+    assert ReduceManager.main(args) == 0
+    assert mgr.call_count == 1
+    assert mgr.return_value.run.call_count == 1
+    mgr_args, _ = mgr.call_args_list[0]
+    LOG.debug("call_args: %r", mgr_args)
+    mgr_testcases = mgr_args[3]
+    assert len(mgr_testcases) == 1
+    if test_index is None:
+        test_index = -1
+    assert mgr_testcases == [tests[test_index]]
+
+
 def test_force_closed(mocker, tmp_path):
     """test that `forced_close` in testcase metadata is respected"""
     load_target = mocker.patch("grizzly.reduce.core.load_target")
@@ -117,6 +168,7 @@ def test_force_closed(mocker, tmp_path):
         prefs=None,
         repeat=1,
         sig=None,
+        test_index=None,
     )
     ReduceManager.main(args)
     assert load_target.return_value.return_value.forced_close is False
@@ -140,6 +192,7 @@ def test_testcase_prefs(mocker, tmp_path, result):
         prefs=None,
         repeat=1,
         sig=None,
+        test_index=None,
     )
     if result == "argprefs":
         (tmp_path / "args.js").write_text("argprefs")

From db8507dc1648477b9724c91a8c767a0d32f53283 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 5 Nov 2020 00:14:53 -0500
Subject: [PATCH 084/531] [reducer] Add '--skip-dd-unmarked' to restrict
 reduction to only files containing DDBEGIN/END (default is all files)

---
 grizzly/reduce/args.py       |  3 +++
 grizzly/reduce/core.py       |  7 +++++--
 grizzly/reduce/strategies.py | 36 +++++++++++++++++++++++++-----------
 3 files changed, 33 insertions(+), 13 deletions(-)

diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 06851c44..6b316f1a 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -49,6 +49,9 @@ def __init__(self):
         )
 
         reduce_args = self.parser.add_argument_group("Reduce Arguments")
+        reduce_args.add_argument(
+            "--skip-dd-unmarked", action="store_false", dest="all_files",
+            help="Only reduce files containing DDBEGIN/END (default: all files)")
         reduce_args.add_argument(
             "--no-analysis", action="store_true",
             help="Disable analysis to auto-set --repeat/--min-crashes.")
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index fa7d80db..1cd18f4d 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -98,7 +98,7 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
                  tool=None, report_to_fuzzmanager=False, any_crash=False,
                  signature=None, use_harness=True, use_analysis=True,
                  static_timeout=False, idle_delay=0, idle_threshold=0,
-                 signature_desc=None):
+                 signature_desc=None, all_files=True):
         """Initialize reduction manager. Many arguments are common with `ReplayManager`.
 
         Args:
@@ -125,6 +125,7 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
                                    less time.
             idle_delay (int): Number of seconds to wait before polling for idle.
             idle_threshold (int): CPU usage threshold to mark the process as idle.
+            all_files (bool): Reduce all files, not just those with DDBEGIN/END.
         """
         self.ignore = ignore
         self.server = server
@@ -132,6 +133,7 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
         self.target = target
         self.testcases = testcases
         self._any_crash = any_crash
+        self._all_files = all_files
         # only coerce `log_path` to `Path` if it's a string
         # this caution is only necessary in python3.5 where pytest uses
         # pathlib2 rather than pathlib
@@ -379,7 +381,7 @@ def run(self, repeat=1, min_results=1):
                                        any_crash=self._any_crash,
                                        signature=self._signature,
                                        use_harness=self._use_harness)
-                strategy = STRATEGIES[strategy](self.testcases)
+                strategy = STRATEGIES[strategy](self.testcases, self._all_files)
                 if last_tried is not None:
                     strategy.update_tried(last_tried)
                     last_tried = None
@@ -663,6 +665,7 @@ def main(cls, args):
                     args.logs,
                     tool=args.tool,
                     report_to_fuzzmanager=args.fuzzmanager,
+                    all_files=args.all_files,
                     any_crash=args.any_crash,
                     signature=signature,
                     signature_desc=signature_desc,
diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index 69333a22..5b63a574 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -87,6 +87,11 @@ def _load_strategies():
     return MappingProxyType(strategies)
 
 
+def _contains_DD(path):
+    data = path.read_text()
+    return "DDBEGIN" in data and "DDEND" in data
+
+
 class Strategy(ABC):
     """A strategy is a procedure for repeatedly running a testcase to find the smallest
     equivalent test.
@@ -98,24 +103,27 @@ class Strategy(ABC):
     """
     name = None
 
-    def __init__(self, testcases):
+    def __init__(self, testcases, all_files):
         """Initialize strategy instance.
 
         Arguments:
             testcases (list(grizzly.common.storage.TestCase)):
                 List of testcases to reduce. The object does not take ownership of the
                 testcases.
+            all_files (bool): Reduce all files, otherwise only files containing
+                              DDBEGIN/END
         """
         self._tried = set()  # set of tuple(tuple(str(Path), SHA512))
         self._testcase_root = Path(mkdtemp(prefix="tc_", dir=grz_tmp("reduce")))
+        self._all_files = all_files
         self.dump_testcases(testcases)
 
     def _calculate_testcase_hash(self):
         """Calculate hashes of all files in testcase root.
 
         Returns:
-            tuple(tuple(str, str)): A tuple of 2-tuples mapping str(Path) to SHA-512 of each
-                                    file in testcase root.
+            tuple(tuple(str, str)): A tuple of 2-tuples mapping str(Path) to SHA-512 of
+                                    each file in testcase root.
         """
         result = []
         for path in self._testcase_root.glob("**/*"):
@@ -303,20 +311,23 @@ class _BeautifyStrategy(Strategy, ABC):
     native_extension = None
     tag_name = None
 
-    def __init__(self, testcases):
+    def __init__(self, testcases, all_files):
         """Initialize beautification strategy instance.
 
         Arguments:
             testcases (list(grizzly.common.storage.TestCase)):
                 List of testcases to reduce. The object does not take ownership of the
                 testcases.
+            all_files (bool): Reduce all files, otherwise only files containing
+                              DDBEGIN/END
         """
-        super().__init__(testcases)
+        super().__init__(testcases, all_files)
         self._files_to_beautify = []
         for path in self._testcase_root.glob("**/*"):
             if (path.is_file() and path.suffix in self.all_extensions
                     and path.name not in self.blacklist_files):
-                self._files_to_beautify.append(path)
+                if self._all_files or _contains_DD(path):
+                    self._files_to_beautify.append(path)
         self._current_feedback = None
         tag_bytes = self.tag_name.encode("ascii")
         self._re_tag_start = re.compile(br"<\s*" + tag_bytes + br".*?>",
@@ -523,15 +534,17 @@ class _LithiumStrategy(Strategy, ABC):
     strategy_cls = None
     testcase_cls = None
 
-    def __init__(self, testcases):
+    def __init__(self, testcases, all_files):
         """Initialize strategy instance.
 
         Arguments:
             testcases (list(grizzly.common.storage.TestCase)):
                 List of testcases to reduce. The object does not take ownership of the
                 testcases.
+            all_files (bool): Reduce all files, otherwise only files containing
+                              DDBEGIN/END
         """
-        super().__init__(testcases)
+        super().__init__(testcases, all_files)
         self._current_reducer = None
         self._files_to_reduce = []
         self.rescan_files_to_reduce()
@@ -548,7 +561,8 @@ def rescan_files_to_reduce(self):
         self._files_to_reduce.clear()
         for path in self._testcase_root.glob("**/*"):
             if path.is_file() and path.name not in {"test_info.json", "prefs.js"}:
-                self._files_to_reduce.append(path)
+                if self._all_files or _contains_DD(path):
+                    self._files_to_reduce.append(path)
 
     @classmethod
     def sanity_check_cls_attrs(cls):
@@ -806,7 +820,7 @@ class MinimizeTestcaseList(Strategy):
     """
     name = "list"
 
-    def __init__(self, testcases):
+    def __init__(self, testcases, all_files):
         """Initialize strategy instance.
 
         Arguments:
@@ -814,7 +828,7 @@ def __init__(self, testcases):
                 List of testcases to reduce. The object does not take ownership of the
                 testcases.
         """
-        super().__init__(testcases)
+        super().__init__(testcases, all_files)
         self._current_feedback = None
         self._current_served = None
 

From 7fdbe67daeb07d7db54870eb2f3c328df34b163b Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 5 Nov 2020 11:46:39 -0500
Subject: [PATCH 085/531] [reducer] Ensure prefs.js is included in the results.

---
 grizzly/reduce/strategies.py      | 21 +++++++++--------
 grizzly/reduce/test_reduce.py     |  4 ++--
 grizzly/reduce/test_strategies.py | 39 ++++++++++++++++++++++---------
 3 files changed, 41 insertions(+), 23 deletions(-)

diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
index 5b63a574..f5501e4e 100644
--- a/grizzly/reduce/strategies.py
+++ b/grizzly/reduce/strategies.py
@@ -151,7 +151,8 @@ def update_tried(self, tried):
         SHA-512 and digested to bytes (`hashlib.sha512(testcase).digest()`)
 
         Arguments:
-            tried (iterable(tuple(tuple(str, str)))): Set of already tried testcase hashes.
+            tried (iterable(tuple(tuple(str, str)))): Set of already tried testcase
+                                                      hashes.
 
         Returns:
             None
@@ -508,7 +509,7 @@ def __iter__(self):
                 lith_tc.dump(file)
                 continue
 
-            yield TestCase.load(str(self._testcase_root), False)
+            yield TestCase.load(str(self._testcase_root), True)
 
             assert self._current_feedback is not None, "No feedback for last iteration"
             if self._current_feedback:
@@ -639,7 +640,7 @@ def __iter__(self):
 
             for reduction in self._current_reducer:
                 reduction.dump()
-                testcases = TestCase.load(str(self._testcase_root), False)
+                testcases = TestCase.load(str(self._testcase_root), True)
                 LOG.info("[%s] %s", self.name, self._current_reducer.description)
                 yield testcases
                 if self._current_feedback:
@@ -647,7 +648,7 @@ def __iter__(self):
                 else:
                     self._tried.add(self._calculate_testcase_hash())
                 if self._current_feedback and self._current_served is not None:
-                    testcases = TestCase.load(str(self._testcase_root), False)
+                    testcases = TestCase.load(str(self._testcase_root), True)
                     try:
                         self.purge_unserved(testcases, self._current_served)
                     finally:
@@ -671,7 +672,7 @@ def __iter__(self):
             # purging unserved files enabled us to exit early from the loop.
             # need to yield once more to set this trimmed version to the current best
             # in ReduceManager
-            testcases = TestCase.load(str(self._testcase_root), False)
+            testcases = TestCase.load(str(self._testcase_root), True)
             LOG.info("[%s] final iteration triggered by purge_optional", self.name)
             yield testcases
             assert self._current_feedback, "Purging unserved files broke the testcase."
@@ -863,7 +864,7 @@ def __iter__(self):
         idx = 0
         testcases = None
         try:
-            testcases = TestCase.load(str(self._testcase_root), False)
+            testcases = TestCase.load(str(self._testcase_root), True)
             n_testcases = len(testcases)
             # indicates that self._testcase_root contains changes that haven't been
             # yielded (if iteration ends, changes would be lost)
@@ -878,7 +879,7 @@ def __iter__(self):
                     break
                 # try removing the testcase at idx
                 if testcases is None:
-                    testcases = TestCase.load(str(self._testcase_root), False)
+                    testcases = TestCase.load(str(self._testcase_root), True)
                     assert n_testcases == len(testcases)
                 testcases.pop(idx).cleanup()
                 yield testcases
@@ -889,7 +890,7 @@ def __iter__(self):
                     testcase_root_dirty = False
                     LOG.info("Removing testcase %d/%d was successful!", idx + 1,
                              n_testcases)
-                    testcases = TestCase.load(str(self._testcase_root), False)
+                    testcases = TestCase.load(str(self._testcase_root), True)
                     try:
                         # remove the actual testcase we were reducing
                         testcases.pop(idx).cleanup()
@@ -901,7 +902,7 @@ def __iter__(self):
                     finally:
                         for testcase in testcases:
                             testcase.cleanup()
-                    testcases = TestCase.load(str(self._testcase_root), False)
+                    testcases = TestCase.load(str(self._testcase_root), True)
                     n_testcases = len(testcases)
                 else:
                     LOG.info("No result without testcase %d/%d", idx + 1, n_testcases)
@@ -913,7 +914,7 @@ def __iter__(self):
                 # purging unserved files enabled us to exit early from the loop.
                 # need to yield once more to set this trimmed version to the current
                 # best in ReduceManager
-                testcases = TestCase.load(str(self._testcase_root), False)
+                testcases = TestCase.load(str(self._testcase_root), True)
                 LOG.info("[%s] final iteration triggered by purge_optional", self.name)
                 yield testcases
                 testcases = None  # caller owns testcases now
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index c8d1e44e..cdfb17e3 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -509,13 +509,13 @@ def replay_run(testcases, **_):
     if n_reports:
         tests = {test.read_text() for test in log_path.glob("reports/*-0/test.html")}
         assert tests == reports
-        assert len(list((log_path / "reports").iterdir())) \
+        assert sum(1 for _ in (log_path / "reports").iterdir()) \
             == n_reports * 2, list((log_path / "reports").iterdir())
     if n_other:
         other_tests = {test.read_text()
                        for test in log_path.glob("other_reports/*-0/test.html")}
         assert other_tests == other_reports
-        assert len(list((log_path / "other_reports").iterdir())) \
+        assert sum(1 for _ in (log_path / "other_reports").iterdir()) \
             == n_other * 2, list((log_path / "other_reports").iterdir())
 
 
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 23ddb186..0527d461 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -12,7 +12,7 @@
 from pytest import raises
 
 from sapphire import Sapphire
-from ..common import TestCase, Report
+from ..common import TestCase, TestFile, Report
 from ..replay import ReplayResult
 from ..target import Target
 from .strategies import _load_strategies, HAVE_CSSBEAUTIFIER, HAVE_JSBEAUTIFIER
@@ -155,7 +155,7 @@ def replay_run(testcases, **_):
     assert set(log_path.iterdir()) == {log_path / "reports"}
     tests = {test.read_text() for test in log_path.glob("reports/*-*/test.html")}
     assert tests == expected_results
-    assert len(list((log_path / "reports").iterdir())) == expected_num_reports, \
+    assert sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports, \
         list((log_path / "reports").iterdir())
 
 
@@ -403,7 +403,8 @@ def replay_run(testcases, **_):
         # test already beautified css (beautify does nothing)
         pytest.param(
             *BeautifyStrategyParams(
-                test_data="<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n</style>\n",
+                test_data=(
+                    "<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n</style>\n"),
                 test_name="test.html",
                 expected_run_calls=1,
                 expected_results={
@@ -415,15 +416,19 @@ def replay_run(testcases, **_):
             marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
                                      reason="cssbeautifier required"),
         ),
-        # test almost beautified css (any change breaks test, beautify only removes an extra blank line,
-        # so `lines` will have already tried it, and this will hit the cache)
+        # test almost beautified css (any change breaks test, beautify only removes an
+        # extra blank line so `lines` will have already tried it, and this will hit the
+        # cache)
         pytest.param(
             *BeautifyStrategyParams(
-                test_data="<style nochange=true>\n/*DDBEGIN*/\n\nrequisite {\n  required: 1\n}\n/*DDEND*/\n</style>\n",
+                test_data=(
+                    "<style nochange=true>\n/*DDBEGIN*/\n\nrequisite {\n"
+                    "  required: 1\n}\n/*DDEND*/\n</style>\n"),
                 test_name="test.html",
                 expected_run_calls=8,
                 expected_results={
-                    "<style nochange=true>\n/*DDBEGIN*/\n\nrequisite {\n  required: 1\n}\n/*DDEND*/\n</style>\n"
+                    "<style nochange=true>\n/*DDBEGIN*/\n\nrequisite {\n"
+                    "  required: 1\n}\n/*DDEND*/\n</style>\n"
                 },
                 expected_num_reports=2,
                 strategies=["check", "lines", "cssbeautify"],
@@ -447,8 +452,10 @@ def replay_run(testcases, **_):
                 LOG.debug("interesting if test unchanged")
                 interesting = test_data == contents
             elif "requisite" in test_data:
-                LOG.debug("interesting if ('requisite' and 'required') or 'requi'+'red' in %r", contents)
-                interesting = ("required" in contents and "requisite" in contents) or "'requi'+'red'" in contents
+                LOG.debug("interesting if ('requisite' and 'required') or "
+                          "'requi'+'red' in %r", contents)
+                interesting = ("required" in contents and "requisite" in contents) \
+                    or "'requi'+'red'" in contents
             else:
                 LOG.debug("interesting if 'required' or 'requi'+'red' in %r", contents)
                 interesting = "required" in contents or "'requi'+'red'" in contents
@@ -482,7 +489,7 @@ def replay_run(testcases, **_):
     assert set(log_path.iterdir()) == {log_path / "reports"}
     tests = {test.read_text() for test in log_path.glob("reports/*-*/" + test_name)}
     assert tests == expected_results
-    assert len(list((log_path / "reports").iterdir())) == expected_num_reports, \
+    assert sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports, \
         list((log_path / "reports").iterdir())
 
 
@@ -615,6 +622,7 @@ def replay_run(testcases, **_):
         test = TestCase("test.html", None, "test-adapter")
         for filename, data in testcase.items():
             test.add_from_data(data, filename)
+        test.add_meta(TestFile.from_data("12345", "prefs.js"))
         tests.append(test)
     log_path = tmp_path / "logs"
 
@@ -638,5 +646,14 @@ def replay_run(testcases, **_):
     assert set(log_path.iterdir()) == {log_path / "reports"}
     tests = {test.read_text() for test in log_path.glob("reports/*-*/*.html")}
     assert tests == expected_results
-    assert len(list((log_path / "reports").iterdir())) == expected_num_reports, \
+    assert sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports, \
         list((log_path / "reports").iterdir())
+    # each input has 2 files, so if there are more than 2 reports, the result has 2
+    # testcases
+    assert (
+        sum(1 for _ in log_path.glob("reports/*-*/prefs.js"))
+        == (expected_num_reports + 1) // 2
+    ), "prefs.js missing in %r" % [
+        str(p.relative_to(log_path)) for p in log_path.glob("reports/**/*")
+        if p.is_file()
+    ]

From 1fa807cfb0c608bde6a700722e9b630efdabc195 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 5 Nov 2020 12:47:27 -0500
Subject: [PATCH 086/531] [reducer] Break out strategies into a sub-module.

---
 grizzly/reduce/strategies.py           | 929 -------------------------
 grizzly/reduce/strategies/__init__.py  | 275 ++++++++
 grizzly/reduce/strategies/beautify.py  | 333 +++++++++
 grizzly/reduce/strategies/lithium.py   | 234 +++++++
 grizzly/reduce/strategies/testcases.py | 132 ++++
 grizzly/reduce/test_strategies.py      |   3 +-
 setup.py                               |  17 +-
 7 files changed, 985 insertions(+), 938 deletions(-)
 delete mode 100644 grizzly/reduce/strategies.py
 create mode 100644 grizzly/reduce/strategies/__init__.py
 create mode 100644 grizzly/reduce/strategies/beautify.py
 create mode 100644 grizzly/reduce/strategies/lithium.py
 create mode 100644 grizzly/reduce/strategies/testcases.py

diff --git a/grizzly/reduce/strategies.py b/grizzly/reduce/strategies.py
deleted file mode 100644
index f5501e4e..00000000
--- a/grizzly/reduce/strategies.py
+++ /dev/null
@@ -1,929 +0,0 @@
-# coding=utf-8
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-"""Grizzly reducer strategy definitions.
-
-Each class defined here is an iterator yielding *potential* reductions. The caller
-should evaluate each set of testcases, and keep the best one. The caller is responsible
-for cleaning up all testcases that are yielded.
-
-Constants:
-    DEFAULT_STRATEGIES (list(str)): List of strategy names run by default if none are
-                                    specified.
-    STRATEGIES (dict{str: Strategy}): Mapping of available strategy names to
-                                      implementing class.
-    HAVE_CSSBEAUTIFIER (bool): True if `cssbeautifier` module is available.
-    HAVE_JSBEAUTIFIER (bool): True if `jsbeautifier` module is available.
-"""
-from abc import ABC, abstractmethod
-from hashlib import sha512
-from logging import DEBUG, getLogger
-from pathlib import Path
-import re
-from shutil import rmtree
-from tempfile import mkdtemp
-from types import MappingProxyType
-
-from lithium.strategies import CheckOnly, \
-    CollapseEmptyBraces as LithCollapseEmptyBraces, Minimize, Strategy as LithStrategy
-from lithium.testcases import TestcaseChar, TestcaseJsStr, TestcaseLine, \
-    Testcase as LithTestcase
-from pkg_resources import iter_entry_points
-
-from ..common.utils import grz_tmp
-from ..common.storage import TestCase
-
-try:
-    import cssbeautifier
-    HAVE_CSSBEAUTIFIER = True
-except ImportError:
-    HAVE_CSSBEAUTIFIER = False
-try:
-    import jsbeautifier
-    HAVE_JSBEAUTIFIER = True
-except ImportError:
-    HAVE_JSBEAUTIFIER = False
-
-
-LOG = getLogger(__name__)
-
-
-DEFAULT_STRATEGIES = (
-    "list",
-    "lines",
-    "cssbeautify",
-    "jsbeautify",
-    "collapsebraces",
-)
-
-
-def _load_strategies():
-    """STRATEGIES is created at the end of this file.
-
-    Returns:
-        mapping: A mapping of strategy names to strategy class.
-    """
-    strategies = {}
-    for entry_point in iter_entry_points("grizzly_reduce_strategies"):
-        try:
-            strategy_cls = entry_point.load()
-            strategy_cls.sanity_check_cls_attrs()
-            assert (
-                strategy_cls.name == entry_point.name
-            ), "entry_point name mismatch, check setup.py and %s.name" % (
-                strategy_cls.__name__,
-            )
-        except Exception as exc:  # pylint: disable=broad-except
-            LOG.debug("error loading strategy type %s: %s", entry_point.name, exc)
-            continue
-        strategies[entry_point.name] = strategy_cls
-    for strategy in DEFAULT_STRATEGIES:
-        assert (
-            strategy in strategies
-        ), "Unknown entry in DEFAULT_STRATEGIES: %s (STRATEGIES: [%s])" % (
-            strategy, ",".join(strategies)
-        )
-    return MappingProxyType(strategies)
-
-
-def _contains_DD(path):
-    data = path.read_text()
-    return "DDBEGIN" in data and "DDEND" in data
-
-
-class Strategy(ABC):
-    """A strategy is a procedure for repeatedly running a testcase to find the smallest
-    equivalent test.
-
-    Implementors must define these class attributes:
-
-    Class Attributes:
-        name (str): The strategy name.
-    """
-    name = None
-
-    def __init__(self, testcases, all_files):
-        """Initialize strategy instance.
-
-        Arguments:
-            testcases (list(grizzly.common.storage.TestCase)):
-                List of testcases to reduce. The object does not take ownership of the
-                testcases.
-            all_files (bool): Reduce all files, otherwise only files containing
-                              DDBEGIN/END
-        """
-        self._tried = set()  # set of tuple(tuple(str(Path), SHA512))
-        self._testcase_root = Path(mkdtemp(prefix="tc_", dir=grz_tmp("reduce")))
-        self._all_files = all_files
-        self.dump_testcases(testcases)
-
-    def _calculate_testcase_hash(self):
-        """Calculate hashes of all files in testcase root.
-
-        Returns:
-            tuple(tuple(str, str)): A tuple of 2-tuples mapping str(Path) to SHA-512 of
-                                    each file in testcase root.
-        """
-        result = []
-        for path in self._testcase_root.glob("**/*"):
-            if path.is_file():
-                tf_hash = sha512()
-                tf_hash.update(path.read_bytes())
-                result.append(
-                    (str(path.relative_to(self._testcase_root)), tf_hash.digest())
-                )
-        result = tuple(sorted(result))
-
-        if LOG.getEffectiveLevel() == DEBUG:
-            print_hash = sha512()
-            print_hash.update(repr(result).encode("utf-8", errors="surrogateescape"))
-            in_tried = result in self._tried
-            LOG.debug(
-                "Testcase hash: %s (%sin cache)",
-                print_hash.hexdigest()[:32], "" if in_tried else "not "
-            )
-
-        return result
-
-    def update_tried(self, tried):
-        """Update the list of tried testcase/hash sets. Testcases are hashed with
-        SHA-512 and digested to bytes (`hashlib.sha512(testcase).digest()`)
-
-        Arguments:
-            tried (iterable(tuple(tuple(str, str)))): Set of already tried testcase
-                                                      hashes.
-
-        Returns:
-            None
-        """
-        self._tried.update(frozenset(tried))
-
-    def get_tried(self):
-        """Return the set of tried testcase hashes. Testcases are hashed with SHA-512
-        and digested to bytes (`hashlib.sha512(testcase).digest()`)
-
-        Returns:
-            frozenset(tuple(tuple(str, str))): Testcase hashes.
-        """
-        return frozenset(self._tried)
-
-    def dump_testcases(self, testcases, recreate_tcroot=False):
-        """Dump a testcase list to the testcase root on disk.
-
-        Arguments:
-            testcases (list(grizzly.common.storage.TestCase)): list of testcases to dump
-            recreate_tcroot (bool): if True, delete testcase root and recreate it before
-                                    dumping
-
-        Returns:
-            None
-        """
-        if recreate_tcroot:
-            rmtree(str(self._testcase_root))
-            self._testcase_root.mkdir()
-        for idx, testcase in enumerate(testcases):
-            LOG.debug("Extracting testcase %d/%d", idx + 1, len(testcases))
-            testpath = self._testcase_root / ("%03d" % (idx,))
-            testcase.dump(str(testpath), include_details=True)
-
-    @classmethod
-    def sanity_check_cls_attrs(cls):
-        """Sanity check the strategy class implementation.
-
-        This should assert that any required class attributes are defined and correct.
-
-        Raises:
-            AssertionError: Any required class attributes are missing or wrong type.
-
-        Returns:
-            None
-        """
-        assert isinstance(cls.name, str)
-
-    @abstractmethod
-    def __iter__(self):
-        """Iterate over potential reductions of testcases according to this strategy.
-
-        The caller should evaluate each reduction yielded, and call `update` with the
-        result. The caller owns the testcases yielded, and should call `cleanup` for
-        each.
-
-        Yields:
-            list(grizzly.common.storage.TestCase): list of testcases with reduction
-                                                   applied
-        """
-
-    @abstractmethod
-    def update(self, success, served=None):
-        """Inform the strategy whether or not the last reduction yielded was good.
-
-        Arguments:
-            success (bool): Whether or not the last reduction was acceptable.
-            served (list(list(str))): The list of served files for each testcase in the
-                                      last reduction.
-
-        Returns:
-            None
-        """
-
-    def __enter__(self):
-        """Enter a runtime context that will automatically call `cleanup` on exit.
-
-        Returns:
-            Strategy: self
-        """
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Exit the runtime context. `cleanup` is called.
-
-        Arguments:
-            exc_type (type or None): Type of exception object currently raised.
-            exc_val (Exception or None): Exception object currently raised.
-            exc_tb (traceback or None): Traceback for currently raised exception.
-
-        Returns:
-            None
-        """
-        self.cleanup()
-
-    def cleanup(self):
-        """Destroy all resources held by the strategy.
-
-        Returns:
-            None
-        """
-        rmtree(str(self._testcase_root))
-
-    def purge_unserved(self, testcases, served):
-        """Given the testcase list yielded and list of what was served, purge
-        everything in testcase root to hold only what was served.
-
-        Arguments:
-            testcases (list(grizzly.common.storage.TestCase): testcases last replayed
-            served (list(list(str))): list of files served for each testcase.
-
-        Returns:
-            bool: True if anything was purged
-        """
-        LOG.debug("purging from %d testcases", len(testcases))
-        anything_purged = False
-        while len(served) < len(testcases):
-            LOG.debug("not all %d testcases served (%d served), popping one",
-                      len(testcases), len(served))
-            testcases.pop().cleanup()
-            anything_purged = True
-        remove_testcases = []
-        for idx, (testcase, tc_served) in enumerate(zip(testcases, served)):
-            LOG.debug("testcase %d served %r", idx, tc_served)
-            if testcase.landing_page not in tc_served:
-                LOG.debug("landing page %r not served", testcase.landing_page)
-                remove_testcases.append(idx)
-                anything_purged = True
-            else:
-                size_before = testcase.data_size
-                testcase.purge_optional(tc_served)
-                anything_purged = anything_purged or testcase.data_size != size_before
-        for idx in reversed(remove_testcases):
-            testcases.pop(idx).cleanup()
-        self.dump_testcases(testcases, recreate_tcroot=True)
-        return anything_purged
-
-
-class _BeautifyStrategy(Strategy, ABC):
-    """A strategy that beautifies code in the testcase to make it more reducible.
-
-    Implementors must define these class attributes:
-
-    Class attributes:
-        all_extensions (set(str)): Set of all file extensions to beautify.
-        import_available (bool): Whether or not the beautify module was imported.
-        import_name (str): The name of the beautify module imported (for error
-                           reporting).
-        name (str): The strategy name.
-        native_extension (str): The native file extension for this type.
-        tag_name (str): Tag name to search for in other (non-native) extensions.
-    """
-    all_extensions = None
-    blacklist_files = {"test_info.json", "prefs.js"}
-    import_available = None
-    import_name = None
-    native_extension = None
-    tag_name = None
-
-    def __init__(self, testcases, all_files):
-        """Initialize beautification strategy instance.
-
-        Arguments:
-            testcases (list(grizzly.common.storage.TestCase)):
-                List of testcases to reduce. The object does not take ownership of the
-                testcases.
-            all_files (bool): Reduce all files, otherwise only files containing
-                              DDBEGIN/END
-        """
-        super().__init__(testcases, all_files)
-        self._files_to_beautify = []
-        for path in self._testcase_root.glob("**/*"):
-            if (path.is_file() and path.suffix in self.all_extensions
-                    and path.name not in self.blacklist_files):
-                if self._all_files or _contains_DD(path):
-                    self._files_to_beautify.append(path)
-        self._current_feedback = None
-        tag_bytes = self.tag_name.encode("ascii")
-        self._re_tag_start = re.compile(br"<\s*" + tag_bytes + br".*?>",
-                                        flags=re.DOTALL | re.IGNORECASE)
-        self._re_tag_end = re.compile(br"</\s*" + tag_bytes + br"\s*>",
-                                      flags=re.IGNORECASE)
-
-    @classmethod
-    def sanity_check_cls_attrs(cls):
-        """Sanity check the strategy class implementation.
-
-        Raises:
-            AssertionError: Required class attributes are missing or wrong type.
-
-        Returns:
-            None
-        """
-        super().sanity_check_cls_attrs()
-        assert isinstance(cls.all_extensions, set)
-        assert all(isinstance(ext, str) for ext in cls.all_extensions)
-        assert isinstance(cls.import_available, bool)
-        assert isinstance(cls.import_name, str)
-        assert isinstance(cls.native_extension, str)
-        assert isinstance(cls.tag_name, str)
-
-    def update(self, success, served=None):
-        """Inform the strategy whether or not the last beautification yielded was good.
-
-        Arguments:
-            success (bool): Whether or not the last beautification was acceptable.
-            served (list(list(str))): The list of served files for each testcase in the
-                                      last beautification.
-
-        Returns:
-            None
-        """
-        # beautify does nothing with served. it's unlikely a beautify operation alone
-        # would render a file unserved.
-        assert self._current_feedback is None
-        self._current_feedback = success
-
-    @classmethod
-    @abstractmethod
-    def beautify_bytes(cls, data):
-        """Perform beautification on a code buffer.
-
-        Arguments:
-            data (bytes): The code data to be beautified.
-
-        Returns:
-            bytes: The beautified result.
-        """
-
-    def _chunks_to_beautify(self, before, to_beautify, file):
-        """Iterate over `to_beautify` and find chunks of style/script to beautify.
-
-        Arguments:
-            before (bytes): The data preceding `to_beautify`. Used to check whether
-                            `to_beautify` is already in an open <script> or <style> tag.
-            to_beautify (bytes): The data to beautify.
-            file (Path): The input file (used only to check if this is a .css/.js file)
-
-        Yields:
-            tuple (int,int): Slices of `to_beautify` that should be beautified.
-        """
-        # native extension, there's no need to search for tags
-        if file.suffix == self.native_extension:
-            yield (0, len(to_beautify))
-            return
-
-        # find the last <tag> preceding DDBEGIN
-        last_tag_start = None
-        for match in self._re_tag_start.finditer(before):
-            last_tag_start = match
-        in_tag_already = (
-            # there was an open <tag>
-            last_tag_start is not None
-            # and it isn't followed by a closing </tag>
-            and self._re_tag_end.search(before[last_tag_start.end(0):]) is None
-        )
-        if in_tag_already:
-            tag_end = self._re_tag_end.search(to_beautify)
-            if tag_end is None:
-                # similar to native case. DDBEGIN/END occurred inside the tag, so
-                # no need to look further
-                yield (0, len(to_beautify))
-                return
-            yield (0, tag_end.start(0))
-            search_start = tag_end.end(0)
-        else:
-            search_start = 0
-
-        # scan for <tag></tag> (with </tag> being optional for the last match)
-        while True:
-            tag_start = self._re_tag_start.search(to_beautify[search_start:])
-            if tag_start is None:
-                break
-            chunk_start = search_start + tag_start.end(0)
-            tag_end = self._re_tag_end.search(to_beautify[chunk_start:])
-            if tag_end is None:
-                # last </tag> was missing, stop looking
-                yield (chunk_start, len(to_beautify))
-                break
-            yield (chunk_start, chunk_start + tag_end.start(0))
-            search_start = chunk_start + tag_end.end(0)
-
-    def __iter__(self):
-        """Iterate over potential beautifications of testcases according to this
-        strategy.
-
-        The caller should evaluate each testcase set yielded, and call `update` with the
-        result. The caller owns the testcases yielded, and should call `cleanup` for
-        each.
-
-        Yields:
-            list(grizzly.common.storage.TestCase): list of testcases with beautification
-                                                   applied
-        """
-        if not self.import_available:
-            LOG.warning("%s not available, skipping strategy.", self.import_name)
-            return
-
-        LOG.info("Beautifying %d files", len(self._files_to_beautify))
-        for file_no, file in enumerate(self._files_to_beautify):
-            LOG.info("Beautifying %s (file %d/%d)",
-                     file.relative_to(self._testcase_root), file_no + 1,
-                     len(self._files_to_beautify))
-
-            # Use Lithium just to split the file at DDBEGIN/END.
-            # Lithium already has the right logic for DDBEGIN/END and line endings.
-            lith_tc = TestcaseLine()
-            lith_tc.load(file)
-            raw = b"".join(lith_tc.parts)
-
-            with file.open("wb") as testcase_fp:
-                last = 0
-                any_beautified = False
-                testcase_fp.write(lith_tc.before)
-                for start, end in self._chunks_to_beautify(lith_tc.before, raw, file):
-                    before = raw[last:start]
-                    testcase_fp.write(before)
-                    to_beautify = raw[start:end]
-                    LOG.debug("before: %r", to_beautify)
-                    beautified = self.beautify_bytes(to_beautify)
-                    LOG.debug("after: %r", beautified)
-                    if beautified:
-                        if before and not before.endswith(b"\n"):
-                            beautified = b"\n" + beautified
-                        if not beautified.endswith(b"\n"):
-                            beautified = beautified + b"\n"
-
-                        testcase_fp.write(beautified)
-                        if beautified == to_beautify:
-                            LOG.warning("Beautify had no effect!")
-                        else:
-                            any_beautified = True
-                    elif to_beautify.strip():  # pragma: no cover
-                        # this should never happen, but just in case...
-                        # pragma: no cover
-                        LOG.warning("No output from beautify! Writing %s unmodified.",
-                                    self.tag_name)
-                        testcase_fp.write(to_beautify)  # pragma: no cover
-                    last = end
-                testcase_fp.write(raw[last:])
-                testcase_fp.write(lith_tc.after)
-
-                if last == 0:
-                    LOG.warning("<%s> tags not found, skipping", self.tag_name)
-                    continue
-
-                if not any_beautified:
-                    LOG.warning("Beautify had no effect on the file, skipping")
-                    continue
-
-            tc_hash = self._calculate_testcase_hash()
-            if tc_hash in self._tried:
-                LOG.info("cache hit, reverting")
-                lith_tc.dump(file)
-                continue
-
-            yield TestCase.load(str(self._testcase_root), True)
-
-            assert self._current_feedback is not None, "No feedback for last iteration"
-            if self._current_feedback:
-                LOG.info("%s was successful", self.name)
-            else:
-                LOG.warning("%s failed (reverting)", self.name)
-                lith_tc.dump(file)
-                self._tried.add(tc_hash)
-            self._current_feedback = None
-
-
-class _LithiumStrategy(Strategy, ABC):
-    """Use a Lithium `Strategy`/`Testcase` pair to reduce the given Grizzly `TestCase`
-    set.
-
-    Implementors must define these class attributes:
-
-    Class attributes:
-        name (str): The strategy name.
-        strategy_cls (lithium.strategies.Strategy): Lithium strategy type.
-        testcase_cls (lithium.testcases.Testcase): Lithium testcase type.
-    """
-    strategy_cls = None
-    testcase_cls = None
-
-    def __init__(self, testcases, all_files):
-        """Initialize strategy instance.
-
-        Arguments:
-            testcases (list(grizzly.common.storage.TestCase)):
-                List of testcases to reduce. The object does not take ownership of the
-                testcases.
-            all_files (bool): Reduce all files, otherwise only files containing
-                              DDBEGIN/END
-        """
-        super().__init__(testcases, all_files)
-        self._current_reducer = None
-        self._files_to_reduce = []
-        self.rescan_files_to_reduce()
-        self._current_feedback = None
-        self._current_served = None
-
-    def rescan_files_to_reduce(self):
-        """Repopulate the private `files_to_reduce` attribute by scanning the testcase
-        root.
-
-        Returns:
-            None
-        """
-        self._files_to_reduce.clear()
-        for path in self._testcase_root.glob("**/*"):
-            if path.is_file() and path.name not in {"test_info.json", "prefs.js"}:
-                if self._all_files or _contains_DD(path):
-                    self._files_to_reduce.append(path)
-
-    @classmethod
-    def sanity_check_cls_attrs(cls):
-        """Sanity check the strategy class implementation.
-
-        Raises:
-            AssertionError: Required class attributes are missing or wrong type.
-
-        Returns:
-            None
-        """
-        super().sanity_check_cls_attrs()
-        assert issubclass(cls.strategy_cls, LithStrategy)
-        assert issubclass(cls.testcase_cls, LithTestcase)
-
-    def update(self, success, served=None):
-        """Inform the strategy whether or not the last reduction yielded was good.
-
-        Arguments:
-            success (bool): Whether or not the last reduction was acceptable.
-            served (list(list(str))): The list of served files for each testcase in the
-                                      last reduction.
-
-        Returns:
-            None
-        """
-        if self._current_reducer is not None:
-            self._current_reducer.feedback(success)
-        self._current_feedback = success
-        self._current_served = served
-
-    def __iter__(self):
-        """Iterate over potential reductions of testcases according to this strategy.
-
-        The caller should evaluate each testcase set yielded, and call `update` with the
-        result. The caller owns the testcases yielded, and should call `cleanup` for
-        each.
-
-        Yields:
-            list(grizzly.common.storage.TestCase): list of testcases with reduction
-                                                   applied
-        """
-        LOG.info("Reducing %d files", len(self._files_to_reduce))
-        file_no = 0
-        reduce_queue = self._files_to_reduce.copy()
-        reduce_queue.sort()  # not necessary, but helps make tests more predictable
-        # indicates that self._testcase_root contains changes that haven't been yielded
-        # (if iteration ends, changes would be lost)
-        testcase_root_dirty = False
-        while reduce_queue:
-            LOG.debug("Reduce queue: %r", reduce_queue)
-            file = reduce_queue.pop(0)
-            file_no += 1
-            LOG.info("[%s] Reducing %s (file %d/%d)", self.name,
-                     file.relative_to(self._testcase_root), file_no,
-                     len(self._files_to_reduce))
-            lithium_testcase = self.testcase_cls()  # pylint: disable=not-callable
-            lithium_testcase.load(file)
-            # pylint: disable=not-callable
-            self._current_reducer = self.strategy_cls().reduce(lithium_testcase)
-
-            # populate the lithium strategy "tried" cache
-            # use all cache values where all hashes other than the current file match
-            # the current testcase_root state.
-            current_tc_hash_map = dict(self._calculate_testcase_hash())
-            del current_tc_hash_map[str(file.relative_to(self._testcase_root))]
-            this_tc_tried = set()
-            for tried in self._tried:
-                tried = dict(tried)
-                tc_tried = tried.pop(str(file.relative_to(self._testcase_root)))
-                if tried == current_tc_hash_map:
-                    this_tc_tried.add(tc_tried)
-            self._current_reducer.update_tried(this_tc_tried)
-
-            for reduction in self._current_reducer:
-                reduction.dump()
-                testcases = TestCase.load(str(self._testcase_root), True)
-                LOG.info("[%s] %s", self.name, self._current_reducer.description)
-                yield testcases
-                if self._current_feedback:
-                    testcase_root_dirty = False
-                else:
-                    self._tried.add(self._calculate_testcase_hash())
-                if self._current_feedback and self._current_served is not None:
-                    testcases = TestCase.load(str(self._testcase_root), True)
-                    try:
-                        self.purge_unserved(testcases, self._current_served)
-                    finally:
-                        for testcase in testcases:
-                            testcase.cleanup()
-                    num_files_before = len(self._files_to_reduce)
-                    LOG.debug("files being reduced before: %r", self._files_to_reduce)
-                    self.rescan_files_to_reduce()
-                    LOG.debug("files being reduced after: %r", self._files_to_reduce)
-                    files_to_reduce = set(self._files_to_reduce)
-                    reduce_queue = list(sorted(set(reduce_queue) & files_to_reduce))
-                    testcase_root_dirty = len(self._files_to_reduce) != num_files_before
-                    if file not in files_to_reduce:
-                        # current reduction was for a purged file
-                        break
-            else:
-                # write out the best found testcase
-                self._current_reducer.testcase.dump()
-            self._current_reducer = None
-        if testcase_root_dirty:
-            # purging unserved files enabled us to exit early from the loop.
-            # need to yield once more to set this trimmed version to the current best
-            # in ReduceManager
-            testcases = TestCase.load(str(self._testcase_root), True)
-            LOG.info("[%s] final iteration triggered by purge_optional", self.name)
-            yield testcases
-            assert self._current_feedback, "Purging unserved files broke the testcase."
-
-
-class Check(_LithiumStrategy):
-    """Check whether the testcase is reproducible.
-
-    This strategy does no reduction, and only yields once. It is intended to provide a
-    pass/fail result in a reduction pipeline.
-    """
-    name = "check"
-    strategy_cls = CheckOnly
-    testcase_cls = TestcaseLine
-
-    def __init__(self, *args, **kwds):
-        super().__init__(*args, **kwds)
-        # trim files_to_reduce, for check we don't need to run on every file
-        # just once per Grizzly TestCase set is enough.
-        self._files_to_reduce = self._files_to_reduce[:1]
-
-
-class CollapseEmptyBraces(_LithiumStrategy):
-    """Minimize lines, but collapse empty curly braces between each iteration.
-
-    During reduction, the contents of a block may be reduced away entirely, but removing
-    the starting brace or ending brace alone will break the syntax of the test file.
-    This strategy tries to collapse empty braces onto the same line between each
-    iteration, so that empty blocks can be removed if otherwise possible.
-    """
-    name = "collapsebraces"
-    strategy_cls = LithCollapseEmptyBraces
-    testcase_cls = TestcaseLine
-
-
-class CSSBeautify(_BeautifyStrategy):
-    """Run CSS beautification on all CSS files and `<style>` tags.
-
-    This should make the CSS more reducible if there are long lines with compound
-    definitions.
-    """
-    all_extensions = {".css", ".htm", ".html", ".xhtml"}
-    import_available = HAVE_CSSBEAUTIFIER
-    import_name = "cssbeautifier"
-    name = "cssbeautify"
-    native_extension = ".css"
-    opts = (
-        ('end_with_newline', False),
-        ('indent_size', 2),
-        ('newline_between_rules', False),
-        ('preserve_newlines', False),
-    )
-    tag_name = "style"
-
-    @classmethod
-    def beautify_bytes(cls, data):
-        """Perform CSS beautification on a code buffer.
-
-        Arguments:
-            data (bytes): The code data to be beautified.
-
-        Returns:
-            bytes: The beautified result.
-        """
-        assert cls.import_available
-        data = data.decode("utf-8", errors="surrogateescape")
-        return (cssbeautifier
-                .beautify(data, cls.opts)
-                .encode("utf-8", errors="surrogateescape"))
-
-
-class JSBeautify(_BeautifyStrategy):
-    """Run JS beautification on all JS files and `<script>` tags.
-
-    This should make the javascript more reducible if there are long lines with
-    compound statements.
-    """
-    all_extensions = {".js", ".htm", ".html", ".xhtml"}
-    import_available = HAVE_JSBEAUTIFIER
-    import_name = "jsbeautifier"
-    name = "jsbeautify"
-    native_extension = ".js"
-    opts = None
-    tag_name = "script"
-    try_catch_re = re.compile(r"(\s*try {)\n\s*(.*)\n\s*(}\s*catch.*)")
-
-    @classmethod
-    def beautify_bytes(cls, data):
-        """Perform JS beautification on a code buffer.
-
-        Arguments:
-            data (bytes): The code data to be beautified.
-
-        Returns:
-            bytes: The beautified result.
-        """
-        assert HAVE_JSBEAUTIFIER
-        data = data.decode("utf-8", errors="surrogateescape")
-
-        beautified = jsbeautifier.beautify(data, cls.opts)
-        # All try/catch pairs will be expanded on their own lines
-        # Collapse these pairs when only a single instruction is contained within
-        beautified = cls.try_catch_re.sub(r"\1 \2 \3", beautified)
-        return beautified.encode("utf-8", errors="surrogateescape")
-
-
-class MinimizeChars(_LithiumStrategy):
-    """Minimize all bytes in the testcase.
-    """
-    name = "chars"
-    strategy_cls = Minimize
-    testcase_cls = TestcaseChar
-
-
-class MinimizeJSChars(_LithiumStrategy):
-    """Minimize all bytes contained in javascript strings.
-
-    This works the same as MinimizeChars, but only operates if it can identify what
-    looks like a quoted string. It also treats escaped characters as a single token
-    for reduction.
-    """
-    name = "jschars"
-    strategy_cls = Minimize
-    testcase_cls = TestcaseJsStr
-
-
-class MinimizeLines(_LithiumStrategy):
-    """Minimize all lines in the testcase.
-    """
-    name = "lines"
-    strategy_cls = Minimize
-    testcase_cls = TestcaseLine
-
-
-class MinimizeTestcaseList(Strategy):
-    """Try removing testcases from a list of sequential testcases (eg. Grizzly result
-    cache). The strategy favours testcases at the tail of the list, so for a list of
-    five testcases:
-                            testcases
-                    0       1 2 3 4 5
-        iteration   1         2 3 4 5
-                    2       1   3 4 5
-                    3       1 2   4 5
-                    4       1 2 3   5
-                    5       1 2 3 4
-    """
-    name = "list"
-
-    def __init__(self, testcases, all_files):
-        """Initialize strategy instance.
-
-        Arguments:
-            testcases (list(grizzly.common.storage.TestCase)):
-                List of testcases to reduce. The object does not take ownership of the
-                testcases.
-        """
-        super().__init__(testcases, all_files)
-        self._current_feedback = None
-        self._current_served = None
-
-    def update(self, success, served=None):
-        """Inform the strategy whether or not the last reduction yielded was good.
-
-        Arguments:
-            success (bool): Whether or not the last reduction was acceptable.
-            served (list(list(str))): The list of served files for each testcase in the
-                                      last reduction.
-
-        Returns:
-            None
-        """
-        assert self._current_feedback is None
-        assert self._current_served is None
-        self._current_feedback = success
-        self._current_served = served
-
-    def __iter__(self):
-        """Iterate over potential reductions of testcases according to this strategy.
-
-        The caller should evaluate each testcase set yielded, and call `update` with the
-        result. The caller owns the testcases yielded, and should call `cleanup` for
-        each.
-
-        Yields:
-            list(grizzly.common.storage.TestCase): list of testcases with reduction
-                                                   applied
-        """
-        assert self._current_feedback is None
-        idx = 0
-        testcases = None
-        try:
-            testcases = TestCase.load(str(self._testcase_root), True)
-            n_testcases = len(testcases)
-            # indicates that self._testcase_root contains changes that haven't been
-            # yielded (if iteration ends, changes would be lost)
-            testcase_root_dirty = False
-            while True:
-                if n_testcases <= 1:
-                    LOG.info("Testcase list has length %d, not enough to reduce!",
-                             n_testcases)
-                    break
-                if idx >= n_testcases:
-                    LOG.info("Attempted to remove every single testcase")
-                    break
-                # try removing the testcase at idx
-                if testcases is None:
-                    testcases = TestCase.load(str(self._testcase_root), True)
-                    assert n_testcases == len(testcases)
-                testcases.pop(idx).cleanup()
-                yield testcases
-                testcases = None  # caller owns testcases now
-                assert self._current_feedback is not None, "no feedback received!"
-
-                if self._current_feedback:
-                    testcase_root_dirty = False
-                    LOG.info("Removing testcase %d/%d was successful!", idx + 1,
-                             n_testcases)
-                    testcases = TestCase.load(str(self._testcase_root), True)
-                    try:
-                        # remove the actual testcase we were reducing
-                        testcases.pop(idx).cleanup()
-                        if testcases and self._current_served is not None:
-                            testcase_root_dirty = \
-                                self.purge_unserved(testcases, self._current_served)
-                        else:
-                            self.dump_testcases(testcases, recreate_tcroot=True)
-                    finally:
-                        for testcase in testcases:
-                            testcase.cleanup()
-                    testcases = TestCase.load(str(self._testcase_root), True)
-                    n_testcases = len(testcases)
-                else:
-                    LOG.info("No result without testcase %d/%d", idx + 1, n_testcases)
-                    idx += 1
-                # reset
-                self._current_feedback = None
-                self._current_served = None
-            if testcase_root_dirty:
-                # purging unserved files enabled us to exit early from the loop.
-                # need to yield once more to set this trimmed version to the current
-                # best in ReduceManager
-                testcases = TestCase.load(str(self._testcase_root), True)
-                LOG.info("[%s] final iteration triggered by purge_optional", self.name)
-                yield testcases
-                testcases = None  # caller owns testcases now
-                assert self._current_feedback, \
-                    "Purging unserved files broke the testcase."
-        finally:
-            if testcases is not None:
-                for testcase in testcases:
-                    testcase.cleanup()
-
-
-STRATEGIES = _load_strategies()
diff --git a/grizzly/reduce/strategies/__init__.py b/grizzly/reduce/strategies/__init__.py
new file mode 100644
index 00000000..19b66906
--- /dev/null
+++ b/grizzly/reduce/strategies/__init__.py
@@ -0,0 +1,275 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Grizzly reducer strategy definitions.
+
+Each class defined here is an iterator yielding *potential* reductions. The caller
+should evaluate each set of testcases, and keep the best one. The caller is responsible
+for cleaning up all testcases that are yielded.
+
+Constants:
+    DEFAULT_STRATEGIES (list(str)): List of strategy names run by default if none are
+                                    specified.
+    STRATEGIES (dict{str: Strategy}): Mapping of available strategy names to
+                                      implementing class.
+"""
+from abc import ABC, abstractmethod
+from hashlib import sha512
+from logging import DEBUG, getLogger
+from pathlib import Path
+from shutil import rmtree
+from tempfile import mkdtemp
+from types import MappingProxyType
+
+from pkg_resources import iter_entry_points
+
+from ...common.utils import grz_tmp
+
+
+LOG = getLogger(__name__)
+
+
+DEFAULT_STRATEGIES = (
+    "list",
+    "lines",
+    "cssbeautify",
+    "jsbeautify",
+    "collapsebraces",
+)
+
+
+def _load_strategies():
+    """STRATEGIES is created at the end of this file.
+
+    Returns:
+        mapping: A mapping of strategy names to strategy class.
+    """
+    strategies = {}
+    for entry_point in iter_entry_points("grizzly_reduce_strategies"):
+        try:
+            strategy_cls = entry_point.load()
+            strategy_cls.sanity_check_cls_attrs()
+            assert (
+                strategy_cls.name == entry_point.name
+            ), "entry_point name mismatch, check setup.py and %s.name" % (
+                strategy_cls.__name__,
+            )
+        except Exception as exc:  # pylint: disable=broad-except
+            LOG.debug("error loading strategy type %s: %s", entry_point.name, exc)
+            continue
+        strategies[entry_point.name] = strategy_cls
+    for strategy in DEFAULT_STRATEGIES:
+        assert (
+            strategy in strategies
+        ), "Unknown entry in DEFAULT_STRATEGIES: %s (STRATEGIES: [%s])" % (
+            strategy, ",".join(strategies)
+        )
+    return MappingProxyType(strategies)
+
+
+def _contains_dd(path):
+    data = path.read_text()
+    return "DDBEGIN" in data and "DDEND" in data
+
+
+class Strategy(ABC):
+    """A strategy is a procedure for repeatedly running a testcase to find the smallest
+    equivalent test.
+
+    Implementors must define these class attributes:
+
+    Class Attributes:
+        name (str): The strategy name.
+    """
+    name = None
+
+    def __init__(self, testcases, all_files):
+        """Initialize strategy instance.
+
+        Arguments:
+            testcases (list(grizzly.common.storage.TestCase)):
+                List of testcases to reduce. The object does not take ownership of the
+                testcases.
+            all_files (bool): Reduce all files, otherwise only files containing
+                              DDBEGIN/END
+        """
+        self._tried = set()  # set of tuple(tuple(str(Path), SHA512))
+        self._testcase_root = Path(mkdtemp(prefix="tc_", dir=grz_tmp("reduce")))
+        self._all_files = all_files
+        self.dump_testcases(testcases)
+
+    def _calculate_testcase_hash(self):
+        """Calculate hashes of all files in testcase root.
+
+        Returns:
+            tuple(tuple(str, str)): A tuple of 2-tuples mapping str(Path) to SHA-512 of
+                                    each file in testcase root.
+        """
+        result = []
+        for path in self._testcase_root.glob("**/*"):
+            if path.is_file():
+                tf_hash = sha512()
+                tf_hash.update(path.read_bytes())
+                result.append(
+                    (str(path.relative_to(self._testcase_root)), tf_hash.digest())
+                )
+        result = tuple(sorted(result))
+
+        if LOG.getEffectiveLevel() == DEBUG:
+            print_hash = sha512()
+            print_hash.update(repr(result).encode("utf-8", errors="surrogateescape"))
+            in_tried = result in self._tried
+            LOG.debug(
+                "Testcase hash: %s (%sin cache)",
+                print_hash.hexdigest()[:32], "" if in_tried else "not "
+            )
+
+        return result
+
+    def update_tried(self, tried):
+        """Update the list of tried testcase/hash sets. Testcases are hashed with
+        SHA-512 and digested to bytes (`hashlib.sha512(testcase).digest()`)
+
+        Arguments:
+            tried (iterable(tuple(tuple(str, str)))): Set of already tried testcase
+                                                      hashes.
+
+        Returns:
+            None
+        """
+        self._tried.update(frozenset(tried))
+
+    def get_tried(self):
+        """Return the set of tried testcase hashes. Testcases are hashed with SHA-512
+        and digested to bytes (`hashlib.sha512(testcase).digest()`)
+
+        Returns:
+            frozenset(tuple(tuple(str, str))): Testcase hashes.
+        """
+        return frozenset(self._tried)
+
+    def dump_testcases(self, testcases, recreate_tcroot=False):
+        """Dump a testcase list to the testcase root on disk.
+
+        Arguments:
+            testcases (list(grizzly.common.storage.TestCase)): list of testcases to dump
+            recreate_tcroot (bool): if True, delete testcase root and recreate it before
+                                    dumping
+
+        Returns:
+            None
+        """
+        if recreate_tcroot:
+            rmtree(str(self._testcase_root))
+            self._testcase_root.mkdir()
+        for idx, testcase in enumerate(testcases):
+            LOG.debug("Extracting testcase %d/%d", idx + 1, len(testcases))
+            testpath = self._testcase_root / ("%03d" % (idx,))
+            testcase.dump(str(testpath), include_details=True)
+
+    @classmethod
+    def sanity_check_cls_attrs(cls):
+        """Sanity check the strategy class implementation.
+
+        This should assert that any required class attributes are defined and correct.
+
+        Raises:
+            AssertionError: Any required class attributes are missing or wrong type.
+
+        Returns:
+            None
+        """
+        assert isinstance(cls.name, str)
+
+    @abstractmethod
+    def __iter__(self):
+        """Iterate over potential reductions of testcases according to this strategy.
+
+        The caller should evaluate each reduction yielded, and call `update` with the
+        result. The caller owns the testcases yielded, and should call `cleanup` for
+        each.
+
+        Yields:
+            list(grizzly.common.storage.TestCase): list of testcases with reduction
+                                                   applied
+        """
+
+    @abstractmethod
+    def update(self, success, served=None):
+        """Inform the strategy whether or not the last reduction yielded was good.
+
+        Arguments:
+            success (bool): Whether or not the last reduction was acceptable.
+            served (list(list(str))): The list of served files for each testcase in the
+                                      last reduction.
+
+        Returns:
+            None
+        """
+
+    def __enter__(self):
+        """Enter a runtime context that will automatically call `cleanup` on exit.
+
+        Returns:
+            Strategy: self
+        """
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit the runtime context. `cleanup` is called.
+
+        Arguments:
+            exc_type (type or None): Type of exception object currently raised.
+            exc_val (Exception or None): Exception object currently raised.
+            exc_tb (traceback or None): Traceback for currently raised exception.
+
+        Returns:
+            None
+        """
+        self.cleanup()
+
+    def cleanup(self):
+        """Destroy all resources held by the strategy.
+
+        Returns:
+            None
+        """
+        rmtree(str(self._testcase_root))
+
+    def purge_unserved(self, testcases, served):
+        """Given the testcase list yielded and list of what was served, purge
+        everything in testcase root to hold only what was served.
+
+        Arguments:
+            testcases (list(grizzly.common.storage.TestCase): testcases last replayed
+            served (list(list(str))): list of files served for each testcase.
+
+        Returns:
+            bool: True if anything was purged
+        """
+        LOG.debug("purging from %d testcases", len(testcases))
+        anything_purged = False
+        while len(served) < len(testcases):
+            LOG.debug("not all %d testcases served (%d served), popping one",
+                      len(testcases), len(served))
+            testcases.pop().cleanup()
+            anything_purged = True
+        remove_testcases = []
+        for idx, (testcase, tc_served) in enumerate(zip(testcases, served)):
+            LOG.debug("testcase %d served %r", idx, tc_served)
+            if testcase.landing_page not in tc_served:
+                LOG.debug("landing page %r not served", testcase.landing_page)
+                remove_testcases.append(idx)
+                anything_purged = True
+            else:
+                size_before = testcase.data_size
+                testcase.purge_optional(tc_served)
+                anything_purged = anything_purged or testcase.data_size != size_before
+        for idx in reversed(remove_testcases):
+            testcases.pop(idx).cleanup()
+        self.dump_testcases(testcases, recreate_tcroot=True)
+        return anything_purged
+
+
+STRATEGIES = _load_strategies()
diff --git a/grizzly/reduce/strategies/beautify.py b/grizzly/reduce/strategies/beautify.py
new file mode 100644
index 00000000..ec12b296
--- /dev/null
+++ b/grizzly/reduce/strategies/beautify.py
@@ -0,0 +1,333 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Grizzly reducer beautify strategy definitions.
+
+Constants:
+    HAVE_CSSBEAUTIFIER (bool): True if `cssbeautifier` module is available.
+    HAVE_JSBEAUTIFIER (bool): True if `jsbeautifier` module is available.
+"""
+from abc import ABC, abstractmethod
+from logging import getLogger
+import re
+
+from lithium.testcases import TestcaseLine
+
+try:
+    import cssbeautifier
+    HAVE_CSSBEAUTIFIER = True
+except ImportError:
+    HAVE_CSSBEAUTIFIER = False
+try:
+    import jsbeautifier
+    HAVE_JSBEAUTIFIER = True
+except ImportError:
+    HAVE_JSBEAUTIFIER = False
+
+from ...common.storage import TestCase
+from . import Strategy, _contains_dd
+
+
+LOG = getLogger(__name__)
+
+
+class _BeautifyStrategy(Strategy, ABC):
+    """A strategy that beautifies code in the testcase to make it more reducible.
+
+    Implementors must define these class attributes:
+
+    Class attributes:
+        all_extensions (set(str)): Set of all file extensions to beautify.
+        import_available (bool): Whether or not the beautify module was imported.
+        import_name (str): The name of the beautify module imported (for error
+                           reporting).
+        name (str): The strategy name.
+        native_extension (str): The native file extension for this type.
+        tag_name (str): Tag name to search for in other (non-native) extensions.
+    """
+    all_extensions = None
+    blacklist_files = {"test_info.json", "prefs.js"}
+    import_available = None
+    import_name = None
+    native_extension = None
+    tag_name = None
+
+    def __init__(self, testcases, all_files):
+        """Initialize beautification strategy instance.
+
+        Arguments:
+            testcases (list(grizzly.common.storage.TestCase)):
+                List of testcases to reduce. The object does not take ownership of the
+                testcases.
+            all_files (bool): Reduce all files, otherwise only files containing
+                              DDBEGIN/END
+        """
+        super().__init__(testcases, all_files)
+        self._files_to_beautify = []
+        for path in self._testcase_root.glob("**/*"):
+            if (path.is_file() and path.suffix in self.all_extensions
+                    and path.name not in self.blacklist_files):
+                if self._all_files or _contains_dd(path):
+                    self._files_to_beautify.append(path)
+        self._current_feedback = None
+        tag_bytes = self.tag_name.encode("ascii")
+        self._re_tag_start = re.compile(br"<\s*" + tag_bytes + br".*?>",
+                                        flags=re.DOTALL | re.IGNORECASE)
+        self._re_tag_end = re.compile(br"</\s*" + tag_bytes + br"\s*>",
+                                      flags=re.IGNORECASE)
+
+    @classmethod
+    def sanity_check_cls_attrs(cls):
+        """Sanity check the strategy class implementation.
+
+        Raises:
+            AssertionError: Required class attributes are missing or wrong type.
+
+        Returns:
+            None
+        """
+        super().sanity_check_cls_attrs()
+        assert isinstance(cls.all_extensions, set)
+        assert all(isinstance(ext, str) for ext in cls.all_extensions)
+        assert isinstance(cls.import_available, bool)
+        assert isinstance(cls.import_name, str)
+        assert isinstance(cls.native_extension, str)
+        assert isinstance(cls.tag_name, str)
+
+    def update(self, success, served=None):
+        """Inform the strategy whether or not the last beautification yielded was good.
+
+        Arguments:
+            success (bool): Whether or not the last beautification was acceptable.
+            served (list(list(str))): The list of served files for each testcase in the
+                                      last beautification.
+
+        Returns:
+            None
+        """
+        # beautify does nothing with served. it's unlikely a beautify operation alone
+        # would render a file unserved.
+        assert self._current_feedback is None
+        self._current_feedback = success
+
+    @classmethod
+    @abstractmethod
+    def beautify_bytes(cls, data):
+        """Perform beautification on a code buffer.
+
+        Arguments:
+            data (bytes): The code data to be beautified.
+
+        Returns:
+            bytes: The beautified result.
+        """
+
+    def _chunks_to_beautify(self, before, to_beautify, file):
+        """Iterate over `to_beautify` and find chunks of style/script to beautify.
+
+        Arguments:
+            before (bytes): The data preceding `to_beautify`. Used to check whether
+                            `to_beautify` is already in an open <script> or <style> tag.
+            to_beautify (bytes): The data to beautify.
+            file (Path): The input file (used only to check if this is a .css/.js file)
+
+        Yields:
+            tuple (int,int): Slices of `to_beautify` that should be beautified.
+        """
+        # native extension, there's no need to search for tags
+        if file.suffix == self.native_extension:
+            yield (0, len(to_beautify))
+            return
+
+        # find the last <tag> preceding DDBEGIN
+        last_tag_start = None
+        for match in self._re_tag_start.finditer(before):
+            last_tag_start = match
+        in_tag_already = (
+            # there was an open <tag>
+            last_tag_start is not None
+            # and it isn't followed by a closing </tag>
+            and self._re_tag_end.search(before[last_tag_start.end(0):]) is None
+        )
+        if in_tag_already:
+            tag_end = self._re_tag_end.search(to_beautify)
+            if tag_end is None:
+                # similar to native case. DDBEGIN/END occurred inside the tag, so
+                # no need to look further
+                yield (0, len(to_beautify))
+                return
+            yield (0, tag_end.start(0))
+            search_start = tag_end.end(0)
+        else:
+            search_start = 0
+
+        # scan for <tag></tag> (with </tag> being optional for the last match)
+        while True:
+            tag_start = self._re_tag_start.search(to_beautify[search_start:])
+            if tag_start is None:
+                break
+            chunk_start = search_start + tag_start.end(0)
+            tag_end = self._re_tag_end.search(to_beautify[chunk_start:])
+            if tag_end is None:
+                # last </tag> was missing, stop looking
+                yield (chunk_start, len(to_beautify))
+                break
+            yield (chunk_start, chunk_start + tag_end.start(0))
+            search_start = chunk_start + tag_end.end(0)
+
+    def __iter__(self):
+        """Iterate over potential beautifications of testcases according to this
+        strategy.
+
+        The caller should evaluate each testcase set yielded, and call `update` with the
+        result. The caller owns the testcases yielded, and should call `cleanup` for
+        each.
+
+        Yields:
+            list(grizzly.common.storage.TestCase): list of testcases with beautification
+                                                   applied
+        """
+        if not self.import_available:
+            LOG.warning("%s not available, skipping strategy.", self.import_name)
+            return
+
+        LOG.info("Beautifying %d files", len(self._files_to_beautify))
+        for file_no, file in enumerate(self._files_to_beautify):
+            LOG.info("Beautifying %s (file %d/%d)",
+                     file.relative_to(self._testcase_root), file_no + 1,
+                     len(self._files_to_beautify))
+
+            # Use Lithium just to split the file at DDBEGIN/END.
+            # Lithium already has the right logic for DDBEGIN/END and line endings.
+            lith_tc = TestcaseLine()
+            lith_tc.load(file)
+            raw = b"".join(lith_tc.parts)
+
+            with file.open("wb") as testcase_fp:
+                last = 0
+                any_beautified = False
+                testcase_fp.write(lith_tc.before)
+                for start, end in self._chunks_to_beautify(lith_tc.before, raw, file):
+                    before = raw[last:start]
+                    testcase_fp.write(before)
+                    to_beautify = raw[start:end]
+                    LOG.debug("before: %r", to_beautify)
+                    beautified = self.beautify_bytes(to_beautify)
+                    LOG.debug("after: %r", beautified)
+                    if beautified:
+                        if before and not before.endswith(b"\n"):
+                            beautified = b"\n" + beautified
+                        if not beautified.endswith(b"\n"):
+                            beautified = beautified + b"\n"
+
+                        testcase_fp.write(beautified)
+                        if beautified == to_beautify:
+                            LOG.warning("Beautify had no effect!")
+                        else:
+                            any_beautified = True
+                    elif to_beautify.strip():  # pragma: no cover
+                        # this should never happen, but just in case...
+                        # pragma: no cover
+                        LOG.warning("No output from beautify! Writing %s unmodified.",
+                                    self.tag_name)
+                        testcase_fp.write(to_beautify)  # pragma: no cover
+                    last = end
+                testcase_fp.write(raw[last:])
+                testcase_fp.write(lith_tc.after)
+
+                if last == 0:
+                    LOG.warning("<%s> tags not found, skipping", self.tag_name)
+                    continue
+
+                if not any_beautified:
+                    LOG.warning("Beautify had no effect on the file, skipping")
+                    continue
+
+            tc_hash = self._calculate_testcase_hash()
+            if tc_hash in self._tried:
+                LOG.info("cache hit, reverting")
+                lith_tc.dump(file)
+                continue
+
+            yield TestCase.load(str(self._testcase_root), True)
+
+            assert self._current_feedback is not None, "No feedback for last iteration"
+            if self._current_feedback:
+                LOG.info("%s was successful", self.name)
+            else:
+                LOG.warning("%s failed (reverting)", self.name)
+                lith_tc.dump(file)
+                self._tried.add(tc_hash)
+            self._current_feedback = None
+
+
+class CSSBeautify(_BeautifyStrategy):
+    """Run CSS beautification on all CSS files and `<style>` tags.
+
+    This should make the CSS more reducible if there are long lines with compound
+    definitions.
+    """
+    all_extensions = {".css", ".htm", ".html", ".xhtml"}
+    import_available = HAVE_CSSBEAUTIFIER
+    import_name = "cssbeautifier"
+    name = "cssbeautify"
+    native_extension = ".css"
+    opts = (
+        ('end_with_newline', False),
+        ('indent_size', 2),
+        ('newline_between_rules', False),
+        ('preserve_newlines', False),
+    )
+    tag_name = "style"
+
+    @classmethod
+    def beautify_bytes(cls, data):
+        """Perform CSS beautification on a code buffer.
+
+        Arguments:
+            data (bytes): The code data to be beautified.
+
+        Returns:
+            bytes: The beautified result.
+        """
+        assert cls.import_available
+        data = data.decode("utf-8", errors="surrogateescape")
+        return (cssbeautifier
+                .beautify(data, cls.opts)
+                .encode("utf-8", errors="surrogateescape"))
+
+
+class JSBeautify(_BeautifyStrategy):
+    """Run JS beautification on all JS files and `<script>` tags.
+
+    This should make the javascript more reducible if there are long lines with
+    compound statements.
+    """
+    all_extensions = {".js", ".htm", ".html", ".xhtml"}
+    import_available = HAVE_JSBEAUTIFIER
+    import_name = "jsbeautifier"
+    name = "jsbeautify"
+    native_extension = ".js"
+    opts = None
+    tag_name = "script"
+    try_catch_re = re.compile(r"(\s*try {)\n\s*(.*)\n\s*(}\s*catch.*)")
+
+    @classmethod
+    def beautify_bytes(cls, data):
+        """Perform JS beautification on a code buffer.
+
+        Arguments:
+            data (bytes): The code data to be beautified.
+
+        Returns:
+            bytes: The beautified result.
+        """
+        assert HAVE_JSBEAUTIFIER
+        data = data.decode("utf-8", errors="surrogateescape")
+
+        beautified = jsbeautifier.beautify(data, cls.opts)
+        # All try/catch pairs will be expanded on their own lines
+        # Collapse these pairs when only a single instruction is contained within
+        beautified = cls.try_catch_re.sub(r"\1 \2 \3", beautified)
+        return beautified.encode("utf-8", errors="surrogateescape")
diff --git a/grizzly/reduce/strategies/lithium.py b/grizzly/reduce/strategies/lithium.py
new file mode 100644
index 00000000..14575f59
--- /dev/null
+++ b/grizzly/reduce/strategies/lithium.py
@@ -0,0 +1,234 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Grizzly reducer lithium strategy definitions."""
+
+from abc import ABC
+from logging import getLogger
+
+from lithium.strategies import CheckOnly, \
+    CollapseEmptyBraces as LithCollapseEmptyBraces, Minimize, Strategy as LithStrategy
+from lithium.testcases import TestcaseChar, TestcaseJsStr, TestcaseLine, \
+    Testcase as LithTestcase
+
+from ...common.storage import TestCase
+from . import Strategy, _contains_dd
+
+
+LOG = getLogger(__name__)
+
+
+class _LithiumStrategy(Strategy, ABC):
+    """Use a Lithium `Strategy`/`Testcase` pair to reduce the given Grizzly `TestCase`
+    set.
+
+    Implementors must define these class attributes:
+
+    Class attributes:
+        name (str): The strategy name.
+        strategy_cls (lithium.strategies.Strategy): Lithium strategy type.
+        testcase_cls (lithium.testcases.Testcase): Lithium testcase type.
+    """
+    strategy_cls = None
+    testcase_cls = None
+
+    def __init__(self, testcases, all_files):
+        """Initialize strategy instance.
+
+        Arguments:
+            testcases (list(grizzly.common.storage.TestCase)):
+                List of testcases to reduce. The object does not take ownership of the
+                testcases.
+            all_files (bool): Reduce all files, otherwise only files containing
+                              DDBEGIN/END
+        """
+        super().__init__(testcases, all_files)
+        self._current_reducer = None
+        self._files_to_reduce = []
+        self.rescan_files_to_reduce()
+        self._current_feedback = None
+        self._current_served = None
+
+    def rescan_files_to_reduce(self):
+        """Repopulate the private `files_to_reduce` attribute by scanning the testcase
+        root.
+
+        Returns:
+            None
+        """
+        self._files_to_reduce.clear()
+        for path in self._testcase_root.glob("**/*"):
+            if path.is_file() and path.name not in {"test_info.json", "prefs.js"}:
+                if self._all_files or _contains_dd(path):
+                    self._files_to_reduce.append(path)
+
+    @classmethod
+    def sanity_check_cls_attrs(cls):
+        """Sanity check the strategy class implementation.
+
+        Raises:
+            AssertionError: Required class attributes are missing or wrong type.
+
+        Returns:
+            None
+        """
+        super().sanity_check_cls_attrs()
+        assert issubclass(cls.strategy_cls, LithStrategy)
+        assert issubclass(cls.testcase_cls, LithTestcase)
+
+    def update(self, success, served=None):
+        """Inform the strategy whether or not the last reduction yielded was good.
+
+        Arguments:
+            success (bool): Whether or not the last reduction was acceptable.
+            served (list(list(str))): The list of served files for each testcase in the
+                                      last reduction.
+
+        Returns:
+            None
+        """
+        if self._current_reducer is not None:
+            self._current_reducer.feedback(success)
+        self._current_feedback = success
+        self._current_served = served
+
+    def __iter__(self):
+        """Iterate over potential reductions of testcases according to this strategy.
+
+        The caller should evaluate each testcase set yielded, and call `update` with the
+        result. The caller owns the testcases yielded, and should call `cleanup` for
+        each.
+
+        Yields:
+            list(grizzly.common.storage.TestCase): list of testcases with reduction
+                                                   applied
+        """
+        LOG.info("Reducing %d files", len(self._files_to_reduce))
+        file_no = 0
+        reduce_queue = self._files_to_reduce.copy()
+        reduce_queue.sort()  # not necessary, but helps make tests more predictable
+        # indicates that self._testcase_root contains changes that haven't been yielded
+        # (if iteration ends, changes would be lost)
+        testcase_root_dirty = False
+        while reduce_queue:
+            LOG.debug("Reduce queue: %r", reduce_queue)
+            file = reduce_queue.pop(0)
+            file_no += 1
+            LOG.info("[%s] Reducing %s (file %d/%d)", self.name,
+                     file.relative_to(self._testcase_root), file_no,
+                     len(self._files_to_reduce))
+            lithium_testcase = self.testcase_cls()  # pylint: disable=not-callable
+            lithium_testcase.load(file)
+            # pylint: disable=not-callable
+            self._current_reducer = self.strategy_cls().reduce(lithium_testcase)
+
+            # populate the lithium strategy "tried" cache
+            # use all cache values where all hashes other than the current file match
+            # the current testcase_root state.
+            current_tc_hash_map = dict(self._calculate_testcase_hash())
+            del current_tc_hash_map[str(file.relative_to(self._testcase_root))]
+            this_tc_tried = set()
+            for tried in self._tried:
+                tried = dict(tried)
+                tc_tried = tried.pop(str(file.relative_to(self._testcase_root)))
+                if tried == current_tc_hash_map:
+                    this_tc_tried.add(tc_tried)
+            self._current_reducer.update_tried(this_tc_tried)
+
+            for reduction in self._current_reducer:
+                reduction.dump()
+                testcases = TestCase.load(str(self._testcase_root), True)
+                LOG.info("[%s] %s", self.name, self._current_reducer.description)
+                yield testcases
+                if self._current_feedback:
+                    testcase_root_dirty = False
+                else:
+                    self._tried.add(self._calculate_testcase_hash())
+                if self._current_feedback and self._current_served is not None:
+                    testcases = TestCase.load(str(self._testcase_root), True)
+                    try:
+                        self.purge_unserved(testcases, self._current_served)
+                    finally:
+                        for testcase in testcases:
+                            testcase.cleanup()
+                    num_files_before = len(self._files_to_reduce)
+                    LOG.debug("files being reduced before: %r", self._files_to_reduce)
+                    self.rescan_files_to_reduce()
+                    LOG.debug("files being reduced after: %r", self._files_to_reduce)
+                    files_to_reduce = set(self._files_to_reduce)
+                    reduce_queue = list(sorted(set(reduce_queue) & files_to_reduce))
+                    testcase_root_dirty = len(self._files_to_reduce) != num_files_before
+                    if file not in files_to_reduce:
+                        # current reduction was for a purged file
+                        break
+            else:
+                # write out the best found testcase
+                self._current_reducer.testcase.dump()
+            self._current_reducer = None
+        if testcase_root_dirty:
+            # purging unserved files enabled us to exit early from the loop.
+            # need to yield once more to set this trimmed version to the current best
+            # in ReduceManager
+            testcases = TestCase.load(str(self._testcase_root), True)
+            LOG.info("[%s] final iteration triggered by purge_optional", self.name)
+            yield testcases
+            assert self._current_feedback, "Purging unserved files broke the testcase."
+
+
+class Check(_LithiumStrategy):
+    """Check whether the testcase is reproducible.
+
+    This strategy does no reduction, and only yields once. It is intended to provide a
+    pass/fail result in a reduction pipeline.
+    """
+    name = "check"
+    strategy_cls = CheckOnly
+    testcase_cls = TestcaseLine
+
+    def __init__(self, *args, **kwds):
+        super().__init__(*args, **kwds)
+        # trim files_to_reduce, for check we don't need to run on every file
+        # just once per Grizzly TestCase set is enough.
+        self._files_to_reduce = self._files_to_reduce[:1]
+
+
+class CollapseEmptyBraces(_LithiumStrategy):
+    """Minimize lines, but collapse empty curly braces between each iteration.
+
+    During reduction, the contents of a block may be reduced away entirely, but removing
+    the starting brace or ending brace alone will break the syntax of the test file.
+    This strategy tries to collapse empty braces onto the same line between each
+    iteration, so that empty blocks can be removed if otherwise possible.
+    """
+    name = "collapsebraces"
+    strategy_cls = LithCollapseEmptyBraces
+    testcase_cls = TestcaseLine
+
+
+class MinimizeChars(_LithiumStrategy):
+    """Minimize all bytes in the testcase.
+    """
+    name = "chars"
+    strategy_cls = Minimize
+    testcase_cls = TestcaseChar
+
+
+class MinimizeJSChars(_LithiumStrategy):
+    """Minimize all bytes contained in javascript strings.
+
+    This works the same as MinimizeChars, but only operates if it can identify what
+    looks like a quoted string. It also treats escaped characters as a single token
+    for reduction.
+    """
+    name = "jschars"
+    strategy_cls = Minimize
+    testcase_cls = TestcaseJsStr
+
+
+class MinimizeLines(_LithiumStrategy):
+    """Minimize all lines in the testcase.
+    """
+    name = "lines"
+    strategy_cls = Minimize
+    testcase_cls = TestcaseLine
diff --git a/grizzly/reduce/strategies/testcases.py b/grizzly/reduce/strategies/testcases.py
new file mode 100644
index 00000000..b63b77e8
--- /dev/null
+++ b/grizzly/reduce/strategies/testcases.py
@@ -0,0 +1,132 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Grizzly reducer testcase list strategy definition."""
+
+from logging import getLogger
+
+from ...common.storage import TestCase
+from . import Strategy
+
+
+LOG = getLogger(__name__)
+
+
+class MinimizeTestcaseList(Strategy):
+    """Try removing testcases from a list of sequential testcases (eg. Grizzly result
+    cache). The strategy favours testcases at the tail of the list, so for a list of
+    five testcases:
+                            testcases
+                    0       1 2 3 4 5
+        iteration   1         2 3 4 5
+                    2       1   3 4 5
+                    3       1 2   4 5
+                    4       1 2 3   5
+                    5       1 2 3 4
+    """
+    name = "list"
+
+    def __init__(self, testcases, all_files):
+        """Initialize strategy instance.
+
+        Arguments:
+            testcases (list(grizzly.common.storage.TestCase)):
+                List of testcases to reduce. The object does not take ownership of the
+                testcases.
+        """
+        super().__init__(testcases, all_files)
+        self._current_feedback = None
+        self._current_served = None
+
+    def update(self, success, served=None):
+        """Inform the strategy whether or not the last reduction yielded was good.
+
+        Arguments:
+            success (bool): Whether or not the last reduction was acceptable.
+            served (list(list(str))): The list of served files for each testcase in the
+                                      last reduction.
+
+        Returns:
+            None
+        """
+        assert self._current_feedback is None
+        assert self._current_served is None
+        self._current_feedback = success
+        self._current_served = served
+
+    def __iter__(self):
+        """Iterate over potential reductions of testcases according to this strategy.
+
+        The caller should evaluate each testcase set yielded, and call `update` with the
+        result. The caller owns the testcases yielded, and should call `cleanup` for
+        each.
+
+        Yields:
+            list(grizzly.common.storage.TestCase): list of testcases with reduction
+                                                   applied
+        """
+        assert self._current_feedback is None
+        idx = 0
+        testcases = None
+        try:
+            testcases = TestCase.load(str(self._testcase_root), True)
+            n_testcases = len(testcases)
+            # indicates that self._testcase_root contains changes that haven't been
+            # yielded (if iteration ends, changes would be lost)
+            testcase_root_dirty = False
+            while True:
+                if n_testcases <= 1:
+                    LOG.info("Testcase list has length %d, not enough to reduce!",
+                             n_testcases)
+                    break
+                if idx >= n_testcases:
+                    LOG.info("Attempted to remove every single testcase")
+                    break
+                # try removing the testcase at idx
+                if testcases is None:
+                    testcases = TestCase.load(str(self._testcase_root), True)
+                    assert n_testcases == len(testcases)
+                testcases.pop(idx).cleanup()
+                yield testcases
+                testcases = None  # caller owns testcases now
+                assert self._current_feedback is not None, "no feedback received!"
+
+                if self._current_feedback:
+                    testcase_root_dirty = False
+                    LOG.info("Removing testcase %d/%d was successful!", idx + 1,
+                             n_testcases)
+                    testcases = TestCase.load(str(self._testcase_root), True)
+                    try:
+                        # remove the actual testcase we were reducing
+                        testcases.pop(idx).cleanup()
+                        if testcases and self._current_served is not None:
+                            testcase_root_dirty = \
+                                self.purge_unserved(testcases, self._current_served)
+                        else:
+                            self.dump_testcases(testcases, recreate_tcroot=True)
+                    finally:
+                        for testcase in testcases:
+                            testcase.cleanup()
+                    testcases = TestCase.load(str(self._testcase_root), True)
+                    n_testcases = len(testcases)
+                else:
+                    LOG.info("No result without testcase %d/%d", idx + 1, n_testcases)
+                    idx += 1
+                # reset
+                self._current_feedback = None
+                self._current_served = None
+            if testcase_root_dirty:
+                # purging unserved files enabled us to exit early from the loop.
+                # need to yield once more to set this trimmed version to the current
+                # best in ReduceManager
+                testcases = TestCase.load(str(self._testcase_root), True)
+                LOG.info("[%s] final iteration triggered by purge_optional", self.name)
+                yield testcases
+                testcases = None  # caller owns testcases now
+                assert self._current_feedback, \
+                    "Purging unserved files broke the testcase."
+        finally:
+            if testcases is not None:
+                for testcase in testcases:
+                    testcase.cleanup()
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 0527d461..fba1382a 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -15,7 +15,8 @@
 from ..common import TestCase, TestFile, Report
 from ..replay import ReplayResult
 from ..target import Target
-from .strategies import _load_strategies, HAVE_CSSBEAUTIFIER, HAVE_JSBEAUTIFIER
+from .strategies import _load_strategies
+from .strategies.beautify import HAVE_CSSBEAUTIFIER, HAVE_JSBEAUTIFIER
 from . import ReduceManager
 
 
diff --git a/setup.py b/setup.py
index 352a1de7..5760a0e2 100755
--- a/setup.py
+++ b/setup.py
@@ -42,14 +42,14 @@
                 'ffpuppet = grizzly.target.puppet_target:PuppetTarget',
             ],
             'grizzly_reduce_strategies': [
-                'chars = grizzly.reduce.strategies:MinimizeChars',
-                'check = grizzly.reduce.strategies:Check',
-                'collapsebraces = grizzly.reduce.strategies:CollapseEmptyBraces',
-                'cssbeautify = grizzly.reduce.strategies:CSSBeautify',
-                'jsbeautify = grizzly.reduce.strategies:JSBeautify',
-                'jschars = grizzly.reduce.strategies:MinimizeJSChars',
-                'lines = grizzly.reduce.strategies:MinimizeLines',
-                'list = grizzly.reduce.strategies:MinimizeTestcaseList',
+                'chars = grizzly.reduce.strategies.lithium:MinimizeChars',
+                'check = grizzly.reduce.strategies.lithium:Check',
+                'collapsebraces = grizzly.reduce.strategies.lithium:CollapseEmptyBraces',
+                'cssbeautify = grizzly.reduce.strategies.beautify:CSSBeautify',
+                'jsbeautify = grizzly.reduce.strategies.beautify:JSBeautify',
+                'jschars = grizzly.reduce.strategies.lithium:MinimizeJSChars',
+                'lines = grizzly.reduce.strategies.lithium:MinimizeLines',
+                'list = grizzly.reduce.strategies.testcases:MinimizeTestcaseList',
             ],
         },
         extras_require=EXTRAS,
@@ -73,6 +73,7 @@
             'grizzly.adapters.NoOpAdapter',
             'grizzly.common',
             'grizzly.reduce',
+            'grizzly.reduce.strategies',
             'grizzly.replay',
             'grizzly.target',
             'loki',

From 911c8433d75b4f590152bddd192c6d6f66ec360e Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 5 Nov 2020 16:55:31 -0500
Subject: [PATCH 087/531] [reducer] Fix issues from local testing:

- time values in statistics wrap after 24h
- relaunch must be 1 when harness is disabled
---
 grizzly/reduce/core.py  | 8 ++++++--
 grizzly/reduce/stats.py | 6 ++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 1cd18f4d..da42bf17 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -228,7 +228,6 @@ def run_reliability_analysis(self, stats):
         #   post-analysis.
         # We're only using repeat=1 instead of repeat=ITERATIONS so we can get feedback
         #   on every call to interesting.
-        self.target.relaunch = self.ANALYSIS_ITERATIONS
 
         for use_harness in [True, False]:
             if use_harness and not self._original_use_harness:
@@ -236,6 +235,8 @@ def run_reliability_analysis(self, stats):
             if not use_harness and harness_crashes >= self.ANALYSIS_ITERATIONS / 2:
                 continue
 
+            self.target.relaunch = self.ANALYSIS_ITERATIONS if use_harness else 1
+
             with ReplayManager(
                 self.ignore, self.server, self.target, any_crash=self._any_crash,
                 signature=self._signature, use_harness=use_harness,
@@ -364,7 +365,10 @@ def run(self, repeat=1, min_results=1):
                         self.run_reliability_analysis(stats)
                 self._stats.add_info("Analysis", reliability_info)
                 any_success = True  # analysis ran and didn't raise
-            self.target.relaunch = min(self._original_relaunch, repeat)
+            if self._use_harness:
+                self.target.relaunch = min(self._original_relaunch, repeat)
+            else:
+                self.target.relaunch = 1
             LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
                      repeat, min_results, self.target.relaunch)
             self._stats.add_info("Run Parameters", {
diff --git a/grizzly/reduce/stats.py b/grizzly/reduce/stats.py
index fc9d0257..3e901a2b 100644
--- a/grizzly/reduce/stats.py
+++ b/grizzly/reduce/stats.py
@@ -9,7 +9,7 @@
 from itertools import zip_longest
 import json
 import re
-from time import gmtime, strftime, time
+from time import time
 
 
 ReductionStat = namedtuple(
@@ -80,7 +80,9 @@ def _format_duration(duration, total=0):
         else:
             percent = int(100 * duration / total)
         # format H:M:S, and then remove all leading zeros with regex
-        result = re.sub("^[0:]*", "", strftime("%H:%M:%S", gmtime(duration)))
+        minutes, seconds = divmod(int(duration), 60)
+        hours, minutes = divmod(minutes, 60)
+        result = re.sub("^[0:]*", "", "%d:%02d:%02d" % (hours, minutes, seconds))
         # if the result is all zeroes, ensure one zero is output
         if not result:
             result = "0"

From 267e2609565f56dc60957447fa423f8cbda7779f Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 5 Nov 2020 17:26:31 -0500
Subject: [PATCH 088/531] [reducer] Periodically print an estimate of remaining
 time

---
 grizzly/reduce/core.py                 | 25 +++++++-
 grizzly/reduce/stats.py                | 19 +++---
 grizzly/reduce/strategies/__init__.py  |  9 +++
 grizzly/reduce/strategies/beautify.py  | 14 +++++
 grizzly/reduce/strategies/lithium.py   | 87 ++++++++++++++++++++++++--
 grizzly/reduce/strategies/testcases.py | 17 +++++
 6 files changed, 159 insertions(+), 12 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index da42bf17..81d4ddd0 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -13,6 +13,7 @@
 from pathlib import Path
 from shutil import rmtree
 from tempfile import mkdtemp
+from time import time
 
 from Collector.Collector import Collector
 from FTB.Signatures.CrashInfo import CrashSignature
@@ -25,7 +26,7 @@
 from ..replay import ReplayManager, ReplayResult
 from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
 from .exceptions import GrizzlyReduceBaseException, NotReproducible
-from .stats import ReductionStats
+from .stats import ReductionStats, format_seconds
 from .strategies import STRATEGIES
 
 
@@ -89,6 +90,8 @@ class ReduceManager(object):
     # to see the worst case, run the `repeat` calculation in run_reliability_analysis
     # using `crashes_percent = 1.0/ANALYSIS_ITERATIONS`
 
+    ESTIMATE_INTERVAL = 300
+
     IDLE_DELAY_MIN = 10
     IDLE_DELAY_DURATION_MULTIPLIER = 1.5
     ITER_TIMEOUT_MIN = 10
@@ -340,6 +343,13 @@ def testcase_size(self):
         """
         return sum(tc.data_size for tc in self.testcases)
 
+    def _estimate_remaining(self, current_strategy):
+        result = 0
+        for rem in self.strategies[current_strategy + 1:]:
+            with STRATEGIES[rem](self.testcases, self._all_files) as inst:
+                result += len(inst)
+        return result
+
     def run(self, repeat=1, min_results=1):
         """Run testcase reduction.
 
@@ -355,6 +365,7 @@ def run(self, repeat=1, min_results=1):
         sig_given = self._signature is not None
         last_reports = None
         last_tried = None
+        last_estimate = 0
         self._stats.add("init", self.testcase_size())
         # record total stats overall so that any time missed by individual milestones
         # will still be included in the total
@@ -377,6 +388,7 @@ def run(self, repeat=1, min_results=1):
                 "Relaunch": self.target.relaunch,
                 "Harness": self._use_harness,
             })
+
             for strategy_no, strategy in enumerate(self.strategies):
                 LOG.info("")
                 LOG.info("Using strategy %s (%d/%d)", strategy, strategy_no + 1,
@@ -389,11 +401,22 @@ def run(self, repeat=1, min_results=1):
                 if last_tried is not None:
                     strategy.update_tried(last_tried)
                     last_tried = None
+
                 strategy_stats = total_stats.add_timed(strategy.name)
                 best_results = []
                 try:
                     with replay, strategy, strategy_stats:
                         for reduction in strategy:
+                            # show worst-case estimate
+                            now = time()
+                            if now - last_estimate > self.ESTIMATE_INTERVAL:
+                                # estimate the remaining attempts in following rounds
+                                remaining_estimate = len(strategy) \
+                                    + self._estimate_remaining(strategy_no)
+                                LOG.info("Estimate remaining time: %s", format_seconds(
+                                    remaining_estimate * self.server.timeout
+                                ))
+                                last_estimate = now
                             keep_reduction = False
                             results = []
                             try:
diff --git a/grizzly/reduce/stats.py b/grizzly/reduce/stats.py
index 3e901a2b..cdbbdd8a 100644
--- a/grizzly/reduce/stats.py
+++ b/grizzly/reduce/stats.py
@@ -72,6 +72,17 @@ def format_rows(self, rows):
             yield format_str % tuple(row)
 
 
+def format_seconds(duration):
+    # format H:M:S, and then remove all leading zeros with regex
+    minutes, seconds = divmod(int(duration), 60)
+    hours, minutes = divmod(minutes, 60)
+    result = re.sub("^[0:]*", "", "%d:%02d:%02d" % (hours, minutes, seconds))
+    # if the result is all zeroes, ensure one zero is output
+    if not result:
+        result = "0"
+    return result
+
+
 def _format_duration(duration, total=0):
     result = ""
     if duration is not None:
@@ -79,13 +90,7 @@ def _format_duration(duration, total=0):
             percent = 0
         else:
             percent = int(100 * duration / total)
-        # format H:M:S, and then remove all leading zeros with regex
-        minutes, seconds = divmod(int(duration), 60)
-        hours, minutes = divmod(minutes, 60)
-        result = re.sub("^[0:]*", "", "%d:%02d:%02d" % (hours, minutes, seconds))
-        # if the result is all zeroes, ensure one zero is output
-        if not result:
-            result = "0"
+        result = format_seconds(duration)
         result += " (%3d%%)" % (percent,)
     return result
 
diff --git a/grizzly/reduce/strategies/__init__.py b/grizzly/reduce/strategies/__init__.py
index 19b66906..1e515654 100644
--- a/grizzly/reduce/strategies/__init__.py
+++ b/grizzly/reduce/strategies/__init__.py
@@ -195,6 +195,15 @@ def __iter__(self):
                                                    applied
         """
 
+    @abstractmethod
+    def __len__(self):
+        """Estimate the maximum # of attempts this strategy might take to finish.
+        ie. The number of times `__iter__` will yield.
+
+        Returns:
+            int: estimate of the # of attempts remaining.
+        """
+
     @abstractmethod
     def update(self, success, served=None):
         """Inform the strategy whether or not the last reduction yielded was good.
diff --git a/grizzly/reduce/strategies/beautify.py b/grizzly/reduce/strategies/beautify.py
index ec12b296..879c870a 100644
--- a/grizzly/reduce/strategies/beautify.py
+++ b/grizzly/reduce/strategies/beautify.py
@@ -76,6 +76,7 @@ def __init__(self, testcases, all_files):
                                         flags=re.DOTALL | re.IGNORECASE)
         self._re_tag_end = re.compile(br"</\s*" + tag_bytes + br"\s*>",
                                       flags=re.IGNORECASE)
+        self._iter_idx = 0
 
     @classmethod
     def sanity_check_cls_attrs(cls):
@@ -176,6 +177,15 @@ def _chunks_to_beautify(self, before, to_beautify, file):
             yield (chunk_start, chunk_start + tag_end.start(0))
             search_start = chunk_start + tag_end.end(0)
 
+    def __len__(self):
+        """Estimate the maximum # of attempts this strategy might take to finish.
+        ie. The number of times `__iter__` will yield.
+
+        Returns:
+            int: estimate of the # of attempts remaining.
+        """
+        return len(self._files_to_beautify) - self._iter_idx
+
     def __iter__(self):
         """Iterate over potential beautifications of testcases according to this
         strategy.
@@ -238,19 +248,23 @@ def __iter__(self):
 
                 if last == 0:
                     LOG.warning("<%s> tags not found, skipping", self.tag_name)
+                    self._iter_idx += 1
                     continue
 
                 if not any_beautified:
                     LOG.warning("Beautify had no effect on the file, skipping")
+                    self._iter_idx += 1
                     continue
 
             tc_hash = self._calculate_testcase_hash()
             if tc_hash in self._tried:
                 LOG.info("cache hit, reverting")
                 lith_tc.dump(file)
+                self._iter_idx += 1
                 continue
 
             yield TestCase.load(str(self._testcase_root), True)
+            self._iter_idx += 1
 
             assert self._current_feedback is not None, "No feedback for last iteration"
             if self._current_feedback:
diff --git a/grizzly/reduce/strategies/lithium.py b/grizzly/reduce/strategies/lithium.py
index 14575f59..050378d9 100644
--- a/grizzly/reduce/strategies/lithium.py
+++ b/grizzly/reduce/strategies/lithium.py
@@ -11,6 +11,7 @@
     CollapseEmptyBraces as LithCollapseEmptyBraces, Minimize, Strategy as LithStrategy
 from lithium.testcases import TestcaseChar, TestcaseJsStr, TestcaseLine, \
     Testcase as LithTestcase
+from lithium.util import divide_rounding_up, largest_power_of_two_smaller_than
 
 from ...common.storage import TestCase
 from . import Strategy, _contains_dd
@@ -49,6 +50,46 @@ def __init__(self, testcases, all_files):
         self.rescan_files_to_reduce()
         self._current_feedback = None
         self._current_served = None
+        self._possible_iters_remain = {}
+        for path in self._files_to_reduce:
+            test = self.testcase_cls()  # pylint: disable=not-callable
+            test.load(path)
+            self._possible_iters_remain[path] = self._possible_iters(len(test))
+        self._testcase_root_dirty = False
+
+    @classmethod
+    def _possible_iters(cls, length):
+        """Calculate iterations that might possibly be performed for this testcase.
+
+        Arguments:
+            length (int): Length of the current testcase.
+
+        Returns:
+            int: Total iterations for reducing this path.
+        """
+        chunk_size = largest_power_of_two_smaller_than(length)
+        return cls._chunk_iters(length, chunk_size * 2) - 1
+
+    @staticmethod
+    def _chunk_iters(length, chunk_size):
+        """How many iterations does this chunk represent (recursively)?
+        ie. a chunk of length 2 and chunk_size 2 actually represents 4
+            iterations (2 + 1 + 1)
+
+        Arguments:
+            length (int): actual length of the chunk
+            chunk_size (int): chunk_size
+
+        Returns:
+            int: Total iterations from this chunk.
+        """
+        if length == chunk_size:
+            return chunk_size * 3 - 1  # *3 not *2 because last chunk_size=1 repeats
+        result = 2 * length  # chunk_size = 1 (repeated)
+        while chunk_size > 1:
+            result += divide_rounding_up(length, chunk_size)
+            chunk_size /= 2
+        return result
 
     def rescan_files_to_reduce(self):
         """Repopulate the private `files_to_reduce` attribute by scanning the testcase
@@ -62,6 +103,10 @@ def rescan_files_to_reduce(self):
             if path.is_file() and path.name not in {"test_info.json", "prefs.js"}:
                 if self._all_files or _contains_dd(path):
                     self._files_to_reduce.append(path)
+        # any files in possible_iters that don't exist anymore can be removed
+        removed = set(self._possible_iters_remain) - set(self._files_to_reduce)
+        for key in removed:
+            del self._possible_iters_remain[key]
 
     @classmethod
     def sanity_check_cls_attrs(cls):
@@ -93,6 +138,16 @@ def update(self, success, served=None):
         self._current_feedback = success
         self._current_served = served
 
+    def __len__(self):
+        """Estimate the maximum # of attempts this strategy might take to finish.
+        ie. The number of times `__iter__` will yield.
+
+        Returns:
+            int: estimate of the # of attempts remaining.
+        """
+        return sum(self._possible_iters_remain.values()) \
+            + int(self._testcase_root_dirty)
+
     def __iter__(self):
         """Iterate over potential reductions of testcases according to this strategy.
 
@@ -110,7 +165,7 @@ def __iter__(self):
         reduce_queue.sort()  # not necessary, but helps make tests more predictable
         # indicates that self._testcase_root contains changes that haven't been yielded
         # (if iteration ends, changes would be lost)
-        testcase_root_dirty = False
+        self._testcase_root_dirty = False
         while reduce_queue:
             LOG.debug("Reduce queue: %r", reduce_queue)
             file = reduce_queue.pop(0)
@@ -122,6 +177,7 @@ def __iter__(self):
             lithium_testcase.load(file)
             # pylint: disable=not-callable
             self._current_reducer = self.strategy_cls().reduce(lithium_testcase)
+            testcase_length = len(lithium_testcase)
 
             # populate the lithium strategy "tried" cache
             # use all cache values where all hashes other than the current file match
@@ -142,9 +198,17 @@ def __iter__(self):
                 LOG.info("[%s] %s", self.name, self._current_reducer.description)
                 yield testcases
                 if self._current_feedback:
-                    testcase_root_dirty = False
+                    self._testcase_root_dirty = False
+                    # this is imperfect, but we only need an estimate anyways
+                    removed = chunk_size = max(1, testcase_length - len(reduction))
+                    if chunk_size > 1:
+                        chunk_size = largest_power_of_two_smaller_than(chunk_size) * 2
+                    self._possible_iters_remain[file] -= \
+                        self._chunk_iters(removed, chunk_size)
+                    testcase_length = len(reduction)
                 else:
                     self._tried.add(self._calculate_testcase_hash())
+                    self._possible_iters_remain[file] -= 1
                 if self._current_feedback and self._current_served is not None:
                     testcases = TestCase.load(str(self._testcase_root), True)
                     try:
@@ -158,7 +222,8 @@ def __iter__(self):
                     LOG.debug("files being reduced after: %r", self._files_to_reduce)
                     files_to_reduce = set(self._files_to_reduce)
                     reduce_queue = list(sorted(set(reduce_queue) & files_to_reduce))
-                    testcase_root_dirty = len(self._files_to_reduce) != num_files_before
+                    self._testcase_root_dirty = \
+                        len(self._files_to_reduce) != num_files_before
                     if file not in files_to_reduce:
                         # current reduction was for a purged file
                         break
@@ -166,7 +231,8 @@ def __iter__(self):
                 # write out the best found testcase
                 self._current_reducer.testcase.dump()
             self._current_reducer = None
-        if testcase_root_dirty:
+            self._possible_iters_remain.pop(file, None)
+        if self._testcase_root_dirty:
             # purging unserved files enabled us to exit early from the loop.
             # need to yield once more to set this trimmed version to the current best
             # in ReduceManager
@@ -174,6 +240,7 @@ def __iter__(self):
             LOG.info("[%s] final iteration triggered by purge_optional", self.name)
             yield testcases
             assert self._current_feedback, "Purging unserved files broke the testcase."
+        self._testcase_root_dirty = False
 
 
 class Check(_LithiumStrategy):
@@ -191,6 +258,14 @@ def __init__(self, *args, **kwds):
         # trim files_to_reduce, for check we don't need to run on every file
         # just once per Grizzly TestCase set is enough.
         self._files_to_reduce = self._files_to_reduce[:1]
+        self._remain = 1
+
+    def __len__(self):
+        return self._remain
+
+    def __iter__(self):
+        self._remain = 0
+        yield from super().__iter__()
 
 
 class CollapseEmptyBraces(_LithiumStrategy):
@@ -205,6 +280,10 @@ class CollapseEmptyBraces(_LithiumStrategy):
     strategy_cls = LithCollapseEmptyBraces
     testcase_cls = TestcaseLine
 
+    @classmethod
+    def _possible_iters(cls, path):
+        return super()._possible_iters(path) * 2
+
 
 class MinimizeChars(_LithiumStrategy):
     """Minimize all bytes in the testcase.
diff --git a/grizzly/reduce/strategies/testcases.py b/grizzly/reduce/strategies/testcases.py
index b63b77e8..14f85f13 100644
--- a/grizzly/reduce/strategies/testcases.py
+++ b/grizzly/reduce/strategies/testcases.py
@@ -38,6 +38,7 @@ def __init__(self, testcases, all_files):
         super().__init__(testcases, all_files)
         self._current_feedback = None
         self._current_served = None
+        self._current_remain = None
 
     def update(self, success, served=None):
         """Inform the strategy whether or not the last reduction yielded was good.
@@ -55,6 +56,20 @@ def update(self, success, served=None):
         self._current_feedback = success
         self._current_served = served
 
+    def __len__(self):
+        """Estimate the maximum # of attempts this strategy might take to finish.
+        ie. The number of times `__iter__` will yield.
+
+        Returns:
+            int: estimate of the # of attempts remaining.
+        """
+        if self._current_remain is None:
+            testcases = TestCase.load(str(self._testcase_root), True)
+            self._current_remain = len(testcases)
+            for test in testcases:
+                test.cleanup()
+        return max(self._current_remain - 1, 0)
+
     def __iter__(self):
         """Iterate over potential reductions of testcases according to this strategy.
 
@@ -72,6 +87,7 @@ def __iter__(self):
         try:
             testcases = TestCase.load(str(self._testcase_root), True)
             n_testcases = len(testcases)
+            self._current_remain = n_testcases
             # indicates that self._testcase_root contains changes that haven't been
             # yielded (if iteration ends, changes would be lost)
             testcase_root_dirty = False
@@ -116,6 +132,7 @@ def __iter__(self):
                 # reset
                 self._current_feedback = None
                 self._current_served = None
+                self._current_remain = n_testcases - idx + int(testcase_root_dirty)
             if testcase_root_dirty:
                 # purging unserved files enabled us to exit early from the loop.
                 # need to yield once more to set this trimmed version to the current

From 162ff22c4db5f340f86365eb6471068b35412200 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 5 Nov 2020 19:41:15 -0500
Subject: [PATCH 089/531] [reducer] Fix bug in lithium estimation code.

---
 grizzly/reduce/strategies/lithium.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/reduce/strategies/lithium.py b/grizzly/reduce/strategies/lithium.py
index 050378d9..64496ffb 100644
--- a/grizzly/reduce/strategies/lithium.py
+++ b/grizzly/reduce/strategies/lithium.py
@@ -47,10 +47,10 @@ def __init__(self, testcases, all_files):
         super().__init__(testcases, all_files)
         self._current_reducer = None
         self._files_to_reduce = []
+        self._possible_iters_remain = {}
         self.rescan_files_to_reduce()
         self._current_feedback = None
         self._current_served = None
-        self._possible_iters_remain = {}
         for path in self._files_to_reduce:
             test = self.testcase_cls()  # pylint: disable=not-callable
             test.load(path)

From b5c62f1dd6f8c72431cdb7f4fcee47e4e7e9396e Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 5 Nov 2020 21:07:14 -0500
Subject: [PATCH 090/531] [reducer] Bug fixes:

- fix bug in remaining estimate calculation for Lithium strategies
- don't update timeouts during reliability analysis
---
 grizzly/reduce/core.py               |  1 -
 grizzly/reduce/strategies/lithium.py |  2 +-
 grizzly/reduce/test_reduce.py        | 15 ++++++++-------
 grizzly/reduce/test_strategies.py    | 12 ++++++------
 4 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 81d4ddd0..28853458 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -266,7 +266,6 @@ def run_reliability_analysis(self, stats):
                     raise
                 try:
                     stats.add_iterations(replay.status.iteration)
-                    self.update_timeout(results)
                     crashes = sum(x.count for x in results if x.expected)
                     if crashes and not self._any_crash and self._signature_desc is None:
                         first_expected = next((report for report in results
diff --git a/grizzly/reduce/strategies/lithium.py b/grizzly/reduce/strategies/lithium.py
index 64496ffb..f28ea239 100644
--- a/grizzly/reduce/strategies/lithium.py
+++ b/grizzly/reduce/strategies/lithium.py
@@ -89,7 +89,7 @@ def _chunk_iters(length, chunk_size):
         while chunk_size > 1:
             result += divide_rounding_up(length, chunk_size)
             chunk_size /= 2
-        return result
+        return int(result)
 
     def rescan_files_to_reduce(self):
         """Repopulate the private `files_to_reduce` attribute by scanning the testcase
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index cdfb17e3..47069a18 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -264,7 +264,8 @@ def _stop_early(_):
 
     stats = _ReduceStats()
     try:
-        mgr = ReduceManager(None, mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target),
+        mgr = ReduceManager(None, mocker.Mock(spec=Sapphire, timeout=30),
+                            mocker.Mock(spec=Target),
                             tests, None, log_path, use_harness=use_harness)
         repeat, min_crashes, _ = mgr.run_reliability_analysis(stats)
     finally:
@@ -487,8 +488,8 @@ def replay_run(testcases, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies,
-                            log_path, use_analysis=False)
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target, tests,
+                            strategies, log_path, use_analysis=False)
         if isinstance(result, type) and issubclass(result, BaseException):
             with raises(result):
                 mgr.run()
@@ -544,8 +545,8 @@ def replay_run(_, **_kw):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, testcases,
-                            ["check"], log_path, use_analysis=False,
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target,
+                            testcases, ["check"], log_path, use_analysis=False,
                             report_to_fuzzmanager=True)
         assert mgr.run()
     finally:
@@ -588,8 +589,8 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
 
     target_obj = mocker.Mock(spec=Target)
     target_obj.relaunch = 1
-    mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target_obj, testcases,
-                        ["check"], None, use_analysis=use_analysis)
+    mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target_obj,
+                        testcases, ["check"], None, use_analysis=use_analysis)
     with raises(exc_type):
         mgr.run()
     if exc_type is TargetLaunchError:
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index fba1382a..7e9260ac 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -145,8 +145,8 @@ def replay_run(testcases, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies,
-                            log_path, use_analysis=False)
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target, tests,
+                            strategies, log_path, use_analysis=False)
         assert mgr.run() == 0
     finally:
         for test in tests:
@@ -479,8 +479,8 @@ def replay_run(testcases, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies,
-                            log_path, use_analysis=False)
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target, tests,
+                            strategies, log_path, use_analysis=False)
         assert mgr.run() == 0
     finally:
         for test in tests:
@@ -630,8 +630,8 @@ def replay_run(testcases, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire), target, tests, strategies,
-                            log_path, use_analysis=False)
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target, tests,
+                            strategies, log_path, use_analysis=False)
         if purging_breaks:
             with raises(AssertionError):
                 mgr.run()

From 551a727328adb950028867cc10c4a03cf3c15c08 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 6 Nov 2020 13:38:54 -0500
Subject: [PATCH 091/531] [reducer] Estimated remaining time changes

- Use a moving average of actual attempt time instead of
  worst-case `server.timeout`
- Use lithium to estimate the attempts remaining for lithium
  strategies.
---
 grizzly/reduce/core.py               |  9 +++--
 grizzly/reduce/stats.py              | 42 ++++++++++++++++++++
 grizzly/reduce/strategies/lithium.py | 58 ++++------------------------
 setup.py                             |  2 +-
 4 files changed, 56 insertions(+), 55 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 28853458..21b392d7 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -26,7 +26,7 @@
 from ..replay import ReplayManager, ReplayResult
 from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
 from .exceptions import GrizzlyReduceBaseException, NotReproducible
-from .stats import ReductionStats, format_seconds
+from .stats import MovingAverage, ReductionStats, format_seconds
 from .strategies import STRATEGIES
 
 
@@ -365,6 +365,7 @@ def run(self, repeat=1, min_results=1):
         last_reports = None
         last_tried = None
         last_estimate = 0
+        average = MovingAverage()
         self._stats.add("init", self.testcase_size())
         # record total stats overall so that any time missed by individual milestones
         # will still be included in the total
@@ -408,12 +409,12 @@ def run(self, repeat=1, min_results=1):
                         for reduction in strategy:
                             # show worst-case estimate
                             now = time()
-                            if now - last_estimate > self.ESTIMATE_INTERVAL:
+                            if now - last_estimate > self.ESTIMATE_INTERVAL and average:
                                 # estimate the remaining attempts in following rounds
                                 remaining_estimate = len(strategy) \
                                     + self._estimate_remaining(strategy_no)
                                 LOG.info("Estimate remaining time: %s", format_seconds(
-                                    remaining_estimate * self.server.timeout
+                                    remaining_estimate * average.median()
                                 ))
                                 last_estimate = now
                             keep_reduction = False
@@ -421,12 +422,14 @@ def run(self, repeat=1, min_results=1):
                             try:
                                 # reduction is a new list of testcases to be
                                 # replayed
+                                run_start = time()
                                 results = replay.run(
                                     reduction,
                                     repeat=repeat,
                                     min_results=min_results,
                                     idle_delay=self._idle_delay,
                                     idle_threshold=self._idle_threshold)
+                                average.append(time() - run_start)
                                 strategy_stats.add_iterations(replay.status.iteration)
                                 strategy_stats.add_attempts(1)
                                 self.update_timeout(results)
diff --git a/grizzly/reduce/stats.py b/grizzly/reduce/stats.py
index cdbbdd8a..b0bbd00e 100644
--- a/grizzly/reduce/stats.py
+++ b/grizzly/reduce/stats.py
@@ -106,6 +106,48 @@ def _format_number(number, total=0):
     return result
 
 
+class MovingAverage(object):
+    """Track an average over a moving window."""
+
+    def __init__(self, window=50):
+        """
+        Arguments:
+            window (int): Size of the moving average window.
+        """
+        self._data = []
+        self._window = window
+
+    def __len__(self):
+        return len(self._data)
+
+    def append(self, value):
+        """Add a value to the average.
+
+        Arguments:
+            value (float): Value to be included in moving average.
+
+        Returns:
+            None
+        """
+        self._data.append(value)
+        if len(self._data) > self._window:
+            self._data.pop(0)
+
+    def median(self):
+        """Find the moving median in the dataset.
+
+        Returns:
+            float: Median value of the dataset.
+        """
+        if not self._data:
+            raise ValueError("No data in MovingAverage")
+        middle = len(self._data) // 2
+        ordered = list(sorted(self._data))
+        if len(self._data) % 2 == 1:
+            return ordered[middle]
+        return (ordered[middle] + ordered[middle - 1]) / 2
+
+
 class ReductionStats(object):
     """Statistics about reduction"""
 
diff --git a/grizzly/reduce/strategies/lithium.py b/grizzly/reduce/strategies/lithium.py
index f28ea239..68eee31f 100644
--- a/grizzly/reduce/strategies/lithium.py
+++ b/grizzly/reduce/strategies/lithium.py
@@ -11,7 +11,6 @@
     CollapseEmptyBraces as LithCollapseEmptyBraces, Minimize, Strategy as LithStrategy
 from lithium.testcases import TestcaseChar, TestcaseJsStr, TestcaseLine, \
     Testcase as LithTestcase
-from lithium.util import divide_rounding_up, largest_power_of_two_smaller_than
 
 from ...common.storage import TestCase
 from . import Strategy, _contains_dd
@@ -54,43 +53,11 @@ def __init__(self, testcases, all_files):
         for path in self._files_to_reduce:
             test = self.testcase_cls()  # pylint: disable=not-callable
             test.load(path)
-            self._possible_iters_remain[path] = self._possible_iters(len(test))
+            strategy = self.strategy_cls()  # pylint: disable=not-callable
+            strategy.estimate_from_testcase(test)
+            self._possible_iters_remain[path] = strategy.estimated_remaining
         self._testcase_root_dirty = False
 
-    @classmethod
-    def _possible_iters(cls, length):
-        """Calculate iterations that might possibly be performed for this testcase.
-
-        Arguments:
-            length (int): Length of the current testcase.
-
-        Returns:
-            int: Total iterations for reducing this path.
-        """
-        chunk_size = largest_power_of_two_smaller_than(length)
-        return cls._chunk_iters(length, chunk_size * 2) - 1
-
-    @staticmethod
-    def _chunk_iters(length, chunk_size):
-        """How many iterations does this chunk represent (recursively)?
-        ie. a chunk of length 2 and chunk_size 2 actually represents 4
-            iterations (2 + 1 + 1)
-
-        Arguments:
-            length (int): actual length of the chunk
-            chunk_size (int): chunk_size
-
-        Returns:
-            int: Total iterations from this chunk.
-        """
-        if length == chunk_size:
-            return chunk_size * 3 - 1  # *3 not *2 because last chunk_size=1 repeats
-        result = 2 * length  # chunk_size = 1 (repeated)
-        while chunk_size > 1:
-            result += divide_rounding_up(length, chunk_size)
-            chunk_size /= 2
-        return int(result)
-
     def rescan_files_to_reduce(self):
         """Repopulate the private `files_to_reduce` attribute by scanning the testcase
         root.
@@ -175,9 +142,9 @@ def __iter__(self):
                      len(self._files_to_reduce))
             lithium_testcase = self.testcase_cls()  # pylint: disable=not-callable
             lithium_testcase.load(file)
-            # pylint: disable=not-callable
-            self._current_reducer = self.strategy_cls().reduce(lithium_testcase)
-            testcase_length = len(lithium_testcase)
+            strategy = self.strategy_cls()  # pylint: disable=not-callable
+            self._current_reducer = strategy.reduce(lithium_testcase)
+            self._possible_iters_remain[file] = strategy.estimated_remaining
 
             # populate the lithium strategy "tried" cache
             # use all cache values where all hashes other than the current file match
@@ -196,19 +163,12 @@ def __iter__(self):
                 reduction.dump()
                 testcases = TestCase.load(str(self._testcase_root), True)
                 LOG.info("[%s] %s", self.name, self._current_reducer.description)
+                self._possible_iters_remain[file] = strategy.estimated_remaining
                 yield testcases
                 if self._current_feedback:
                     self._testcase_root_dirty = False
-                    # this is imperfect, but we only need an estimate anyways
-                    removed = chunk_size = max(1, testcase_length - len(reduction))
-                    if chunk_size > 1:
-                        chunk_size = largest_power_of_two_smaller_than(chunk_size) * 2
-                    self._possible_iters_remain[file] -= \
-                        self._chunk_iters(removed, chunk_size)
-                    testcase_length = len(reduction)
                 else:
                     self._tried.add(self._calculate_testcase_hash())
-                    self._possible_iters_remain[file] -= 1
                 if self._current_feedback and self._current_served is not None:
                     testcases = TestCase.load(str(self._testcase_root), True)
                     try:
@@ -280,10 +240,6 @@ class CollapseEmptyBraces(_LithiumStrategy):
     strategy_cls = LithCollapseEmptyBraces
     testcase_cls = TestcaseLine
 
-    @classmethod
-    def _possible_iters(cls, path):
-        return super()._possible_iters(path) * 2
-
 
 class MinimizeChars(_LithiumStrategy):
     """Minimize all bytes in the testcase.
diff --git a/setup.py b/setup.py
index 5760a0e2..322838c6 100755
--- a/setup.py
+++ b/setup.py
@@ -10,7 +10,7 @@
 
 
 EXTRAS = {
-    'reduce': ['cssbeautifier', 'lithium-reducer>=0.4.3', 'jsbeautifier'],
+    'reduce': ['cssbeautifier', 'lithium-reducer>=0.4.4', 'jsbeautifier'],
     's3': ['boto3'],
 }
 EXTRAS['all'] = list(set(chain.from_iterable(EXTRAS.values())))

From 8d5459b9ec790c99704d47dfb82968f1eafd1588 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 6 Nov 2020 14:08:48 -0500
Subject: [PATCH 092/531] [reducer] Add another analysis pass to try with
 harness and last testcase only.

---
 grizzly/reduce/core.py | 30 +++++++++++++++++++++++-------
 1 file changed, 23 insertions(+), 7 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 21b392d7..deb72d60 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -222,6 +222,7 @@ def run_reliability_analysis(self, stats):
             tuple(int, int, dict): Values for `repeat` and `min_crashes` resulting from
                                    analysis, and info to include in stats.
         """
+        harness_last_crashes = 0
         harness_crashes = 0
         non_harness_crashes = 0
         info = {}
@@ -232,11 +233,13 @@ def run_reliability_analysis(self, stats):
         # We're only using repeat=1 instead of repeat=ITERATIONS so we can get feedback
         #   on every call to interesting.
 
-        for use_harness in [True, False]:
-            if use_harness and not self._original_use_harness:
+        for (use_harness, last_test) in [(True, True), (True, False), (False, False)]:
+            if use_harness and (not self._original_use_harness or harness_last_crashes):
                 continue
             if not use_harness and harness_crashes >= self.ANALYSIS_ITERATIONS / 2:
                 continue
+            if last_test and len(self.testcases) == 1:
+                continue
 
             self.target.relaunch = self.ANALYSIS_ITERATIONS if use_harness else 1
 
@@ -248,6 +251,9 @@ def run_reliability_analysis(self, stats):
                          self.ANALYSIS_ITERATIONS,
                          "using" if use_harness else "without")
                 testcases = self.testcases
+                if last_test:
+                    LOG.warning("Checking reliability with only the last testcase.")
+                    testcases = [testcases[-1]]
                 if not use_harness and len(testcases) > 1:
                     LOG.warning("Only the last testcase of %d given will be used to "
                                 "assess reliability without harness.", len(testcases))
@@ -275,24 +281,33 @@ def run_reliability_analysis(self, stats):
                     self.report(
                         [result for result in results if not result.expected],
                         testcases, self._stats.copy(stats))
-                    if crashes and use_harness:
+                    if use_harness and last_test:
+                        harness_last_crashes = crashes
+                    elif use_harness:
                         harness_crashes = crashes
-                    elif crashes:
+                    else:
                         non_harness_crashes = crashes
                 finally:
                     for result in results:
                         result.report.cleanup()
                 reliability = crashes / self.ANALYSIS_ITERATIONS
                 key = ("using" if use_harness else "without") + " harness"
+                if last_test or (not use_harness and len(self.testcases) > 1):
+                    key += "/last test only"
                 LOG.info("Testcase was interesting %0.1f%% of %d attempts %s.",
                          100.0 * reliability, self.ANALYSIS_ITERATIONS, key)
                 info[key] = reliability
                 # ensure same signature is always used
                 self._signature = replay.signature
 
-        if harness_crashes == 0 and non_harness_crashes == 0:
+        if not any([harness_last_crashes, harness_crashes, non_harness_crashes]):
             raise NotReproducible("Did not reproduce during analysis")
 
+        # if harness is selected, we'll only use the last testcase
+        last_test = bool(harness_last_crashes)
+        if last_test:
+            harness_crashes = harness_last_crashes
+
         # should we use the harness? go with harness unless no-harness crashed 50% more
         self._use_harness = not (
             non_harness_crashes > harness_crashes and (
@@ -301,9 +316,10 @@ def run_reliability_analysis(self, stats):
             )
         )
 
-        if not self._use_harness and len(self.testcases) > 1:
-            LOG.warning("Last testcase without harness was selected, other %d "
+        if (not self._use_harness or last_test) and len(self.testcases) > 1:
+            LOG.warning("Last testcase %s harness was selected, other %d "
                         "testcases in the original will be ignored.",
+                        "with" if self._use_harness else "without",
                         len(self.testcases) - 1)
             while len(self.testcases) > 1:
                 self.testcases.pop(0).cleanup()

From 96de2d927319c8f3fd6f869f6630d35e954d15e2 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 6 Nov 2020 14:52:00 -0500
Subject: [PATCH 093/531] [reducer] Disable estimated remaining time.

We're not sure what the best way to present this is.
---
 grizzly/reduce/core.py  | 26 +------------------------
 grizzly/reduce/stats.py | 42 -----------------------------------------
 2 files changed, 1 insertion(+), 67 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index deb72d60..02257220 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -13,7 +13,6 @@
 from pathlib import Path
 from shutil import rmtree
 from tempfile import mkdtemp
-from time import time
 
 from Collector.Collector import Collector
 from FTB.Signatures.CrashInfo import CrashSignature
@@ -26,7 +25,7 @@
 from ..replay import ReplayManager, ReplayResult
 from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
 from .exceptions import GrizzlyReduceBaseException, NotReproducible
-from .stats import MovingAverage, ReductionStats, format_seconds
+from .stats import ReductionStats, format_seconds
 from .strategies import STRATEGIES
 
 
@@ -90,8 +89,6 @@ class ReduceManager(object):
     # to see the worst case, run the `repeat` calculation in run_reliability_analysis
     # using `crashes_percent = 1.0/ANALYSIS_ITERATIONS`
 
-    ESTIMATE_INTERVAL = 300
-
     IDLE_DELAY_MIN = 10
     IDLE_DELAY_DURATION_MULTIPLIER = 1.5
     ITER_TIMEOUT_MIN = 10
@@ -358,13 +355,6 @@ def testcase_size(self):
         """
         return sum(tc.data_size for tc in self.testcases)
 
-    def _estimate_remaining(self, current_strategy):
-        result = 0
-        for rem in self.strategies[current_strategy + 1:]:
-            with STRATEGIES[rem](self.testcases, self._all_files) as inst:
-                result += len(inst)
-        return result
-
     def run(self, repeat=1, min_results=1):
         """Run testcase reduction.
 
@@ -380,8 +370,6 @@ def run(self, repeat=1, min_results=1):
         sig_given = self._signature is not None
         last_reports = None
         last_tried = None
-        last_estimate = 0
-        average = MovingAverage()
         self._stats.add("init", self.testcase_size())
         # record total stats overall so that any time missed by individual milestones
         # will still be included in the total
@@ -423,29 +411,17 @@ def run(self, repeat=1, min_results=1):
                 try:
                     with replay, strategy, strategy_stats:
                         for reduction in strategy:
-                            # show worst-case estimate
-                            now = time()
-                            if now - last_estimate > self.ESTIMATE_INTERVAL and average:
-                                # estimate the remaining attempts in following rounds
-                                remaining_estimate = len(strategy) \
-                                    + self._estimate_remaining(strategy_no)
-                                LOG.info("Estimate remaining time: %s", format_seconds(
-                                    remaining_estimate * average.median()
-                                ))
-                                last_estimate = now
                             keep_reduction = False
                             results = []
                             try:
                                 # reduction is a new list of testcases to be
                                 # replayed
-                                run_start = time()
                                 results = replay.run(
                                     reduction,
                                     repeat=repeat,
                                     min_results=min_results,
                                     idle_delay=self._idle_delay,
                                     idle_threshold=self._idle_threshold)
-                                average.append(time() - run_start)
                                 strategy_stats.add_iterations(replay.status.iteration)
                                 strategy_stats.add_attempts(1)
                                 self.update_timeout(results)
diff --git a/grizzly/reduce/stats.py b/grizzly/reduce/stats.py
index b0bbd00e..cdbbdd8a 100644
--- a/grizzly/reduce/stats.py
+++ b/grizzly/reduce/stats.py
@@ -106,48 +106,6 @@ def _format_number(number, total=0):
     return result
 
 
-class MovingAverage(object):
-    """Track an average over a moving window."""
-
-    def __init__(self, window=50):
-        """
-        Arguments:
-            window (int): Size of the moving average window.
-        """
-        self._data = []
-        self._window = window
-
-    def __len__(self):
-        return len(self._data)
-
-    def append(self, value):
-        """Add a value to the average.
-
-        Arguments:
-            value (float): Value to be included in moving average.
-
-        Returns:
-            None
-        """
-        self._data.append(value)
-        if len(self._data) > self._window:
-            self._data.pop(0)
-
-    def median(self):
-        """Find the moving median in the dataset.
-
-        Returns:
-            float: Median value of the dataset.
-        """
-        if not self._data:
-            raise ValueError("No data in MovingAverage")
-        middle = len(self._data) // 2
-        ordered = list(sorted(self._data))
-        if len(self._data) % 2 == 1:
-            return ordered[middle]
-        return (ordered[middle] + ordered[middle - 1]) / 2
-
-
 class ReductionStats(object):
     """Statistics about reduction"""
 

From 2a9ad185f57139cd77d763810c2867a18e11cc14 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 6 Nov 2020 17:13:09 -0500
Subject: [PATCH 094/531] [reducer] Add --report-period to periodically report
 the best results for long-running strategies.

This mitigates against sudden interruption in automation, such as
spot-instance termination.
---
 grizzly/reduce/args.py        |  16 +++-
 grizzly/reduce/core.py        |  77 ++++++++++++-------
 grizzly/reduce/test_main.py   |   5 ++
 grizzly/reduce/test_reduce.py | 136 ++++++++++++++++++++++++++++++++--
 4 files changed, 198 insertions(+), 36 deletions(-)

diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 6b316f1a..5cd99e17 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -49,12 +49,16 @@ def __init__(self):
         )
 
         reduce_args = self.parser.add_argument_group("Reduce Arguments")
-        reduce_args.add_argument(
-            "--skip-dd-unmarked", action="store_false", dest="all_files",
-            help="Only reduce files containing DDBEGIN/END (default: all files)")
         reduce_args.add_argument(
             "--no-analysis", action="store_true",
             help="Disable analysis to auto-set --repeat/--min-crashes.")
+        reduce_args.add_argument(
+            "--report-period", type=int,
+            help="Periodically report the best testcase for long-running strategies."
+            " (value in seconds, default: no)")
+        reduce_args.add_argument(
+            "--skip-dd-unmarked", action="store_false", dest="all_files",
+            help="Only reduce files containing DDBEGIN/END (default: all files)")
         reduce_args.add_argument(
             "--static-timeout", action="store_true",
             help="Disable automatically updating the iteration timeout.")
@@ -84,6 +88,12 @@ def sanity_check(self, args):
             if strategy not in STRATEGIES:
                 self.parser.error("Unrecognized '--strategy': '%s'" % (strategy,))
 
+        if args.report_period is not None:
+            if args.report_period <= 0:
+                self.parser.error("Invalid --report-period (value is in seconds)")
+            if args.report_period < 60:
+                self.parser.error("Very short --report-period (value is in seconds)")
+
         if not args.no_analysis:
             # analysis is enabled, but repeat/min_crashes specified. doesn't make sense
             errors = []
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 02257220..463ebe5c 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -13,6 +13,7 @@
 from pathlib import Path
 from shutil import rmtree
 from tempfile import mkdtemp
+from time import time
 
 from Collector.Collector import Collector
 from FTB.Signatures.CrashInfo import CrashSignature
@@ -25,7 +26,7 @@
 from ..replay import ReplayManager, ReplayResult
 from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
 from .exceptions import GrizzlyReduceBaseException, NotReproducible
-from .stats import ReductionStats, format_seconds
+from .stats import ReductionStats
 from .strategies import STRATEGIES
 
 
@@ -95,10 +96,10 @@ class ReduceManager(object):
     ITER_TIMEOUT_DURATION_MULTIPLIER = 2
 
     def __init__(self, ignore, server, target, testcases, strategies, log_path,
-                 tool=None, report_to_fuzzmanager=False, any_crash=False,
-                 signature=None, use_harness=True, use_analysis=True,
-                 static_timeout=False, idle_delay=0, idle_threshold=0,
-                 signature_desc=None, all_files=True):
+                 all_files=True, any_crash=False, idle_delay=0, idle_threshold=0,
+                 report_period=None, report_to_fuzzmanager=False, signature=None,
+                 signature_desc=None, static_timeout=False, tool=None,
+                 use_analysis=True, use_harness=True):
         """Initialize reduction manager. Many arguments are common with `ReplayManager`.
 
         Args:
@@ -109,31 +110,36 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
                 Value for `self.testcases` attribute.
             strategies (list(str)): Value for `self.strategies` attribute.
             log_path (Path or str): Path to save results when reporting to filesystem.
-            tool (str or None): Override tool when reporting to FuzzManager.
-            report_to_fuzzmanager (bool): Report to FuzzManager rather than filesystem.
+
+            all_files (bool): Reduce all files, not just those with DDBEGIN/END.
             any_crash (bool): Accept any crash when reducing, not just those matching
                               the specified or first observed signature.
+            idle_delay (int): Number of seconds to wait before polling for idle.
+            idle_threshold (int): CPU usage threshold to mark the process as idle.
+            report_period (int or None): Periodically report best results for
+                                         long-running strategies.
+            report_to_fuzzmanager (bool): Report to FuzzManager rather than filesystem.
             signature (FTB.Signatures.CrashInfo.CrashSignature or None):
                 Signature for accepting crashes.
             signature_desc (str): Short description of the given signature.
-            use_harness (bool): Whether to allow use of harness when navigating
-                                between testcases.
-            use_analysis (bool): Analyse reliability of testcase before running each
-                                 reduction strategy.
             static_timeout (bool): Use only specified timeouts (`--timeout` and
                                    `--idle-delay`), even if testcase appears to need
                                    less time.
-            idle_delay (int): Number of seconds to wait before polling for idle.
-            idle_threshold (int): CPU usage threshold to mark the process as idle.
-            all_files (bool): Reduce all files, not just those with DDBEGIN/END.
+            tool (str or None): Override tool when reporting to FuzzManager.
+            use_analysis (bool): Analyse reliability of testcase before running each
+                                 reduction strategy.
+            use_harness (bool): Whether to allow use of harness when navigating
+                                between testcases.
         """
         self.ignore = ignore
         self.server = server
         self.strategies = strategies
         self.target = target
         self.testcases = testcases
-        self._any_crash = any_crash
         self._all_files = all_files
+        self._any_crash = any_crash
+        self._idle_delay = idle_delay
+        self._idle_threshold = idle_threshold
         # only coerce `log_path` to `Path` if it's a string
         # this caution is only necessary in python3.5 where pytest uses
         # pathlib2 rather than pathlib
@@ -142,15 +148,14 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
         self._original_relaunch = target.relaunch
         self._original_use_harness = use_harness
         self._report_to_fuzzmanager = report_to_fuzzmanager
+        self._report_periodically = report_period
         self._report_tool = tool
         self._signature = signature
         self._signature_desc = signature_desc
-        self._use_analysis = use_analysis
-        self._use_harness = use_harness
         self._static_timeout = static_timeout
-        self._idle_delay = idle_delay
-        self._idle_threshold = idle_threshold
         self._stats = ReductionStats()
+        self._use_analysis = use_analysis
+        self._use_harness = use_harness
 
     def update_timeout(self, results):
         """Tune idle/server timeout values based on actual duration of expected results.
@@ -406,8 +411,10 @@ def run(self, repeat=1, min_results=1):
                     strategy.update_tried(last_tried)
                     last_tried = None
 
+                strategy_last_report = time()
                 strategy_stats = total_stats.add_timed(strategy.name)
                 best_results = []
+                best_reported = False
                 try:
                     with replay, strategy, strategy_stats:
                         for reduction in strategy:
@@ -463,6 +470,7 @@ def run(self, repeat=1, min_results=1):
                                                     if result.expected]
                                     results = [result for result in results
                                                if not result.expected]
+                                    best_reported = False
                                 else:
                                     LOG.info("Attempt failed")
                                 # if the reduction found other crashes,
@@ -470,6 +478,17 @@ def run(self, repeat=1, min_results=1):
                                 self.report(
                                     results, reduction,
                                     self._stats.copy(strategy_stats))
+
+                                now = time()
+                                if self._report_periodically and \
+                                        now - strategy_last_report > self._report_periodically:
+                                    last_reports = self.report(
+                                        best_results, self.testcases,
+                                        self._stats.copy(strategy_stats))
+                                    best_reported = True
+                                    strategy_last_report = now
+                                    LOG.info("Best results reported (periodic)")
+
                             except TargetLaunchError as exc:
                                 if exc.report:
                                     self.report(
@@ -489,9 +508,10 @@ def run(self, repeat=1, min_results=1):
                         # otherwise, ensure the first found signature is used throughout
                         self._signature = replay.signature
 
-                    last_reports = self.report(
-                        best_results, self.testcases,
-                        self._stats.copy(total_stats))
+                    if not best_reported:
+                        last_reports = self.report(
+                            best_results, self.testcases,
+                            self._stats.copy(total_stats))
 
                 except KeyboardInterrupt:
                     if best_results:
@@ -684,17 +704,18 @@ def main(cls, args):
                     testcases,
                     args.strategies,
                     args.logs,
-                    tool=args.tool,
-                    report_to_fuzzmanager=args.fuzzmanager,
                     all_files=args.all_files,
                     any_crash=args.any_crash,
+                    idle_delay=args.idle_delay,
+                    idle_threshold=args.idle_threshold,
+                    report_period=args.report_period,
+                    report_to_fuzzmanager=args.fuzzmanager,
                     signature=signature,
                     signature_desc=signature_desc,
-                    use_harness=not args.no_harness,
-                    use_analysis=not args.no_analysis,
                     static_timeout=args.static_timeout,
-                    idle_delay=args.idle_delay,
-                    idle_threshold=args.idle_threshold)
+                    tool=args.tool,
+                    use_analysis=not args.no_analysis,
+                    use_harness=not args.no_harness)
                 return_code = mgr.run(repeat=args.repeat, min_results=args.min_crashes)
             return return_code
 
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index d87e8e1f..5b2dd810 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -61,6 +61,11 @@ def test_args_02(tmp_path):
     # these should both log a warning that the args will be ignored due to analysis
     ReduceArgs().parse_args([str(exe), str(inp), "--repeat", "99"])
     ReduceArgs().parse_args([str(exe), str(inp), "--min-crashes", "99"])
+    ReduceArgs().parse_args([str(exe), str(inp), "--report-period", "99"])
+    with raises(SystemExit):
+        ReduceArgs().parse_args([str(exe), str(inp), "--report-period", "0"])
+    with raises(SystemExit):
+        ReduceArgs().parse_args([str(exe), str(inp), "--report-period", "15"])
 
 
 @pytest.mark.parametrize(
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 47069a18..201cabf2 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -6,7 +6,8 @@
 """Unit tests for `grizzly.reduce.reduce`.
 """
 from collections import namedtuple
-import functools
+from functools import partial, wraps
+from itertools import count
 from logging import getLogger
 
 import pytest
@@ -18,10 +19,11 @@
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from . import ReduceManager
 from .exceptions import NotReproducible
+from .strategies import Strategy
 
 
 LOG = getLogger(__name__)
-pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")
+pytestmark = pytest.mark.usefixtures("tmp_path_fm_config", "reporter_sequential_strftime")
 
 
 def _fake_save_logs_foo(result_logs, meta=False):  # pylint: disable=unused-argument
@@ -281,7 +283,7 @@ def _stop_early(_):
 
 def _ignore_arg(func):
     """Function wrapper that simply ignores 1 argument"""
-    @functools.wraps(func)
+    @wraps(func)
     def wrapped(_):
         return func()
     return wrapped
@@ -437,7 +439,7 @@ def wrapped(_):
             original="1\n2\n3\n",
             strategies=["check", "lines", "lines"],
             detect_failure=_ignore_arg(
-                functools.partial(
+                partial(
                     [True, False, False, False, False, False, True, True].pop, 0)),
             interesting_str="%r is anything, only in second strategy",
             is_expected=lambda _: True,
@@ -520,6 +522,129 @@ def replay_run(testcases, **_):
             == n_other * 2, list((log_path / "other_reports").iterdir())
 
 
+def test_report_01(mocker, tmp_path):
+    """test that report is called with --report-period is set"""
+    mocker.patch("grizzly.reduce.core.time", side_effect=count())
+
+    replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    replayer = replayer.return_value
+    replayer.status.iteration = 1
+
+    def replay_run(_, **_kw):
+        if replayer.run.call_count in {20, 40}:
+            log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
+            log_path.mkdir()
+            _fake_save_logs_foo(log_path)
+            report = Report(str(log_path), "bin")
+            return [ReplayResult(report, [["test.html"]], [], True)]
+        return []
+
+    replayer.run.side_effect = replay_run
+
+    (tmp_path / "test.html").touch()
+    testcases = TestCase.load(str(tmp_path / "test.html"), False)
+    assert testcases
+    log_path = tmp_path / "logs"
+
+    fake_strat = mocker.MagicMock(spec=Strategy)
+    fake_strat.return_value.name = "fake"
+
+    def fake_iter():
+        for count_ in range(1, 61):
+            LOG.debug("fake_iter() %d", count_)
+            (tmp_path / "test.html").write_text(str(count_))
+            testcases = TestCase.load(str(tmp_path / "test.html"), False)
+            assert testcases
+            yield testcases
+
+    fake_strat.return_value.__iter__.side_effect = fake_iter
+    mocker.patch("grizzly.reduce.core.STRATEGIES", new={"fake": fake_strat})
+
+    target = mocker.Mock(spec=Target)
+    target.relaunch = 1
+    try:
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target,
+                            testcases, ["fake"], log_path, use_analysis=False,
+                            report_period=30)
+        assert mgr.run() == 0
+    finally:
+        for test in testcases:
+            test.cleanup()
+
+    # should be 2 reports: one made at time=30 (for crash on 20th iter),
+    # and one at time=60 (for crash on 40th iter)
+    n_reports = 2
+    reports = {"20", "40"}
+    assert replayer.run.call_count == 60
+    expected_dirs = {log_path / "reports"}
+    assert set(log_path.iterdir()) == expected_dirs
+    tests = {test.read_text() for test in log_path.glob("reports/*-0/test.html")}
+    assert tests == reports
+    assert sum(1 for _ in (log_path / "reports").iterdir()) \
+        == n_reports * 2, list((log_path / "reports").iterdir())
+
+
+def test_report_02(mocker, tmp_path):
+    """test that report is called when KeyboardInterrupt occurs"""
+    mocker.patch("grizzly.reduce.core.time", side_effect=count())
+
+    replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    replayer = replayer.return_value
+    replayer.status.iteration = 1
+
+    def replay_run(_, **_kw):
+        if replayer.run.call_count in {10, 20}:
+            log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
+            log_path.mkdir()
+            _fake_save_logs_foo(log_path)
+            report = Report(str(log_path), "bin")
+            return [ReplayResult(report, [["test.html"]], [], True)]
+        return []
+
+    replayer.run.side_effect = replay_run
+
+    (tmp_path / "test.html").touch()
+    testcases = TestCase.load(str(tmp_path / "test.html"), False)
+    assert testcases
+    log_path = tmp_path / "logs"
+
+    fake_strat = mocker.MagicMock(spec=Strategy)
+    fake_strat.return_value.name = "fake"
+
+    def fake_iter():
+        for count_ in range(1, 31):
+            LOG.debug("fake_iter() %d", count_)
+            (tmp_path / "test.html").write_text(str(count_))
+            testcases = TestCase.load(str(tmp_path / "test.html"), False)
+            assert testcases
+            yield testcases
+        raise KeyboardInterrupt()
+
+    fake_strat.return_value.__iter__.side_effect = fake_iter
+    mocker.patch("grizzly.reduce.core.STRATEGIES", new={"fake": fake_strat})
+
+    target = mocker.Mock(spec=Target)
+    target.relaunch = 1
+    try:
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target,
+                            testcases, ["fake"], log_path, use_analysis=False)
+        with raises(KeyboardInterrupt):
+            mgr.run()
+    finally:
+        for test in testcases:
+            test.cleanup()
+
+    n_reports = 1
+    reports = {"20"}
+    assert replayer.run.call_count == 30
+    expected_dirs = {log_path / "reports"}
+    assert set(log_path.iterdir()) == expected_dirs
+    tests = {test.read_text() for test in log_path.glob("reports/*-0/test.html")}
+    assert tests == reports
+    assert sum(1 for _ in (log_path / "reports").iterdir()) \
+        == n_reports * 2, list((log_path / "reports").iterdir())
+
+
 def test_quality_update(mocker, tmp_path):
     """test that the final result gets changed to Q0 with --fuzzmanager"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
@@ -541,6 +666,7 @@ def replay_run(_, **_kw):
 
     mocker.patch("grizzly.common.reporter.Collector")
     reporter = mocker.patch("grizzly.reduce.core.FuzzManagerReporter")
+    reporter.QUAL_REDUCED_RESULT = 0
     update_coll = mocker.patch("grizzly.reduce.core.Collector")
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
@@ -548,7 +674,7 @@ def replay_run(_, **_kw):
         mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target,
                             testcases, ["check"], log_path, use_analysis=False,
                             report_to_fuzzmanager=True)
-        assert mgr.run()
+        assert mgr.run() == 0
     finally:
         for test in testcases:
             test.cleanup()

From 27fa2cfabfdbc5a405ad6f47b5d077de50907656 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 6 Nov 2020 17:20:35 -0500
Subject: [PATCH 095/531] [reducer] Set --tool from test_info.json if not
 given.

---
 grizzly/reduce/core.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 463ebe5c..30f6ab54 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -641,6 +641,11 @@ def main(cls, args):
                 LOG.error("Error: %s", str(exc))
                 return FuzzManagerReporter.QUAL_NO_TESTCASE
 
+            if args.tool is None and testcases[0].adapter_name is not None:
+                LOG.warning("Setting default --tool=grizzly-%s from testcase",
+                            testcases[0].adapter_name)
+                args.tool = "grizzly-%s" % (testcases[0].adapter_name,)
+
             if args.test_index is not None or (args.no_harness and len(testcases) > 1):
                 if args.test_index is None:
                     LOG.warning("'--no-harness' given with %d testcases and without "

From 6607500c61c4e7d3aac141dcf56df0295a2b6906 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 9 Nov 2020 13:34:51 -0500
Subject: [PATCH 096/531] [reducer] Report reducer stats in FM metadata.

---
 grizzly/common/reporter.py | 26 +++++++++++++++++++++-----
 grizzly/reduce/core.py     |  2 ++
 grizzly/reduce/stats.py    | 11 +++++++++++
 3 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index c63fc43b..00c662c2 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -6,7 +6,7 @@
 from abc import ABCMeta, abstractmethod
 from collections import namedtuple
 from hashlib import sha1
-from json import dump
+from json import dump, dumps, loads
 from logging import getLogger, WARNING
 from platform import machine, system
 from os import listdir, getcwd, getenv, makedirs, mkdir, SEEK_END, stat, unlink, walk
@@ -462,7 +462,7 @@ def __init__(self, tool=None):
         self.tool = tool  # optional tool name
 
     def _post_submit(self):
-        self._extra_metadata = {}
+        self._extra_metadata.clear()
 
     @staticmethod
     def sanity_check(bin_file):
@@ -480,6 +480,22 @@ def sanity_check(bin_file):
             raise IOError("Missing: %s.fuzzmanagerconf" % (bin_file,))
         ProgramConfiguration.fromBinary(bin_file)
 
+    def add_extra_metadata(self, key, value):
+        """Add extra metadata to be reported with any CrashEntrys reported.
+
+        Arguments:
+            key (str): key for this data in the metadata dict
+            value (object): JSON serializable object to be included in the FM crash metadata.
+                            The object will be deep-copied.
+
+        Returns:
+            None
+        """
+        assert isinstance(key, str)
+        assert key not in self._extra_metadata
+        # this not only does a deep copy, but also ensures that value is JSON serializable
+        self._extra_metadata[key] = loads(dumps(value))
+
     @classmethod
     def quality_name(cls, value):
         for name in dir(cls):
@@ -495,7 +511,7 @@ def _process_rr_trace(self, report):
         trace_path = pathjoin(report.path, "rr-traces")
         if isdir(trace_path):
             LOG.info("Ignored rr trace")
-            self._extra_metadata["rr-trace"] = "ignored"
+            self.add_extra_metadata("rr-trace",  "ignored")
             # remove traces so they are not uploaded to FM (because they are huge)
             # use S3FuzzManagerReporter instead
             rmtree(trace_path)
@@ -655,7 +671,7 @@ def _process_rr_trace(self, report):
         else:
             # The object already exists.
             LOG.info("rr trace exists at %r", s3_url)
-            self._extra_metadata["rr-trace"] = s3_url
+            self.add_extra_metadata("rr-trace", s3_url)
             # remove traces so they are not reported to FM
             rmtree(trace_path)
             return s3_url
@@ -664,7 +680,7 @@ def _process_rr_trace(self, report):
         rr_arc = self.compress_rr_trace(trace_path, report.path)
         s3.meta.client.upload_file(rr_arc, s3_bucket, s3_key, ExtraArgs={"ACL": "public-read"})
         unlink(rr_arc)
-        self._extra_metadata["rr-trace"] = s3_url
+        self.add_extra_metadata("rr-trace", s3_url)
         return s3_url
 
     @staticmethod
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 30f6ab54..a1600460 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -580,6 +580,8 @@ def report(self, results, testcases, stats=None):
                     for line in stats.format_lines():
                         print(line, file=out)
                 (report_path / "reduce_stats.json").write_text(stats.json())
+                if self._report_to_fuzzmanager:
+                    stats.add_to_reporter(reporter)
             # clone the tests so we can safely call purge_optional here for each report
             # (report.served may be different for non-expected or any-crash results)
             clones = [test.clone() for test in testcases]
diff --git a/grizzly/reduce/stats.py b/grizzly/reduce/stats.py
index cdbbdd8a..94b75a6a 100644
--- a/grizzly/reduce/stats.py
+++ b/grizzly/reduce/stats.py
@@ -292,6 +292,17 @@ def format_lines(self):
         )
         yield from tabulator.format_rows(stats)
 
+    def add_to_reporter(self, reporter):
+        """Add the reducer stats to reported metadata for the given reporter.
+
+        Arguments:
+            reporter (FuzzManagerReporter): Reporter to update.
+
+        Returns:
+            None
+        """
+        reporter.add_extra_metadata("reducer-stats", self._data)
+
     def json(self):
         """Serialize the stats using JSON.
 

From 81ffe12fc8d9d20b877364346e67b69499848d63 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 9 Nov 2020 14:27:19 -0500
Subject: [PATCH 097/531] [reducer] Fix analysis rounds.

- Only iterate through all tests if last-test-only doesn't repro
- Count last-test-only as a harness crash, so same logic applies for
  skipping without-harness
---
 grizzly/reduce/core.py        |  13 ++-
 grizzly/reduce/test_reduce.py | 190 +++++++++++++++++++---------------
 2 files changed, 113 insertions(+), 90 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index a1600460..18c67c49 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -236,7 +236,7 @@ def run_reliability_analysis(self, stats):
         #   on every call to interesting.
 
         for (use_harness, last_test) in [(True, True), (True, False), (False, False)]:
-            if use_harness and (not self._original_use_harness or harness_last_crashes):
+            if use_harness and (not self._original_use_harness or harness_crashes):
                 continue
             if not use_harness and harness_crashes >= self.ANALYSIS_ITERATIONS / 2:
                 continue
@@ -283,10 +283,13 @@ def run_reliability_analysis(self, stats):
                     self.report(
                         [result for result in results if not result.expected],
                         testcases, self._stats.copy(stats))
-                    if use_harness and last_test:
-                        harness_last_crashes = crashes
-                    elif use_harness:
+                    if use_harness:
+                        # set harness_crashes in both cases (last_test True/False)
+                        # we only want to iterate through all testcases if the last
+                        # testcase alone never reproduced (crashes == 0).
                         harness_crashes = crashes
+                        if last_test:
+                            harness_last_crashes = crashes
                     else:
                         non_harness_crashes = crashes
                 finally:
@@ -302,7 +305,7 @@ def run_reliability_analysis(self, stats):
                 # ensure same signature is always used
                 self._signature = replay.signature
 
-        if not any([harness_last_crashes, harness_crashes, non_harness_crashes]):
+        if not (harness_crashes or non_harness_crashes):
             raise NotReproducible("Did not reproduce during analysis")
 
         # if harness is selected, we'll only use the last testcase
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 201cabf2..187d3e4a 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -52,8 +52,8 @@ def _fake_save_logs_bar(result_logs, meta=False):  # pylint: disable=unused-argu
 
 AnalysisTestParams = namedtuple(
     "AnalysisTestParams",
-    "harness_crashes, no_harness_crashes, expected_repeat, expected_min_crashes, "
-    "use_harness, result_harness"
+    "harness_last_crashes, harness_crashes, no_harness_crashes, expected_repeat, "
+    "expected_min_crashes, use_harness, result_harness"
 )
 
 
@@ -61,171 +61,187 @@ def _fake_save_logs_bar(result_logs, meta=False):  # pylint: disable=unused-argu
     AnalysisTestParams._fields,
     [
         # perfect with harness
-        AnalysisTestParams(11, None, 2, 2, True, True),
+        AnalysisTestParams(None, 11, None, 2, 2, True, True),
         # perfect, use_harness=False
-        AnalysisTestParams(11, None, 2, 2, False, False),
+        AnalysisTestParams(None, 11, None, 2, 2, False, False),
         # 10/11 with harness
-        AnalysisTestParams(10, None, 2, 1, True, True),
+        AnalysisTestParams(None, 10, None, 2, 1, True, True),
         # 9/11 with harness
-        AnalysisTestParams(9, None, 2, 1, True, True),
+        AnalysisTestParams(None, 9, None, 2, 1, True, True),
         # 8/11 with harness
-        AnalysisTestParams(8, None, 3, 1, True, True),
+        AnalysisTestParams(None, 8, None, 3, 1, True, True),
         # 7/11 with harness
-        AnalysisTestParams(7, None, 3, 1, True, True),
+        AnalysisTestParams(None, 7, None, 3, 1, True, True),
         # 6/11 with harness
-        AnalysisTestParams(6, None, 4, 1, True, True),
+        AnalysisTestParams(None, 6, None, 4, 1, True, True),
         # 5/11 with harness
-        AnalysisTestParams(5, 0, 5, 1, True, True),
+        AnalysisTestParams(None, 5, 0, 5, 1, True, True),
         # 5/11 with harness, 1/11 without
-        AnalysisTestParams(5, 1, 5, 1, True, True),
+        AnalysisTestParams(None, 5, 1, 5, 1, True, True),
         # 5/11 with harness, 2/11 without
-        AnalysisTestParams(5, 2, 5, 1, True, True),
+        AnalysisTestParams(None, 5, 2, 5, 1, True, True),
         # 5/11 with harness, 3/11 without
-        AnalysisTestParams(5, 3, 5, 1, True, True),
+        AnalysisTestParams(None, 5, 3, 5, 1, True, True),
         # 5/11 with harness, 4/11 without
-        AnalysisTestParams(5, 4, 5, 1, True, True),
+        AnalysisTestParams(None, 5, 4, 5, 1, True, True),
         # 5/11 with harness, 5/11 without
-        AnalysisTestParams(5, 5, 5, 1, True, True),
+        AnalysisTestParams(None, 5, 5, 5, 1, True, True),
         # 5/11 with harness, 6/11 without
-        AnalysisTestParams(5, 6, 5, 1, True, True),
+        AnalysisTestParams(None, 5, 6, 5, 1, True, True),
         # 5/11 with harness, 7/11 without
-        AnalysisTestParams(5, 7, 5, 1, True, True),
+        AnalysisTestParams(None, 5, 7, 5, 1, True, True),
         # 5/11 with harness, 8/11 without
-        AnalysisTestParams(5, 8, 3, 1, True, False),
+        AnalysisTestParams(None, 5, 8, 3, 1, True, False),
         # 5/11 with harness, 9/11 without
-        AnalysisTestParams(5, 9, 2, 1, True, False),
+        AnalysisTestParams(None, 5, 9, 2, 1, True, False),
         # 5/11 with harness, 10/11 without
-        AnalysisTestParams(5, 10, 2, 1, True, False),
+        AnalysisTestParams(None, 5, 10, 2, 1, True, False),
         # 5/11 with harness, perfect without
-        AnalysisTestParams(5, 11, 2, 2, True, False),
+        AnalysisTestParams(None, 5, 11, 2, 2, True, False),
         # 4/11 with harness
-        AnalysisTestParams(4, 0, 7, 1, True, True),
+        AnalysisTestParams(None, 4, 0, 7, 1, True, True),
         # 4/11 with harness, 1/11 without
-        AnalysisTestParams(4, 1, 7, 1, True, True),
+        AnalysisTestParams(None, 4, 1, 7, 1, True, True),
         # 4/11 with harness, 2/11 without
-        AnalysisTestParams(4, 2, 7, 1, True, True),
+        AnalysisTestParams(None, 4, 2, 7, 1, True, True),
         # 4/11 with harness, 3/11 without
-        AnalysisTestParams(4, 3, 7, 1, True, True),
+        AnalysisTestParams(None, 4, 3, 7, 1, True, True),
         # 4/11 with harness, 4/11 without
-        AnalysisTestParams(4, 4, 7, 1, True, True),
+        AnalysisTestParams(None, 4, 4, 7, 1, True, True),
         # 4/11 with harness, 5/11 without
-        AnalysisTestParams(4, 5, 7, 1, True, True),
+        AnalysisTestParams(None, 4, 5, 7, 1, True, True),
         # 4/11 with harness, 6/11 without
-        AnalysisTestParams(4, 6, 4, 1, True, False),
+        AnalysisTestParams(None, 4, 6, 4, 1, True, False),
         # 4/11 with harness, 7/11 without
-        AnalysisTestParams(4, 7, 3, 1, True, False),
+        AnalysisTestParams(None, 4, 7, 3, 1, True, False),
         # 4/11 with harness, 8/11 without
-        AnalysisTestParams(4, 8, 3, 1, True, False),
+        AnalysisTestParams(None, 4, 8, 3, 1, True, False),
         # 4/11 with harness, 9/11 without
-        AnalysisTestParams(4, 9, 2, 1, True, False),
+        AnalysisTestParams(None, 4, 9, 2, 1, True, False),
         # 4/11 with harness, 10/11 without
-        AnalysisTestParams(4, 10, 2, 1, True, False),
+        AnalysisTestParams(None, 4, 10, 2, 1, True, False),
         # 4/11 with harness, perfect without
-        AnalysisTestParams(4, 11, 2, 2, True, False),
+        AnalysisTestParams(None, 4, 11, 2, 2, True, False),
         # 3/11 with harness
-        AnalysisTestParams(3, 0, 10, 1, True, True),
+        AnalysisTestParams(None, 3, 0, 10, 1, True, True),
         # 3/11 with harness, 1/11 without
-        AnalysisTestParams(3, 1, 10, 1, True, True),
+        AnalysisTestParams(None, 3, 1, 10, 1, True, True),
         # 3/11 with harness, 2/11 without
-        AnalysisTestParams(3, 2, 10, 1, True, True),
+        AnalysisTestParams(None, 3, 2, 10, 1, True, True),
         # 3/11 with harness, 3/11 without
-        AnalysisTestParams(3, 3, 10, 1, True, True),
+        AnalysisTestParams(None, 3, 3, 10, 1, True, True),
         # 3/11 with harness, 4/11 without
-        AnalysisTestParams(3, 4, 10, 1, True, True),
+        AnalysisTestParams(None, 3, 4, 10, 1, True, True),
         # 3/11 with harness, 5/11 without
-        AnalysisTestParams(3, 5, 5, 1, True, False),
+        AnalysisTestParams(None, 3, 5, 5, 1, True, False),
         # 3/11 with harness, 6/11 without
-        AnalysisTestParams(3, 6, 4, 1, True, False),
+        AnalysisTestParams(None, 3, 6, 4, 1, True, False),
         # 3/11 with harness, 7/11 without
-        AnalysisTestParams(3, 7, 3, 1, True, False),
+        AnalysisTestParams(None, 3, 7, 3, 1, True, False),
         # 3/11 with harness, 8/11 without
-        AnalysisTestParams(3, 8, 3, 1, True, False),
+        AnalysisTestParams(None, 3, 8, 3, 1, True, False),
         # 3/11 with harness, 9/11 without
-        AnalysisTestParams(3, 9, 2, 1, True, False),
+        AnalysisTestParams(None, 3, 9, 2, 1, True, False),
         # 3/11 with harness, 10/11 without
-        AnalysisTestParams(3, 10, 2, 1, True, False),
+        AnalysisTestParams(None, 3, 10, 2, 1, True, False),
         # 3/11 with harness, perfect without
-        AnalysisTestParams(3, 11, 2, 2, True, False),
+        AnalysisTestParams(None, 3, 11, 2, 2, True, False),
         # 2/11 with harness
-        AnalysisTestParams(2, 0, 15, 1, True, True),
+        AnalysisTestParams(None, 2, 0, 15, 1, True, True),
         # 2/11 with harness, 1/11 without
-        AnalysisTestParams(2, 1, 15, 1, True, True),
+        AnalysisTestParams(None, 2, 1, 15, 1, True, True),
         # 2/11 with harness, 2/11 without
-        AnalysisTestParams(2, 2, 15, 1, True, True),
+        AnalysisTestParams(None, 2, 2, 15, 1, True, True),
         # 2/11 with harness, 3/11 without
-        AnalysisTestParams(2, 3, 10, 1, True, False),
+        AnalysisTestParams(None, 2, 3, 10, 1, True, False),
         # 2/11 with harness, 4/11 without
-        AnalysisTestParams(2, 4, 7, 1, True, False),
+        AnalysisTestParams(None, 2, 4, 7, 1, True, False),
         # 2/11 with harness, 5/11 without
-        AnalysisTestParams(2, 5, 5, 1, True, False),
+        AnalysisTestParams(None, 2, 5, 5, 1, True, False),
         # 2/11 with harness, 6/11 without
-        AnalysisTestParams(2, 6, 4, 1, True, False),
+        AnalysisTestParams(None, 2, 6, 4, 1, True, False),
         # 2/11 with harness, 7/11 without
-        AnalysisTestParams(2, 7, 3, 1, True, False),
+        AnalysisTestParams(None, 2, 7, 3, 1, True, False),
         # 2/11 with harness, 8/11 without
-        AnalysisTestParams(2, 8, 3, 1, True, False),
+        AnalysisTestParams(None, 2, 8, 3, 1, True, False),
         # 2/11 with harness, 9/11 without
-        AnalysisTestParams(2, 9, 2, 1, True, False),
+        AnalysisTestParams(None, 2, 9, 2, 1, True, False),
         # 2/11 with harness, 10/11 without
-        AnalysisTestParams(2, 10, 2, 1, True, False),
+        AnalysisTestParams(None, 2, 10, 2, 1, True, False),
         # 2/11 with harness, perfect without
-        AnalysisTestParams(2, 11, 2, 2, True, False),
+        AnalysisTestParams(None, 2, 11, 2, 2, True, False),
         # 1/11 with harness
-        AnalysisTestParams(1, 0, 32, 1, True, True),
+        AnalysisTestParams(None, 1, 0, 32, 1, True, True),
         # 1/11 with harness, 1/11 without
-        AnalysisTestParams(1, 1, 32, 1, True, True),
+        AnalysisTestParams(None, 1, 1, 32, 1, True, True),
         # 1/11 with harness, 2/11 without
-        AnalysisTestParams(1, 2, 15, 1, True, False),
+        AnalysisTestParams(None, 1, 2, 15, 1, True, False),
         # 1/11 with harness, 3/11 without
-        AnalysisTestParams(1, 3, 10, 1, True, False),
+        AnalysisTestParams(None, 1, 3, 10, 1, True, False),
         # 1/11 with harness, 4/11 without
-        AnalysisTestParams(1, 4, 7, 1, True, False),
+        AnalysisTestParams(None, 1, 4, 7, 1, True, False),
         # 1/11 with harness, 5/11 without
-        AnalysisTestParams(1, 5, 5, 1, True, False),
+        AnalysisTestParams(None, 1, 5, 5, 1, True, False),
         # 1/11 with harness, 6/11 without
-        AnalysisTestParams(1, 6, 4, 1, True, False),
+        AnalysisTestParams(None, 1, 6, 4, 1, True, False),
         # 1/11 with harness, 7/11 without
-        AnalysisTestParams(1, 7, 3, 1, True, False),
+        AnalysisTestParams(None, 1, 7, 3, 1, True, False),
         # 1/11 with harness, 8/11 without
-        AnalysisTestParams(1, 8, 3, 1, True, False),
+        AnalysisTestParams(None, 1, 8, 3, 1, True, False),
         # 1/11 with harness, 9/11 without
-        AnalysisTestParams(1, 9, 2, 1, True, False),
+        AnalysisTestParams(None, 1, 9, 2, 1, True, False),
         # 1/11 with harness, 10/11 without
-        AnalysisTestParams(1, 10, 2, 1, True, False),
+        AnalysisTestParams(None, 1, 10, 2, 1, True, False),
         # 1/11 with harness, perfect without
-        AnalysisTestParams(1, 11, 2, 2, True, False),
+        AnalysisTestParams(None, 1, 11, 2, 2, True, False),
         # perfect without harness
-        AnalysisTestParams(0, 11, 2, 2, True, False),
+        AnalysisTestParams(None, 0, 11, 2, 2, True, False),
         # 10/11 without harness
-        AnalysisTestParams(0, 10, 2, 1, True, False),
+        AnalysisTestParams(None, 0, 10, 2, 1, True, False),
         # 9/11 without harness
-        AnalysisTestParams(0, 9, 2, 1, True, False),
+        AnalysisTestParams(None, 0, 9, 2, 1, True, False),
         # 8/11 without harness
-        AnalysisTestParams(0, 8, 3, 1, True, False),
+        AnalysisTestParams(None, 0, 8, 3, 1, True, False),
         # 7/11 without harness
-        AnalysisTestParams(0, 7, 3, 1, True, False),
+        AnalysisTestParams(None, 0, 7, 3, 1, True, False),
         # 6/11 without harness
-        AnalysisTestParams(0, 6, 4, 1, True, False),
+        AnalysisTestParams(None, 0, 6, 4, 1, True, False),
         # 5/11 without harness
-        AnalysisTestParams(0, 5, 5, 1, True, False),
+        AnalysisTestParams(None, 0, 5, 5, 1, True, False),
         # 4/11 without harness
-        AnalysisTestParams(0, 4, 7, 1, True, False),
+        AnalysisTestParams(None, 0, 4, 7, 1, True, False),
         # 3/11 without harness
-        AnalysisTestParams(0, 3, 10, 1, True, False),
+        AnalysisTestParams(None, 0, 3, 10, 1, True, False),
         # 2/11 without harness
-        AnalysisTestParams(0, 2, 15, 1, True, False),
+        AnalysisTestParams(None, 0, 2, 15, 1, True, False),
         # 1/11 without harness
-        AnalysisTestParams(0, 1, 32, 1, True, False),
+        AnalysisTestParams(None, 0, 1, 32, 1, True, False),
+        # last test repros (1/11), all tests are not tried, without_harness is tried
+        AnalysisTestParams(1, None, 0, 32, 1, True, True),
+        # last test repros (11/11), no other rounds are tried
+        AnalysisTestParams(11, None, None, 2, 2, True, True),
+        # last test doesn't repro, harness+all tests is (1/11), without harness is tried
+        AnalysisTestParams(None, 1, 0, 32, 1, True, True),
+        # last test doesn't repro, harness+all tests is (11/11), skip without harness
+        AnalysisTestParams(None, 11, None, 2, 2, True, True),
+
     ]
 )
-def test_analysis(mocker, tmp_path, harness_crashes, no_harness_crashes,
-                  expected_repeat, expected_min_crashes, use_harness, result_harness):
+def test_analysis(mocker, tmp_path, harness_last_crashes, harness_crashes,
+                  no_harness_crashes, expected_repeat, expected_min_crashes,
+                  use_harness, result_harness):
     """test that analysis sets reasonable params"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value.__enter__.return_value
     replayer.status.iteration = 11
-    expected_iters = 1
-    crashes = [True] * harness_crashes + [False] * (11 - harness_crashes)
+    crashes = []
+    expected_iters = 0
+    if harness_last_crashes is not None:
+        crashes += [False] * (11 - harness_last_crashes) + [True] * harness_last_crashes
+        expected_iters += 1
+    if harness_crashes is not None:
+        crashes += [True] * harness_crashes + [False] * (11 - harness_crashes)
+        expected_iters = 1
     if no_harness_crashes is not None:
         crashes += [False] * (11 - no_harness_crashes) + [True] * no_harness_crashes
         expected_iters += 1
@@ -249,8 +265,12 @@ def replay_run(_, **kw):
     replayer.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
-    test.add_from_data("", "test.html")
+    test.add_from_data("1", "test.html")
     tests = [test]
+    if harness_last_crashes is not None:
+        test = TestCase("test.html", None, "test-adapter")
+        test.add_from_data("2", "test.html")
+        tests.append(test.clone())
     log_path = tmp_path / "logs"
 
     class _ReduceStats:

From b316f539458b46ddfdf7bafa28af9f8ab6d8f984 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 9 Nov 2020 15:29:14 -0500
Subject: [PATCH 098/531] [reducer] Fix reducible file detection:

- Require reducible files to contain DDBEGIN/DDEND
- Detect DDBEGIN/END in binary mode to avoid decoding errors
---
 grizzly/reduce/args.py                 |  3 ---
 grizzly/reduce/core.py                 | 12 ++++--------
 grizzly/reduce/strategies/__init__.py  |  9 +++------
 grizzly/reduce/strategies/beautify.py  |  8 +++-----
 grizzly/reduce/strategies/lithium.py   |  8 +++-----
 grizzly/reduce/strategies/testcases.py |  4 ++--
 grizzly/reduce/test_reduce.py          |  6 +++++-
 grizzly/reduce/test_strategies.py      |  4 ++++
 8 files changed, 24 insertions(+), 30 deletions(-)

diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 5cd99e17..40146f4d 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -56,9 +56,6 @@ def __init__(self):
             "--report-period", type=int,
             help="Periodically report the best testcase for long-running strategies."
             " (value in seconds, default: no)")
-        reduce_args.add_argument(
-            "--skip-dd-unmarked", action="store_false", dest="all_files",
-            help="Only reduce files containing DDBEGIN/END (default: all files)")
         reduce_args.add_argument(
             "--static-timeout", action="store_true",
             help="Disable automatically updating the iteration timeout.")
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 18c67c49..2f562254 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -96,10 +96,9 @@ class ReduceManager(object):
     ITER_TIMEOUT_DURATION_MULTIPLIER = 2
 
     def __init__(self, ignore, server, target, testcases, strategies, log_path,
-                 all_files=True, any_crash=False, idle_delay=0, idle_threshold=0,
-                 report_period=None, report_to_fuzzmanager=False, signature=None,
-                 signature_desc=None, static_timeout=False, tool=None,
-                 use_analysis=True, use_harness=True):
+                 any_crash=False, idle_delay=0, idle_threshold=0, report_period=None,
+                 report_to_fuzzmanager=False, signature=None, signature_desc=None,
+                 static_timeout=False, tool=None, use_analysis=True, use_harness=True):
         """Initialize reduction manager. Many arguments are common with `ReplayManager`.
 
         Args:
@@ -111,7 +110,6 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
             strategies (list(str)): Value for `self.strategies` attribute.
             log_path (Path or str): Path to save results when reporting to filesystem.
 
-            all_files (bool): Reduce all files, not just those with DDBEGIN/END.
             any_crash (bool): Accept any crash when reducing, not just those matching
                               the specified or first observed signature.
             idle_delay (int): Number of seconds to wait before polling for idle.
@@ -136,7 +134,6 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
         self.strategies = strategies
         self.target = target
         self.testcases = testcases
-        self._all_files = all_files
         self._any_crash = any_crash
         self._idle_delay = idle_delay
         self._idle_threshold = idle_threshold
@@ -409,7 +406,7 @@ def run(self, repeat=1, min_results=1):
                                        any_crash=self._any_crash,
                                        signature=self._signature,
                                        use_harness=self._use_harness)
-                strategy = STRATEGIES[strategy](self.testcases, self._all_files)
+                strategy = STRATEGIES[strategy](self.testcases)
                 if last_tried is not None:
                     strategy.update_tried(last_tried)
                     last_tried = None
@@ -714,7 +711,6 @@ def main(cls, args):
                     testcases,
                     args.strategies,
                     args.logs,
-                    all_files=args.all_files,
                     any_crash=args.any_crash,
                     idle_delay=args.idle_delay,
                     idle_threshold=args.idle_threshold,
diff --git a/grizzly/reduce/strategies/__init__.py b/grizzly/reduce/strategies/__init__.py
index 1e515654..f12e15e1 100644
--- a/grizzly/reduce/strategies/__init__.py
+++ b/grizzly/reduce/strategies/__init__.py
@@ -69,8 +69,8 @@ def _load_strategies():
 
 
 def _contains_dd(path):
-    data = path.read_text()
-    return "DDBEGIN" in data and "DDEND" in data
+    data = path.read_bytes()
+    return b"DDBEGIN" in data and b"DDEND" in data
 
 
 class Strategy(ABC):
@@ -84,19 +84,16 @@ class Strategy(ABC):
     """
     name = None
 
-    def __init__(self, testcases, all_files):
+    def __init__(self, testcases):
         """Initialize strategy instance.
 
         Arguments:
             testcases (list(grizzly.common.storage.TestCase)):
                 List of testcases to reduce. The object does not take ownership of the
                 testcases.
-            all_files (bool): Reduce all files, otherwise only files containing
-                              DDBEGIN/END
         """
         self._tried = set()  # set of tuple(tuple(str(Path), SHA512))
         self._testcase_root = Path(mkdtemp(prefix="tc_", dir=grz_tmp("reduce")))
-        self._all_files = all_files
         self.dump_testcases(testcases)
 
     def _calculate_testcase_hash(self):
diff --git a/grizzly/reduce/strategies/beautify.py b/grizzly/reduce/strategies/beautify.py
index 879c870a..c2cf1073 100644
--- a/grizzly/reduce/strategies/beautify.py
+++ b/grizzly/reduce/strategies/beautify.py
@@ -53,22 +53,20 @@ class _BeautifyStrategy(Strategy, ABC):
     native_extension = None
     tag_name = None
 
-    def __init__(self, testcases, all_files):
+    def __init__(self, testcases):
         """Initialize beautification strategy instance.
 
         Arguments:
             testcases (list(grizzly.common.storage.TestCase)):
                 List of testcases to reduce. The object does not take ownership of the
                 testcases.
-            all_files (bool): Reduce all files, otherwise only files containing
-                              DDBEGIN/END
         """
-        super().__init__(testcases, all_files)
+        super().__init__(testcases)
         self._files_to_beautify = []
         for path in self._testcase_root.glob("**/*"):
             if (path.is_file() and path.suffix in self.all_extensions
                     and path.name not in self.blacklist_files):
-                if self._all_files or _contains_dd(path):
+                if _contains_dd(path):
                     self._files_to_beautify.append(path)
         self._current_feedback = None
         tag_bytes = self.tag_name.encode("ascii")
diff --git a/grizzly/reduce/strategies/lithium.py b/grizzly/reduce/strategies/lithium.py
index 68eee31f..8db3ba0a 100644
--- a/grizzly/reduce/strategies/lithium.py
+++ b/grizzly/reduce/strategies/lithium.py
@@ -33,17 +33,15 @@ class _LithiumStrategy(Strategy, ABC):
     strategy_cls = None
     testcase_cls = None
 
-    def __init__(self, testcases, all_files):
+    def __init__(self, testcases):
         """Initialize strategy instance.
 
         Arguments:
             testcases (list(grizzly.common.storage.TestCase)):
                 List of testcases to reduce. The object does not take ownership of the
                 testcases.
-            all_files (bool): Reduce all files, otherwise only files containing
-                              DDBEGIN/END
         """
-        super().__init__(testcases, all_files)
+        super().__init__(testcases)
         self._current_reducer = None
         self._files_to_reduce = []
         self._possible_iters_remain = {}
@@ -68,7 +66,7 @@ def rescan_files_to_reduce(self):
         self._files_to_reduce.clear()
         for path in self._testcase_root.glob("**/*"):
             if path.is_file() and path.name not in {"test_info.json", "prefs.js"}:
-                if self._all_files or _contains_dd(path):
+                if _contains_dd(path):
                     self._files_to_reduce.append(path)
         # any files in possible_iters that don't exist anymore can be removed
         removed = set(self._possible_iters_remain) - set(self._files_to_reduce)
diff --git a/grizzly/reduce/strategies/testcases.py b/grizzly/reduce/strategies/testcases.py
index 14f85f13..f790b9bd 100644
--- a/grizzly/reduce/strategies/testcases.py
+++ b/grizzly/reduce/strategies/testcases.py
@@ -27,7 +27,7 @@ class MinimizeTestcaseList(Strategy):
     """
     name = "list"
 
-    def __init__(self, testcases, all_files):
+    def __init__(self, testcases):
         """Initialize strategy instance.
 
         Arguments:
@@ -35,7 +35,7 @@ def __init__(self, testcases, all_files):
                 List of testcases to reduce. The object does not take ownership of the
                 testcases.
         """
-        super().__init__(testcases, all_files)
+        super().__init__(testcases)
         self._current_feedback = None
         self._current_served = None
         self._current_remain = None
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 187d3e4a..7fcf8bb1 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -478,6 +478,7 @@ def test_repro(mocker, tmp_path, original, strategies, detect_failure, interesti
                other_reports, result):
     """test ReduceManager, difference scenarios produce correct expected/other
     results"""
+    mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
     replayer.status.iteration = 1
@@ -521,7 +522,6 @@ def replay_run(testcases, **_):
         for test in tests:
             test.cleanup()
 
-    assert replayer.run.call_count == expected_run_calls
     expected_dirs = set()
     if n_reports:
         expected_dirs.add(log_path / "reports")
@@ -540,6 +540,7 @@ def replay_run(testcases, **_):
         assert other_tests == other_reports
         assert sum(1 for _ in (log_path / "other_reports").iterdir()) \
             == n_other * 2, list((log_path / "other_reports").iterdir())
+    assert replayer.run.call_count == expected_run_calls
 
 
 def test_report_01(mocker, tmp_path):
@@ -667,6 +668,7 @@ def fake_iter():
 
 def test_quality_update(mocker, tmp_path):
     """test that the final result gets changed to Q0 with --fuzzmanager"""
+    mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
     replayer.status.iteration = 1
@@ -717,6 +719,7 @@ def replay_run(_, **_kw):
 @pytest.mark.parametrize("exc_type", [TargetLaunchError, TargetLaunchTimeout])
 def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
     """test that launch errors are reported"""
+    mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     report_fcn = mocker.patch("grizzly.reduce.core.ReduceManager.report", autospec=True)
     replay_mock = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     if exc_type is TargetLaunchError:
@@ -825,6 +828,7 @@ def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
 def test_timeout_update(mocker, tmp_path, durations, interesting, static_timeout,
                         idle_input, idle_output, iter_input, iter_output, result):
     "timeout will be updated based on time to crash"
+    mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
     replayer.status.iteration = 1
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 7e9260ac..cbfce8b8 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -112,6 +112,7 @@ def entries(_):
 def test_list(mocker, tmp_path, test_data, strategies, required_first,
               expected_run_calls, expected_results, expected_num_reports):
     """tests for the "list" strategy"""
+    mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
     replayer.status.iteration = 1
@@ -442,6 +443,8 @@ def replay_run(testcases, **_):
 def test_beautifier(mocker, tmp_path, test_data, test_name, expected_run_calls,
                     expected_results, expected_num_reports, strategies):
     """test for the "beautify" strategies"""
+    mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
+    mocker.patch("grizzly.reduce.strategies.beautify._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
     replayer.status.iteration = 1
@@ -593,6 +596,7 @@ def test_purge_unserved(mocker, tmp_path, strategies, test_data, served,
                         expected_results, expected_run_calls, expected_num_reports,
                         purging_breaks):
     """test purging unserved files"""
+    mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
     replayer.status.iteration = 1

From a441c01eff9f2b9f193596f65a2c2283b95ce845 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 9 Nov 2020 15:34:44 -0500
Subject: [PATCH 099/531] [reducer] Remove dead code related to "remaining
 time" estimation.

---
 grizzly/reduce/strategies/__init__.py  |  9 -------
 grizzly/reduce/strategies/beautify.py  | 14 -----------
 grizzly/reduce/strategies/lithium.py   | 34 +++-----------------------
 grizzly/reduce/strategies/testcases.py | 17 -------------
 4 files changed, 4 insertions(+), 70 deletions(-)

diff --git a/grizzly/reduce/strategies/__init__.py b/grizzly/reduce/strategies/__init__.py
index f12e15e1..007d9a0a 100644
--- a/grizzly/reduce/strategies/__init__.py
+++ b/grizzly/reduce/strategies/__init__.py
@@ -192,15 +192,6 @@ def __iter__(self):
                                                    applied
         """
 
-    @abstractmethod
-    def __len__(self):
-        """Estimate the maximum # of attempts this strategy might take to finish.
-        ie. The number of times `__iter__` will yield.
-
-        Returns:
-            int: estimate of the # of attempts remaining.
-        """
-
     @abstractmethod
     def update(self, success, served=None):
         """Inform the strategy whether or not the last reduction yielded was good.
diff --git a/grizzly/reduce/strategies/beautify.py b/grizzly/reduce/strategies/beautify.py
index c2cf1073..89e3440b 100644
--- a/grizzly/reduce/strategies/beautify.py
+++ b/grizzly/reduce/strategies/beautify.py
@@ -74,7 +74,6 @@ def __init__(self, testcases):
                                         flags=re.DOTALL | re.IGNORECASE)
         self._re_tag_end = re.compile(br"</\s*" + tag_bytes + br"\s*>",
                                       flags=re.IGNORECASE)
-        self._iter_idx = 0
 
     @classmethod
     def sanity_check_cls_attrs(cls):
@@ -175,15 +174,6 @@ def _chunks_to_beautify(self, before, to_beautify, file):
             yield (chunk_start, chunk_start + tag_end.start(0))
             search_start = chunk_start + tag_end.end(0)
 
-    def __len__(self):
-        """Estimate the maximum # of attempts this strategy might take to finish.
-        ie. The number of times `__iter__` will yield.
-
-        Returns:
-            int: estimate of the # of attempts remaining.
-        """
-        return len(self._files_to_beautify) - self._iter_idx
-
     def __iter__(self):
         """Iterate over potential beautifications of testcases according to this
         strategy.
@@ -246,23 +236,19 @@ def __iter__(self):
 
                 if last == 0:
                     LOG.warning("<%s> tags not found, skipping", self.tag_name)
-                    self._iter_idx += 1
                     continue
 
                 if not any_beautified:
                     LOG.warning("Beautify had no effect on the file, skipping")
-                    self._iter_idx += 1
                     continue
 
             tc_hash = self._calculate_testcase_hash()
             if tc_hash in self._tried:
                 LOG.info("cache hit, reverting")
                 lith_tc.dump(file)
-                self._iter_idx += 1
                 continue
 
             yield TestCase.load(str(self._testcase_root), True)
-            self._iter_idx += 1
 
             assert self._current_feedback is not None, "No feedback for last iteration"
             if self._current_feedback:
diff --git a/grizzly/reduce/strategies/lithium.py b/grizzly/reduce/strategies/lithium.py
index 8db3ba0a..4871b6d8 100644
--- a/grizzly/reduce/strategies/lithium.py
+++ b/grizzly/reduce/strategies/lithium.py
@@ -44,17 +44,9 @@ def __init__(self, testcases):
         super().__init__(testcases)
         self._current_reducer = None
         self._files_to_reduce = []
-        self._possible_iters_remain = {}
         self.rescan_files_to_reduce()
         self._current_feedback = None
         self._current_served = None
-        for path in self._files_to_reduce:
-            test = self.testcase_cls()  # pylint: disable=not-callable
-            test.load(path)
-            strategy = self.strategy_cls()  # pylint: disable=not-callable
-            strategy.estimate_from_testcase(test)
-            self._possible_iters_remain[path] = strategy.estimated_remaining
-        self._testcase_root_dirty = False
 
     def rescan_files_to_reduce(self):
         """Repopulate the private `files_to_reduce` attribute by scanning the testcase
@@ -68,10 +60,6 @@ def rescan_files_to_reduce(self):
             if path.is_file() and path.name not in {"test_info.json", "prefs.js"}:
                 if _contains_dd(path):
                     self._files_to_reduce.append(path)
-        # any files in possible_iters that don't exist anymore can be removed
-        removed = set(self._possible_iters_remain) - set(self._files_to_reduce)
-        for key in removed:
-            del self._possible_iters_remain[key]
 
     @classmethod
     def sanity_check_cls_attrs(cls):
@@ -103,16 +91,6 @@ def update(self, success, served=None):
         self._current_feedback = success
         self._current_served = served
 
-    def __len__(self):
-        """Estimate the maximum # of attempts this strategy might take to finish.
-        ie. The number of times `__iter__` will yield.
-
-        Returns:
-            int: estimate of the # of attempts remaining.
-        """
-        return sum(self._possible_iters_remain.values()) \
-            + int(self._testcase_root_dirty)
-
     def __iter__(self):
         """Iterate over potential reductions of testcases according to this strategy.
 
@@ -130,7 +108,7 @@ def __iter__(self):
         reduce_queue.sort()  # not necessary, but helps make tests more predictable
         # indicates that self._testcase_root contains changes that haven't been yielded
         # (if iteration ends, changes would be lost)
-        self._testcase_root_dirty = False
+        testcase_root_dirty = False
         while reduce_queue:
             LOG.debug("Reduce queue: %r", reduce_queue)
             file = reduce_queue.pop(0)
@@ -142,7 +120,6 @@ def __iter__(self):
             lithium_testcase.load(file)
             strategy = self.strategy_cls()  # pylint: disable=not-callable
             self._current_reducer = strategy.reduce(lithium_testcase)
-            self._possible_iters_remain[file] = strategy.estimated_remaining
 
             # populate the lithium strategy "tried" cache
             # use all cache values where all hashes other than the current file match
@@ -161,10 +138,9 @@ def __iter__(self):
                 reduction.dump()
                 testcases = TestCase.load(str(self._testcase_root), True)
                 LOG.info("[%s] %s", self.name, self._current_reducer.description)
-                self._possible_iters_remain[file] = strategy.estimated_remaining
                 yield testcases
                 if self._current_feedback:
-                    self._testcase_root_dirty = False
+                    testcase_root_dirty = False
                 else:
                     self._tried.add(self._calculate_testcase_hash())
                 if self._current_feedback and self._current_served is not None:
@@ -180,7 +156,7 @@ def __iter__(self):
                     LOG.debug("files being reduced after: %r", self._files_to_reduce)
                     files_to_reduce = set(self._files_to_reduce)
                     reduce_queue = list(sorted(set(reduce_queue) & files_to_reduce))
-                    self._testcase_root_dirty = \
+                    testcase_root_dirty = \
                         len(self._files_to_reduce) != num_files_before
                     if file not in files_to_reduce:
                         # current reduction was for a purged file
@@ -189,8 +165,7 @@ def __iter__(self):
                 # write out the best found testcase
                 self._current_reducer.testcase.dump()
             self._current_reducer = None
-            self._possible_iters_remain.pop(file, None)
-        if self._testcase_root_dirty:
+        if testcase_root_dirty:
             # purging unserved files enabled us to exit early from the loop.
             # need to yield once more to set this trimmed version to the current best
             # in ReduceManager
@@ -198,7 +173,6 @@ def __iter__(self):
             LOG.info("[%s] final iteration triggered by purge_optional", self.name)
             yield testcases
             assert self._current_feedback, "Purging unserved files broke the testcase."
-        self._testcase_root_dirty = False
 
 
 class Check(_LithiumStrategy):
diff --git a/grizzly/reduce/strategies/testcases.py b/grizzly/reduce/strategies/testcases.py
index f790b9bd..3f80ff79 100644
--- a/grizzly/reduce/strategies/testcases.py
+++ b/grizzly/reduce/strategies/testcases.py
@@ -38,7 +38,6 @@ def __init__(self, testcases):
         super().__init__(testcases)
         self._current_feedback = None
         self._current_served = None
-        self._current_remain = None
 
     def update(self, success, served=None):
         """Inform the strategy whether or not the last reduction yielded was good.
@@ -56,20 +55,6 @@ def update(self, success, served=None):
         self._current_feedback = success
         self._current_served = served
 
-    def __len__(self):
-        """Estimate the maximum # of attempts this strategy might take to finish.
-        ie. The number of times `__iter__` will yield.
-
-        Returns:
-            int: estimate of the # of attempts remaining.
-        """
-        if self._current_remain is None:
-            testcases = TestCase.load(str(self._testcase_root), True)
-            self._current_remain = len(testcases)
-            for test in testcases:
-                test.cleanup()
-        return max(self._current_remain - 1, 0)
-
     def __iter__(self):
         """Iterate over potential reductions of testcases according to this strategy.
 
@@ -87,7 +72,6 @@ def __iter__(self):
         try:
             testcases = TestCase.load(str(self._testcase_root), True)
             n_testcases = len(testcases)
-            self._current_remain = n_testcases
             # indicates that self._testcase_root contains changes that haven't been
             # yielded (if iteration ends, changes would be lost)
             testcase_root_dirty = False
@@ -132,7 +116,6 @@ def __iter__(self):
                 # reset
                 self._current_feedback = None
                 self._current_served = None
-                self._current_remain = n_testcases - idx + int(testcase_root_dirty)
             if testcase_root_dirty:
                 # purging unserved files enabled us to exit early from the loop.
                 # need to yield once more to set this trimmed version to the current

From 5f43698e45ce48643e761bcafe1563f29e8139f0 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 9 Nov 2020 15:56:05 -0500
Subject: [PATCH 100/531] [reducer] Fix lithium requirement.

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 322838c6..5760a0e2 100755
--- a/setup.py
+++ b/setup.py
@@ -10,7 +10,7 @@
 
 
 EXTRAS = {
-    'reduce': ['cssbeautifier', 'lithium-reducer>=0.4.4', 'jsbeautifier'],
+    'reduce': ['cssbeautifier', 'lithium-reducer>=0.4.3', 'jsbeautifier'],
     's3': ['boto3'],
 }
 EXTRAS['all'] = list(set(chain.from_iterable(EXTRAS.values())))

From cabc7539136a4812527f1b5ae78cbe281776ed7a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 9 Nov 2020 14:04:29 -0800
Subject: [PATCH 101/531] Update exit codes

---
 grizzly/main.py             |  5 +++--
 grizzly/replay/replay.py    | 14 ++++++++------
 grizzly/replay/test_main.py | 25 +++++++++++++------------
 grizzly/session.py          |  5 ++++-
 grizzly/test_main.py        | 19 ++++++-------------
 5 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/grizzly/main.py b/grizzly/main.py
index 32abd73c..ef7f7257 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -61,8 +61,9 @@ def main(args):
         adapter = get_adapter(args.adapter)()
 
         if adapter.TEST_DURATION >= args.timeout:
-            raise RuntimeError("Test duration (%ds) should be less than browser timeout (%ds)" % (
-                adapter.TEST_DURATION, args.timeout))
+            log.error("Test duration (%ds) must be less than --timeout (%ds)",
+                      adapter.TEST_DURATION, args.timeout)
+            return Session.EXIT_ARGS
 
         if adapter.RELAUNCH > 0:
             log.debug("relaunch (%d) set in Adapter", adapter.RELAUNCH)
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index dc0e2e3c..483eb9a5 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -18,6 +18,7 @@
 from ..common.storage import TestCase, TestCaseLoadFailure, TestFile
 from ..common.utils import grz_tmp
 from ..main import configure_logging
+from ..session import Session
 from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
 
 __author__ = "Tyson Smith"
@@ -362,14 +363,15 @@ def main(cls, args):
                 try:
                     selected = testcases.pop(args.test_index)
                 except IndexError:
-                    raise TestCaseLoadFailure("Invalid '--test-index'") from None
+                    LOG.error("Invalid '--test-index'")
+                    return Session.EXIT_ARGS
                 finally:
                     for test in testcases:
                         test.cleanup()
                 testcases = [selected]
         except TestCaseLoadFailure as exc:
             LOG.error("Error: %s", str(exc))
-            return 1
+            return Session.EXIT_ERROR
 
         results = None
         target = None
@@ -379,7 +381,7 @@ def main(cls, args):
                 LOG.error(
                     "'--no-harness' cannot be used with multiple testcases. " \
                     "Perhaps '--test-index' can help.")
-                return 1
+                return Session.EXIT_ARGS
             repeat = max(args.min_crashes, args.repeat)
             relaunch = min(args.relaunch, repeat)
             LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
@@ -443,10 +445,10 @@ def main(cls, args):
                     results,
                     testcases if args.include_test else None)
             # TODO: add fuzzmanager reporting
-            return 0 if success else 1
+            return Session.EXIT_SUCCESS if success else Session.EXIT_FAILURE
 
         except KeyboardInterrupt:
-            return 1
+            return Session.EXIT_ABORT
 
         except (TargetLaunchError, TargetLaunchTimeout) as exc:
             LOG.error(str(exc))
@@ -455,7 +457,7 @@ def main(cls, args):
                 LOG.error("Logs can be found here %r", path)
                 reporter = FilesystemReporter(path, major_bucket=False)
                 reporter.submit([], exc.report)
-            return 1
+            return Session.EXIT_LAUNCH_FAILURE
 
         finally:
             LOG.warning("Shutting down...")
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 960e0a3a..abccf27f 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -14,6 +14,7 @@
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from ..replay import ReplayManager
 from ..replay.args import ReplayArgs
+from ..session import Session
 
 from .test_replay import _fake_save_logs
 
@@ -106,7 +107,7 @@ def test_main_01(mocker, tmp_path):
         test_index=None,
         timeout=10,
         valgrind=False)
-    assert ReplayManager.main(args) == 0
+    assert ReplayManager.main(args) == Session.EXIT_SUCCESS
     assert target.forced_close
     assert target.reverse.call_count == 1
     assert target.launch.call_count == 3
@@ -144,31 +145,31 @@ def test_main_02(mocker):
     # coverage
     args.rr = True
     args.valgrind = False
-    assert ReplayManager.main(args) == 1
+    assert ReplayManager.main(args) == Session.EXIT_ABORT
     fake_load_target.reset_mock()
     # invalid test case
     fake_tc.load.side_effect = TestCaseLoadFailure
     # coverage
     args.rr = False
     args.valgrind = True
-    assert ReplayManager.main(args) == 1
+    assert ReplayManager.main(args) == Session.EXIT_ERROR
     assert fake_load_target.call_count == 0
     # no test cases
     args.valgrind = False
     fake_tc.load.side_effect = None
     fake_tc.load.return_value = list()
-    assert ReplayManager.main(args) == 1
+    assert ReplayManager.main(args) == Session.EXIT_ERROR
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
     # multiple test cases with --no-harness
     fake_tc.load.return_value = [mocker.Mock(), mocker.Mock()]
-    assert ReplayManager.main(args) == 1
+    assert ReplayManager.main(args) == Session.EXIT_ARGS
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
     # multiple test cases with invalid --test-index
     args.test_index = 100
     fake_tc.load.return_value = [mocker.Mock(), mocker.Mock()]
-    assert ReplayManager.main(args) == 1
+    assert ReplayManager.main(args) == Session.EXIT_ARGS
     assert fake_load_target.call_count == 0
 
 def test_main_03(mocker, tmp_path):
@@ -198,12 +199,12 @@ def test_main_03(mocker, tmp_path):
     fake_logs.mkdir()
     report = mocker.Mock(spec=Report, prefix="fake_report", path=str(fake_logs))
     mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchError("", report))
-    assert ReplayManager.main(args) == 1
+    assert ReplayManager.main(args) == Session.EXIT_LAUNCH_FAILURE
     assert not fake_logs.is_dir()
     assert any(fake_tmp.glob("fake_report_logs"))
     # target launch timeout
     mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchTimeout)
-    assert ReplayManager.main(args) == 1
+    assert ReplayManager.main(args) == Session.EXIT_LAUNCH_FAILURE
 
 def test_main_04(mocker):
     """test ReplayManager.main() loading GRZ_FORCED_CLOSE from selected test case"""
@@ -233,7 +234,7 @@ def test_main_04(mocker):
         sig=None,
         test_index=0,
         timeout=1)
-    ReplayManager.main(args)
+    assert ReplayManager.main(args) == Session.EXIT_FAILURE
     assert test0.cleanup.call_count == 1
     assert test0.dump.call_count == 1
     assert test1.cleanup.call_count == 1
@@ -279,7 +280,7 @@ def test_main_05(mocker, tmp_path):
 
     # test no specified prefs.js
     args.prefs = None
-    assert ReplayManager.main(args) == 0
+    assert ReplayManager.main(args) == Session.EXIT_SUCCESS
     assert target.launch.call_count == 1
     assert target.detect_failure.call_count == 1
     assert serve_path.call_count == 1
@@ -292,7 +293,7 @@ def test_main_05(mocker, tmp_path):
 
     # test included prefs.js
     (input_path / "prefs.js").write_bytes(b"included")
-    assert ReplayManager.main(args) == 0
+    assert ReplayManager.main(args) == Session.EXIT_SUCCESS
     assert target.launch.call_count == 1
     assert target.detect_failure.call_count == 1
     assert serve_path.call_count == 1
@@ -307,7 +308,7 @@ def test_main_05(mocker, tmp_path):
     # test specified prefs.js
     (tmp_path / "prefs.js").write_bytes(b"specified")
     args.prefs = str(tmp_path / "prefs.js")
-    assert ReplayManager.main(args) == 0
+    assert ReplayManager.main(args) == Session.EXIT_SUCCESS
     assert target.launch.call_count == 1
     assert target.detect_failure.call_count == 1
     assert serve_path.call_count == 1
diff --git a/grizzly/session.py b/grizzly/session.py
index da0ef748..b7926a2b 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -58,8 +58,11 @@ class Session(object):
     DISPLAY_NORMAL = 1  # quickly reduce the amount of output
     EXIT_SUCCESS = 0
     EXIT_ERROR = 1
+    EXIT_ARGS = 2
     EXIT_ABORT = 3
-    EXIT_LAUNCH_FAILURE = 7
+    EXIT_LAUNCH_FAILURE = 4
+    EXIT_FAILURE = 5
+
     TARGET_LOG_SIZE_WARN = 0x1900000  # display warning when target log files exceed limit (25MB)
 
     __slots__ = ("adapter", "coverage", "iomanager", "reporter", "server", "status", "target")
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 1ee28d42..9508abc5 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -77,19 +77,7 @@ def test_main_01(mocker):
     args.s3_fuzzmanager = True
     assert main(args) == Session.EXIT_SUCCESS
 
-def test_main_02(mocker):
-    """test main()"""
-    fake_adapter = mocker.Mock(spec=Adapter)
-    mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
-    fake_session = mocker.patch("grizzly.main.Session", autospec=True)
-    fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
-    args = FakeArgs()
-    args.adapter = "fake"
-    fake_adapter.TEST_DURATION = args.timeout + 10
-    with raises(RuntimeError, match=r"Test duration \([0-9]+s\) should be less than browser timeout \([0-9]+s\)"):
-        main(args)
-
-def test_main_03(mocker, tmp_path):
+def test_main_02(mocker, tmp_path):
     """test main() exit codes"""
     fake_adapter = mocker.Mock(spec=Adapter)
     fake_adapter.TEST_DURATION = 10
@@ -100,6 +88,7 @@ def test_main_03(mocker, tmp_path):
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     fake_session.EXIT_ABORT = Session.EXIT_ABORT
+    fake_session.EXIT_ARGS = Session.EXIT_ARGS
     fake_session.EXIT_LAUNCH_FAILURE = Session.EXIT_LAUNCH_FAILURE
     fake_session.return_value.server = mocker.Mock(spec=Sapphire)
     args = FakeArgs()
@@ -118,3 +107,7 @@ def test_main_03(mocker, tmp_path):
     assert main(args) == Session.EXIT_LAUNCH_FAILURE
     assert any(fake_tmp.glob("fake_report_logs"))
     assert not fake_logs.is_dir()
+    # invalid timeout arg
+    fake_adapter.TEST_DURATION = args.timeout + 10
+    assert main(args) == Session.EXIT_ARGS
+    fake_session.EXIT_ARGS = Session.EXIT_ARGS

From b3788a6317e226ab844df51c1e6f0161dd0e6fd6 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 9 Nov 2020 18:12:21 -0500
Subject: [PATCH 102/531] [reducer] Switch to using Session.EXIT_* exit codes.

---
 grizzly/reduce/args.py       | 17 -----------------
 grizzly/reduce/core.py       | 25 +++++++++++++++----------
 grizzly/reduce/exceptions.py |  6 +++---
 grizzly/reduce/test_main.py  | 14 +++++++-------
 4 files changed, 25 insertions(+), 37 deletions(-)

diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 40146f4d..fb7d1d75 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -4,13 +4,9 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """CLI argument parsing for Grizzly reduction.
 """
-from argparse import ArgumentParser
 from logging import getLogger
 from pathlib import Path
-import sys
 
-from ..args import SortingHelpFormatter
-from ..common.reporter import FuzzManagerReporter
 from ..replay.args import ReplayArgs
 from .strategies import DEFAULT_STRATEGIES, STRATEGIES
 
@@ -18,16 +14,6 @@
 LOG = getLogger(__name__)
 
 
-class _ArgparserExitReducerError(ArgumentParser):
-    def exit(self, status=0, message=None):
-        if message is not None:
-            print(message, file=sys.stderr)
-        if status != 0:
-            LOG.debug("overriding original argparse exit code (%d)", status)
-            status = FuzzManagerReporter.QUAL_REDUCER_ERROR
-        sys.exit(status)
-
-
 class ReduceArgs(ReplayArgs):
     """Argument parser for `grizzly.reduce`.
 
@@ -37,9 +23,6 @@ class ReduceArgs(ReplayArgs):
     def __init__(self):
         """Initialize argument parser.
         """
-        self.parser = _ArgparserExitReducerError(
-                formatter_class=SortingHelpFormatter,
-                conflict_handler="resolve")
         super().__init__()
 
         # these arguments have other defaults vs how they are defined in ReplayArgs
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 2f562254..243ab444 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -2,8 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-"""`ReduceManager` finds the smallest testcase(s) to reproduce an issue.
-"""
+"""`ReduceManager` finds the smallest testcase(s) to reproduce an issue."""
 from itertools import chain
 import json
 from locale import LC_ALL, setlocale
@@ -24,6 +23,7 @@
 from ..common.utils import grz_tmp
 from ..main import configure_logging
 from ..replay import ReplayManager, ReplayResult
+from ..session import Session
 from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
 from .exceptions import GrizzlyReduceBaseException, NotReproducible
 from .stats import ReductionStats
@@ -369,7 +369,7 @@ def run(self, repeat=1, min_results=1):
                                be considered successful.
 
         Returns:
-            int: One of the `FuzzManagerReporter.QUAL_*` constants.
+            int: One of the `Session.EXIT_*` constants.
         """
         any_success = False
         sig_given = self._signature is not None
@@ -547,8 +547,8 @@ def run(self, repeat=1, min_results=1):
                  os.linesep.join(self._stats.format_lines()))
 
         if any_success:
-            return FuzzManagerReporter.QUAL_REDUCED_RESULT
-        return FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE
+            return Session.EXIT_SUCCESS
+        return Session.EXIT_FAILURE
 
     def report(self, results, testcases, stats=None):
         """Report results, either to FuzzManager or to filesystem.
@@ -641,7 +641,7 @@ def main(cls, args):
                     raise TestCaseLoadFailure("Failed to load TestCases")
             except TestCaseLoadFailure as exc:
                 LOG.error("Error: %s", str(exc))
-                return FuzzManagerReporter.QUAL_NO_TESTCASE
+                return Session.EXIT_ERROR
 
             if args.tool is None and testcases[0].adapter_name is not None:
                 LOG.warning("Setting default --tool=grizzly-%s from testcase",
@@ -659,7 +659,7 @@ def main(cls, args):
                     selected = testcases.pop(args.test_index)
                 except IndexError:
                     LOG.error("Error: Invalid '--test-index'")
-                    return FuzzManagerReporter.QUAL_NO_TESTCASE
+                    return Session.EXIT_ERROR
                 for test in testcases:
                     test.cleanup()
                 testcases = [selected]
@@ -725,8 +725,13 @@ def main(cls, args):
                 return_code = mgr.run(repeat=args.repeat, min_results=args.min_crashes)
             return return_code
 
-        except (KeyboardInterrupt, TargetLaunchError, TargetLaunchTimeout):
-            return FuzzManagerReporter.QUAL_REDUCER_ERROR
+        except KeyboardInterrupt as exc:
+            LOG.error("Exception: %r", exc)
+            return Session.EXIT_ABORT
+
+        except (TargetLaunchError, TargetLaunchTimeout) as exc:
+            LOG.error("Exception: %s", exc)
+            return Session.EXIT_LAUNCH_FAILURE
 
         except GrizzlyReduceBaseException as exc:
             LOG.error(exc.msg)
@@ -734,7 +739,7 @@ def main(cls, args):
 
         except Exception:  # noqa pylint: disable=broad-except
             LOG.exception("Exception during reduction!")
-            return FuzzManagerReporter.QUAL_REDUCER_ERROR
+            return Session.EXIT_ERROR
 
         finally:
             LOG.warning("Shutting down...")
diff --git a/grizzly/reduce/exceptions.py b/grizzly/reduce/exceptions.py
index b69fc08c..5a9b1d0f 100644
--- a/grizzly/reduce/exceptions.py
+++ b/grizzly/reduce/exceptions.py
@@ -3,12 +3,12 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Grizzly Reduction exceptions."""
-from ..common.reporter import FuzzManagerReporter
+from ..session import Session
 
 
 class GrizzlyReduceBaseException(Exception):
     """Base for other Grizzly Reducer specific exceptions."""
-    def __init__(self, msg, code=FuzzManagerReporter.QUAL_REDUCER_ERROR):
+    def __init__(self, msg, code=Session.EXIT_ERROR):
         super().__init__()
         self.msg = msg
         self.code = code
@@ -17,4 +17,4 @@ def __init__(self, msg, code=FuzzManagerReporter.QUAL_REDUCER_ERROR):
 class NotReproducible(GrizzlyReduceBaseException):
     """Crash was not observed when expected during reduction."""
     def __init__(self, msg):
-        super().__init__(msg, code=FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE)
+        super().__init__(msg, code=Session.EXIT_FAILURE)
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 5b2dd810..2c2ccf97 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -73,19 +73,19 @@ def test_args_02(tmp_path):
     [
         (
             "grizzly.reduce.core.ReduceManager.run",
-            TargetLaunchError("error", None), None, {}, 9
+            TargetLaunchError("error", None), None, {}, 1
         ),
-        ("grizzly.reduce.core.ReduceManager.run", TargetLaunchTimeout, None, {}, 9),
-        ("grizzly.reduce.core.load_target", KeyboardInterrupt, None, {}, 9),
+        ("grizzly.reduce.core.ReduceManager.run", TargetLaunchTimeout, None, {}, 1),
+        ("grizzly.reduce.core.load_target", KeyboardInterrupt, None, {}, 1),
         (
             "grizzly.reduce.core.load_target",
-            GrizzlyReduceBaseException(""), None, {}, 9
+            GrizzlyReduceBaseException(""), None, {}, 1
         ),
-        ("grizzly.reduce.core.TestCase.load", TestCaseLoadFailure, None, {}, 7),
-        ("grizzly.reduce.core.TestCase.load", None, [], {}, 7),
+        ("grizzly.reduce.core.TestCase.load", TestCaseLoadFailure, None, {}, 1),
+        ("grizzly.reduce.core.TestCase.load", None, [], {}, 1),
         (
             "grizzly.reduce.core.TestCase.load", None, [Mock(), Mock()],
-            {"test_index": 100}, 7
+            {"test_index": 100}, 1
         ),
     ]
 )

From c199aab528a760ad2d26832f6fec21c3dcf8e719 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 9 Nov 2020 18:12:44 -0500
Subject: [PATCH 103/531] Remove unused ReducerStats

---
 grizzly/common/__init__.py             |  4 +-
 grizzly/common/status.py               | 47 +--------------
 grizzly/common/status_reporter.py      | 53 ++++------------
 grizzly/common/test_status.py          | 76 +----------------------
 grizzly/common/test_status_reporter.py | 83 +-------------------------
 5 files changed, 18 insertions(+), 245 deletions(-)

diff --git a/grizzly/common/__init__.py b/grizzly/common/__init__.py
index c95dee8a..74bf84ce 100644
--- a/grizzly/common/__init__.py
+++ b/grizzly/common/__init__.py
@@ -7,14 +7,14 @@
 from .iomanager import IOManager, ServerMap
 from .reporter import FilesystemReporter, FuzzManagerReporter, Report, Reporter, S3FuzzManagerReporter
 from .runner import Runner, RunResult
-from .status import ReducerStats, Status
+from .status import Status
 from .storage import TestCaseLoadFailure, TestCase, TestFile, TestFileExists
 from .utils import grz_tmp
 
 
 __all__ = (
     "Adapter", "AdapterError", "FilesystemReporter", "FuzzManagerReporter", "grz_tmp", "IOManager",
-    "ReducerStats", "Report", "Reporter", "Runner", "RunResult", "S3FuzzManagerReporter",
+    "Report", "Reporter", "Runner", "RunResult", "S3FuzzManagerReporter",
     "ServerMap", "Status", "TestCase", "TestCaseLoadFailure", "TestFile", "TestFileExists")
 __author__ = "Jesse Schwartzentruber"
 __credits__ = ["Jesse Schwartzentruber", "Tyson Smith"]
diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 8b77e1b2..0ebf6a0b 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -15,7 +15,7 @@
 
 from .utils import grz_tmp
 
-__all__ = ("ReducerStats", "Status")
+__all__ = ("Status",)
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
@@ -224,48 +224,3 @@ def start(cls):
         status = cls(filepath, start_time=time())
         status.report(force=True)
         return status
-
-
-class ReducerStats(object):
-    """ReducerStats holds stats for the Grizzly reducer.
-    """
-    FILE = "reducer-stats.json"
-    PATH = grz_tmp("status")
-
-    __slots__ = ("_file", "_lock", "error", "failed", "passed")
-
-    def __init__(self):
-        self._file = pathjoin(self.PATH, self.FILE)
-        self._lock = None
-        self.error = 0
-        self.failed = 0
-        self.passed = 0
-
-    def __enter__(self):
-        self._lock = InterProcessLock("%s.lock" % (self._file,))
-        self._lock.acquire()
-        try:
-            with open(self._file, "r") as in_fp:
-                data = load(in_fp)
-            self.error = data["error"]
-            self.failed = data["failed"]
-            self.passed = data["passed"]
-        except KeyError:
-            LOG.debug("invalid status data in %r", self._file)
-        except OSError:
-            LOG.debug("%r does not exist", self._file)
-        except ValueError:
-            LOG.debug("failed to load stats from %r", self._file)
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        try:
-            with open(self._file, "w") as out_fp:
-                dump({
-                    "error": self.error,
-                    "failed": self.failed,
-                    "passed": self.passed}, out_fp)
-        finally:
-            if self._lock:
-                self._lock.release()
-                self._lock = None
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index dba784aa..7d4b1403 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -16,7 +16,7 @@
 
 import psutil
 
-from .status import ReducerStats, Status
+from .status import Status
 
 __all__ = ("StatusReporter",)
 __author__ = "Tyson Smith"
@@ -32,8 +32,7 @@ class StatusReporter(object):
     READ_BUF_SIZE = 0x10000  # 64KB
     SUMMARY_LIMIT = 4095  # summary output must be no more than 4KB
 
-    def __init__(self, reports, reducer=False, tracebacks=None):
-        self._reducer = reducer
+    def __init__(self, reports, tracebacks=None):
         self.reports = reports
         self.tracebacks = tracebacks
 
@@ -65,7 +64,7 @@ def dump_summary(self, filename, runtime=False, sysinfo=True, timestamp=True):
             ofp.write(self._summary(runtime=runtime, sysinfo=sysinfo, timestamp=timestamp))
 
     @classmethod
-    def load(cls, reducer=False, tb_path=None):
+    def load(cls, tb_path=None):
         """Read Grizzly status reports and create a StatusReporter object
 
         Args:
@@ -77,7 +76,7 @@ def load(cls, reducer=False, tb_path=None):
         if tb_path is not None and not os.path.isdir(tb_path):
             raise OSError("%r is not a directory" % (tb_path,))
         tracebacks = None if tb_path is None else cls._tracebacks(tb_path)
-        return cls(list(Status.loadall()), reducer=reducer, tracebacks=tracebacks)
+        return cls(list(Status.loadall()), tracebacks=tracebacks)
 
     def print_specific(self):
         print(self._specific())
@@ -120,9 +119,8 @@ def _specific(self):
             txt.append(" Runtime %s\n" % str(timedelta(seconds=int(report.duration))))
             txt.append(" * Iterations: %03d" % report.iteration)
             txt.append(" - Rate: %0.2f" % report.rate)
-            if not self._reducer:
-                txt.append(" - Ignored: %02d" % report.ignored)
-                txt.append(" - Results: %d" % report.results)
+            txt.append(" - Ignored: %02d" % report.ignored)
+            txt.append(" - Results: %d" % report.results)
             txt.append("\n")
         return "".join(txt)
 
@@ -139,20 +137,6 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
             str: A summary of merged reports
         """
         txt = list()
-        if self._reducer:
-            # reducer stats
-            with ReducerStats() as stats:
-                r_error = stats.error
-                r_failed = stats.failed
-                r_passed = stats.passed
-            txt.append("======== Stats ========\n")
-            # Reduced successfully
-            txt.append("   Reduced : %d\n" % (r_passed,))
-            # Failed to reproduce
-            txt.append("  No Repro : %d\n" % (r_failed,))
-            # Error during reduction
-            txt.append("    Errors : %d\n" % (r_error,))
-            txt.append("======= Active ========\n")
         # Job specific status
         exp = int(time.time()) - self.EXP_LIMIT
         reports = tuple(x for x in self.reports if x.timestamp > exp)
@@ -176,27 +160,15 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
                 txt.append(" (%0.2f, %0.2f)" % (max(rates), min(rates)))
             txt.append("\n")
             # Results / Signature mismatch
-            if self._reducer:
-                txt.append("  Mismatch : %d" % (sum(results),))
-            else:
-                txt.append("   Results : %d" % (sum(results),))
+            txt.append("   Results : %d" % (sum(results),))
             if total_ignored:
                 ignore_pct = (total_ignored / float(total_iters)) * 100
                 txt.append(" (%d ignored @ %0.2f%%)" % (total_ignored, ignore_pct))
             # Runtime
             if runtime:
                 txt.append("\n")
-                if self._reducer:
-                    durations = tuple(x.duration for x in reports)
-                    if count > 1:
-                        max_duration = str(timedelta(seconds=int(max(durations))))
-                        min_duration = str(timedelta(seconds=int(min(durations))))
-                        txt.append("   Runtime : (%s, %s)" % (max_duration, min_duration))
-                    else:
-                        txt.append("   Runtime : %s" % (str(timedelta(seconds=int(durations[0]))),))
-                else:
-                    total_runtime = sum(x.duration for x in reports)
-                    txt.append("   Runtime : %s" % (str(timedelta(seconds=int(total_runtime))),))
+                total_runtime = sum(x.duration for x in reports)
+                txt.append("   Runtime : %s" % (str(timedelta(seconds=int(total_runtime))),))
             # Log size
             log_usage = sum(log_sizes) / 1048576.0
             if log_usage > self.DISPLAY_LIMIT_LOG:
@@ -410,7 +382,7 @@ def main(args=None):
         log_fmt = "%(levelname).1s %(name)s [%(asctime)s] %(message)s"
     logging.basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
 
-    modes = ("reduce-status", "status")
+    modes = ("status",)
     parser = argparse.ArgumentParser(description="Grizzly status report generator")
     parser.add_argument(
         "--dump",
@@ -428,10 +400,9 @@ def main(args=None):
 
     if args.mode not in modes:
         parser.error("Invalid mode %r" % args.mode)
-    reducer_mode = args.mode == "reduce-status"
-    reporter = StatusReporter.load(tb_path=args.tracebacks, reducer=reducer_mode)
+    reporter = StatusReporter.load(tb_path=args.tracebacks)
     if args.dump:
-        reporter.dump_summary(args.dump, runtime=reducer_mode)
+        reporter.dump_summary(args.dump)
         return 0
     if not reporter.reports:
         print("No status reports to display")
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 5a259726..53113015 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -10,7 +10,7 @@
 from os.path import isfile
 from time import sleep, time
 
-from .status import ReducerStats, Status
+from .status import Status
 
 
 def test_status_01(tmp_path):
@@ -172,77 +172,3 @@ def test_status_08(tmp_path):
                 proc.join()
     # verify cleanup
     assert not any(Status.loadall())
-
-def test_reducer_stats_01(tmp_path):
-    """test ReducerStats() empty"""
-    ReducerStats.PATH = str(tmp_path)
-    with ReducerStats() as stats:
-        assert stats.error == 0
-        assert stats.failed == 0
-        assert stats.passed == 0
-        stats_file = stats._file
-        assert not isfile(stats_file)
-    assert isfile(stats_file)
-
-def test_reducer_stats_02(tmp_path):
-    """test ReducerStats() simple"""
-    ReducerStats.PATH = str(tmp_path)
-    with ReducerStats() as stats:
-        stats.error += 1
-        stats.failed += 1
-        stats.passed += 1
-    with ReducerStats() as stats:
-        assert stats.error == 1
-        assert stats.failed == 1
-        assert stats.passed == 1
-
-def test_reducer_stats_03(tmp_path):
-    """test ReducerStats() empty/incomplete/invalid data file"""
-    ReducerStats.PATH = str(tmp_path)
-    stats_file = tmp_path / ReducerStats.FILE
-    # missing file
-    with ReducerStats() as stats:
-        stats.passed += 1
-    # invalid empty file
-    stats_file.write_bytes(b"")
-    with ReducerStats() as stats:
-        assert stats.passed == 0
-    # incomplete file
-    stats_file.write_bytes(b"{}")
-    with ReducerStats() as stats:
-        assert stats.passed == 0
-
-def _reducer_client(working_path, reported, unrestrict):
-    """Used by test_reducer_stats_04"""
-    # NOTE: this must be at the top level to work on Windows
-    ReducerStats.PATH = working_path
-    for _ in range(20):
-        with ReducerStats() as stats:
-            stats.passed += 1
-        if not reported.is_set():
-            reported.set()
-            unrestrict.wait(timeout=60)
-
-def test_reducer_stats_04(tmp_path):
-    """test ReducerStats() with multiple processes"""
-    ReducerStats.PATH = str(tmp_path)
-    report_events = list()
-    procs = list()
-    unrestrict = Event()  # used to sync client procs
-    try:
-        # launch processes
-        for _ in range(5):
-            report_events.append(Event())
-            procs.append(Process(
-                target=_reducer_client, args=(ReducerStats.PATH, report_events[-1], unrestrict)))
-            procs[-1].start()
-        # wait for processes to report
-        for has_reported in report_events:
-            assert has_reported.wait(timeout=60)
-    finally:
-        unrestrict.set()
-        for proc in procs:
-            if proc.pid is not None:
-                proc.join()
-    with ReducerStats() as stats:
-        assert stats.passed == 100
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 39a514c5..a3532965 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -9,7 +9,7 @@
 
 import pytest
 
-from .status_reporter import main, ReducerStats, Status, StatusReporter, TracebackReport
+from .status_reporter import main, Status, StatusReporter, TracebackReport
 
 def _fake_sys_info():
     return "CPU & Load : 64 @ 93.1% (85.25, 76.21, 51.06)\n" \
@@ -265,71 +265,6 @@ def test_status_reporter_09(tmp_path):
     merged_log = rptr._summary(runtime=True, sysinfo=True, timestamp=True)
     assert len(merged_log) < StatusReporter.SUMMARY_LIMIT
 
-def test_reduce_status_reporter_01(tmp_path):
-    """test empty StatusReporter in reducer mode"""
-    Status.PATH = str(tmp_path)
-    ReducerStats.PATH = Status.PATH
-    rptr = StatusReporter.load(reducer=True)
-    assert rptr is not None
-    assert not rptr.reports
-    output = rptr._specific()
-    assert "No status reports available" in output
-    output = rptr._summary()
-    assert "No status reports available" in output
-
-def test_reduce_status_reporter_02(tmp_path):
-    """test StatusReporter._specific() in reducer mode"""
-    Status.PATH = str(tmp_path)
-    ReducerStats.PATH = Status.PATH
-    status = Status.start()
-    status.ignored = 12
-    status.iteration = 432422
-    status._results = {"sig": 123}
-    status.report(force=True)
-    rptr = StatusReporter.load(reducer=True)
-    assert rptr.reports
-    output = rptr._specific()
-    assert len(output.split("\n")[:-1]) == 2
-    assert "Iteration" in output
-    assert "Rate" in output
-    assert "Ignored" not in output
-    assert "Results" not in output
-
-def test_reduce_status_reporter_03(tmp_path):
-    """test StatusReporter._summary() in reducer mode"""
-    Status.PATH = str(tmp_path)
-    ReducerStats.PATH = Status.PATH
-    status = Status.start()
-    status.iteration = 1
-    status.report(force=True)
-    status = Status.start()
-    status.iteration = 10
-    status.report(force=True)
-    rptr = StatusReporter.load(reducer=True)
-    rptr._sys_info = _fake_sys_info
-    assert rptr.reports is not None
-    output = rptr._summary(sysinfo=True, timestamp=True)
-    assert "======== Stats ========" in output
-    assert "======= Active ========" in output
-    assert "Reduced" in output
-    assert "No Repro" in output
-    assert "Iteration" in output
-    assert "Results" not in output
-    assert "Mismatch" in output
-    assert "Rate" in output
-    assert "Runtime" in output
-    assert "ignored" not in output
-    assert "Timestamp" in output
-    lines = output.split("\n")
-    assert len(lines) == 13
-    # verify alignment
-    position = len(lines[1].split(":")[0])
-    for line in lines:
-        if line.startswith("="):
-            # skip headers
-            continue
-        assert re.match(r"\S\s:\s\S", line[position - 2:])
-
 def test_traceback_report_01():
     """test simple TracebackReport"""
     tbr = TracebackReport("log.txt", ["0", "1", "2"], prev_lines=["-2", "-1"])
@@ -520,22 +455,8 @@ def test_main_03(tmp_path):
     assert dump_file.is_file()
     assert b"Runtime" not in dump_file.read_bytes()
     #assert False, dump_file.read_bytes()
-    dump_file.unlink()
-    dump_file = tmp_path / "output.txt"
-    assert main(["--dump", str(dump_file), "--mode", "reduce-status"]) == 0
-    assert dump_file.is_file()
-    assert b"Runtime" in dump_file.read_bytes()
-
-def test_main_04(tmp_path):
-    """test main() with --mode reduce-status"""
-    Status.PATH = str(tmp_path)
-    StatusReporter.CPU_POLL_INTERVAL = 0.01
-    status = Status.start()
-    status.iteration = 1
-    status.report(force=True)
-    assert main(["--mode", "reduce-status"]) == 0
 
-def test_main_05():
+def test_main_04():
     """test main() with invalid mode"""
     with pytest.raises(SystemExit):
         main(["--mode", "invalid"])

From a64d2e80883df9fb6e8d1c354c6f6b52f012b744 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 11 Nov 2020 11:51:31 -0500
Subject: [PATCH 104/531] [reducer] Ensure reduced result gets marked Q0 even
 if final strategy has no effect.

---
 grizzly/reduce/core.py        |  9 +++++----
 grizzly/reduce/test_reduce.py | 21 +++++++++++++--------
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 243ab444..7e98a03f 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -414,7 +414,6 @@ def run(self, repeat=1, min_results=1):
                 strategy_last_report = time()
                 strategy_stats = total_stats.add_timed(strategy.name)
                 best_results = []
-                best_reported = False
                 try:
                     with replay, strategy, strategy_stats:
                         for reduction in strategy:
@@ -470,7 +469,6 @@ def run(self, repeat=1, min_results=1):
                                                     if result.expected]
                                     results = [result for result in results
                                                if not result.expected]
-                                    best_reported = False
                                 else:
                                     LOG.info("Attempt failed")
                                 # if the reduction found other crashes,
@@ -481,11 +479,14 @@ def run(self, repeat=1, min_results=1):
 
                                 now = time()
                                 if self._report_periodically and \
+                                        best_results and \
                                         now - strategy_last_report > self._report_periodically:
                                     last_reports = self.report(
                                         best_results, self.testcases,
                                         self._stats.copy(strategy_stats))
-                                    best_reported = True
+                                    for result in best_results:
+                                        result.report.cleanup()
+                                    best_results = []
                                     strategy_last_report = now
                                     LOG.info("Best results reported (periodic)")
 
@@ -508,7 +509,7 @@ def run(self, repeat=1, min_results=1):
                         # otherwise, ensure the first found signature is used throughout
                         self._signature = replay.signature
 
-                    if not best_reported:
+                    if best_results:
                         last_reports = self.report(
                             best_results, self.testcases,
                             self._stats.copy(total_stats))
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 7fcf8bb1..08d24eee 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -673,15 +673,20 @@ def test_quality_update(mocker, tmp_path):
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(_, **_kw):
-        log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
-        log_path.mkdir()
-        _fake_save_logs_foo(log_path)
-        report = Report(str(log_path), "bin")
-        return [ReplayResult(report, [["test.html"]], [], True)]
+    def replay_run(testcases, **_kw):
+        for test in testcases:
+            contents = test.get_file("test.html").data.decode("ascii")
+            if not contents.strip():
+                continue
+            log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
+            log_path.mkdir()
+            _fake_save_logs_foo(log_path)
+            report = Report(str(log_path), "bin")
+            return [ReplayResult(report, [["test.html"]], [], True)]
+        return []
     replayer.run.side_effect = replay_run
 
-    (tmp_path / "test.html").touch()
+    (tmp_path / "test.html").write_text("123\n")
     testcases = TestCase.load(str(tmp_path / "test.html"), False)
     assert testcases
     log_path = tmp_path / "logs"
@@ -694,7 +699,7 @@ def replay_run(_, **_kw):
     target.relaunch = 1
     try:
         mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target,
-                            testcases, ["check"], log_path, use_analysis=False,
+                            testcases, ["check", "lines"], log_path, use_analysis=False,
                             report_to_fuzzmanager=True)
         assert mgr.run() == 0
     finally:

From 3e9e92d030bbdd21dd7955fdb297871afc3661f9 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 11 Nov 2020 11:35:57 -0500
Subject: [PATCH 105/531] [reducer] Add back grizzly.reduce.crash &
 grizzly.reduce.bucket

---
 grizzly/reduce/args.py   |  49 ++++++-
 grizzly/reduce/bucket.py |  56 ++++++++
 grizzly/reduce/core.py   |   2 +-
 grizzly/reduce/crash.py  | 269 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 373 insertions(+), 3 deletions(-)
 create mode 100644 grizzly/reduce/bucket.py
 create mode 100644 grizzly/reduce/crash.py

diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index fb7d1d75..62d74ce1 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -21,8 +21,7 @@ class ReduceArgs(ReplayArgs):
     """
 
     def __init__(self):
-        """Initialize argument parser.
-        """
+        """Initialize argument parser."""
         super().__init__()
 
         # these arguments have other defaults vs how they are defined in ReplayArgs
@@ -87,3 +86,49 @@ def sanity_check(self, args):
                     "%s specified, with analysis enabled, they will be ignored",
                     error_str
                 )
+
+
+class ReduceFuzzManagerIDArgs(ReduceArgs):
+
+    def __init__(self):
+        """Initialize argument parser."""
+        super().__init__()
+
+        # madhax alert!
+        #
+        # We need to modify the meaning of the 'input' positional to accept an int ID instead of a
+        # local testcase. This is not possible with the public argparse API.
+        #
+        # refs: https://stackoverflow.com/questions/32807319/disable-remove-argument-in-argparse
+        #       https://bugs.python.org/issue19462
+
+        # look up the action for the positional `input` arg
+        action = None
+        for arg in self.parser._actions:
+            if arg.dest == "input" and not arg.option_strings:
+                action = arg
+                break
+        assert action is not None
+
+        # modify it's type and help string
+        action.type = int
+        action.help = "FuzzManager ID to reduce"
+
+        # ... and Bob's your uncle
+        self._sanity_skip.add("input")
+
+
+class ReduceFuzzManagerIDQualityArgs(ReduceFuzzManagerIDArgs):
+
+    def __init__(self):
+        """Initialize argument parser."""
+        super().__init__()
+        self.parser.add_argument(
+            "--quality", type=int,
+            help="Only try crashes with a given quality value")
+
+    def sanity_check(self, args):
+        super().sanity_check(args)
+
+        if args.quality is not None and args.quality < 0:
+            self.parser.error("'--quality' value cannot be negative")
diff --git a/grizzly/reduce/bucket.py b/grizzly/reduce/bucket.py
new file mode 100644
index 00000000..55d2e3cd
--- /dev/null
+++ b/grizzly/reduce/bucket.py
@@ -0,0 +1,56 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from logging import getLogger
+import sys
+
+from .args import ReduceFuzzManagerIDQualityArgs
+from .crash import CrashEntry, main as crash_main
+from ..main import configure_logging
+from ..session import Session
+
+
+LOG = getLogger(__name__)
+
+
+def main(args):
+    """CLI for `grizzly.reduce.bucket`.
+
+    Arguments:
+        args (argparse.Namespace): Result from `ReduceArgs.parse_args`.
+
+    Returns:
+        int: 0 for success. non-0 indicates a problem.
+    """
+    configure_logging(args.log_level)
+    LOG.info("Trying all crashes in bucket %d until one reduces", args.input)
+    # ensure --tool is reset for each call to grizzly.reduce.crash.main()
+    orig_tool = args.tool
+
+    # if no crashes in bucket, return success
+    result = Session.EXIT_SUCCESS
+
+    # create a fake CrashEntry used only to download the signature once
+    crash = CrashEntry(0)
+    crash._data = {"bucket": args.input}  # pylint: disable=protected-access
+    try:
+        if args.sig is None:
+            args.sig = str(crash.bucket_path())
+
+        for crash in CrashEntry.iter_bucket(args.input, args.quality):
+            args.input = crash.id
+            args.tool = orig_tool
+
+            # call grizzly.reduce.crash
+            result = crash_main(args)
+            if result == 0:
+                break
+
+    finally:
+        crash.cleanup()
+    return result
+
+
+if __name__ == "__main__":
+    sys.exit(main(ReduceFuzzManagerIDQualityArgs().parse_args()))
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 7e98a03f..d4496de5 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -598,7 +598,7 @@ def report(self, results, testcases, stats=None):
 
     @classmethod
     def main(cls, args):
-        """CLI for `grizzly.replay`.
+        """CLI for `grizzly.reduce`.
 
         Arguments:
             args (argparse.Namespace): Result from `ReduceArgs.parse_args`.
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
new file mode 100644
index 00000000..8cdba271
--- /dev/null
+++ b/grizzly/reduce/crash.py
@@ -0,0 +1,269 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+import json
+from logging import getLogger
+from os import unlink
+from pathlib import Path
+from shutil import rmtree
+import sys
+from tempfile import mkdtemp, mkstemp
+
+from Collector.Collector import Collector
+
+from .args import ReduceFuzzManagerIDArgs
+from .core import ReduceManager
+from ..common.reporter import FuzzManagerReporter
+from ..main import configure_logging
+from ..session import Session
+
+
+LOG = getLogger(__name__)
+
+
+class CrashEntry(object):
+    """Get the CrashEntry data for the specified CrashManager crash.
+
+    Attributes:
+        see crashmanager.serializers.CrashEntrySerializer
+    """
+
+    def __init__(self, crash_id):
+        """Initialize CrashEntry.
+
+        Arguments:
+            crash_id (int): ID of the requested crash on the server side
+        """
+        self._coll = Collector()
+        self._url = "%s://%s:%d/crashmanager/rest/crashes/%d/" % (
+            self._coll.serverProtocol,
+            self._coll.serverHost,
+            self._coll.serverPort,
+            crash_id,
+        )
+        self._data = None
+        self._tc_filename = None
+        self._sig_filename = None
+
+    @classmethod
+    def iter_bucket(cls, bucket_id, quality_filter=None):
+        """Fetch all crash IDs for the specified FuzzManager bucket.
+        Only crashes with testcases are returned.
+
+        Args:
+            bucket_id (int): ID of the requested bucket on the server side
+            quality_filter (int): Filter crashes by quality value (None for all)
+
+        Returns:
+            generator: generator of crash ID (int)
+        """
+        coll = Collector()
+
+        def _get_results(endpoint, params=None):
+            """
+            Function to get paginated results from FuzzManager
+
+            Args:
+                endpoint (str): FuzzManager REST API to query (eg. "crashes").
+                params (dict): Params to pass through to requests.get
+
+            Returns:
+                generator: objects returned by FuzzManager (as dicts)
+            """
+            LOG.debug("first request to /%s/", endpoint)
+
+            url = "%s://%s:%d/crashmanager/rest/%s/" \
+                % (coll.serverProtocol, coll.serverHost, coll.serverPort, endpoint)
+
+            response = coll.get(url, params=params).json()
+
+            while True:
+                LOG.debug("got %d/%d %s", len(response["results"]), response["count"], endpoint)
+                while response["results"]:
+                    yield response["results"].pop()
+
+                if response["next"] is None:
+                    break
+
+                LOG.debug("next request to /%s/", endpoint)
+                response = coll.get(response["next"]).json()
+
+        # Get all crashes for bucket
+        query_args = [
+            ("op", "AND"),
+            ("bucket", bucket_id),
+        ]
+        if quality_filter is not None:
+            query_args.append(("testcase__quality", quality_filter))
+        query = json.dumps(dict(query_args))
+
+        n_yielded = 0
+        for crash in _get_results("crashes", params={"query": query, "include_raw": "0"}):
+
+            if not crash["testcase"]:
+                LOG.warning("crash %d has no testcase, skipping", crash["id"])
+                continue
+
+            n_yielded += 1
+            LOG.debug("yielding crash #%d", n_yielded)
+            result = cls(crash["id"])
+            result._data = crash  # pylint: disable=protected-access
+            yield result
+
+    def __getattr__(self, name):
+        if self._data is None:
+            self._data = self._coll.get(self._url, params={"include_raw": "0"}).json()
+        if name not in self._data:
+            raise AttributeError(
+                "'%s' object has no attribute '%s' (has: %s)"
+                % (type(self).__name__, name, list(self._data))
+            )
+        return self._data[name]
+
+    def __setattr__(self, name, value):
+        if name.startswith("_"):
+            super().__setattr__(name, value)
+            return
+        if name != "testcase_quality":
+            raise AttributeError("can't set attribute")
+        self._coll.patch(self._url, data={name: value})
+        self._data[name] = value
+
+    def cleanup(self):
+        """Cleanup any resources held by this instance.
+
+        Arguments:
+            None
+
+        Returns:
+            None
+        """
+        if self._tc_filename is not None:
+            self._tc_filename.unlink()
+        if self._sig_filename is not None:
+            rmtree(str(self._sig_filename.parent))
+
+    def testcase_path(self):
+        """Download the testcase data from CrashManager.
+
+        Arguments:
+            None
+
+        Returns:
+            Path: Path on disk where testcase exists.
+        """
+        if self._tc_filename is not None:
+            return self._tc_filename
+
+        dlurl = self._url + "download/"
+        response = self._coll.get(dlurl)
+
+        if "content-disposition" not in response.headers:
+            raise RuntimeError("Server sent malformed response: %r" % (response,))
+
+        handle, filename = mkstemp(
+            prefix="grizzly-reduce-%d-" % (self.id,), suffix=Path(self.testcase).suffix
+        )
+        try:
+            with open(handle, "wb") as output:
+                output.write(response.content)
+        except:  # noqa pylint: disable=bare-except
+            unlink(filename)
+            raise
+        self._tc_filename = Path(filename)
+        return self._tc_filename
+
+    def bucket_path(self):
+        """Download the bucket data from CrashManager.
+
+        Arguments:
+            None
+
+        Returns:
+            Path: Path on disk where signature exists.
+        """
+        if self._sig_filename is not None:
+            return self._sig_filename
+
+        if self.bucket is None:
+            return None
+
+        bucket_url = "%s://%s:%d/crashmanager/rest/buckets/%d/" % (
+            self._coll.serverProtocol,
+            self._coll.serverHost,
+            self._coll.serverPort,
+            self.bucket,
+        )
+        bucket_data = self._coll.get(bucket_url).json()
+
+        tmpd = Path(mkdtemp(prefix="grizzly-reduce-"))
+        try:
+            sig_basename = "%d.signature" % (self.bucket,)
+            sig_filename = tmpd / sig_basename
+            sig_filename.write_text(bucket_data["signature"])
+            sigmeta_filename = sig_filename.with_suffix(".metadata")
+            sigmeta_filename.write_text(
+                json.dumps(
+                    {
+                        "size": bucket_data["size"],
+                        "frequent": bucket_data["frequent"],
+                        "shortDescription": bucket_data["shortDescription"],
+                        "testcase__quality": bucket_data["best_quality"],
+                    }
+                )
+            )
+        except:  # noqa pylint: disable=bare-except
+            rmtree(str(tmpd))
+            raise
+
+        self._sig_filename = sig_filename
+        return self._sig_filename
+
+
+def main(args):
+    """CLI for `grizzly.reduce.crash`.
+
+    Arguments:
+        args (argparse.Namespace): Result from `ReduceArgs.parse_args`.
+
+    Returns:
+        int: 0 for success. non-0 indicates a problem.
+    """
+    configure_logging(args.log_level)
+    crash = CrashEntry(args.input)
+    try:
+        # download the crash
+        args.input = str(crash.testcase_path())
+        if args.sig is None and crash.bucket_path() is not None:
+            args.sig = str(crash.bucket_path())
+        if args.tool is None:
+            args.tool = crash.tool
+
+        # call grizzly.reduce
+        result = ReduceManager.main(args)
+
+        # update quality
+        # map Session.EXIT_* -> FuzzManagerReporter.QUAL_*
+        # default back to UNREDUCED
+        # most errors will not be related to the testcase
+        # so they should be retried later
+        quality = {
+            Session.EXIT_SUCCESS: FuzzManagerReporter.QUAL_REDUCED_RESULT,
+            Session.EXIT_FAILURE: FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE,
+        }.get(
+            result, FuzzManagerReporter.QUAL_UNREDUCED
+        )
+        LOG.info(
+            "reducer finished -> exit(%d) -> Q%d",
+            result,
+            quality,
+        )
+        crash.testcase_quality = quality
+    finally:
+        crash.cleanup()
+    return result
+
+
+if __name__ == "__main__":
+    sys.exit(main(ReduceFuzzManagerIDArgs().parse_args()))

From 94869403952bea0712481383ef259e5cd4e2c186 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 11 Nov 2020 17:19:19 -0500
Subject: [PATCH 106/531] Move FuzzManager access code to common.

---
 grizzly/common/fuzzmanager.py      | 261 +++++++++++++++++++++++++++++
 grizzly/common/test_fuzzmanager.py | 191 +++++++++++++++++++++
 grizzly/reduce/bucket.py           |  16 +-
 grizzly/reduce/core.py             |  37 +---
 grizzly/reduce/crash.py            | 217 +-----------------------
 grizzly/reduce/test_main.py        |   4 +-
 grizzly/reduce/test_main_fm.py     | 133 +++++++++++++++
 grizzly/reduce/test_reduce.py      |   2 +-
 8 files changed, 607 insertions(+), 254 deletions(-)
 create mode 100644 grizzly/common/fuzzmanager.py
 create mode 100644 grizzly/common/test_fuzzmanager.py
 create mode 100644 grizzly/reduce/test_main_fm.py

diff --git a/grizzly/common/fuzzmanager.py b/grizzly/common/fuzzmanager.py
new file mode 100644
index 00000000..9aded758
--- /dev/null
+++ b/grizzly/common/fuzzmanager.py
@@ -0,0 +1,261 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Interface for getting Crash and Bucket data from CrashManager API"""
+import json
+from logging import getLogger
+from os import unlink
+from pathlib import Path
+from shutil import rmtree
+from tempfile import mkdtemp, mkstemp
+
+from Collector.Collector import Collector
+
+
+LOG = getLogger(__name__)
+
+
+class Bucket(object):
+    """Get Bucket data for a specified CrashManager bucket."""
+
+    def __init__(self, bucket_id):
+        """Initialize a Bucket instance.
+
+        Arguments:
+            bucket_id (int): ID of the requested bucket on the server side
+        """
+        self._bucket_id = bucket_id
+        self._sig_filename = None
+        self._coll = Collector()
+        self._url = "%s://%s:%d/crashmanager/rest/buckets/%d/" % (
+            self._coll.serverProtocol,
+            self._coll.serverHost,
+            self._coll.serverPort,
+            bucket_id,
+        )
+        self._data = None
+
+    @property
+    def bucket_id(self):
+        return self._bucket_id
+
+    def __getattr__(self, name):
+        if self._data is None:
+            self._data = self._coll.get(self._url).json()
+        if name not in self._data:
+            raise AttributeError(
+                "'%s' object has no attribute '%s' (has: %s)"
+                % (type(self).__name__, name, list(self._data))
+            )
+        return self._data[name]
+
+    def __setattr__(self, name, value):
+        if name.startswith("_"):
+            super().__setattr__(name, value)
+            return
+        raise AttributeError("can't set attribute")
+
+    def cleanup(self):
+        """Cleanup any resources held by this instance.
+
+        Arguments:
+            None
+
+        Returns:
+            None
+        """
+        if self._sig_filename is not None:
+            rmtree(str(self._sig_filename.parent))
+
+    def iter_crashes(self, quality_filter=None):
+        """Fetch all crash IDs for this FuzzManager bucket.
+        Only crashes with testcases are returned.
+
+        Arguments:
+            quality_filter (int): Filter crashes by quality value (None for all)
+
+        Returns:
+            generator: generator of CrashEntry
+        """
+
+        def _get_results(endpoint, params=None):
+            """
+            Function to get paginated results from FuzzManager
+
+            Args:
+                endpoint (str): FuzzManager REST API to query (eg. "crashes").
+                params (dict): Params to pass through to requests.get
+
+            Returns:
+                generator: objects returned by FuzzManager (as dicts)
+            """
+            LOG.debug("first request to /%s/", endpoint)
+
+            url = "%s://%s:%d/crashmanager/rest/%s/" \
+                % (self._coll.serverProtocol, self._coll.serverHost,
+                   self._coll.serverPort, endpoint)
+
+            response = self._coll.get(url, params=params).json()
+
+            while True:
+                LOG.debug("got %d/%d %s", len(response["results"]), response["count"], endpoint)
+                while response["results"]:
+                    yield response["results"].pop()
+
+                if response["next"] is None:
+                    break
+
+                LOG.debug("next request to /%s/", endpoint)
+                response = self._coll.get(response["next"]).json()
+
+        # Get all crashes for bucket
+        query_args = [
+            ("op", "AND"),
+            ("bucket", self.bucket_id),
+        ]
+        if quality_filter is not None:
+            query_args.append(("testcase__quality", quality_filter))
+        query = json.dumps(dict(query_args))
+
+        n_yielded = 0
+        for crash in _get_results("crashes", params={"query": query, "include_raw": "0"}):
+
+            if not crash["testcase"]:
+                LOG.warning("crash %d has no testcase, skipping", crash["id"])
+                continue
+
+            n_yielded += 1
+            LOG.debug("yielding crash #%d", n_yielded)
+            result = CrashEntry(crash["id"])
+            result._data = crash  # pylint: disable=protected-access
+            yield result
+
+    def signature_path(self):
+        """Download the bucket data from CrashManager.
+
+        Arguments:
+            None
+
+        Returns:
+            Path: Path on disk where signature exists.
+        """
+        if self._sig_filename is not None:
+            return self._sig_filename
+
+        tmpd = Path(mkdtemp(prefix="grizzly-reduce-"))
+        try:
+            sig_basename = "%d.signature" % (self._bucket_id,)
+            sig_filename = tmpd / sig_basename
+            sig_filename.write_text(self.signature)
+            sigmeta_filename = sig_filename.with_suffix(".metadata")
+            sigmeta_filename.write_text(
+                json.dumps(
+                    {
+                        "size": self.size,
+                        "frequent": self.frequent,
+                        "shortDescription": self.shortDescription,
+                        "testcase__quality": self.best_quality,
+                    }
+                )
+            )
+        except:  # noqa pragma: no cover pylint: disable=bare-except
+            rmtree(str(tmpd))
+            raise
+
+        self._sig_filename = sig_filename
+        return self._sig_filename
+
+
+class CrashEntry(object):
+    """Get the CrashEntry data for the specified CrashManager crash.
+
+    Attributes:
+        crash_id (int): the server ID for the crash
+        see crashmanager.serializers.CrashEntrySerializer
+    """
+    RAW_FIELDS = frozenset({"rawCrashData", "rawStderr", "rawStdout"})
+
+    def __init__(self, crash_id):
+        """Initialize CrashEntry.
+
+        Arguments:
+            crash_id (int): ID of the requested crash on the server side
+        """
+        self._crash_id = crash_id
+        self._coll = Collector()
+        self._url = "%s://%s:%d/crashmanager/rest/crashes/%d/" % (
+            self._coll.serverProtocol,
+            self._coll.serverHost,
+            self._coll.serverPort,
+            crash_id,
+        )
+        self._data = None
+        self._tc_filename = None
+
+    @property
+    def crash_id(self):
+        return self._crash_id
+
+    def __getattr__(self, name):
+        if self._data is None or (name in self.RAW_FIELDS and name not in self._data):
+            need_raw = "1" if name in self.RAW_FIELDS else "0"
+            self._data = self._coll.get(self._url, params={"include_raw": need_raw}).json()
+        if name not in self._data:
+            raise AttributeError(
+                "'%s' object has no attribute '%s' (has: %s)"
+                % (type(self).__name__, name, list(self._data))
+            )
+        return self._data[name]
+
+    def __setattr__(self, name, value):
+        if name.startswith("_"):
+            super().__setattr__(name, value)
+            return
+        if name != "testcase_quality":
+            raise AttributeError("can't set attribute")
+        self._coll.patch(self._url, data={name: value})
+        if self._data:
+            self._data[name] = value
+
+    def cleanup(self):
+        """Cleanup any resources held by this instance.
+
+        Arguments:
+            None
+
+        Returns:
+            None
+        """
+        if self._tc_filename is not None:
+            self._tc_filename.unlink()
+
+    def testcase_path(self):
+        """Download the testcase data from CrashManager.
+
+        Arguments:
+            None
+
+        Returns:
+            Path: Path on disk where testcase exists_
+        """
+        if self._tc_filename is not None:
+            return self._tc_filename
+
+        dlurl = self._url + "download/"
+        response = self._coll.get(dlurl)
+
+        if "content-disposition" not in response.headers:
+            raise RuntimeError("Server sent malformed response: %r" % (response,))  # pragma: no cover
+
+        handle, filename = mkstemp(
+            prefix="grizzly-reduce-%d-" % (self.crash_id,), suffix=Path(self.testcase).suffix
+        )
+        try:
+            with open(handle, "wb") as output:
+                output.write(response.content)
+        except:  # noqa pragma: no cover pylint: disable=bare-except
+            unlink(filename)
+            raise
+        self._tc_filename = Path(filename)
+        return self._tc_filename
diff --git a/grizzly/common/test_fuzzmanager.py b/grizzly/common/test_fuzzmanager.py
new file mode 100644
index 00000000..d549de67
--- /dev/null
+++ b/grizzly/common/test_fuzzmanager.py
@@ -0,0 +1,191 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Tests for interface for getting Crash and Bucket data from CrashManager API"""
+import json
+
+from pytest import raises
+
+from .fuzzmanager import Bucket, CrashEntry
+
+
+def test_bucket_1(mocker):
+    """bucket getattr uses data from get"""
+    coll = mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
+    coll.return_value.get.return_value.json.return_value = {"testcase": "data"}
+    coll.return_value.serverProtocol = "http"
+    coll.return_value.serverPort = 123
+    coll.return_value.serverHost = "allizom.org"
+    bucket = Bucket(123)
+    assert coll.return_value.get.call_count == 0
+    assert bucket.testcase == "data"
+    with raises(AttributeError):
+        getattr(bucket, "other")
+    assert coll.return_value.get.call_count == 1
+
+
+def test_bucket_2(mocker):
+    """bucket setattr raises"""
+    coll = mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
+    coll.return_value.serverProtocol = "http"
+    coll.return_value.serverPort = 123
+    coll.return_value.serverHost = "allizom.org"
+    bucket = Bucket(123)
+    with raises(AttributeError):
+        bucket.other = "data"
+    assert coll.return_value.get.call_count == 0
+
+
+def test_bucket_3(mocker):
+    """bucket iter_crashes flattens across pages"""
+    coll = mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
+    coll.return_value.serverProtocol = "http"
+    coll.return_value.serverPort = 123
+    coll.return_value.serverHost = "allizom.org"
+    coll.return_value.get.return_value.json.side_effect = [
+        {
+            "count": 2,
+            "next": "url",
+            "results": [
+                {"id": 234, "testcase": "test1"},
+                {"id": 345, "testcase": None},
+            ],
+        },
+        {
+            "count": 1,
+            "next": None,
+            "results": [
+                {"id": 456, "testcase": "test2"},
+            ],
+        },
+    ]
+    bucket = Bucket(123)
+    assert coll.return_value.get.call_count == 0
+    crashes = list(bucket.iter_crashes(quality_filter=5))
+    assert coll.return_value.get.call_count == 2
+    assert coll.return_value.get.call_args_list[0][1]["params"]["include_raw"] == "0"
+    assert json.loads(coll.return_value.get.call_args_list[0][1]["params"]["query"]) == {
+        "op": "AND",
+        "bucket": 123,
+        "testcase__quality": 5,
+    }
+    assert len(crashes) == 2
+    assert crashes[0].crash_id == 234
+    assert crashes[1].crash_id == 456
+
+
+def test_bucket_4(mocker):
+    """bucket signature_path writes and returns sig json and metadata"""
+    coll = mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
+    coll.return_value.serverProtocol = "http"
+    coll.return_value.serverPort = 123
+    coll.return_value.serverHost = "allizom.org"
+    coll.return_value.get.return_value.json.return_value = {
+        "signature": "sigdata",
+        "size": 10,
+        "frequent": True,
+        "shortDescription": "sig desc",
+        "best_quality": 0,
+    }
+    bucket = Bucket(123)
+    try:
+        assert coll.return_value.get.call_count == 0
+        sig_path = bucket.signature_path()
+        assert sig_path.is_file()
+        assert sig_path.with_suffix(".metadata").is_file()
+        assert sig_path.read_text() == "sigdata"
+        assert json.loads(sig_path.with_suffix(".metadata").read_text()) == {
+                        "size": 10,
+                        "frequent": True,
+                        "shortDescription": "sig desc",
+                        "testcase__quality": 0,
+        }
+        assert coll.return_value.get.call_count == 1
+        # second call returns same path
+        assert bucket.signature_path() == sig_path
+    finally:
+        bucket.cleanup()
+    assert coll.return_value.get.call_count == 1
+
+
+def test_crash_1(mocker):
+    """crash getattr uses data from get"""
+    coll = mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
+    coll.return_value.get.return_value.json.return_value = {"testcase": "data"}
+    coll.return_value.serverProtocol = "http"
+    coll.return_value.serverPort = 123
+    coll.return_value.serverHost = "allizom.org"
+    crash = CrashEntry(123)
+    assert coll.return_value.get.call_count == 0
+    assert crash.testcase == "data"
+    with raises(AttributeError):
+        getattr(crash, "other")
+    assert coll.return_value.get.call_count == 1
+    assert coll.return_value.get.call_args[1]["params"] == {"include_raw": "0"}
+
+    # crash getattr for raw field re-gets
+    coll.return_value.get.return_value.json.return_value = {"rawStderr": "stderr"}
+    assert crash.rawStderr == "stderr"
+    assert coll.return_value.get.call_count == 2
+    assert coll.return_value.get.call_args[1]["params"] == {"include_raw": "1"}
+
+
+def test_crash_2(mocker):
+    """crash setattr raises except testcase_quality"""
+    coll = mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
+    coll.return_value.get.return_value.json.return_value = {"testcase": "data"}
+    coll.return_value.serverProtocol = "http"
+    coll.return_value.serverPort = 123
+    coll.return_value.serverHost = "allizom.org"
+    crash = CrashEntry(123)
+
+    # crash setattr raises for other field
+    with raises(AttributeError):
+        crash.other = "data"
+    assert coll.return_value.get.call_count == 0
+
+    # crash setattr for testcase_quality works and updates data if set
+    assert coll.return_value.patch.call_count == 0
+    crash.testcase_quality = 5
+    assert coll.return_value.get.call_count == 0
+    assert coll.return_value.patch.call_count == 1
+    with raises(AttributeError):
+        getattr(crash, "testcase_quality")
+    assert coll.return_value.get.call_count == 1
+    getattr(crash, "testcase")
+    assert coll.return_value.get.call_count == 1
+    crash.testcase_quality = 10
+    assert coll.return_value.patch.call_count == 2
+    assert crash.testcase_quality == 10
+    assert coll.return_value.get.call_count == 1
+
+
+def test_crash_3(mocker):
+    """crash testcase_path writes and returns testcase zip"""
+    coll = mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
+    coll.return_value.serverProtocol = "http"
+    coll.return_value.serverPort = 123
+    coll.return_value.serverHost = "allizom.org"
+    coll.return_value.get.return_value.json.return_value = {
+        "id": 234,
+        "testcase": "test.bz2",
+    }
+    crash = CrashEntry(234)
+    assert crash.testcase == "test.bz2"  # pre-load data dict so I can re-patch get
+    coll.return_value.get.return_value = mocker.Mock(
+        content=b"\x01\x02\x03",
+        headers={"content-disposition"},
+    )
+    try:
+        assert coll.return_value.get.call_count == 1
+        tc_path = crash.testcase_path()
+        assert tc_path.is_file()
+        assert tc_path.suffix == ".bz2"
+        assert tc_path.read_bytes() == b"\x01\x02\x03"
+        assert coll.return_value.get.call_count == 2
+        # second call returns same path
+        assert crash.testcase_path() == tc_path
+    finally:
+        crash.cleanup()
+    assert coll.return_value.get.call_count == 2
diff --git a/grizzly/reduce/bucket.py b/grizzly/reduce/bucket.py
index 55d2e3cd..cf63a447 100644
--- a/grizzly/reduce/bucket.py
+++ b/grizzly/reduce/bucket.py
@@ -6,7 +6,8 @@
 import sys
 
 from .args import ReduceFuzzManagerIDQualityArgs
-from .crash import CrashEntry, main as crash_main
+from .crash import main as crash_main
+from ..common.fuzzmanager import Bucket
 from ..main import configure_logging
 from ..session import Session
 
@@ -25,21 +26,20 @@ def main(args):
     """
     configure_logging(args.log_level)
     LOG.info("Trying all crashes in bucket %d until one reduces", args.input)
+
     # ensure --tool is reset for each call to grizzly.reduce.crash.main()
     orig_tool = args.tool
 
     # if no crashes in bucket, return success
     result = Session.EXIT_SUCCESS
 
-    # create a fake CrashEntry used only to download the signature once
-    crash = CrashEntry(0)
-    crash._data = {"bucket": args.input}  # pylint: disable=protected-access
+    bucket = Bucket(args.input)
     try:
         if args.sig is None:
-            args.sig = str(crash.bucket_path())
+            args.sig = str(bucket.signature_path())
 
-        for crash in CrashEntry.iter_bucket(args.input, args.quality):
-            args.input = crash.id
+        for crash in bucket.iter_crashes(args.quality):
+            args.input = crash.crash_id
             args.tool = orig_tool
 
             # call grizzly.reduce.crash
@@ -48,7 +48,7 @@ def main(args):
                 break
 
     finally:
-        crash.cleanup()
+        bucket.cleanup()
     return result
 
 
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index d4496de5..cf0d1de8 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -14,10 +14,10 @@
 from tempfile import mkdtemp
 from time import time
 
-from Collector.Collector import Collector
 from FTB.Signatures.CrashInfo import CrashSignature
 from sapphire import Sapphire
 
+from ..common.fuzzmanager import CrashEntry
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter
 from ..common.storage import TestCase, TestCaseLoadFailure, TestFile
 from ..common.utils import grz_tmp
@@ -37,37 +37,6 @@
 LOG = getLogger(__name__)
 
 
-def change_quality(crash_id, quality):
-    """Update a FuzzManager crash entry quality (if the crash entry exists).
-
-    Missing crash entries are ignored with a warning.
-
-    Args:
-        crash_id (int): Crash ID on FuzzManager server
-        quality (int): Quality constant defined in FuzzManagerReporter.QUAL_*
-
-    Raises:
-        RuntimeError: Error communicating with FuzzManager server.
-
-    Returns:
-        None
-    """
-    LOG.info("Updating crash %d to quality %s", crash_id,
-             FuzzManagerReporter.quality_name(quality))
-    coll = Collector()
-
-    url = "%s://%s:%d/crashmanager/rest/crashes/%d/" \
-        % (coll.serverProtocol, coll.serverHost, coll.serverPort, crash_id)
-    try:
-        coll.patch(url, data={"testcase_quality": quality})
-    except RuntimeError as exc:
-        # let 404's go .. evidently the crash was deleted
-        if str(exc) == "Unexpected HTTP response: 404":
-            LOG.warning("Failed to update (404), does the crash still exist?")
-        else:
-            raise
-
-
 class ReduceManager(object):
     """Manage reduction of one or more testcases to find the smallest testcase
     that reproduces a given issue.
@@ -532,7 +501,9 @@ def run(self, repeat=1, min_results=1):
             # if we complete all strategies, mark the last reported crashes as reduced
             if self._report_to_fuzzmanager and last_reports:
                 for crash_id in last_reports:
-                    change_quality(crash_id, FuzzManagerReporter.QUAL_REDUCED_RESULT)
+                    LOG.info("Updating crash %d to quality %s", crash_id,
+                             FuzzManagerReporter.quality_name(FuzzManagerReporter.QUAL_REDUCED_RESULT))
+                    CrashEntry(crash_id).testcase_quality = FuzzManagerReporter.QUAL_REDUCED_RESULT
 
         # it's possible we made it this far without ever setting signature_desc.
         # this is only possible if --no-analysis is given
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index 8cdba271..4bc91c03 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -2,18 +2,12 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-import json
 from logging import getLogger
-from os import unlink
-from pathlib import Path
-from shutil import rmtree
 import sys
-from tempfile import mkdtemp, mkstemp
-
-from Collector.Collector import Collector
 
 from .args import ReduceFuzzManagerIDArgs
 from .core import ReduceManager
+from ..common.fuzzmanager import Bucket, CrashEntry
 from ..common.reporter import FuzzManagerReporter
 from ..main import configure_logging
 from ..session import Session
@@ -22,205 +16,6 @@
 LOG = getLogger(__name__)
 
 
-class CrashEntry(object):
-    """Get the CrashEntry data for the specified CrashManager crash.
-
-    Attributes:
-        see crashmanager.serializers.CrashEntrySerializer
-    """
-
-    def __init__(self, crash_id):
-        """Initialize CrashEntry.
-
-        Arguments:
-            crash_id (int): ID of the requested crash on the server side
-        """
-        self._coll = Collector()
-        self._url = "%s://%s:%d/crashmanager/rest/crashes/%d/" % (
-            self._coll.serverProtocol,
-            self._coll.serverHost,
-            self._coll.serverPort,
-            crash_id,
-        )
-        self._data = None
-        self._tc_filename = None
-        self._sig_filename = None
-
-    @classmethod
-    def iter_bucket(cls, bucket_id, quality_filter=None):
-        """Fetch all crash IDs for the specified FuzzManager bucket.
-        Only crashes with testcases are returned.
-
-        Args:
-            bucket_id (int): ID of the requested bucket on the server side
-            quality_filter (int): Filter crashes by quality value (None for all)
-
-        Returns:
-            generator: generator of crash ID (int)
-        """
-        coll = Collector()
-
-        def _get_results(endpoint, params=None):
-            """
-            Function to get paginated results from FuzzManager
-
-            Args:
-                endpoint (str): FuzzManager REST API to query (eg. "crashes").
-                params (dict): Params to pass through to requests.get
-
-            Returns:
-                generator: objects returned by FuzzManager (as dicts)
-            """
-            LOG.debug("first request to /%s/", endpoint)
-
-            url = "%s://%s:%d/crashmanager/rest/%s/" \
-                % (coll.serverProtocol, coll.serverHost, coll.serverPort, endpoint)
-
-            response = coll.get(url, params=params).json()
-
-            while True:
-                LOG.debug("got %d/%d %s", len(response["results"]), response["count"], endpoint)
-                while response["results"]:
-                    yield response["results"].pop()
-
-                if response["next"] is None:
-                    break
-
-                LOG.debug("next request to /%s/", endpoint)
-                response = coll.get(response["next"]).json()
-
-        # Get all crashes for bucket
-        query_args = [
-            ("op", "AND"),
-            ("bucket", bucket_id),
-        ]
-        if quality_filter is not None:
-            query_args.append(("testcase__quality", quality_filter))
-        query = json.dumps(dict(query_args))
-
-        n_yielded = 0
-        for crash in _get_results("crashes", params={"query": query, "include_raw": "0"}):
-
-            if not crash["testcase"]:
-                LOG.warning("crash %d has no testcase, skipping", crash["id"])
-                continue
-
-            n_yielded += 1
-            LOG.debug("yielding crash #%d", n_yielded)
-            result = cls(crash["id"])
-            result._data = crash  # pylint: disable=protected-access
-            yield result
-
-    def __getattr__(self, name):
-        if self._data is None:
-            self._data = self._coll.get(self._url, params={"include_raw": "0"}).json()
-        if name not in self._data:
-            raise AttributeError(
-                "'%s' object has no attribute '%s' (has: %s)"
-                % (type(self).__name__, name, list(self._data))
-            )
-        return self._data[name]
-
-    def __setattr__(self, name, value):
-        if name.startswith("_"):
-            super().__setattr__(name, value)
-            return
-        if name != "testcase_quality":
-            raise AttributeError("can't set attribute")
-        self._coll.patch(self._url, data={name: value})
-        self._data[name] = value
-
-    def cleanup(self):
-        """Cleanup any resources held by this instance.
-
-        Arguments:
-            None
-
-        Returns:
-            None
-        """
-        if self._tc_filename is not None:
-            self._tc_filename.unlink()
-        if self._sig_filename is not None:
-            rmtree(str(self._sig_filename.parent))
-
-    def testcase_path(self):
-        """Download the testcase data from CrashManager.
-
-        Arguments:
-            None
-
-        Returns:
-            Path: Path on disk where testcase exists.
-        """
-        if self._tc_filename is not None:
-            return self._tc_filename
-
-        dlurl = self._url + "download/"
-        response = self._coll.get(dlurl)
-
-        if "content-disposition" not in response.headers:
-            raise RuntimeError("Server sent malformed response: %r" % (response,))
-
-        handle, filename = mkstemp(
-            prefix="grizzly-reduce-%d-" % (self.id,), suffix=Path(self.testcase).suffix
-        )
-        try:
-            with open(handle, "wb") as output:
-                output.write(response.content)
-        except:  # noqa pylint: disable=bare-except
-            unlink(filename)
-            raise
-        self._tc_filename = Path(filename)
-        return self._tc_filename
-
-    def bucket_path(self):
-        """Download the bucket data from CrashManager.
-
-        Arguments:
-            None
-
-        Returns:
-            Path: Path on disk where signature exists.
-        """
-        if self._sig_filename is not None:
-            return self._sig_filename
-
-        if self.bucket is None:
-            return None
-
-        bucket_url = "%s://%s:%d/crashmanager/rest/buckets/%d/" % (
-            self._coll.serverProtocol,
-            self._coll.serverHost,
-            self._coll.serverPort,
-            self.bucket,
-        )
-        bucket_data = self._coll.get(bucket_url).json()
-
-        tmpd = Path(mkdtemp(prefix="grizzly-reduce-"))
-        try:
-            sig_basename = "%d.signature" % (self.bucket,)
-            sig_filename = tmpd / sig_basename
-            sig_filename.write_text(bucket_data["signature"])
-            sigmeta_filename = sig_filename.with_suffix(".metadata")
-            sigmeta_filename.write_text(
-                json.dumps(
-                    {
-                        "size": bucket_data["size"],
-                        "frequent": bucket_data["frequent"],
-                        "shortDescription": bucket_data["shortDescription"],
-                        "testcase__quality": bucket_data["best_quality"],
-                    }
-                )
-            )
-        except:  # noqa pylint: disable=bare-except
-            rmtree(str(tmpd))
-            raise
-
-        self._sig_filename = sig_filename
-        return self._sig_filename
-
-
 def main(args):
     """CLI for `grizzly.reduce.crash`.
 
@@ -232,11 +27,13 @@ def main(args):
     """
     configure_logging(args.log_level)
     crash = CrashEntry(args.input)
+    bucket = None
     try:
         # download the crash
         args.input = str(crash.testcase_path())
-        if args.sig is None and crash.bucket_path() is not None:
-            args.sig = str(crash.bucket_path())
+        if args.sig is None and crash.bucket is not None:
+            bucket = Bucket(crash.bucket)
+            args.sig = str(bucket.signature_path())
         if args.tool is None:
             args.tool = crash.tool
 
@@ -249,7 +46,7 @@ def main(args):
         # most errors will not be related to the testcase
         # so they should be retried later
         quality = {
-            Session.EXIT_SUCCESS: FuzzManagerReporter.QUAL_REDUCED_RESULT,
+            Session.EXIT_SUCCESS: FuzzManagerReporter.QUAL_REDUCED_ORIGINAL,
             Session.EXIT_FAILURE: FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE,
         }.get(
             result, FuzzManagerReporter.QUAL_UNREDUCED
@@ -262,6 +59,8 @@ def main(args):
         crash.testcase_quality = quality
     finally:
         crash.cleanup()
+        if bucket is not None:
+            bucket.cleanup()
     return result
 
 
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 2c2ccf97..3001c8a6 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -2,9 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-# pylint: disable=protected-access
-"""Unit tests for `grizzly.reduce.main`.
-"""
+"""Unit tests for `grizzly.reduce.main`."""
 import json
 from logging import getLogger
 from pathlib import Path
diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
new file mode 100644
index 00000000..3edc3a0e
--- /dev/null
+++ b/grizzly/reduce/test_main_fm.py
@@ -0,0 +1,133 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Unit tests for `grizzly.reduce.crash` and `grizzly.reduce.bucket`."""
+from copy import deepcopy
+from logging import getLogger
+
+import pytest
+
+from .crash import main as crash_main
+from .bucket import main as bucket_main
+
+
+LOG = getLogger(__name__)
+pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")
+
+
+@pytest.mark.parametrize(
+    "arg_sig, arg_tool, crash_bucket, result_sig, result_tool",
+    [
+        # crash id is downloaded and core.main is called with the path
+        (None, None, None, None, "test-tool"),
+        # crash in bucket, bucket will be downloaded and passed to --sig
+        (None, None, 789, "test_sig.json", "test-tool"),
+        # crash in bucket, --sig is respected
+        ("arg_sig.json", None, 789, "arg_sig.json", "test-tool"),
+        # --tool respected
+        (None, "tool2", None, None, "tool2"),
+
+    ]
+)
+def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_tool):
+    """tests for `grizzly.reduce.crash.main`"""
+    mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
+    crash = mocker.patch("grizzly.reduce.crash.CrashEntry", autospec=True)
+    bucket = mocker.patch("grizzly.reduce.crash.Bucket", autospec=True)
+    mocker.patch("grizzly.reduce.crash.ReduceManager", autospec=True)
+    crash.return_value.testcase_path.return_value = "test_path.zip"
+    crash.return_value.bucket = crash_bucket
+    crash.return_value.tool = "test-tool"
+    bucket.return_value.signature_path.return_value = "test_sig.json"
+
+    args = mocker.Mock(
+        input=12345,
+        sig=arg_sig,
+        tool=arg_tool,
+    )
+    crash_main(args)
+    assert args.input == "test_path.zip"
+    assert args.sig == result_sig
+    assert args.tool == result_tool
+
+
+@pytest.mark.parametrize(
+    "mgr_exit_code, quality",
+    [
+        (0, 1),
+        (1, 5),
+        (2, 5),
+        (3, 5),
+        (4, 5),
+        (5, 10),
+    ]
+)
+def test_crash_main_quality(mocker, mgr_exit_code, quality):
+    """test that quality is updated"""
+    mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
+    crash = mocker.patch("grizzly.reduce.crash.CrashEntry", autospec=True)
+    mocker.patch("grizzly.reduce.crash.Bucket", autospec=True)
+    mgr = mocker.patch("grizzly.reduce.crash.ReduceManager", autospec=True)
+    crash.return_value.testcase_path.return_value = "test_path.zip"
+    crash.return_value.bucket = None
+    crash.return_value.tool = "test-tool"
+    mgr.main.return_value = mgr_exit_code
+
+    args = mocker.Mock(
+        input=12345,
+        sig=None,
+        tool=None,
+    )
+    assert crash_main(args) == mgr_exit_code
+    assert crash.return_value.testcase_quality == quality
+
+
+@pytest.mark.parametrize(
+    "crashes, main_exit_codes, result, arg_sig, arg_tool",
+    [
+        # no crashes -> success
+        ([], [], 0, None, None),
+        # 1 crash fails -> no success
+        ([(123, "test-tool")], [1], 1, None, None),
+        # second of 3 succeeds -> success
+        ([(123, "test-tool"), (456, "test-tool2")], [1, 0], 0, None, None),
+        # --sig is respected
+        ([(123, "test-tool")], [0], 0, "test_sig2.json", None),
+        # --tool is respected
+        ([(123, "test-tool")], [0], 0, None, "test-tool-arg"),
+    ]
+)
+def test_bucket_main(mocker, crashes, main_exit_codes, result, arg_sig, arg_tool):
+    """tests for `grizzly.reduce.crash.main`"""
+    call_args = []
+
+    def copy_args(args):
+        call_args.append(deepcopy(args))
+        return main_exit_codes[main.call_count - 1]
+    mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
+    bucket = mocker.patch("grizzly.reduce.bucket.Bucket", autospec=True)
+    main = mocker.patch("grizzly.reduce.bucket.crash_main", autospec=True,
+                        side_effect=copy_args)
+    bucket.return_value.signature_path.return_value = "test_sig.json"
+    bucket.return_value.iter_crashes.return_value = [
+        mocker.Mock(crash_id=crash, tool=tool) for crash, tool in crashes
+    ]
+
+    args = mocker.Mock(
+        input=789,
+        sig=arg_sig,
+        tool=arg_tool,
+    )
+    bucket_main(args)
+    assert main.call_count == len(main_exit_codes)
+    for idx, (crash, tool) in enumerate(crashes[:main.call_count]):
+        assert call_args[idx].input == crash
+        if arg_tool is not None:
+            assert call_args[idx].tool == arg_tool
+        else:
+            assert call_args[idx].tool is None
+        if arg_sig is not None:
+            assert call_args[idx].sig == arg_sig
+        else:
+            assert call_args[idx].sig == "test_sig.json"
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 08d24eee..0f9d3476 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -694,7 +694,7 @@ def replay_run(testcases, **_kw):
     mocker.patch("grizzly.common.reporter.Collector")
     reporter = mocker.patch("grizzly.reduce.core.FuzzManagerReporter")
     reporter.QUAL_REDUCED_RESULT = 0
-    update_coll = mocker.patch("grizzly.reduce.core.Collector")
+    update_coll = mocker.patch("grizzly.common.fuzzmanager.Collector")
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:

From c791950d6a8766ed18108defe0167716792ae0f7 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 12 Nov 2020 15:16:51 -0500
Subject: [PATCH 107/531] FuzzManager crash/bucket reduction:

- use common grizzly temp folder for fuzzmanager downloads
- only update quality if `--fuzzmanager` is given
---
 grizzly/common/fuzzmanager.py |  9 ++++++---
 grizzly/reduce/crash.py       | 25 +++++++++++++------------
 2 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/grizzly/common/fuzzmanager.py b/grizzly/common/fuzzmanager.py
index 9aded758..5c6d48d3 100644
--- a/grizzly/common/fuzzmanager.py
+++ b/grizzly/common/fuzzmanager.py
@@ -12,6 +12,8 @@
 
 from Collector.Collector import Collector
 
+from .utils import grz_tmp
+
 
 LOG = getLogger(__name__)
 
@@ -143,7 +145,8 @@ def signature_path(self):
         if self._sig_filename is not None:
             return self._sig_filename
 
-        tmpd = Path(mkdtemp(prefix="grizzly-reduce-"))
+        tmpd = Path(mkdtemp(prefix="bucket-%d-" % (self._bucket_id,),
+                            dir=grz_tmp("fuzzmanager")))
         try:
             sig_basename = "%d.signature" % (self._bucket_id,)
             sig_filename = tmpd / sig_basename
@@ -248,8 +251,8 @@ def testcase_path(self):
         if "content-disposition" not in response.headers:
             raise RuntimeError("Server sent malformed response: %r" % (response,))  # pragma: no cover
 
-        handle, filename = mkstemp(
-            prefix="grizzly-reduce-%d-" % (self.crash_id,), suffix=Path(self.testcase).suffix
+        handle, filename = mkstemp(dir=grz_tmp("fuzzmanager"),
+            prefix="crash-%d-" % (self.crash_id,), suffix=Path(self.testcase).suffix
         )
         try:
             with open(handle, "wb") as output:
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index 4bc91c03..4799cb21 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -45,18 +45,19 @@ def main(args):
         # default back to UNREDUCED
         # most errors will not be related to the testcase
         # so they should be retried later
-        quality = {
-            Session.EXIT_SUCCESS: FuzzManagerReporter.QUAL_REDUCED_ORIGINAL,
-            Session.EXIT_FAILURE: FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE,
-        }.get(
-            result, FuzzManagerReporter.QUAL_UNREDUCED
-        )
-        LOG.info(
-            "reducer finished -> exit(%d) -> Q%d",
-            result,
-            quality,
-        )
-        crash.testcase_quality = quality
+        if args.fuzzmanager:
+            quality = {
+                Session.EXIT_SUCCESS: FuzzManagerReporter.QUAL_REDUCED_ORIGINAL,
+                Session.EXIT_FAILURE: FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE,
+            }.get(
+                result, FuzzManagerReporter.QUAL_UNREDUCED
+            )
+            LOG.info(
+                "reducer finished -> exit(%d) -> Q%d",
+                result,
+                quality,
+            )
+            crash.testcase_quality = quality
     finally:
         crash.cleanup()
         if bucket is not None:

From ec1e6be6ac63614d75375d6e53a6e02396aae771 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 12 Nov 2020 15:58:11 -0500
Subject: [PATCH 108/531] [reducer] Add more test coverage.

---
 grizzly/reduce/stats.py               |  2 +-
 grizzly/reduce/strategies/beautify.py |  4 +-
 grizzly/reduce/strategies/lithium.py  |  5 --
 grizzly/reduce/test_strategies.py     | 90 ++++++++++++++++++++++++++-
 4 files changed, 90 insertions(+), 11 deletions(-)

diff --git a/grizzly/reduce/stats.py b/grizzly/reduce/stats.py
index 94b75a6a..956dd1c8 100644
--- a/grizzly/reduce/stats.py
+++ b/grizzly/reduce/stats.py
@@ -87,7 +87,7 @@ def _format_duration(duration, total=0):
     result = ""
     if duration is not None:
         if total == 0:
-            percent = 0
+            percent = 0  # pragma: no cover
         else:
             percent = int(100 * duration / total)
         result = format_seconds(duration)
diff --git a/grizzly/reduce/strategies/beautify.py b/grizzly/reduce/strategies/beautify.py
index 89e3440b..eaa937ba 100644
--- a/grizzly/reduce/strategies/beautify.py
+++ b/grizzly/reduce/strategies/beautify.py
@@ -17,12 +17,12 @@
 try:
     import cssbeautifier
     HAVE_CSSBEAUTIFIER = True
-except ImportError:
+except ImportError:  # pragma: no cover
     HAVE_CSSBEAUTIFIER = False
 try:
     import jsbeautifier
     HAVE_JSBEAUTIFIER = True
-except ImportError:
+except ImportError:  # pragma: no cover
     HAVE_JSBEAUTIFIER = False
 
 from ...common.storage import TestCase
diff --git a/grizzly/reduce/strategies/lithium.py b/grizzly/reduce/strategies/lithium.py
index 4871b6d8..15496108 100644
--- a/grizzly/reduce/strategies/lithium.py
+++ b/grizzly/reduce/strategies/lithium.py
@@ -190,13 +190,8 @@ def __init__(self, *args, **kwds):
         # trim files_to_reduce, for check we don't need to run on every file
         # just once per Grizzly TestCase set is enough.
         self._files_to_reduce = self._files_to_reduce[:1]
-        self._remain = 1
-
-    def __len__(self):
-        return self._remain
 
     def __iter__(self):
-        self._remain = 0
         yield from super().__iter__()
 
 
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index cbfce8b8..b88a8e70 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -16,7 +16,8 @@
 from ..replay import ReplayResult
 from ..target import Target
 from .strategies import _load_strategies
-from .strategies.beautify import HAVE_CSSBEAUTIFIER, HAVE_JSBEAUTIFIER
+from .strategies.beautify import \
+    HAVE_CSSBEAUTIFIER, HAVE_JSBEAUTIFIER, CSSBeautify, JSBeautify
 from . import ReduceManager
 
 
@@ -164,7 +165,7 @@ def replay_run(testcases, **_):
 BeautifyStrategyParams = namedtuple(
     "BeautifyStrategyParams",
     "test_data, test_name, expected_run_calls, expected_results, expected_num_reports,"
-    "strategies"
+    "strategies, have_beautifiers"
 )
 
 
@@ -182,6 +183,7 @@ def replay_run(testcases, **_):
                 },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
                                      reason="jsbeautifier required"),
@@ -196,6 +198,7 @@ def replay_run(testcases, **_):
                                   "catch (e) {}\n</script>\n"},
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
                                      reason="jsbeautifier required"),
@@ -212,6 +215,7 @@ def replay_run(testcases, **_):
                                   "requisite'\n</script>\n"},
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
                                      reason="jsbeautifier required"),
@@ -227,6 +231,7 @@ def replay_run(testcases, **_):
                 },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
                                      reason="jsbeautifier required"),
@@ -242,6 +247,7 @@ def replay_run(testcases, **_):
                 },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
                                      reason="jsbeautifier required"),
@@ -259,6 +265,7 @@ def replay_run(testcases, **_):
                 },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
                                      reason="jsbeautifier required"),
@@ -276,6 +283,7 @@ def replay_run(testcases, **_):
                 },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
                                      reason="jsbeautifier required"),
@@ -294,6 +302,7 @@ def replay_run(testcases, **_):
                 },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
                                      reason="jsbeautifier required"),
@@ -311,6 +320,7 @@ def replay_run(testcases, **_):
                 },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
                                      reason="jsbeautifier required"),
@@ -329,6 +339,7 @@ def replay_run(testcases, **_):
                 },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
                                      reason="jsbeautifier required"),
@@ -343,6 +354,7 @@ def replay_run(testcases, **_):
                 expected_num_reports=2,
                 # no beautify performed, add check so the run succeeds
                 strategies=["jsbeautify", "check"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
                                      reason="jsbeautifier required"),
@@ -357,6 +369,7 @@ def replay_run(testcases, **_):
                 expected_num_reports=2,
                 # no beautify performed, add check so the run succeeds
                 strategies=["jsbeautify", "check"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
                                      reason="jsbeautifier required"),
@@ -370,6 +383,7 @@ def replay_run(testcases, **_):
                 expected_results={"*,\n#a {\n  fluff: 0;\n  required: 1\n}\n"},
                 expected_num_reports=2,
                 strategies=["cssbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
                                      reason="cssbeautifier required"),
@@ -385,6 +399,7 @@ def replay_run(testcases, **_):
                 },
                 expected_num_reports=2,
                 strategies=["cssbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
                                      reason="cssbeautifier required"),
@@ -398,6 +413,7 @@ def replay_run(testcases, **_):
                 expected_results={"<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n"},
                 expected_num_reports=2,
                 strategies=["cssbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
                                      reason="cssbeautifier required"),
@@ -414,6 +430,7 @@ def replay_run(testcases, **_):
                 },
                 expected_num_reports=2,
                 strategies=["check", "cssbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
                                      reason="cssbeautifier required"),
@@ -434,15 +451,30 @@ def replay_run(testcases, **_):
                 },
                 expected_num_reports=2,
                 strategies=["check", "lines", "cssbeautify"],
+                have_beautifiers=True,
             ),
             marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
                                      reason="cssbeautifier required"),
         ),
+        # test that when beautifiers are not available, the strategies have no effect
+        BeautifyStrategyParams(
+            test_data="<style>*,#a{fluff:0;required:1}\n",
+            test_name="test.html",
+            expected_run_calls=1,
+            expected_results={"<style>*,#a{fluff:0;required:1}\n"},
+            expected_num_reports=2,
+            strategies=["check", "cssbeautify"],
+            have_beautifiers=False,
+        ),
     ]
 )
 def test_beautifier(mocker, tmp_path, test_data, test_name, expected_run_calls,
-                    expected_results, expected_num_reports, strategies):
+                    expected_results, expected_num_reports, strategies,
+                    have_beautifiers):
     """test for the "beautify" strategies"""
+    if not have_beautifiers:
+        mocker.patch.object(CSSBeautify, "import_available", False)
+        mocker.patch.object(JSBeautify, "import_available", False)
     mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     mocker.patch("grizzly.reduce.strategies.beautify._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
@@ -662,3 +694,55 @@ def replay_run(testcases, **_):
         str(p.relative_to(log_path)) for p in log_path.glob("reports/**/*")
         if p.is_file()
     ]
+
+
+def test_dd_only(mocker, tmp_path):
+    """test that only files containing DDBEGIN/END are reduced"""
+    replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    replayer = replayer.return_value
+    replayer.status.iteration = 1
+
+    def replay_run(testcases, **_):
+        for test in testcases:
+            contents = test.get_file("test.html").data.decode("ascii")
+            LOG.debug("interesting if 'required' in %r", contents)
+            interesting = "required" in contents
+            if interesting:
+                log_path = tmp_path / (
+                    "crash%d_logs" % (replayer.run.call_count,)
+                )
+                log_path.mkdir()
+                _fake_save_logs_foo(log_path)
+                report = Report(str(log_path), "bin")
+                return [ReplayResult(report, [["test.html", "other.html"]], [], True)]
+        return []
+    replayer.run.side_effect = replay_run
+
+    test = TestCase("test.html", None, "test-adapter")
+    test.add_from_data("DDBEGIN\n123\nrequired\nDDEND\n", "test.html")
+    test.add_from_data("blah\n", "other.html")
+    tests = [test]
+    log_path = tmp_path / "logs"
+
+    target = mocker.Mock(spec=Target)
+    target.relaunch = 1
+    try:
+        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target, tests,
+                            ["lines"], log_path, use_analysis=False)
+        assert mgr.run() == 0
+    finally:
+        for test in tests:
+            test.cleanup()
+
+    expected_run_calls = 3
+    expected_results = {"DDBEGIN\nrequired\nDDEND\n"}
+    expected_num_reports = 2
+
+    assert replayer.run.call_count == expected_run_calls
+    assert set(log_path.iterdir()) == {log_path / "reports"}
+    tests = {test.read_text() for test in log_path.glob("reports/*-*/test.html")}
+    assert tests == expected_results
+    assert sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports, \
+        list((log_path / "reports").iterdir())
+    others = {test.read_text() for test in log_path.glob("reports/*-*/other.html")}
+    assert others == {"blah\n"}

From c852c586453172b75368a55cc7e7ecce89fb5855 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 20 Nov 2020 15:13:31 -0800
Subject: [PATCH 109/531] Reuse test case loading code

* Add support to select a subset of test cases when loading
---
 grizzly/common/test_storage.py |  2 +-
 grizzly/reduce/core.py         | 31 +++++++-------------
 grizzly/reduce/test_main.py    | 53 +++++-----------------------------
 grizzly/replay/args.py         |  4 +--
 grizzly/replay/replay.py       | 48 ++++++++++++++++++++----------
 grizzly/replay/test_main.py    |  7 +----
 grizzly/replay/test_replay.py  | 36 ++++++++++++++++++++++-
 7 files changed, 89 insertions(+), 92 deletions(-)

diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index f7348e92..1980ebd7 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -379,7 +379,7 @@ def test_testcase_18():
         assert src.get_file("missing") is None
         assert src.get_file("test.htm").data == b"test"
 
-def test_testcase_19(tmp_path):
+def test_testcase_19():
     """test TestCase.clone()"""
     with TestCase("test.htm", "redirect.htm", "test-adaptor", "input.py") as src:
         src.add_from_data("123", "test.htm")
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index cf0d1de8..00f21e93 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -19,7 +19,7 @@
 
 from ..common.fuzzmanager import CrashEntry
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter
-from ..common.storage import TestCase, TestCaseLoadFailure, TestFile
+from ..common.storage import TestCaseLoadFailure, TestFile
 from ..common.utils import grz_tmp
 from ..main import configure_logging
 from ..replay import ReplayManager, ReplayResult
@@ -606,11 +606,11 @@ def main(cls, args):
                     meta = json.loads(meta.read_text())
                     signature_desc = meta["shortDescription"]
 
-            LOG.debug("loading the TestCases")
             try:
-                testcases = TestCase.load(args.input, args.prefs is None)
-                if not testcases:
-                    raise TestCaseLoadFailure("Failed to load TestCases")
+                testcases = ReplayManager.load_testcases(
+                    args.input,
+                    args.prefs is None,
+                    subset=args.test_index)
             except TestCaseLoadFailure as exc:
                 LOG.error("Error: %s", str(exc))
                 return Session.EXIT_ERROR
@@ -620,23 +620,12 @@ def main(cls, args):
                             testcases[0].adapter_name)
                 args.tool = "grizzly-%s" % (testcases[0].adapter_name,)
 
-            if args.test_index is not None or (args.no_harness and len(testcases) > 1):
-                if args.test_index is None:
-                    LOG.warning("'--no-harness' given with %d testcases and without "
-                                "'--test-index', defaulting to last testcase",
-                                len(testcases))
-                    args.test_index = -1
-                LOG.debug("using TestCase with index %d", args.test_index)
-                try:
-                    selected = testcases.pop(args.test_index)
-                except IndexError:
-                    LOG.error("Error: Invalid '--test-index'")
-                    return Session.EXIT_ERROR
-                for test in testcases:
-                    test.cleanup()
-                testcases = [selected]
-
             if args.no_harness:
+                if len(testcases) > 1:
+                    LOG.error(
+                        "Error: '--no-harness' cannot be used with multiple " \
+                        "testcases. Perhaps '--test-index' can help.")
+                    return Session.EXIT_ARGS
                 LOG.debug("--no-harness specified relaunch set to 1")
                 args.relaunch = 1
             args.repeat = max(args.min_crashes, args.repeat)
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 3001c8a6..63e148fe 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -13,7 +13,6 @@
 from pytest import raises
 
 from ..common import TestCaseLoadFailure
-from ..common.storage import TestCase
 from ..target import TargetLaunchError, TargetLaunchTimeout
 from .args import ReduceArgs
 from . import ReduceManager
@@ -79,11 +78,14 @@ def test_args_02(tmp_path):
             "grizzly.reduce.core.load_target",
             GrizzlyReduceBaseException(""), None, {}, 1
         ),
-        ("grizzly.reduce.core.TestCase.load", TestCaseLoadFailure, None, {}, 1),
-        ("grizzly.reduce.core.TestCase.load", None, [], {}, 1),
         (
-            "grizzly.reduce.core.TestCase.load", None, [Mock(), Mock()],
-            {"test_index": 100}, 1
+            "grizzly.reduce.core.ReplayManager.load_testcases",
+            TestCaseLoadFailure, None, {}, 1
+        ),
+        ("grizzly.reduce.core.ReplayManager.load_testcases", None, [], {}, 1),
+        (
+            "grizzly.reduce.core.ReplayManager.load_testcases", None, [Mock(), Mock()],
+            {"no_harness": True}, 2
         ),
     ]
 )
@@ -95,7 +97,6 @@ def test_main_01(mocker, patch_func, side_effect, return_value, kwargs, result):
         QUAL_REDUCER_ERROR=9)
     mocker.patch("grizzly.reduce.core.load_target", autospec=True)
     mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
-    mocker.patch("grizzly.reduce.core.TestCase", autospec=True)
     # setup args
     args = mocker.Mock(
         ignore=["fake"],
@@ -110,46 +111,6 @@ def test_main_01(mocker, patch_func, side_effect, return_value, kwargs, result):
     mocker.patch(patch_func, side_effect=side_effect, return_value=return_value)
     assert ReduceManager.main(args) == result
 
-
-@pytest.mark.parametrize("test_index", [0, 1, 2, -1, None])
-def test_main_02(mocker, test_index):
-    """test Reducemanager.main() testcases with --test-index"""
-    mocker.patch(
-        "grizzly.reduce.core.FuzzManagerReporter", autospec=True,
-        QUAL_NO_TESTCASE=7,
-        QUAL_REDUCER_ERROR=9)
-    mgr = mocker.patch("grizzly.reduce.core.ReduceManager", autospec=True)
-    mgr.return_value.run.return_value = 0
-    mocker.patch("grizzly.reduce.core.load_target", autospec=True)
-    mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
-    mocker.patch("grizzly.reduce.core.TestCase", autospec=True)
-    # setup args
-    tests = [mocker.Mock(spec=TestCase) for _ in range(3)]
-    LOG.debug("test mocks: %r", tests)
-    args = mocker.Mock(
-        ignore=["fake"],
-        input="test",
-        min_crashes=1,
-        prefs=None,
-        relaunch=1,
-        repeat=1,
-        sig=None,
-        no_harness=True,
-        test_index=test_index)
-
-    mocker.patch("grizzly.reduce.core.TestCase.load", return_value=tests.copy())
-    assert ReduceManager.main(args) == 0
-    assert mgr.call_count == 1
-    assert mgr.return_value.run.call_count == 1
-    mgr_args, _ = mgr.call_args_list[0]
-    LOG.debug("call_args: %r", mgr_args)
-    mgr_testcases = mgr_args[3]
-    assert len(mgr_testcases) == 1
-    if test_index is None:
-        test_index = -1
-    assert mgr_testcases == [tests[test_index]]
-
-
 def test_force_closed(mocker, tmp_path):
     """test that `forced_close` in testcase metadata is respected"""
     load_target = mocker.patch("grizzly.reduce.core.load_target")
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index d11b201a..579db5c6 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -49,10 +49,10 @@ def __init__(self):
             "--sig",
             help="Signature (JSON) file to match.")
         replay_args.add_argument(
-            "--test-index", type=int,
+            "--test-index", type=int, nargs="+",
             help="Select a testcase to run when multiple testcases are loaded. " \
                  "Testscases are ordered oldest to newest. Indexing is 0 based. " \
-                 "0 == Oldest, -1 == Newest (default: run all testcases)")
+                 "0 == Oldest, n-1 == Newest (default: run all testcases)")
 
         self.launcher_grp.add_argument(
             "--rr", action="store_true",
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 483eb9a5..2f4d76bb 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -81,6 +81,35 @@ def cleanup(self):
         if self.status is not None:
             self.status.cleanup()
 
+    @classmethod
+    def load_testcases(cls, path, load_prefs, subset=None):
+        """Load TestCases.
+
+        Args:
+            path (str): Path to load.
+            load_prefs (bool): Load prefs.js file if available.
+            subset (list(int)): Indices of tests to load when loading multiple
+                                tests.
+        Returns:
+            list(TestCase): Loaded TestCases.
+        """
+        LOG.debug("loading the TestCases")
+        testcases = TestCase.load(path, load_prefs)
+        if not testcases:
+            raise TestCaseLoadFailure("Failed to load TestCases")
+        if subset:
+            count = len(testcases)
+            # deduplicate and limit requested indices to valid range
+            reqs = {max(count + x, 0) if x < 0 else min(x, count - 1) for x in subset}
+            LOG.debug("using TestCase(s) with index %r", reqs)
+            selected = list()
+            for idx in sorted(reqs, reverse=True):
+                selected.append(testcases.pop(idx))
+            for test in testcases:
+                test.cleanup()
+            testcases = selected
+        return testcases
+
     @staticmethod
     def report_to_filesystem(path, results, tests=None):
         """Use FilesystemReporter to write reports and testcase to disk in a
@@ -353,22 +382,11 @@ def main(cls, args):
         else:
             signature = None
 
-        LOG.debug("loading the TestCases")
         try:
-            testcases = TestCase.load(args.input, args.prefs is None)
-            if not testcases:
-                raise TestCaseLoadFailure("Failed to load TestCases")
-            if args.test_index is not None:
-                LOG.debug("using TestCase with index %d", args.test_index)
-                try:
-                    selected = testcases.pop(args.test_index)
-                except IndexError:
-                    LOG.error("Invalid '--test-index'")
-                    return Session.EXIT_ARGS
-                finally:
-                    for test in testcases:
-                        test.cleanup()
-                testcases = [selected]
+            testcases = cls.load_testcases(
+                args.input,
+                args.prefs is None,
+                subset=args.test_index)
         except TestCaseLoadFailure as exc:
             LOG.error("Error: %s", str(exc))
             return Session.EXIT_ERROR
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index abccf27f..65a120bd 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -166,11 +166,6 @@ def test_main_02(mocker):
     assert ReplayManager.main(args) == Session.EXIT_ARGS
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
-    # multiple test cases with invalid --test-index
-    args.test_index = 100
-    fake_tc.load.return_value = [mocker.Mock(), mocker.Mock()]
-    assert ReplayManager.main(args) == Session.EXIT_ARGS
-    assert fake_load_target.call_count == 0
 
 def test_main_03(mocker, tmp_path):
     """test ReplayManager.main() target exceptions"""
@@ -232,7 +227,7 @@ def test_main_04(mocker):
         relaunch=1,
         repeat=1,
         sig=None,
-        test_index=0,
+        test_index=[0],
         timeout=1)
     assert ReplayManager.main(args) == Session.EXIT_FAILURE
     assert test0.cleanup.call_count == 1
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 9aca0404..acfc9882 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -12,7 +12,7 @@
 
 from sapphire import Sapphire, SERVED_ALL, SERVED_REQUEST
 from .replay import ReplayManager, ReplayResult
-from ..common import Report, Status, TestCase
+from ..common import Report, Status, TestCase, TestCaseLoadFailure
 from ..target import Target
 
 
@@ -516,3 +516,37 @@ def test_replay_18(mocker, tmp_path):
     assert not (tmp_path / "report_expected").is_dir()
     assert path.is_dir()
     assert (path / "reports" / "expected_logs").is_dir()
+
+def test_replay_19(mocker, tmp_path):
+    """test ReplayManager.load_testcases()"""
+    fake_load = mocker.patch("grizzly.replay.replay.TestCase.load")
+    test0 = mocker.Mock(spec=TestCase)
+    test1 = mocker.Mock(spec=TestCase, landing_page="x.html")
+    test2 = mocker.Mock(spec=TestCase)
+    # failure
+    fake_load.return_value = ()
+    with raises(TestCaseLoadFailure, match="Failed to load TestCases"):
+        ReplayManager.load_testcases(str(tmp_path), False)
+    # success
+    fake_load.return_value = [test0, test1]
+    tests = ReplayManager.load_testcases(str(tmp_path), False)
+    assert len(tests) == 2
+    assert tests[0].cleanup.call_count == 0
+    assert tests[1].cleanup.call_count == 0
+    # success select
+    fake_load.return_value = [test0, test1, test2]
+    tests = ReplayManager.load_testcases(str(tmp_path), False, subset=[1])
+    assert len(tests) == 1
+    assert tests[0].landing_page == "x.html"
+    assert test0.cleanup.call_count == 1
+    assert test1.cleanup.call_count == 0
+    assert test2.cleanup.call_count == 1
+    test0.reset_mock()
+    test2.reset_mock()
+    # select (first and last) with invalid input
+    fake_load.return_value = [test0, test1, test2]
+    tests = ReplayManager.load_testcases(str(tmp_path), False, subset=[0, 10, -10, -1])
+    assert len(tests) == 2
+    assert test0.cleanup.call_count == 0
+    assert test1.cleanup.call_count == 1
+    assert test2.cleanup.call_count == 0

From 4025ce1838aa0a364ff7220817c9e6e043e50376 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 20 Nov 2020 15:15:57 -0800
Subject: [PATCH 110/531] [tests] Use replay.signature property

---
 grizzly/replay/test_replay.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index acfc9882..ca90c00d 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -46,7 +46,7 @@ def test_replay_02(mocker, tmp_path):
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True) as replay:
             assert not replay.run([testcase])
-            assert replay._signature is None
+            assert replay.signature is None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
             assert replay.status.results == 0
@@ -64,7 +64,7 @@ def test_replay_03(mocker):
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True) as replay:
             assert not replay.run([testcase], repeat=10, min_results=1)
-            assert replay._signature is None
+            assert replay.signature is None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 10
             assert replay.status.results == 0
@@ -84,7 +84,7 @@ def test_replay_04(mocker, tmp_path):
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target) as replay:
             results = replay.run([testcase])
-            assert replay._signature is not None
+            assert replay.signature is not None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
             assert replay.status.results == 1
@@ -211,7 +211,7 @@ def test_replay_08(mocker, tmp_path):
     with ReplayManager([], server, target, signature=signature, use_harness=False) as replay:
         results = replay.run(testcases, repeat=4, min_results=2)
         assert target.close.call_count == 1
-        assert replay._signature == signature
+        assert replay.signature == signature
         assert replay.status.iteration == 4
         assert replay.status.results == 1
         assert replay.status.ignored == 2
@@ -246,7 +246,7 @@ def test_replay_09(mocker, tmp_path):
     with ReplayManager([], server, target, signature=signature, use_harness=False) as replay:
         results = replay.run(testcases, repeat=2, min_results=2)
         assert target.close.call_count == 1
-        assert replay._signature == signature
+        assert replay.signature == signature
         assert replay.status.iteration == 2
         assert replay.status.results == 2
         assert replay.status.ignored == 0
@@ -278,7 +278,7 @@ def test_replay_10(mocker, tmp_path):
     with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
         results = replay.run(testcases, repeat=3, min_results=2)
         assert target.close.call_count == 1
-        assert replay._signature is None
+        assert replay.signature is None
         assert replay.status.iteration == 3
         assert replay.status.results == 2
         assert replay.status.ignored == 0
@@ -311,7 +311,7 @@ def test_replay_11(mocker, tmp_path):
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, any_crash=True) as replay:
         assert not replay.run(testcases, repeat=4, min_results=3)
-        assert replay._signature is None
+        assert replay.signature is None
         assert replay.status.iteration == 4
         assert replay.status.results == 2
         assert replay.status.ignored == 0
@@ -344,7 +344,7 @@ def test_replay_12(mocker, tmp_path):
     with ReplayManager([], server, target, use_harness=False) as replay:
         results = replay.run(testcases, repeat=3, min_results=2)
         assert target.close.call_count == 1
-        assert replay._signature == auto_sig
+        assert replay.signature == auto_sig
         assert replay.status.iteration == 3
         assert replay.status.results == 2
         assert replay.status.ignored == 1
@@ -373,7 +373,7 @@ def test_replay_13(mocker, tmp_path):
         with raises(KeyboardInterrupt):
             replay.run(testcases, repeat=3, min_results=2)
         assert target.close.call_count == 1
-        assert replay._signature is None
+        assert replay.signature is None
         assert replay.status.iteration == 2
         assert replay.status.results == 1
         assert replay.status.ignored == 0

From 548625e7e448520578e486c60422cd3458d4b7de Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 20 Nov 2020 16:12:55 -0800
Subject: [PATCH 111/531] [replay] Fix TestCase subset ordering

---
 grizzly/replay/replay.py      | 1 +
 grizzly/replay/test_replay.py | 6 +++---
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 2f4d76bb..2be64567 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -105,6 +105,7 @@ def load_testcases(cls, path, load_prefs, subset=None):
             selected = list()
             for idx in sorted(reqs, reverse=True):
                 selected.append(testcases.pop(idx))
+            selected.reverse()
             for test in testcases:
                 test.cleanup()
             testcases = selected
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index ca90c00d..9e3b2bb4 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -534,9 +534,9 @@ def test_replay_19(mocker, tmp_path):
     assert tests[0].cleanup.call_count == 0
     assert tests[1].cleanup.call_count == 0
     # success select
-    fake_load.return_value = [test0, test1, test2]
-    tests = ReplayManager.load_testcases(str(tmp_path), False, subset=[1])
-    assert len(tests) == 1
+    fake_load.return_value = [test0, test1, test2, mocker.Mock(spec=TestCase)]
+    tests = ReplayManager.load_testcases(str(tmp_path), False, subset=[1, 3])
+    assert len(tests) == 2
     assert tests[0].landing_page == "x.html"
     assert test0.cleanup.call_count == 1
     assert test1.cleanup.call_count == 0

From 048e7e920b4eba933dcd5caf331d745eeceb3c29 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 26 Nov 2020 09:52:11 -0800
Subject: [PATCH 112/531] [ci] Disable MacOS

---
 .travis.yml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 3cf0f519..ed6d9e49 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -10,9 +10,6 @@ python:
   - 3.9
 jobs:
   include:
-    - os: osx
-      osx_image: xcode11.2
-      language: shell
     - os: windows
       language: shell
       before_install:

From 4a174a9e33a11d14692259d496c29f256e171b02 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 26 Nov 2020 11:08:34 -0800
Subject: [PATCH 113/531] [ci] Use Python3.9 on Windows

---
 .travis.yml | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index ed6d9e49..0d40ba58 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,10 +13,8 @@ jobs:
     - os: windows
       language: shell
       before_install:
-        - choco install python --version 3.8
-      env: PATH=/c/Python38:/c/Python38/Scripts:$PATH
-  allow_failures:
-    - python: 3.9
+        - choco install python --version 3.9
+      env: PATH=/c/Python39:/c/Python39/Scripts:$PATH
 before_install:
   - pip3 install --upgrade setuptools pip
 install:

From db38cee3b1b6cdbb7cd079224caed2259ed838d7 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tysmith@users.noreply.github.com>
Date: Thu, 26 Nov 2020 15:18:54 -0800
Subject: [PATCH 114/531] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 00db32f5..241482a8 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ For additional information please check out the [wiki](https://github.com/Mozill
 
 Installation
 ------------
-See [getting started](https://github.com/MozillaSecurity/grizzly/wiki/Getting-Started) on the wiki.
+To install the latest version from PyPI run `python3 -m pip install grizzly-framework`. See [getting started](https://github.com/MozillaSecurity/grizzly/wiki/Getting-Started) on the wiki for more details.
 
 Target platforms
 -------

From e11e3f507ba824fa4bb276a4e83250907aa8f738 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 1 Dec 2020 08:20:33 -0800
Subject: [PATCH 115/531] Bump version to 0.10.0

---
 setup.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/setup.py b/setup.py
index 5760a0e2..3c104f35 100755
--- a/setup.py
+++ b/setup.py
@@ -30,7 +30,8 @@
             'Programming Language :: Python :: 3.5',
             'Programming Language :: Python :: 3.6',
             'Programming Language :: Python :: 3.7',
-            'Programming Language :: Python :: 3.8'
+            'Programming Language :: Python :: 3.8',
+            'Programming Language :: Python :: 3.9',
         ],
         description='A framework for developing and running browser fuzzers',
         entry_points={
@@ -81,4 +82,4 @@
         ],
         package_data={"grizzly.common": ["harness.html"]},
         url='https://github.com/MozillaSecurity/grizzly',
-        version='0.9.8')
+        version='0.10.0')

From 0b5347f74a4a5945a36ff995a42e2d2e6def6b09 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 2 Dec 2020 15:01:54 -0500
Subject: [PATCH 116/531] [reduce.crash] Fix quality reporting.

---
 grizzly/reduce/crash.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index 4799cb21..d2f57c6b 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -47,11 +47,17 @@ def main(args):
         # so they should be retried later
         if args.fuzzmanager:
             quality = {
+                Session.EXIT_ERROR: FuzzManagerReporter.QUAL_REDUCER_ERROR,
+                Session.EXIT_ABORT: crash.testcase_quality,
                 Session.EXIT_SUCCESS: FuzzManagerReporter.QUAL_REDUCED_ORIGINAL,
                 Session.EXIT_FAILURE: FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE,
             }.get(
                 result, FuzzManagerReporter.QUAL_UNREDUCED
             )
+            # don't ever set things back to Q4, default to Q5 for that case.
+            # Q4 is only used in automation, so ABORT should never happen.
+            if quality == FuzzManagerReporter.QUAL_REDUCING:
+                quality = FuzzManagerReporter.QUAL_UNREDUCED
             LOG.info(
                 "reducer finished -> exit(%d) -> Q%d",
                 result,

From d9f97cf9fd5b887d7dcbbf957ccdb0ff2f6096e7 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 2 Dec 2020 16:45:41 -0500
Subject: [PATCH 117/531] [grizzly.crash] Update tests

---
 grizzly/reduce/test_main_fm.py | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
index 3edc3a0e..48a18a40 100644
--- a/grizzly/reduce/test_main_fm.py
+++ b/grizzly/reduce/test_main_fm.py
@@ -38,6 +38,7 @@ def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_
     mocker.patch("grizzly.reduce.crash.ReduceManager", autospec=True)
     crash.return_value.testcase_path.return_value = "test_path.zip"
     crash.return_value.bucket = crash_bucket
+    crash.return_value.testcase_quality = 5
     crash.return_value.tool = "test-tool"
     bucket.return_value.signature_path.return_value = "test_sig.json"
 
@@ -53,23 +54,25 @@ def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_
 
 
 @pytest.mark.parametrize(
-    "mgr_exit_code, quality",
+    "mgr_exit_code, pre_quality, post_quality",
     [
-        (0, 1),
-        (1, 5),
-        (2, 5),
-        (3, 5),
-        (4, 5),
-        (5, 10),
+        (0, 5, 1),
+        (1, 5, 9),
+        (2, 6, 5),
+        (3, 4, 5),
+        (3, 0, 0),
+        (4, 6, 5),
+        (5, 5, 10),
     ]
 )
-def test_crash_main_quality(mocker, mgr_exit_code, quality):
+def test_crash_main_quality(mocker, mgr_exit_code, pre_quality, post_quality):
     """test that quality is updated"""
     mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
     crash = mocker.patch("grizzly.reduce.crash.CrashEntry", autospec=True)
     mocker.patch("grizzly.reduce.crash.Bucket", autospec=True)
     mgr = mocker.patch("grizzly.reduce.crash.ReduceManager", autospec=True)
     crash.return_value.testcase_path.return_value = "test_path.zip"
+    crash.return_value.testcase_quality = pre_quality
     crash.return_value.bucket = None
     crash.return_value.tool = "test-tool"
     mgr.main.return_value = mgr_exit_code
@@ -80,7 +83,7 @@ def test_crash_main_quality(mocker, mgr_exit_code, quality):
         tool=None,
     )
     assert crash_main(args) == mgr_exit_code
-    assert crash.return_value.testcase_quality == quality
+    assert crash.return_value.testcase_quality == post_quality
 
 
 @pytest.mark.parametrize(

From ad0d28c59dbb22ee5383e863fb0be05b948f16ba Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 4 Dec 2020 15:14:56 -0800
Subject: [PATCH 118/531] Add retries for launch errors

---
 grizzly/common/runner.py      | 18 +++++++++++++-----
 grizzly/common/test_runner.py |  2 +-
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 1f9b9f6a..08318e3b 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -8,7 +8,7 @@
 from time import sleep, time
 
 from sapphire import SERVED_TIMEOUT
-from ..target import TargetLaunchTimeout
+from ..target import TargetLaunchError, TargetLaunchTimeout
 from .utils import grz_tmp
 
 __all__ = ("Runner", "RunResult")
@@ -106,12 +106,20 @@ def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
         for retries in reversed(range(max_retries)):
             try:
                 self._target.launch(location, env_mod=env_mod)
+            except TargetLaunchError as exc:
+                # This is likely due to a bad build or environment configuration.
+                if retries:
+                    LOG.warning("Failure detected during launch (retries %d)", retries)
+                    exc.report.cleanup()
+                    sleep(retry_delay)
+                    continue
+                raise
             except TargetLaunchTimeout:
-                # likely has nothing to do with Grizzly but is seen frequently
-                # on machines under a high load. After multiple consecutive timeouts
-                # something is likely wrong so raise.
+                # A TargetLaunchTimeout likely has nothing to do with Grizzly but is
+                # seen frequently on machines under a high load. After multiple
+                # consecutive timeouts something is likely wrong so raise.
                 if retries:
-                    LOG.warning("Launch timeout (attempts remaining %d)", retries)
+                    LOG.warning("Timeout detected during launch (retries %d)", retries)
                     sleep(retry_delay)
                     continue
                 raise
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 435991ff..5511f670 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -185,7 +185,7 @@ def test_runner_08(mocker):
     target.launch.side_effect = TargetLaunchError("test", mocker.Mock(spec=Report))
     with raises(TargetLaunchError, match="test"):
         runner.launch("http://a/")
-    assert target.launch.call_count == 1
+    assert target.launch.call_count == 3
     target.reset_mock()
 
     target.launch.side_effect = TargetLaunchTimeout

From e7776cc6186c5fed62e8e88fb71a7281e79199f5 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 4 Dec 2020 16:38:38 -0500
Subject: [PATCH 119/531] [grizzly.reduce] Log launch errors to /tmp instead of
 trying to report to FuzzManager (which will likely fail).

This is how `grizzly.replay` works too.
---
 grizzly/reduce/core.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 00f21e93..afdefb02 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -234,9 +234,10 @@ def run_reliability_analysis(self, stats):
                     )
                 except (TargetLaunchError, TargetLaunchTimeout) as exc:
                     if isinstance(exc, TargetLaunchError) and exc.report:
-                        self.report([ReplayResult(exc.report, None, [], False)],
-                                    testcases, self._stats.copy(stats))
-                        exc.report.cleanup()
+                        path = grz_tmp("launch_failures")
+                        LOG.error("Logs can be found here %r", path)
+                        reporter = FilesystemReporter(path, major_bucket=False)
+                        reporter.submit([], exc.report)
                     raise
                 try:
                     stats.add_iterations(replay.status.iteration)
@@ -461,11 +462,10 @@ def run(self, repeat=1, min_results=1):
 
                             except TargetLaunchError as exc:
                                 if exc.report:
-                                    self.report(
-                                        [ReplayResult(exc.report, None, [], False)],
-                                        reduction,
-                                        self._stats.copy(strategy_stats))
-                                    exc.report.cleanup()
+                                    path = grz_tmp("launch_failures")
+                                    LOG.error("Logs can be found here %r", path)
+                                    reporter = FilesystemReporter(path, major_bucket=False)
+                                    reporter.submit([], exc.report)
                                 raise
                             finally:
                                 if not keep_reduction:

From 9dc799fc2ccc4e9a930e7e3488d7478613b25fee Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 4 Dec 2020 17:30:54 -0500
Subject: [PATCH 120/531] [grizzly.reduce] Make launch error handling more
 generic.

Tests are partially updated (still failing).
---
 grizzly/reduce/core.py        | 30 ++++++++----------------
 grizzly/reduce/test_main.py   | 38 ++++++++++++++++++++++++++++++-
 grizzly/reduce/test_reduce.py | 43 -----------------------------------
 3 files changed, 47 insertions(+), 64 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index afdefb02..74a03d78 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -226,19 +226,11 @@ def run_reliability_analysis(self, stats):
                     LOG.warning("Only the last testcase of %d given will be used to "
                                 "assess reliability without harness.", len(testcases))
                     testcases = [testcases[-1]]
-                try:
-                    results = replay.run(
-                        testcases, repeat=self.ANALYSIS_ITERATIONS, min_results=1,
-                        exit_early=False, idle_delay=self._idle_delay,
-                        idle_threshold=self._idle_threshold,
-                    )
-                except (TargetLaunchError, TargetLaunchTimeout) as exc:
-                    if isinstance(exc, TargetLaunchError) and exc.report:
-                        path = grz_tmp("launch_failures")
-                        LOG.error("Logs can be found here %r", path)
-                        reporter = FilesystemReporter(path, major_bucket=False)
-                        reporter.submit([], exc.report)
-                    raise
+                results = replay.run(
+                    testcases, repeat=self.ANALYSIS_ITERATIONS, min_results=1,
+                    exit_early=False, idle_delay=self._idle_delay,
+                    idle_threshold=self._idle_threshold,
+                )
                 try:
                     stats.add_iterations(replay.status.iteration)
                     crashes = sum(x.count for x in results if x.expected)
@@ -460,13 +452,6 @@ def run(self, repeat=1, min_results=1):
                                     strategy_last_report = now
                                     LOG.info("Best results reported (periodic)")
 
-                            except TargetLaunchError as exc:
-                                if exc.report:
-                                    path = grz_tmp("launch_failures")
-                                    LOG.error("Logs can be found here %r", path)
-                                    reporter = FilesystemReporter(path, major_bucket=False)
-                                    reporter.submit([], exc.report)
-                                raise
                             finally:
                                 if not keep_reduction:
                                     for testcase in reduction:
@@ -692,6 +677,11 @@ def main(cls, args):
 
         except (TargetLaunchError, TargetLaunchTimeout) as exc:
             LOG.error("Exception: %s", exc)
+            if isinstance(exc, TargetLaunchError) and exc.report:
+                path = grz_tmp("launch_failures")
+                LOG.error("Logs can be found here %r", path)
+                reporter = FilesystemReporter(path, major_bucket=False)
+                reporter.submit([], exc.report)
             return Session.EXIT_LAUNCH_FAILURE
 
         except GrizzlyReduceBaseException as exc:
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 63e148fe..89703c0d 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -89,7 +89,7 @@ def test_args_02(tmp_path):
         ),
     ]
 )
-def test_main_01(mocker, patch_func, side_effect, return_value, kwargs, result):
+def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, result):
     """test ReduceManager.main() failure cases"""
     mocker.patch(
         "grizzly.reduce.core.FuzzManagerReporter", autospec=True,
@@ -111,6 +111,42 @@ def test_main_01(mocker, patch_func, side_effect, return_value, kwargs, result):
     mocker.patch(patch_func, side_effect=side_effect, return_value=return_value)
     assert ReduceManager.main(args) == result
 
+
+@pytest.mark.parametrize(
+    "exc_type",
+    [
+        TargetLaunchError,
+        TargetLaunchTimeout,
+    ]
+)
+def test_main_launch_error(mocker, exc_type):
+    mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
+    reporter = mocker.patch("grizzly.reduce.core.FilesystemReporter", autospec=True)
+    reporter = reporter.return_value
+    mocker.patch("grizzly.reduce.core.load_target", autospec=True)
+    mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
+    # setup args
+    args = mocker.Mock(
+        ignore=["fake"],
+        input="test",
+        min_crashes=1,
+        prefs=None,
+        relaunch=1,
+        repeat=1,
+        sig=None)
+
+    exc_obj = exc_type("error", None)
+    mocker.patch("grizzly.reduce.core.ReduceManager.run", side_effect=exc_obj)
+    assert ReduceManager.main(args) == 1
+    if exc_type is TargetLaunchError:
+        assert reporter.submit.call_count == 1
+        reported_testcases, report = reporter.submit.call_args[0]
+        assert reported_testcases == []
+        assert report is exc_obj.report
+    else:
+        assert reporter.submit.call_count == 0
+
+
 def test_force_closed(mocker, tmp_path):
     """test that `forced_close` in testcase metadata is respected"""
     load_target = mocker.patch("grizzly.reduce.core.load_target")
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 0f9d3476..2ee03b2b 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -720,49 +720,6 @@ def replay_run(testcases, **_kw):
     }
 
 
-@pytest.mark.parametrize("use_analysis", [True, False])
-@pytest.mark.parametrize("exc_type", [TargetLaunchError, TargetLaunchTimeout])
-def test_launch_error(mocker, tmp_path, use_analysis, exc_type):
-    """test that launch errors are reported"""
-    mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
-    report_fcn = mocker.patch("grizzly.reduce.core.ReduceManager.report", autospec=True)
-    replay_mock = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
-    if exc_type is TargetLaunchError:
-        report_obj = mocker.Mock(spec=Report)
-        replay_mock.return_value.__enter__.return_value.run.side_effect = \
-            TargetLaunchError("msg", report_obj)
-        replay_mock.return_value.run.side_effect = TargetLaunchError("msg", report_obj)
-    else:
-        replay_mock.return_value.__enter__.return_value.run.side_effect = \
-            TargetLaunchTimeout("msg")
-        replay_mock.return_value.run.side_effect = TargetLaunchTimeout("msg")
-
-    (tmp_path / "test.html").touch()
-    testcases = TestCase.load(str(tmp_path / "test.html"), False)
-    assert testcases
-
-    target_obj = mocker.Mock(spec=Target)
-    target_obj.relaunch = 1
-    mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target_obj,
-                        testcases, ["check"], None, use_analysis=use_analysis)
-    with raises(exc_type):
-        mgr.run()
-    if exc_type is TargetLaunchError:
-        assert report_fcn.call_count == 1
-        _mgr, reports, reported_testcases, _stats = report_fcn.call_args[0]
-        if use_analysis:
-            assert reported_testcases == testcases
-        else:
-            # should be testcases reported, but from the strategy, not the original
-            assert reported_testcases
-            assert reported_testcases != testcases
-        assert len(reports) == 1
-        assert reports[0].report == report_obj
-        assert report_obj.cleanup.call_count == 1
-    else:
-        assert report_fcn.call_count == 0
-
-
 TimeoutTestParams = namedtuple(
     "TimeoutTestParams",
     "durations, interesting, static_timeout, idle_input, idle_output, iter_input,"

From 9ad029bce783aa4b105a822bbae326e449866feb Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 7 Dec 2020 13:59:12 -0800
Subject: [PATCH 121/531] [tests] Finish grizzly.reduce target launch failure
 tests

---
 grizzly/reduce/core.py      |  2 +-
 grizzly/reduce/test_main.py | 19 +++++++++++--------
 2 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 74a03d78..dab11f87 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -22,7 +22,7 @@
 from ..common.storage import TestCaseLoadFailure, TestFile
 from ..common.utils import grz_tmp
 from ..main import configure_logging
-from ..replay import ReplayManager, ReplayResult
+from ..replay import ReplayManager
 from ..session import Session
 from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
 from .exceptions import GrizzlyReduceBaseException, NotReproducible
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 89703c0d..0459ff77 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -122,8 +122,9 @@ def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, result
 def test_main_launch_error(mocker, exc_type):
     mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
     reporter = mocker.patch("grizzly.reduce.core.FilesystemReporter", autospec=True)
-    reporter = reporter.return_value
     mocker.patch("grizzly.reduce.core.load_target", autospec=True)
+    mocker.patch("grizzly.reduce.core.ReplayManager.load_testcases")
+    run = mocker.patch("grizzly.reduce.core.ReduceManager.run", autospec=True)
     mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
     # setup args
     args = mocker.Mock(
@@ -133,18 +134,20 @@ def test_main_launch_error(mocker, exc_type):
         prefs=None,
         relaunch=1,
         repeat=1,
-        sig=None)
+        sig=None,
+    )
 
-    exc_obj = exc_type("error", None)
-    mocker.patch("grizzly.reduce.core.ReduceManager.run", side_effect=exc_obj)
-    assert ReduceManager.main(args) == 1
+    exc_obj = exc_type("error",
+                     mocker.Mock() if exc_type is TargetLaunchError else None)
+    run.side_effect = exc_obj
+    assert ReduceManager.main(args) == 4
     if exc_type is TargetLaunchError:
-        assert reporter.submit.call_count == 1
-        reported_testcases, report = reporter.submit.call_args[0]
+        assert reporter.return_value.submit.call_count == 1
+        reported_testcases, report = reporter.return_value.submit.call_args[0]
         assert reported_testcases == []
         assert report is exc_obj.report
     else:
-        assert reporter.submit.call_count == 0
+        assert reporter.return_value.submit.call_count == 0
 
 
 def test_force_closed(mocker, tmp_path):

From 90d5aed5abea962304efe0d2b379c5c4aa5424c2 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 9 Dec 2020 17:54:32 -0800
Subject: [PATCH 122/531] Handle iterations with unattempted test cases
 consistently

This will allow grizzly.reduce and grizzly.replay to continue if failures are delayed.
---
 grizzly/common/runner.py      | 36 +++++++++++-----------
 grizzly/common/test_runner.py | 31 ++++++++++++++-----
 grizzly/replay/replay.py      | 13 +++++---
 grizzly/replay/test_replay.py | 56 ++++++++++++++++++++++++-----------
 grizzly/session.py            | 23 ++++++++------
 grizzly/test_session.py       | 10 ++-----
 6 files changed, 108 insertions(+), 61 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 08318e3b..442a1c94 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -74,7 +74,7 @@ def schedule_poll(self, initial=False, now=None):
 
 
 class Runner(object):
-    __slots__ = ("_idle", "_server", "_target")
+    __slots__ = ("_idle", "_server", "_target", "_tests_run")
 
     def __init__(self, server, target, idle_threshold=0, idle_delay=0):
         if idle_threshold > 0:
@@ -85,6 +85,7 @@ def __init__(self, server, target, idle_threshold=0, idle_delay=0):
             self._idle = None
         self._server = server  # a sapphire instance to serve the test case
         self._target = target  # target to run test case
+        self._tests_run = 0  # number of tests run since target (re)launched
 
     def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
         """Launch a target and open `location`.
@@ -92,7 +93,8 @@ def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
         Args:
             location (str): URL to open via Target.
             env_mod (dict): Environment modifications.
-            max_retries (int): Number of retries to preform before re-raising TargetLaunchTimeout.
+            max_retries (int): Number of retries to preform before re-raising
+                               TargetLaunchTimeout.
             retry_delay (int): Time in seconds to wait between retries.
 
         Returns:
@@ -124,6 +126,7 @@ def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
                     continue
                 raise
             break
+        self._tests_run = 0
 
     @staticmethod
     def location(srv_path, srv_port, close_after=None, forced_close=True, timeout=None):
@@ -196,26 +199,25 @@ def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait
         # add all include files that were served
         for url, resource in server_map.include.items():
             testcase.add_batch(resource.target, result.served, prefix=url)
-        served_lpage = testcase.landing_page in result.served
-        if not served_lpage:
-            LOG.debug("%r not served!", testcase.landing_page)
-        elif coverage and not result.timeout:
+        result.attempted = testcase.landing_page in result.served
+        if result.attempted and coverage and not result.timeout:
             # dump_coverage() should be called before detect_failure()
             # to help catch any coverage related issues.
             self._target.dump_coverage()
         # detect failure
         failure_detected = self._target.detect_failure(ignore, result.timeout)
-        if failure_detected == self._target.RESULT_FAILURE:
-            result.status = RunResult.FAILED
-        elif not served_lpage:
+        result.initial = self._tests_run == 0
+        if not result.attempted:
             # something is wrong so close the target
             # previous iteration put target in a bad state?
+            LOG.debug("landing page %r not served!", testcase.landing_page)
             self._target.close()
-            result.status = RunResult.ERROR
+        else:
+            self._tests_run += 1
+        if failure_detected == self._target.RESULT_FAILURE:
+            result.status = RunResult.FAILED
         elif failure_detected == self._target.RESULT_IGNORED:
             result.status = RunResult.IGNORED
-        else:
-            result.status = RunResult.COMPLETE
         return result
 
     def _keep_waiting(self):
@@ -235,15 +237,15 @@ def _keep_waiting(self):
 
 
 class RunResult(object):
-    COMPLETE = 1
-    ERROR = 2
-    FAILED = 3
-    IGNORED = 4
+    FAILED = 1
+    IGNORED = 2
 
-    __slots__ = ("duration", "served", "status", "timeout")
+    __slots__ = ("attempted", "duration", "initial", "served", "status", "timeout")
 
     def __init__(self, served, duration, status=None, timeout=False):
+        self.attempted = False  # entry point/landing page was requested
         self.duration = duration
+        self.initial = False  # target was (re)launched prior to attempt
         self.served = served
         self.status = status
         self.timeout = timeout
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 5511f670..e923bb04 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -28,8 +28,10 @@ def test_runner_01(mocker, tmp_path):
     fake_time.side_effect = (1, 2)
     server.serve_path.return_value = (SERVED_ALL, serv_files)
     result = runner.run([], ServerMap(), testcase)
+    assert result.attempted
     assert result.duration == 1
-    assert result.status == RunResult.COMPLETE
+    assert result.initial
+    assert result.status is None
     assert result.served == serv_files
     assert not result.timeout
     assert target.close.call_count == 0
@@ -39,7 +41,9 @@ def test_runner_01(mocker, tmp_path):
     fake_time.side_effect = (1, 2)
     server.serve_path.return_value = (SERVED_REQUEST, serv_files)
     result = runner.run([], ServerMap(), testcase, coverage=True)
-    assert result.status == RunResult.COMPLETE
+    assert result.attempted
+    assert not result.initial
+    assert result.status is None
     assert result.served == serv_files
     assert not result.timeout
     assert target.close.call_count == 0
@@ -51,7 +55,9 @@ def test_runner_01(mocker, tmp_path):
     tc_path.mkdir()
     server.serve_path.return_value = (SERVED_ALL, serv_files)
     result = runner.run([], ServerMap(), testcase, test_path=str(tc_path))
-    assert result.status == RunResult.COMPLETE
+    assert result.attempted
+    assert not result.initial
+    assert result.status is None
     assert target.close.call_count == 0
     assert testcase.dump.call_count == 0
     tc_path.is_dir()
@@ -66,7 +72,9 @@ def test_runner_02(mocker):
     server.serve_path.return_value = (SERVED_NONE, [])
     target.detect_failure.return_value = target.RESULT_NONE
     result = runner.run([], ServerMap(), testcase)
-    assert result.status == RunResult.ERROR
+    assert result.status is None
+    assert not result.attempted
+    assert result.initial
     assert not result.served
     assert not result.timeout
     assert target.close.call_count == 1
@@ -74,7 +82,9 @@ def test_runner_02(mocker):
     # landing page not served
     server.serve_path.return_value = (SERVED_REQUEST, ["harness"])
     result = runner.run([], ServerMap(), testcase)
-    assert result.status == RunResult.ERROR
+    assert result.status is None
+    assert not result.attempted
+    assert result.initial
     assert result.served
     assert target.close.call_count == 1
 
@@ -102,12 +112,14 @@ def test_runner_04(mocker):
     # test FAILURE
     target.detect_failure.return_value = target.RESULT_FAILURE
     result = runner.run([], ServerMap(), testcase)
+    assert result.attempted
     assert result.status == RunResult.FAILED
     assert result.served == serv_files
     assert not result.timeout
     # test IGNORED
     target.detect_failure.return_value = target.RESULT_IGNORED
     result = runner.run([], ServerMap(), testcase)
+    assert result.attempted
     assert result.status == RunResult.IGNORED
     assert result.served == serv_files
     assert not result.timeout
@@ -115,6 +127,7 @@ def test_runner_04(mocker):
     server.serve_path.return_value = (SERVED_REQUEST, ["harness"])
     target.detect_failure.return_value = target.RESULT_FAILURE
     result = runner.run([], ServerMap(), testcase)
+    assert not result.attempted
     assert result.status == RunResult.FAILED
     assert result.served
     assert not result.timeout
@@ -129,7 +142,8 @@ def test_runner_05(mocker):
     runner = Runner(server, target, idle_threshold=0.01, idle_delay=0.01)
     assert runner._idle is not None
     result = runner.run([], ServerMap(), mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[]))
-    assert result.status == RunResult.COMPLETE
+    assert result.status is None
+    assert result.attempted
     assert target.close.call_count == 0
 
 def test_runner_06(mocker):
@@ -178,7 +192,9 @@ def test_runner_08(mocker):
     target = mocker.Mock(spec=Target, launch_timeout=30)
 
     runner = Runner(server, target)
+    runner._tests_run = 1
     runner.launch("http://a/")
+    assert runner._tests_run == 0
     assert target.launch.call_count == 1
     target.reset_mock()
 
@@ -219,7 +235,8 @@ def test_runner_09(mocker, tmp_path):
     server.serve_path.return_value = (SERVED_ALL, serv_files)
     with TestCase("a.b", "x", "x") as tcase:
         result = runner.run([], smap, tcase)
-        assert result.status == RunResult.COMPLETE
+        assert result.attempted
+        assert result.status is None
         assert "inc_file.bin" in tcase._existing_paths
         assert pathjoin("nested", "nested_inc.bin") in tcase._existing_paths
         assert pathjoin("test", "inc_file3.txt") in tcase._existing_paths
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 2be64567..40f61ce5 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -247,8 +247,16 @@ def _dyn_close():  # pragma: no cover
                         wait_for_callback=self._harness is None)
                     durations.append(run_result.duration)
                     served.append(run_result.served)
-                    if run_result.status != RunResult.COMPLETE:
+                    if run_result.status is not None or not run_result.attempted:
                         break
+                if not run_result.attempted:
+                    if run_result.initial:
+                        err_logs = mkdtemp(prefix="error_", dir=grz_tmp("logs"))
+                        self.target.save_logs(err_logs)
+                        LOG.error("ERROR: Test case was not served. Timeout too short?")
+                        LOG.error("Logs can be found here %r", err_logs)
+                        break
+                    LOG.warning("Test case was not served")
                 # process run results
                 if run_result.status == RunResult.FAILED:
                     log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
@@ -297,9 +305,6 @@ def _dyn_close():  # pragma: no cover
                 elif run_result.status == RunResult.IGNORED:
                     self.status.ignored += 1
                     LOG.info("Result: Ignored (%d)", self.status.ignored)
-                elif run_result.status == RunResult.ERROR:
-                    LOG.error("ERROR: Test case was not served. Timeout too short?")
-                    break
 
                 if exit_early:
                     # failed to meet minimum number of results
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 9e3b2bb4..14602eab 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -100,14 +100,15 @@ def test_replay_04(mocker, tmp_path):
         results[0].report.cleanup()
         assert not any(tmp_path.glob("*"))
 
-def test_replay_05(mocker):
-    """test ReplayManager.run() - Error (landing page not requested/served)"""
+def test_replay_05(mocker, tmp_path):
+    """test ReplayManager.run() - error - landing page not requested on first iteration"""
+    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_REQUEST, ["x"])
-    target = mocker.Mock(spec=Target, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, closed=False, launch_timeout=30, rl_reset=1)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+    server.serve_path.return_value = (SERVED_REQUEST, ["x"])
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases, repeat=2)
         assert replay.status.ignored == 0
@@ -116,8 +117,29 @@ def test_replay_05(mocker):
         # target.close() called once in runner and once by ReplayManager.run()
         assert target.close.call_count == 2
     assert target.check_relaunch.call_count == 0
+    assert target.save_logs.call_count == 1
 
 def test_replay_06(mocker, tmp_path):
+    """test ReplayManager.run() - delayed failure - following test landing page not requested"""
+    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    target = mocker.Mock(spec=Target, binary="bin", closed=False, launch_timeout=30, rl_reset=10)
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.detect_failure.side_effect = (Target.RESULT_NONE, Target.RESULT_FAILURE)
+    target.save_logs = _fake_save_logs
+    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+    server.serve_path.side_effect = ((SERVED_ALL, ["index.html"]), (SERVED_REQUEST, ["x"]))
+    with ReplayManager([], server, target, use_harness=True) as replay:
+        assert replay.run(testcases, repeat=2)
+        assert replay.status.ignored == 0
+        assert replay.status.iteration == 2
+        assert replay.status.results == 1
+        # target.close() called once in runner and once by ReplayManager.run()
+        assert target.close.call_count == 2
+    assert target.check_relaunch.call_count == 1
+
+def test_replay_07(mocker, tmp_path):
     """test ReplayManager.run() - ignored"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
@@ -134,7 +156,7 @@ def test_replay_06(mocker, tmp_path):
         assert replay.status.results == 0
     assert not any(tmp_path.glob("*"))
 
-def test_replay_07(mocker, tmp_path):
+def test_replay_08(mocker, tmp_path):
     """test ReplayManager.run() - early exit"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
@@ -186,7 +208,7 @@ def test_replay_07(mocker, tmp_path):
     assert len(results) == 1
     assert sum(x.count for x in results) == 4
 
-def test_replay_08(mocker, tmp_path):
+def test_replay_09(mocker, tmp_path):
     """test ReplayManager.run() - test signatures - fail to meet minimum"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report)
@@ -225,7 +247,7 @@ def test_replay_08(mocker, tmp_path):
     assert report_3.cleanup.call_count == 1
     assert signature.matches.call_count == 3
 
-def test_replay_09(mocker, tmp_path):
+def test_replay_10(mocker, tmp_path):
     """test ReplayManager.run() - test signatures - multiple matches"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
@@ -258,7 +280,7 @@ def test_replay_09(mocker, tmp_path):
     assert report_1.cleanup.call_count == 1
     assert signature.matches.call_count == 2
 
-def test_replay_10(mocker, tmp_path):
+def test_replay_11(mocker, tmp_path):
     """test ReplayManager.run() - any crash - success"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report)
@@ -290,7 +312,7 @@ def test_replay_10(mocker, tmp_path):
     assert report_1.cleanup.call_count == 0
     assert report_2.cleanup.call_count == 0
 
-def test_replay_11(mocker, tmp_path):
+def test_replay_12(mocker, tmp_path):
     """test ReplayManager.run() - any crash - fail to meet minimum"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report)
@@ -321,7 +343,7 @@ def test_replay_11(mocker, tmp_path):
     assert report_2.cleanup.call_count == 1
     assert report_3.cleanup.call_count == 1
 
-def test_replay_12(mocker, tmp_path):
+def test_replay_13(mocker, tmp_path):
     """test ReplayManager.run() - no signature - use first crash"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_1 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123", minor="9999")
@@ -356,7 +378,7 @@ def test_replay_12(mocker, tmp_path):
     assert report_2.cleanup.call_count == 0
     assert report_3.cleanup.call_count == 1
 
-def test_replay_13(mocker, tmp_path):
+def test_replay_14(mocker, tmp_path):
     """test ReplayManager.run() - unexpected exception"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
@@ -380,7 +402,7 @@ def test_replay_13(mocker, tmp_path):
     assert fake_report.call_count == 1
     assert report_0.cleanup.call_count == 1
 
-def test_replay_14(mocker):
+def test_replay_15(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
@@ -399,7 +421,7 @@ def test_replay_14(mocker):
         assert replay.status.results == 0
     assert all(x.dump.call_count == 1 for x in testcases)
 
-def test_replay_15(mocker):
+def test_replay_16(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
@@ -419,7 +441,7 @@ def test_replay_15(mocker):
         assert replay.status.results == 0
     assert all(x.dump.call_count == 1 for x in testcases)
 
-def test_replay_16(mocker, tmp_path):
+def test_replay_17(mocker, tmp_path):
     """test ReplayManager.run() - multiple TestCases - successful repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
@@ -453,7 +475,7 @@ def test_replay_16(mocker, tmp_path):
     assert len(results[0].durations) == len(testcases)
     assert all(x.dump.call_count == 1 for x in testcases)
 
-def test_replay_17(mocker, tmp_path):
+def test_replay_18(mocker, tmp_path):
     """test ReplayManager.run() - multiple calls"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
@@ -471,7 +493,7 @@ def test_replay_17(mocker, tmp_path):
             assert replay.status.iteration == 1
     assert server.serve_path.call_count == 3
 
-def test_replay_18(mocker, tmp_path):
+def test_replay_19(mocker, tmp_path):
     """test ReplayManager.report_to_filesystem()"""
     # no reports
     ReplayManager.report_to_filesystem(str(tmp_path), [])
@@ -517,7 +539,7 @@ def test_replay_18(mocker, tmp_path):
     assert path.is_dir()
     assert (path / "reports" / "expected_logs").is_dir()
 
-def test_replay_19(mocker, tmp_path):
+def test_replay_20(mocker, tmp_path):
     """test ReplayManager.load_testcases()"""
     fake_load = mocker.patch("grizzly.replay.replay.TestCase.load")
     test0 = mocker.Mock(spec=TestCase)
diff --git a/grizzly/session.py b/grizzly/session.py
index b7926a2b..38a62689 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -176,7 +176,7 @@ def _dyn_close():  # pragma: no cover
                 log.debug("calling self.adapter.on_served()")
                 self.adapter.on_served(current_test, result.served)
             # update test case
-            if result.status != RunResult.ERROR:
+            if result.attempted:
                 if not result.served:
                     # this can happen if the target crashes between serving test cases
                     log.info("Ignoring test case since nothing was served")
@@ -184,6 +184,19 @@ def _dyn_close():  # pragma: no cover
                 elif self.adapter.IGNORE_UNSERVED:
                     log.debug("removing unserved files from the test case")
                     current_test.purge_optional(result.served)
+            else:
+                log.error("Test case was not served")
+                if not current_test.contains(current_test.landing_page):
+                    log.warning("Test case is missing landing page")
+                if result.initial:
+                    # since this is the first iteration since the Target launched
+                    # something is likely wrong with the Target or Adapter
+                    err_logs = mkdtemp(prefix="error_", dir=grz_tmp("logs"))
+                    self.target.save_logs(err_logs)
+                    log.error("ERROR: Test case was not served. Timeout too short?")
+                    log.error("Logs can be found here %r", err_logs)
+                    raise SessionError("Please check Adapter and Target")
+
             # process results
             if result.status == RunResult.FAILED:
                 log.debug("result detected")
@@ -191,14 +204,6 @@ def _dyn_close():  # pragma: no cover
             elif result.status == RunResult.IGNORED:
                 self.status.ignored += 1
                 log.info("Ignored (%d)", self.status.ignored)
-            elif result.status == RunResult.ERROR:
-                log.error("Test case was not served")
-                if not current_test.contains(current_test.landing_page):
-                    log.warning("Test case is missing landing page")
-                if self.status.iteration < 3:
-                    # since this is the first few iteration something is
-                    # likely wrong with the Target (caching?) or the Adapter
-                    raise SessionError("Please check Adapter and Target")
 
             # trigger relaunch by closing the browser if needed
             self.target.check_relaunch()
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index ffc1e780..cee84f1b 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -126,15 +126,9 @@ def generate(self, testcase, server_map):
     fake_target.monitor.launches = 1
     with IOManager() as iomgr:
         fake_serv.serve_path.return_value = (SERVED_NONE, [])
-        # test error on first iteration
         with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
             with raises(SessionError, match="Please check Adapter and Target"):
                 session.run([], iteration_limit=10)
-        # test that we continue if error happens later on
-        fake_serv.serve_path.return_value = (SERVED_REQUEST, ["x"])
-        with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
-            session.status.iteration = 2
-            session.run([], iteration_limit=3)
 
 def test_session_05(tmp_path, mocker):
     """test basic Session functions"""
@@ -215,8 +209,10 @@ def test_session_07(tmp_path, mocker):
 def test_session_08(tmp_path, mocker):
     """test Session.run() ignoring failures"""
     Status.PATH = str(tmp_path)
+    result = RunResult([], 0.1, status=RunResult.IGNORED)
+    result.attempted = True
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
-    fake_runner.return_value.run.return_value = RunResult([], 0.1, status=RunResult.IGNORED)
+    fake_runner.return_value.run.return_value = result
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
     fake_adapter.IGNORE_UNSERVED = True

From f3929ea9c9bb5eadf5534168d4536318bcc26001 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 10 Dec 2020 12:22:08 -0800
Subject: [PATCH 123/531] [sapphire] Add clear_backlog()

---
 sapphire/core.py          | 36 ++++++++++++++++++++++++++++++++----
 sapphire/test_sapphire.py | 14 ++++++++++++++
 2 files changed, 46 insertions(+), 4 deletions(-)

diff --git a/sapphire/core.py b/sapphire/core.py
index efb6aaf7..9b699a8e 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -11,7 +11,7 @@
 from random import randint
 from socket import AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
 from socket import error as sock_error, gethostname, socket
-from time import sleep
+from time import sleep, time
 
 from .job import Job, SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT
 from .connection_manager import ConnectionManager
@@ -25,6 +25,8 @@
 
 
 class Sapphire(object):
+    LISTEN_TIMEOUT = 0.25
+
     __slots__ = ("_auto_close", "_max_workers", "_socket", "_timeout")
 
     def __init__(self, allow_remote=False, auto_close=-1, max_workers=10, port=None, timeout=60):
@@ -40,8 +42,8 @@ def __enter__(self):
     def __exit__(self, *exc):
         self.close()
 
-    @staticmethod
-    def _create_listening_socket(remote, port=None, retries=20):
+    @classmethod
+    def _create_listening_socket(cls, remote, port=None, retries=20):
         """Create listening socket. Search for an open socket if needed and
         and configure the socket. If a specific port is unavailable or no
         available ports can be found a socket.error will be raised.
@@ -61,7 +63,7 @@ def _create_listening_socket(remote, port=None, retries=20):
             try:
                 sock = socket(AF_INET, SOCK_STREAM)
                 sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
-                sock.settimeout(0.25)
+                sock.settimeout(cls.LISTEN_TIMEOUT)
                 # find an unused port and avoid blocked ports
                 # see: dxr.mozilla.org/mozilla-central/source/netwerk/base/nsIOService.cpp
                 sock.bind((addr, port or randint(0x2000, 0xFFFF)))
@@ -76,6 +78,32 @@ def _create_listening_socket(remote, port=None, retries=20):
             break
         return sock
 
+    def clear_backlog(self):
+        """Remove all pending connections from backlog. This should only be
+        called when there isn't anything actively trying to connect.
+
+        Args:
+            None
+
+        Returns:
+            None
+        """
+        LOG.debug("clearing socket backlog")
+        self._socket.settimeout(0)
+        deadline = time() + 10
+        while True:
+            try:
+                self._socket.accept()[0].close()
+            except BlockingIOError:
+                break
+            except OSError as exc:
+                LOG.debug("Error closing socket: %r", exc)
+            else:
+                LOG.debug("pending socket closed")
+            # if this fires something is likely actively trying to connect
+            assert deadline > time()
+        self._socket.settimeout(self.LISTEN_TIMEOUT)
+
     def close(self):
         """Close listening server socket.
 
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 41e0e752..08c35c73 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -7,6 +7,7 @@
 import hashlib
 import os
 import random
+import socket
 import threading
 
 import pytest
@@ -624,6 +625,19 @@ def test_sapphire_31(mocker):
     assert fake_sock.return_value.listen.call_count == 1
     assert fake_sleep.call_count == 1
 
+def test_sapphire_32(mocker):
+    """test Sapphire.clear_backlog()"""
+    mocker.patch("sapphire.core.socket", autospec=True)
+    mocker.patch("sapphire.core.time", autospec=True, return_value=1)
+    pending = mocker.Mock(spec=socket.socket)
+    with Sapphire(timeout=10) as serv:
+        serv._socket = mocker.Mock(spec=socket.socket)
+        serv._socket.accept.side_effect = ((pending, None), OSError, BlockingIOError)
+        serv.clear_backlog()
+        assert serv._socket.accept.call_count == 3
+        assert serv._socket.settimeout.call_count == 2
+    assert pending.close.call_count == 1
+
 def test_main_01(mocker, tmp_path):
     """test Sapphire.main()"""
     args = mocker.Mock(

From 478fcd1101570b637390c8d4924b12cb3afa02f2 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 10 Dec 2020 12:26:21 -0800
Subject: [PATCH 124/531] [sapphire] Remove use of deprecated alias
 socket.error

---
 sapphire/core.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sapphire/core.py b/sapphire/core.py
index 9b699a8e..a686273d 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -10,7 +10,7 @@
 from os.path import abspath
 from random import randint
 from socket import AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
-from socket import error as sock_error, gethostname, socket
+from socket import gethostname, socket
 from time import sleep, time
 
 from .job import Job, SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT
@@ -68,7 +68,7 @@ def _create_listening_socket(cls, remote, port=None, retries=20):
                 # see: dxr.mozilla.org/mozilla-central/source/netwerk/base/nsIOService.cpp
                 sock.bind((addr, port or randint(0x2000, 0xFFFF)))
                 sock.listen(5)
-            except (OSError, sock_error) as soc_e:
+            except OSError as soc_e:
                 if sock is not None:
                     sock.close()
                 if retry > 1 and soc_e.errno in (EADDRINUSE, 10013):

From 78fa835371fc2ef2b6f76a51b7c9f582d1919c7a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 10 Dec 2020 12:27:59 -0800
Subject: [PATCH 125/531] Clear server connection backlog before launching
 target

---
 grizzly/common/runner.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 442a1c94..82689547 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -104,6 +104,7 @@ def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
         assert self._target is not None
         assert max_retries >= 0
         assert retry_delay >= 0
+        self._server.clear_backlog()
         LOG.debug("launching target (timeout %ds)", self._target.launch_timeout)
         for retries in reversed(range(max_retries)):
             try:

From 10e2d63629d5de3f02730ab911b349d37ce0d0eb Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 14 Dec 2020 10:02:07 -0800
Subject: [PATCH 126/531] [reduce] Change a variable name

---
 grizzly/reduce/strategies/beautify.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/grizzly/reduce/strategies/beautify.py b/grizzly/reduce/strategies/beautify.py
index eaa937ba..7f03e0c0 100644
--- a/grizzly/reduce/strategies/beautify.py
+++ b/grizzly/reduce/strategies/beautify.py
@@ -47,7 +47,7 @@ class _BeautifyStrategy(Strategy, ABC):
         tag_name (str): Tag name to search for in other (non-native) extensions.
     """
     all_extensions = None
-    blacklist_files = {"test_info.json", "prefs.js"}
+    ignore_files = {"test_info.json", "prefs.js"}
     import_available = None
     import_name = None
     native_extension = None
@@ -65,7 +65,7 @@ def __init__(self, testcases):
         self._files_to_beautify = []
         for path in self._testcase_root.glob("**/*"):
             if (path.is_file() and path.suffix in self.all_extensions
-                    and path.name not in self.blacklist_files):
+                    and path.name not in self.ignore_files):
                 if _contains_dd(path):
                     self._files_to_beautify.append(path)
         self._current_feedback = None

From 71e070a1d3f3d9911bd6e00467ee26295837c0dc Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 14 Dec 2020 10:03:18 -0800
Subject: [PATCH 127/531] [test] Fix indentation alignment

---
 grizzly/reduce/test_main.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 0459ff77..b1363e24 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -138,7 +138,7 @@ def test_main_launch_error(mocker, exc_type):
     )
 
     exc_obj = exc_type("error",
-                     mocker.Mock() if exc_type is TargetLaunchError else None)
+                       mocker.Mock() if exc_type is TargetLaunchError else None)
     run.side_effect = exc_obj
     assert ReduceManager.main(args) == 4
     if exc_type is TargetLaunchError:

From c0854a23d2a170165e0fc50aed52ea8ed126c171 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 14 Dec 2020 10:05:21 -0800
Subject: [PATCH 128/531] Change log level of 'Shutting down...' message

---
 grizzly/main.py          | 2 +-
 grizzly/reduce/core.py   | 2 +-
 grizzly/replay/replay.py | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/grizzly/main.py b/grizzly/main.py
index ef7f7257..00202486 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -143,7 +143,7 @@ def main(args):
         return Session.EXIT_LAUNCH_FAILURE
 
     finally:
-        log.warning("Shutting down...")
+        log.info("Shutting down...")
         if session is not None:
             log.debug("calling session.close()")
             session.close()
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index dab11f87..7f047892 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -693,7 +693,7 @@ def main(cls, args):
             return Session.EXIT_ERROR
 
         finally:
-            LOG.warning("Shutting down...")
+            LOG.info("Shutting down...")
             if target is not None:
                 target.cleanup()
             for testcase in testcases:
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 40f61ce5..1ced7d80 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -484,7 +484,7 @@ def main(cls, args):
             return Session.EXIT_LAUNCH_FAILURE
 
         finally:
-            LOG.warning("Shutting down...")
+            LOG.info("Shutting down...")
             if results:
                 # cleanup unreported results
                 for result in results:

From f755812042f266fb5efaab9001de7983f6ff8658 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 15 Dec 2020 16:38:26 -0800
Subject: [PATCH 129/531] [sapphire] Add support for required dynamic requests

---
 sapphire/job.py           |  4 +++
 sapphire/server_map.py    |  5 ++--
 sapphire/test_sapphire.py | 58 +++++++++++++++++++++++----------------
 sapphire/worker.py        |  6 ++--
 4 files changed, 45 insertions(+), 28 deletions(-)

diff --git a/sapphire/job.py b/sapphire/job.py
index 625f533a..d2e4773d 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -88,6 +88,10 @@ def _build_queue(self, optional_files):
                     "required" if resource.required else "optional",
                     redirect,
                     resource.target)
+            for dyn_resp, resource in self.server_map.dynamic.items():
+                if resource.required:
+                    self._pending.files.add(dyn_resp)
+                    LOG.debug("%s: %r -> %r", "required", dyn_resp, resource.target)
         self.initial_queue_size = len(self._pending.files)
         LOG.debug("%d files required to serve", self.initial_queue_size)
 
diff --git a/sapphire/server_map.py b/sapphire/server_map.py
index 1b565f8f..b0021949 100644
--- a/sapphire/server_map.py
+++ b/sapphire/server_map.py
@@ -53,7 +53,7 @@ def _check_url(url):
             raise InvalidURLError("Only alpha-numeric characters accepted in URL.")
         return url
 
-    def set_dynamic_response(self, url, callback, mime_type="application/octet-stream"):
+    def set_dynamic_response(self, url, callback, mime_type="application/octet-stream", required=False):
         url = self._check_url(url)
         if not callable(callback):
             raise TypeError("callback must be callable")
@@ -65,7 +65,8 @@ def set_dynamic_response(self, url, callback, mime_type="application/octet-strea
         self.dynamic[url] = Resource(
             Resource.URL_DYNAMIC,
             callback,
-            mime=mime_type)
+            mime=mime_type,
+            required=required)
 
     def set_include(self, url, target_path):
         url = self._check_url(url)
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 08c35c73..9ef706c5 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -385,17 +385,13 @@ def test_sapphire_18(client, tmp_path):
     assert inc403.code == 403
 
 def test_sapphire_19(client, tmp_path):
-    """test dynamic response"""
-    _test_string = b"dynamic response -- TEST DATA!"
-
-    def _dyn_test_cb():
-        return _test_string
-
+    """test dynamic response - not required"""
+    _data = b"dynamic response -- TEST DATA!"
+    test_dr = _TestFile("dyn_test")
+    test_dr.len_org = len(_data)
+    test_dr.md5_org = hashlib.md5(_data).hexdigest()
     smap = ServerMap()
-    test_dr = _TestFile("dynm_test")
-    test_dr.len_org = len(_test_string)
-    test_dr.md5_org = hashlib.md5(_test_string).hexdigest()
-    smap.set_dynamic_response("dynm_test", _dyn_test_cb, mime_type="text/plain")
+    smap.set_dynamic_response("dyn_test", lambda: _data, mime_type="text/plain")
     test = _create_test("test_case.html", tmp_path)
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [test_dr, test], in_order=True)
@@ -407,7 +403,23 @@ def _dyn_test_cb():
     assert test_dr.len_srv == test_dr.len_org
     assert test_dr.md5_srv == test_dr.md5_org
 
-def test_sapphire_20(client_factory, tmp_path):
+def test_sapphire_20(client, tmp_path):
+    """test dynamic response - required"""
+    _data = b"dynamic response -- TEST DATA!"
+    test_dr = _TestFile("dyn_test")
+    test_dr.len_org = len(_data)
+    test_dr.md5_org = hashlib.md5(_data).hexdigest()
+    smap = ServerMap()
+    smap.set_dynamic_response("dyn_test", lambda: _data, mime_type="text/plain", required=True)
+    with Sapphire(timeout=10) as serv:
+        client.launch("127.0.0.1", serv.port, [test_dr], in_order=True)
+        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == SERVED_ALL
+    assert client.wait(timeout=10)
+    assert test_dr.code == 200
+    assert test_dr.len_srv == test_dr.len_org
+    assert test_dr.md5_srv == test_dr.md5_org
+
+def test_sapphire_21(client_factory, tmp_path):
     """test pending_files == 0 in worker thread"""
     client_defer = client_factory(rx_size=2)
     # server should shutdown while this file is being served
@@ -426,7 +438,7 @@ def test_sapphire_20(client_factory, tmp_path):
     assert test.code == 200
     assert test_defer.code == 0
 
-def test_sapphire_21(client, tmp_path):
+def test_sapphire_22(client, tmp_path):
     """test handling an invalid request"""
     bad_test = _TestFile("bad.html")
     bad_test.custom_request = b"a bad request...0+%\xef\xb7\xba\r\n"
@@ -439,7 +451,7 @@ def test_sapphire_21(client, tmp_path):
     assert test.code == 200
     assert bad_test.code == 400
 
-def test_sapphire_22(client, tmp_path):
+def test_sapphire_23(client, tmp_path):
     """test handling an empty request"""
     bad_test = _TestFile("bad.html")
     bad_test.custom_request = b""
@@ -452,7 +464,7 @@ def test_sapphire_22(client, tmp_path):
     assert test.code == 200
     assert bad_test.code == 0
 
-def test_sapphire_23(client_factory, tmp_path):
+def test_sapphire_24(client_factory, tmp_path):
     """test requesting multiple files via multiple connections"""
     to_serve = list()
     for i in range(2):
@@ -478,7 +490,7 @@ def test_sapphire_23(client_factory, tmp_path):
         assert t_file.code == 200
         assert t_file.len_srv == t_file.len_org
 
-def test_sapphire_24(client_factory, tmp_path):
+def test_sapphire_25(client_factory, tmp_path):
     """test all request types via multiple connections"""
     def _dyn_test_cb():
         return b"A" if random.getrandbits(1) else b"AA"
@@ -509,7 +521,7 @@ def _dyn_test_cb():
             clients[-1].launch("127.0.0.1", serv.port, to_serve, throttle=throttle)
         assert serv.serve_path(str(tmp_path), server_map=smap)[0] == SERVED_ALL
 
-def test_sapphire_25(client, tmp_path):
+def test_sapphire_26(client, tmp_path):
     """test dynamic response with bad callbacks"""
     test_dr = _TestFile("dynm_test")
     smap = ServerMap()
@@ -520,7 +532,7 @@ def test_sapphire_25(client, tmp_path):
         with pytest.raises(TypeError):
             serv.serve_path(str(tmp_path), server_map=smap)
 
-def test_sapphire_26(client, tmp_path):
+def test_sapphire_27(client, tmp_path):
     """test serving to a slow client"""
     t_data = "".join(random.choice("ABCD1234") for _ in range(0x19000))  # 100KB
     t_file = _create_test("test_case.html", tmp_path, data=t_data.encode("ascii"), calc_hash=True)
@@ -536,7 +548,7 @@ def test_sapphire_26(client, tmp_path):
     assert t_file.len_srv == t_file.len_org
     assert t_file.md5_srv == t_file.md5_org
 
-def test_sapphire_27(client, tmp_path):
+def test_sapphire_28(client, tmp_path):
     """test timeout while requesting multiple files"""
     files_to_serve = list()
     t_data = "".join(random.choice("ABCD1234") for _ in range(1024)).encode("ascii")
@@ -549,7 +561,7 @@ def test_sapphire_27(client, tmp_path):
     assert status == SERVED_TIMEOUT
     assert len(files_served) < len(files_to_serve)
 
-def test_sapphire_28(client_factory, tmp_path):
+def test_sapphire_29(client_factory, tmp_path):
     """test Sapphire.serve_path() with forever=True"""
     clients = list()
     with Sapphire(timeout=10) as serv:
@@ -570,7 +582,7 @@ def _test_callback():
     assert test.code == 200
     assert test.len_srv == test.len_org
 
-def test_sapphire_29(client, tmp_path):
+def test_sapphire_30(client, tmp_path):
     """test interesting file names"""
     to_serve = [
         # space in file name
@@ -583,7 +595,7 @@ def test_sapphire_29(client, tmp_path):
     assert client.wait(timeout=10)
     assert all(t_file.code == 200 for t_file in to_serve)
 
-def test_sapphire_30(client, tmp_path):
+def test_sapphire_31(client, tmp_path):
     """test interesting path string"""
     all_bytes = "".join(chr(i) for i in range(256))
     to_serve = [
@@ -597,7 +609,7 @@ def test_sapphire_30(client, tmp_path):
     assert client.wait(timeout=10)
     assert all(t_file.code is not None for t_file in to_serve)
 
-def test_sapphire_31(mocker):
+def test_sapphire_32(mocker):
     """test Sapphire._create_listening_socket()"""
     fake_sleep = mocker.patch("sapphire.core.sleep", autospec=True)
     fake_sock = mocker.patch("sapphire.core.socket", autospec=True)
@@ -625,7 +637,7 @@ def test_sapphire_31(mocker):
     assert fake_sock.return_value.listen.call_count == 1
     assert fake_sleep.call_count == 1
 
-def test_sapphire_32(mocker):
+def test_sapphire_33(mocker):
     """test Sapphire.clear_backlog()"""
     mocker.patch("sapphire.core.socket", autospec=True)
     mocker.patch("sapphire.core.time", autospec=True, return_value=1)
diff --git a/sapphire/worker.py b/sapphire/worker.py
index 46915eda..c06fa4dd 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -111,9 +111,9 @@ def handle_request(cls, conn, serv_job):
                 LOG.debug("resource is None")  # 404
             elif resource.type in (Resource.URL_FILE, Resource.URL_INCLUDE):
                 finish_job = serv_job.remove_pending(resource.target)
-            elif resource.type == Resource.URL_REDIRECT:
+            elif resource.type in (Resource.URL_DYNAMIC, Resource.URL_REDIRECT):
                 finish_job = serv_job.remove_pending(request)
-            elif resource.type != Resource.URL_DYNAMIC:  # pragma: no cover
+            else:  # pragma: no cover
                 # this should never happen
                 raise WorkerError("Unknown resource type %r" % (resource.type,))
 
@@ -155,7 +155,7 @@ def handle_request(cls, conn, serv_job):
                     raise TypeError("dynamic request callback must return 'bytes'")
                 conn.sendall(cls._200_header(len(data), resource.mime))
                 conn.sendall(data)
-                LOG.debug("200 %r (dynamic request)", request)
+                LOG.debug("200 %r - dynamic request (%d to go)", request, serv_job.pending)
                 return
 
             # at this point we know "resource.target" maps to a file on disk

From 78211347ac14fbab0ade753ea39fc696a96565aa Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 15 Dec 2020 19:26:17 -0800
Subject: [PATCH 130/531] Remove grz_close_browser and move Target
 shutdown/relaunch to runner

---
 grizzly/common/harness.html   | 24 ++++-----
 grizzly/common/runner.py      | 56 ++++++++++++++++-----
 grizzly/common/test_runner.py | 95 +++++++++++++++++++++++++++++------
 grizzly/replay/replay.py      | 18 +++----
 grizzly/replay/test_main.py   |  6 ++-
 grizzly/replay/test_replay.py | 52 ++++++++++++-------
 grizzly/session.py            | 19 +------
 grizzly/target/target.py      |  1 +
 grizzly/test_session.py       |  9 ++--
 9 files changed, 188 insertions(+), 92 deletions(-)

diff --git a/grizzly/common/harness.html b/grizzly/common/harness.html
index 04f86c36..a22ff1db 100644
--- a/grizzly/common/harness.html
+++ b/grizzly/common/harness.html
@@ -5,7 +5,6 @@
 <title>&#x1f43b; &sdot; Grizzly &sdot; &#x1f98a;</title>
 <script>
 let close_after, limit_tmr, time_limit
-let forced_close = true
 let sub = null
 
 let grzDump = (msg) => {
@@ -42,13 +41,18 @@
   }
 
   if ((close_after !== undefined) && (close_after-- < 1)) {
-    grzDump('Hit close limit.')
-    if (forced_close) {
-      // use window.open() to call `/grz_close_browser` then close the harness
-      // this helps catch crashes that are triggered when the test window closes
-      window.open('/grz_close_browser')
-    }
-    setTimeout(window.close, 0)
+    grzDump('Iteration limit hit.')
+    setBanner('Iteration limit hit. Browser should close momentarily...<br>' +
+              'Warning: Any additional open tabs can block browser from closing.')
+    try { window.focus() } catch(e) { }
+    let xhr = new XMLHttpRequest()
+    // indicate test is complete by requesting `/grz_next_test`
+    try { xhr.open('GET', '/grz_next_test', true) } catch (e) {}
+    xhr.onabort = () => { window.close() }
+    xhr.onerror = () => { window.close() }
+    xhr.onload = () => { window.close() }
+    // close the harness to catch crashes that are triggered when the browser closes
+    setTimeout(() => { xhr.send() }, 100)
     return
   }
 
@@ -86,10 +90,6 @@
         time_limit = Number(v)
       } else if (k === 'close_after') {
         close_after = Number(v)
-      } else if (k === 'forced_close') {
-        if (v === 'false' || v === '0') {
-          forced_close = false
-        }
       } else {
         grzDump(`unknown arg '${k}'`)
       }
diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 82689547..757630ae 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -74,15 +74,19 @@ def schedule_poll(self, initial=False, now=None):
 
 
 class Runner(object):
-    __slots__ = ("_idle", "_server", "_target", "_tests_run")
+    __slots__ = ("_close_delay", "_idle", "_relaunch", "_server", "_target", "_tests_run")
 
-    def __init__(self, server, target, idle_threshold=0, idle_delay=0):
+    def __init__(self, server, target, close_delay=30, idle_threshold=0, idle_delay=0, relaunch=1):
+        self._close_delay = close_delay
         if idle_threshold > 0:
             assert idle_delay > 0
             LOG.debug("using idle check, th %d, delay %ds", idle_threshold, idle_delay)
             self._idle = _IdleChecker(target.is_idle, idle_threshold, idle_delay)
         else:
             self._idle = None
+        assert close_delay > 0
+        assert relaunch > 0
+        self._relaunch = relaunch  # tests to run before relaunching target
         self._server = server  # a sapphire instance to serve the test case
         self._target = target  # target to run test case
         self._tests_run = 0  # number of tests run since target (re)launched
@@ -175,6 +179,10 @@ def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait
         """
         if self._idle is not None:
             self._idle.schedule_poll(initial=True)
+        if self._tests_run == self._relaunch - 1:
+            # overwrite instead of replace 'grz_next_test' for consistency
+            server_map.set_redirect("grz_next_test", "grz_empty", required=True)
+            server_map.set_dynamic_response("grz_empty", lambda: b"", required=True)
         try:
             # unpack test case
             if test_path is None:
@@ -196,25 +204,47 @@ def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait
             if test_path is None:
                 rmtree(wwwdir)
         result = RunResult(served, duration, timeout=server_status == SERVED_TIMEOUT)
+        result.attempted = testcase.landing_page in result.served
+        result.initial = self._tests_run == 0
         # TODO: fix calling TestCase.add_batch() for multi-test replay
         # add all include files that were served
         for url, resource in server_map.include.items():
             testcase.add_batch(resource.target, result.served, prefix=url)
-        result.attempted = testcase.landing_page in result.served
-        if result.attempted and coverage and not result.timeout:
-            # dump_coverage() should be called before detect_failure()
-            # to help catch any coverage related issues.
-            self._target.dump_coverage()
-        # detect failure
-        failure_detected = self._target.detect_failure(ignore, result.timeout)
-        result.initial = self._tests_run == 0
-        if not result.attempted:
+        if result.attempted:
+            self._tests_run += 1
+            if coverage and not result.timeout:
+                # dump_coverage() should be called before detect_failure()
+                # to help catch any coverage related issues.
+                self._target.dump_coverage()
+            # relaunch check
+            if self._tests_run >= self._relaunch:
+                assert self._tests_run >= self._relaunch
+                server_map.dynamic.pop("grz_empty", None)
+                LOG.debug("relaunch/shutdown limit hit")
+                # ideally all browser tabs should be closed at this point
+                # and the browser should exit on its own
+                # NOTE: this will take the full duration if target.is_idle()
+                # is not implemented
+                for close_delay in range(max(int(self._close_delay / 0.5), 1)):
+                    if not self._target.monitor.is_healthy():
+                        break
+                    # wait 2 seconds (4 passes) before attempting idle exit
+                    if close_delay > 3 and self._target.is_idle(10):
+                        LOG.debug("target idle")
+                        break
+                    # delay to help catch shutdown related crashes, LSan, etc.
+                    # debugger and different builds can slow shutdown
+                    sleep(0.5)
+                else:
+                    LOG.debug("target.close() required")
+                self._target.close()
+        else:
             # something is wrong so close the target
             # previous iteration put target in a bad state?
             LOG.debug("landing page %r not served!", testcase.landing_page)
             self._target.close()
-        else:
-            self._tests_run += 1
+        # detect failure
+        failure_detected = self._target.detect_failure(ignore, result.timeout)
         if failure_detected == self._target.RESULT_FAILURE:
             result.status = RunResult.FAILED
         elif failure_detected == self._target.RESULT_IGNORED:
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index e923bb04..ab89ce60 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -16,19 +16,21 @@
 
 def test_runner_01(mocker, tmp_path):
     """test Runner()"""
-    fake_time = mocker.patch("grizzly.common.runner.time", autospec=True)
+    mocker.patch("grizzly.common.runner.time", autospec=True, side_effect=range(10))
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
     target.detect_failure.return_value = target.RESULT_NONE
-    runner = Runner(server, target)
+    runner = Runner(server, target, relaunch=10)
     assert runner._idle is None
+    assert runner._relaunch == 10
+    assert runner._tests_run == 0
     serv_files = ["a.bin", "/another/file.bin"]
     testcase = mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[])
     # all files served
-    fake_time.side_effect = (1, 2)
     server.serve_path.return_value = (SERVED_ALL, serv_files)
     result = runner.run([], ServerMap(), testcase)
     assert result.attempted
+    assert runner._tests_run == 1
     assert result.duration == 1
     assert result.initial
     assert result.status is None
@@ -38,10 +40,10 @@ def test_runner_01(mocker, tmp_path):
     assert target.dump_coverage.call_count == 0
     assert testcase.dump.call_count == 1
     # some files served
-    fake_time.side_effect = (1, 2)
     server.serve_path.return_value = (SERVED_REQUEST, serv_files)
     result = runner.run([], ServerMap(), testcase, coverage=True)
     assert result.attempted
+    assert runner._tests_run == 2
     assert not result.initial
     assert result.status is None
     assert result.served == serv_files
@@ -49,13 +51,13 @@ def test_runner_01(mocker, tmp_path):
     assert target.close.call_count == 0
     assert target.dump_coverage.call_count == 1
     # existing test path
-    fake_time.side_effect = (1, 2)
     testcase.reset_mock()
     tc_path = (tmp_path / "tc")
     tc_path.mkdir()
     server.serve_path.return_value = (SERVED_ALL, serv_files)
     result = runner.run([], ServerMap(), testcase, test_path=str(tc_path))
     assert result.attempted
+    assert runner._tests_run == 3
     assert not result.initial
     assert result.status is None
     assert target.close.call_count == 0
@@ -63,6 +65,70 @@ def test_runner_01(mocker, tmp_path):
     tc_path.is_dir()
 
 def test_runner_02(mocker):
+    """test Runner.run() relaunch"""
+    mocker.patch("grizzly.common.runner.time", autospec=True, return_value=1)
+    mocker.patch("grizzly.common.runner.sleep", autospec=True)
+    server = mocker.Mock(spec=Sapphire)
+    target = mocker.Mock(spec=Target)
+    target.detect_failure.return_value = target.RESULT_NONE
+    serv_files = ["a.bin"]
+    server.serve_path.return_value = (SERVED_ALL, serv_files)
+    testcase = mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[])
+    # single run/iteration relaunch (not idle exit)
+    target.is_idle.return_value = False
+    runner = Runner(server, target, relaunch=1)
+    assert runner._relaunch == 1
+    smap = ServerMap()
+    result = runner.run([], smap, testcase)
+    assert result.attempted
+    assert result.initial
+    assert target.close.call_count == 1
+    assert target.is_idle.call_count > 0
+    assert target.monitor.is_healthy.call_count > 0
+    assert result.status is None
+    assert result.served == serv_files
+    assert not smap.dynamic
+    assert smap.redirect.get("grz_next_test").target == "grz_empty"
+    assert not result.timeout
+    target.reset_mock()
+    testcase.reset_mock()
+    # single run/iteration relaunch (idle exit)
+    target.is_idle.return_value = True
+    runner = Runner(server, target, relaunch=1)
+    assert runner._relaunch == 1
+    result = runner.run([], ServerMap(), testcase)
+    assert result.attempted
+    assert target.close.call_count == 1
+    assert target.monitor.is_healthy.call_count > 0
+    target.reset_mock()
+    testcase.reset_mock()
+    # multiple runs/iterations relaunch (is_healty exit)
+    runner = Runner(server, target, relaunch=3)
+    target.monitor.is_healthy.return_value = False
+    for _ in range(2):
+        smap = ServerMap()
+        result = runner.run([], smap, testcase)
+        assert result.attempted
+        assert target.close.call_count == 0
+        assert target.monitor.is_healthy.call_count == 0
+        assert result.status is None
+        assert result.served == serv_files
+        assert not result.timeout
+        assert not smap.dynamic
+        assert "grz_next_test" not in smap.redirect
+    smap = ServerMap()
+    result = runner.run([], smap, testcase)
+    assert runner._tests_run == 3
+    assert result.attempted
+    assert target.close.call_count == 1
+    assert target.is_idle.call_count == 0
+    assert target.monitor.is_healthy.call_count == 1
+    assert result.status is None
+    assert result.served == serv_files
+    assert not smap.dynamic
+    assert smap.redirect.get("grz_next_test").target == "grz_empty"
+
+def test_runner_03(mocker):
     """test Runner() errors"""
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
@@ -88,7 +154,7 @@ def test_runner_02(mocker):
     assert result.served
     assert target.close.call_count == 1
 
-def test_runner_03(mocker):
+def test_runner_04(mocker):
     """test reporting timeout"""
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
@@ -101,10 +167,11 @@ def test_runner_03(mocker):
     assert result.served == serv_files
     assert result.timeout
 
-def test_runner_04(mocker):
+def test_runner_05(mocker):
     """test reporting failures"""
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
+    target.monitor.is_healthy.return_value = False
     serv_files = ["file.bin"]
     server.serve_path.return_value = (SERVED_REQUEST, serv_files)
     testcase = mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[])
@@ -132,21 +199,21 @@ def test_runner_04(mocker):
     assert result.served
     assert not result.timeout
 
-def test_runner_05(mocker):
+def test_runner_06(mocker):
     """test Runner() with idle checking"""
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
     target.detect_failure.return_value = target.RESULT_NONE
     serv_files = ["/fake/file", "/another/file.bin"]
     server.serve_path.return_value = (SERVED_REQUEST, serv_files)
-    runner = Runner(server, target, idle_threshold=0.01, idle_delay=0.01)
+    runner = Runner(server, target, idle_threshold=0.01, idle_delay=0.01, relaunch=10)
     assert runner._idle is not None
     result = runner.run([], ServerMap(), mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[]))
     assert result.status is None
     assert result.attempted
     assert target.close.call_count == 0
 
-def test_runner_06(mocker):
+def test_runner_07(mocker):
     """test Runner._keep_waiting()"""
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
@@ -171,7 +238,7 @@ def test_runner_06(mocker):
     target.monitor.is_healthy.return_value = False
     assert not runner._keep_waiting()
 
-def test_runner_07():
+def test_runner_08():
     """test Runner.location()"""
     result = Runner.location("a.html", 34567)
     assert result == "http://127.0.0.1:34567/a.html"
@@ -186,7 +253,7 @@ def test_runner_07():
     result = Runner.location("a.html", 9999, close_after=10, forced_close=False, timeout=60)
     assert result == "http://127.0.0.1:9999/a.html?close_after=10&forced_close=0&timeout=60000"
 
-def test_runner_08(mocker):
+def test_runner_09(mocker):
     """test Runner.launch()"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     target = mocker.Mock(spec=Target, launch_timeout=30)
@@ -209,12 +276,12 @@ def test_runner_08(mocker):
         runner.launch("http://a/", max_retries=3)
     assert target.launch.call_count == 3
 
-def test_runner_09(mocker, tmp_path):
+def test_runner_10(mocker, tmp_path):
     """test Runner.run() adding includes to testcase"""
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
     target.detect_failure.return_value = target.RESULT_NONE
-    runner = Runner(server, target)
+    runner = Runner(server, target, relaunch=10)
     # create test files
     inc_path1 = (tmp_path / "include")
     inc_path1.mkdir()
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 1ced7d80..1822510a 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -6,7 +6,6 @@
 from logging import getLogger
 from os.path import dirname, join as pathjoin
 from tempfile import mkdtemp
-from time import sleep
 from shutil import rmtree
 
 from FTB.Signatures.CrashInfo import CrashSignature
@@ -175,16 +174,8 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
 
         server_map = ServerMap()
         if self._harness is not None:
-            def _dyn_close():  # pragma: no cover
-                if self.target.monitor.is_healthy():
-                    # delay to help catch window close/shutdown related crashes
-                    sleep(0.1)
-                    self.target.close()
-                return b"<h1>Close Browser</h1>"
-            server_map.set_dynamic_response("grz_close_browser", _dyn_close, mime_type="text/html")
             server_map.set_dynamic_response("grz_harness", lambda: self._harness, mime_type="text/html")
 
-        runner = Runner(self.server, self.target, idle_threshold=idle_threshold, idle_delay=idle_delay)
         # track unprocessed results
         reports = dict()
         # track unpacked testcases
@@ -197,6 +188,12 @@ def _dyn_close():  # pragma: no cover
                 dst_path = mkdtemp(prefix="tc_", dir=grz_tmp("serve"))
                 unpacked.append(dst_path)
                 test.dump(dst_path)
+            runner = Runner(
+                self.server,
+                self.target,
+                idle_threshold=idle_threshold,
+                idle_delay=idle_delay,
+                relaunch=self.target.rl_reset * test_count)
             # perform iterations
             for _ in range(repeat):
                 self.status.iteration += 1
@@ -328,9 +325,6 @@ def _dyn_close():  # pragma: no cover
                 #if self.status.log_size > self.TARGET_LOG_SIZE_WARN:
                 #    LOG.warning("Large browser logs: %dMBs", (self.status.log_size / 0x100000))
 
-                # trigger relaunch by closing the browser if needed
-                self.target.check_relaunch()
-
             # process results
             results = list()
             if self._any_crash:
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 65a120bd..55e8cfc1 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -74,6 +74,7 @@ def test_main_01(mocker, tmp_path):
     # Of the four attempts only the first and third will 'reproduce' the result
     # and the forth attempt should be skipped.
     # mock Sapphire.serve_path only
+    mocker.patch("grizzly.common.runner.sleep", autospec=True)
     serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
     serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
@@ -115,9 +116,8 @@ def test_main_01(mocker, tmp_path):
     assert target.detect_failure.call_count == 3
     assert serve_path.call_count == 3
     assert load_target.call_count == 1
-    assert target.close.call_count == 1
+    assert target.close.call_count == 4
     assert target.cleanup.call_count == 1
-    assert target.check_relaunch.call_count == 2
     assert log_path.is_dir()
     assert any(log_path.glob('**/log_asan_blah.txt'))
     assert any(log_path.glob('**/log_stderr.txt'))
@@ -203,6 +203,7 @@ def test_main_03(mocker, tmp_path):
 
 def test_main_04(mocker):
     """test ReplayManager.main() loading GRZ_FORCED_CLOSE from selected test case"""
+    # TODO: Remove this test when removing 'target.forced_close'
     mocker.patch("grizzly.replay.replay.Sapphire.serve_path", return_value=(None, ["x.html"]))
     target = mocker.Mock(spec=Target, forced_close=True, launch_timeout=30, rl_reset=1)
     load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
@@ -245,6 +246,7 @@ def test_main_05(mocker, tmp_path):
     target = mocker.Mock(spec=Target, binary="bin", forced_close=True, launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     load_target = mocker.patch("grizzly.replay.replay.load_target")
     load_target.return_value.return_value = target
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 14602eab..d200ae7e 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -37,6 +37,7 @@ def test_replay_01(mocker):
 
 def test_replay_02(mocker, tmp_path):
     """test ReplayManager.run() - no repro"""
+    mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
@@ -50,8 +51,8 @@ def test_replay_02(mocker, tmp_path):
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
             assert replay.status.results == 0
-            assert target.close.call_count == 1
-            assert target.check_relaunch.call_count == 0
+            assert target.monitor.is_healthy.call_count > 0
+            assert target.close.call_count == 2
         assert not any(tmp_path.glob("*"))
 
 def test_replay_03(mocker):
@@ -69,7 +70,6 @@ def test_replay_03(mocker):
             assert replay.status.iteration == 10
             assert replay.status.results == 0
             assert target.close.call_count == 1
-            assert target.check_relaunch.call_count == 9
 
 def test_replay_04(mocker, tmp_path):
     """test ReplayManager.run() - successful repro"""
@@ -88,8 +88,8 @@ def test_replay_04(mocker, tmp_path):
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
             assert replay.status.results == 1
+            assert target.monitor.is_healthy.call_count == 0
             assert target.close.call_count == 1
-            assert target.check_relaunch.call_count == 0
         assert len(results) == 1
         assert results[0].count == 1
         assert results[0].expected
@@ -116,7 +116,6 @@ def test_replay_05(mocker, tmp_path):
         assert replay.status.results == 0
         # target.close() called once in runner and once by ReplayManager.run()
         assert target.close.call_count == 2
-    assert target.check_relaunch.call_count == 0
     assert target.save_logs.call_count == 1
 
 def test_replay_06(mocker, tmp_path):
@@ -137,7 +136,6 @@ def test_replay_06(mocker, tmp_path):
         assert replay.status.results == 1
         # target.close() called once in runner and once by ReplayManager.run()
         assert target.close.call_count == 2
-    assert target.check_relaunch.call_count == 1
 
 def test_replay_07(mocker, tmp_path):
     """test ReplayManager.run() - ignored"""
@@ -147,10 +145,12 @@ def test_replay_07(mocker, tmp_path):
     target = mocker.Mock(spec=Target, launch_timeout=30, rl_reset=1)
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = Target.RESULT_IGNORED
+    target.monitor.is_healthy.return_value = False
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases)
-        assert target.close.call_count == 1
+        assert target.monitor.is_healthy.call_count == 1
+        assert target.close.call_count == 2
         assert replay.status.ignored == 1
         assert replay.status.iteration == 1
         assert replay.status.results == 0
@@ -158,6 +158,7 @@ def test_replay_07(mocker, tmp_path):
 
 def test_replay_08(mocker, tmp_path):
     """test ReplayManager.run() - early exit"""
+    mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
@@ -169,18 +170,20 @@ def test_replay_08(mocker, tmp_path):
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     # early failure
     target.detect_failure.side_effect = (Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_NONE)
+    target.monitor.is_healthy.side_effect = (False, False, True, False)
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases, repeat=4, min_results=3)
-        assert target.close.call_count == 1
+        assert target.close.call_count == 4
         assert replay.status.iteration == 3
         assert replay.status.results == 1
         assert replay.status.ignored == 1
     # early success
     target.reset_mock()
     target.detect_failure.side_effect = (Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_FAILURE)
+    target.monitor.is_healthy.side_effect = (False, False, False)
     with ReplayManager([], server, target, use_harness=False) as replay:
         results = replay.run(testcases, repeat=4, min_results=2)
-        assert target.close.call_count == 1
+        assert target.close.call_count == 4
         assert replay.status.iteration == 3
         assert replay.status.results == 2
         assert replay.status.ignored == 1
@@ -190,18 +193,21 @@ def test_replay_08(mocker, tmp_path):
     # ignore early failure (perform all repeats)
     target.detect_failure.return_value = Target.RESULT_NONE
     target.detect_failure.side_effect = None
+    target.monitor.is_healthy.side_effect = None
+    target.monitor.is_healthy.return_value = True
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases, repeat=4, min_results=4, exit_early=False)
-        assert target.close.call_count == 1
+        assert target.close.call_count == 5
         assert replay.status.iteration == 4
         assert replay.status.results == 0
         assert replay.status.ignored == 0
     target.reset_mock()
     # ignore early success (perform all repeats)
     target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.monitor.is_healthy.return_value = False
     with ReplayManager([], server, target, use_harness=False) as replay:
         results = replay.run(testcases, repeat=4, min_results=1, exit_early=False)
-        assert target.close.call_count == 1
+        assert target.close.call_count == 5
         assert replay.status.iteration == 4
         assert replay.status.results == 4
         assert replay.status.ignored == 0
@@ -210,6 +216,7 @@ def test_replay_08(mocker, tmp_path):
 
 def test_replay_09(mocker, tmp_path):
     """test ReplayManager.run() - test signatures - fail to meet minimum"""
+    mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report)
     report_0.crash_info.createShortSignature.return_value = "No crash detected"
@@ -232,7 +239,7 @@ def test_replay_09(mocker, tmp_path):
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, signature=signature, use_harness=False) as replay:
         results = replay.run(testcases, repeat=4, min_results=2)
-        assert target.close.call_count == 1
+        assert target.close.call_count == 5
         assert replay.signature == signature
         assert replay.status.iteration == 4
         assert replay.status.results == 1
@@ -264,10 +271,11 @@ def test_replay_10(mocker, tmp_path):
     target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.monitor.is_healthy.return_value = False
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[])]
     with ReplayManager([], server, target, signature=signature, use_harness=False) as replay:
         results = replay.run(testcases, repeat=2, min_results=2)
-        assert target.close.call_count == 1
+        assert target.close.call_count == 3
         assert replay.signature == signature
         assert replay.status.iteration == 2
         assert replay.status.results == 2
@@ -296,10 +304,11 @@ def test_replay_11(mocker, tmp_path):
     target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.monitor.is_healthy.return_value = False
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
         results = replay.run(testcases, repeat=3, min_results=2)
-        assert target.close.call_count == 1
+        assert target.close.call_count == 4
         assert replay.signature is None
         assert replay.status.iteration == 3
         assert replay.status.results == 2
@@ -330,9 +339,11 @@ def test_replay_12(mocker, tmp_path):
     target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.monitor.is_healthy.return_value = False
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, any_crash=True) as replay:
         assert not replay.run(testcases, repeat=4, min_results=3)
+        assert target.close.call_count == 5
         assert replay.signature is None
         assert replay.status.iteration == 4
         assert replay.status.results == 2
@@ -362,10 +373,11 @@ def test_replay_13(mocker, tmp_path):
     target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.monitor.is_healthy.return_value = False
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, use_harness=False) as replay:
         results = replay.run(testcases, repeat=3, min_results=2)
-        assert target.close.call_count == 1
+        assert target.close.call_count == 4
         assert replay.signature == auto_sig
         assert replay.status.iteration == 3
         assert replay.status.results == 2
@@ -390,11 +402,12 @@ def test_replay_14(mocker, tmp_path):
     target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.monitor.is_healthy.return_value = False
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
         with raises(KeyboardInterrupt):
             replay.run(testcases, repeat=3, min_results=2)
-        assert target.close.call_count == 1
+        assert target.close.call_count == 2
         assert replay.signature is None
         assert replay.status.iteration == 2
         assert replay.status.results == 1
@@ -404,6 +417,7 @@ def test_replay_14(mocker, tmp_path):
 
 def test_replay_15(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
+    mocker.patch("grizzly.common.runner.sleep", autospec=True)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target, closed=True, forced_close=True, launch_timeout=30, rl_reset=1)
@@ -415,7 +429,7 @@ def test_replay_15(mocker):
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, use_harness=True) as replay:
         assert not replay.run(testcases)
-        assert target.close.call_count == 1
+        assert target.close.call_count == 2
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 0
@@ -456,6 +470,7 @@ def test_replay_17(mocker, tmp_path):
         Target.RESULT_NONE,
         Target.RESULT_NONE,
         Target.RESULT_FAILURE)
+    target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     testcases = [
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[]),
@@ -463,7 +478,7 @@ def test_replay_17(mocker, tmp_path):
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="c.html", optional=[])]
     with ReplayManager([], server, target, use_harness=True) as replay:
         results = replay.run(testcases)
-        assert target.close.call_count == 1
+        assert target.close.call_count == 2
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 1
@@ -477,6 +492,7 @@ def test_replay_17(mocker, tmp_path):
 
 def test_replay_18(mocker, tmp_path):
     """test ReplayManager.run() - multiple calls"""
+    mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
diff --git a/grizzly/session.py b/grizzly/session.py
index 38a62689..a74a459c 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -7,7 +7,7 @@
 from os.path import isdir
 from shutil import rmtree
 from tempfile import mkdtemp
-from time import sleep, time
+from time import time
 
 from .common import grz_tmp, Report, Runner, RunResult, Status, TestFile
 
@@ -123,19 +123,7 @@ def report_result(self):
 
     def run(self, ignore, iteration_limit=None, display_mode=DISPLAY_NORMAL):
         log_limiter = LogOutputLimiter(verbose=display_mode == self.DISPLAY_VERBOSE)
-        runner = Runner(self.server, self.target)
-
-        def _dyn_close():  # pragma: no cover
-            if self.target.monitor.is_healthy():
-                # delay to help catch window close/shutdown related crashes
-                sleep(0.1)
-                self.target.close()
-            return b"<h1>Close Browser</h1>"
-        self.iomanager.server_map.set_dynamic_response(
-            "grz_close_browser",
-            _dyn_close,
-            mime_type="text/html")
-
+        runner = Runner(self.server, self.target, relaunch=self.target.rl_reset)
         while True:
             self.status.report()
             self.status.iteration += 1
@@ -205,9 +193,6 @@ def _dyn_close():  # pragma: no cover
                 self.status.ignored += 1
                 log.info("Ignored (%d)", self.status.ignored)
 
-            # trigger relaunch by closing the browser if needed
-            self.target.check_relaunch()
-
             if self.adapter.remaining is not None and self.adapter.remaining < 1:
                 # all test cases have been replayed
                 log.info("Replay Complete")
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 1263b416..08e3a0af 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -53,6 +53,7 @@ class TargetLaunchTimeout(TargetError):
     """Raised if the target does not launch within the defined amount of time"""
 
 
+# TODO: remove forced_close, rl_countdown, rl_reset, relaunch, check_relaunch, expect_close
 class Target(metaclass=ABCMeta):
     RESULT_NONE = 0
     RESULT_FAILURE = 1
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index cee84f1b..8b696ab9 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -10,7 +10,7 @@
 
 from pytest import raises
 
-from sapphire import Sapphire, ServerMap, SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
+from sapphire import Sapphire, ServerMap, SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT
 from .common import Adapter, IOManager, Report, Reporter, RunResult, Status, TestCase
 from .session import LogOutputLimiter, Session, SessionError
 from .target import Target, TargetLaunchError
@@ -49,7 +49,7 @@ def generate(self, testcase, server_map):
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     prefs = tmp_path / "prefs.js"
     prefs.touch()
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=str(prefs))
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=str(prefs), rl_reset=10)
     # set target.log_size to test warning code path
     fake_target.log_size.return_value = Session.TARGET_LOG_SIZE_WARN + 1
     with IOManager() as iomgr:
@@ -95,6 +95,7 @@ def generate(self, testcase, server_map):
             assert testcase.adapter_name == self.NAME
             testcase.add_from_data("test", testcase.landing_page)
     Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.common.runner.sleep", autospec=True)
     adapter = FuzzAdapter()
     adapter.setup(None, None)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
@@ -122,7 +123,7 @@ def generate(self, testcase, server_map):
     adapter = FuzzAdapter()
     adapter.setup(None, None)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None, rl_reset=10)
     fake_target.monitor.launches = 1
     with IOManager() as iomgr:
         fake_serv.serve_path.return_value = (SERVED_NONE, [])
@@ -143,7 +144,7 @@ def test_session_05(tmp_path, mocker):
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     # return SERVED_TIMEOUT to test IGNORE_UNSERVED code path
     fake_serv.serve_path.return_value = (SERVED_TIMEOUT, [fake_testcase.landing_page])
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None, rl_reset=10)
     fake_target.monitor.launches = 1
     with Session(fake_adapter, fake_iomgr, None, fake_serv, fake_target) as session:
         session.run([], iteration_limit=1)

From 9aacf494770192a52f887106e4b0562fea009535 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 16 Dec 2020 17:02:56 -0800
Subject: [PATCH 131/531] Remove Target.forced_close and Target.expect_close

---
 grizzly/common/runner.py             |  5 +-
 grizzly/common/test_runner.py        | 10 ++--
 grizzly/reduce/test_main.py          | 27 ---------
 grizzly/replay/replay.py             |  6 +-
 grizzly/replay/test_main.py          | 86 ++++++++++++++--------------
 grizzly/replay/test_replay.py        |  8 +--
 grizzly/session.py                   |  1 -
 grizzly/target/puppet_target.py      |  3 -
 grizzly/target/target.py             |  9 +--
 grizzly/target/test_puppet_target.py | 10 ----
 grizzly/target/test_target.py        | 16 ------
 11 files changed, 54 insertions(+), 127 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 757630ae..98b48868 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -134,14 +134,13 @@ def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
         self._tests_run = 0
 
     @staticmethod
-    def location(srv_path, srv_port, close_after=None, forced_close=True, timeout=None):
+    def location(srv_path, srv_port, close_after=None, timeout=None):
         """Build a valid URL to pass to a browser.
 
         Args:
             srv_path (str): Path segment of the URL
             srv_port (int): Server listening port
             close_after (int): Harness argument.
-            forced_close (bool): Harness argument.
             timeout (int): Harness argument.
 
         Returns:
@@ -153,8 +152,6 @@ def location(srv_path, srv_port, close_after=None, forced_close=True, timeout=No
         if close_after is not None:
             assert close_after >= 0
             args.append("close_after=%d" % (close_after,))
-        if not forced_close:
-            args.append("forced_close=0")
         if timeout is not None:
             assert timeout >= 0
             args.append("timeout=%d" % (timeout * 1000,))
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index ab89ce60..1f29f9d9 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -246,12 +246,10 @@ def test_runner_08():
     assert result == "http://127.0.0.1:34567/a.html"
     result = Runner.location("a.html", 34567, close_after=10)
     assert result == "http://127.0.0.1:34567/a.html?close_after=10"
-    result = Runner.location("a.html", 34567, close_after=10, forced_close=False)
-    assert result == "http://127.0.0.1:34567/a.html?close_after=10&forced_close=0"
-    result = Runner.location("a.html", 34567, forced_close=False)
-    assert result == "http://127.0.0.1:34567/a.html?forced_close=0"
-    result = Runner.location("a.html", 9999, close_after=10, forced_close=False, timeout=60)
-    assert result == "http://127.0.0.1:9999/a.html?close_after=10&forced_close=0&timeout=60000"
+    result = Runner.location("a.html", 9999, timeout=60)
+    assert result == "http://127.0.0.1:9999/a.html?timeout=60000"
+    result = Runner.location("a.html", 9999, close_after=10, timeout=60)
+    assert result == "http://127.0.0.1:9999/a.html?close_after=10&timeout=60000"
 
 def test_runner_09(mocker):
     """test Runner.launch()"""
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index b1363e24..46993e37 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -150,33 +150,6 @@ def test_main_launch_error(mocker, exc_type):
         assert reporter.return_value.submit.call_count == 0
 
 
-def test_force_closed(mocker, tmp_path):
-    """test that `forced_close` in testcase metadata is respected"""
-    load_target = mocker.patch("grizzly.reduce.core.load_target")
-    mocker.patch("grizzly.reduce.core.ReduceManager.run", autospec=True)
-    mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
-    (tmp_path / "test.html").touch()
-    (tmp_path / "test_info.json").write_text(
-        json.dumps({
-            "timestamp": 1,
-            "target": "test.html",
-            "env": {"GRZ_FORCED_CLOSE": "0"}
-        })
-    )
-    args = mocker.Mock(
-        fuzzmanager=False,
-        ignore=[],
-        input=str(tmp_path),
-        min_crashes=1,
-        prefs=None,
-        repeat=1,
-        sig=None,
-        test_index=None,
-    )
-    ReduceManager.main(args)
-    assert load_target.return_value.return_value.forced_close is False
-
-
 @pytest.mark.parametrize("result", ["testprefs", "argprefs"])
 def test_testcase_prefs(mocker, tmp_path, result):
     """test that prefs from testcase are used if --prefs not specified and --prefs
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 1822510a..bb90442a 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -206,8 +206,7 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
                         location = runner.location(
                             "/grz_harness",
                             self.server.port,
-                            close_after=self.target.rl_reset * test_count,
-                            forced_close=self.target.forced_close)
+                            close_after=self.target.rl_reset * test_count)
                     # The environment from the initial testcase is used because
                     # a sequence of testcases is expected to be run without
                     # relaunching the Target to match the functionality of
@@ -430,9 +429,6 @@ def main(cls, args):
                         LOG.info("Using prefs.js from testcase")
                         target.prefs = pathjoin(tmp_prefs, "prefs.js")
                         break
-            if testcases[0].env_vars.get("GRZ_FORCED_CLOSE") == "0":
-                LOG.debug("setting target.forced_close=False")
-                target.forced_close = False
             LOG.debug("starting sapphire server")
             # launch HTTP server used to serve test cases
             with Sapphire(auto_close=1, timeout=args.timeout) as server:
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 55e8cfc1..6eeee348 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -79,7 +79,7 @@ def test_main_01(mocker, tmp_path):
     serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_target")
-    target = mocker.Mock(spec=Target, binary="bin", forced_close=True, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
@@ -109,7 +109,6 @@ def test_main_01(mocker, tmp_path):
         timeout=10,
         valgrind=False)
     assert ReplayManager.main(args) == Session.EXIT_SUCCESS
-    assert target.forced_close
     assert target.reverse.call_count == 1
     assert target.launch.call_count == 3
     assert target.step.call_count == 3
@@ -123,8 +122,44 @@ def test_main_01(mocker, tmp_path):
     assert any(log_path.glob('**/log_stderr.txt'))
     assert any(log_path.glob('**/log_stdout.txt'))
 
-def test_main_02(mocker):
-    """test ReplayManager.main() failure cases"""
+def test_main_02(mocker, tmp_path):
+    """test ReplayManager.main() - no repro"""
+    # mock Sapphire.serve_path only
+    mocker.patch("grizzly.common.runner.sleep", autospec=True)
+    serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
+    serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
+    # setup Target
+    load_target = mocker.patch("grizzly.replay.replay.load_target")
+    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30, rl_reset=1)
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.detect_failure.return_value = Target.RESULT_NONE
+    load_target.return_value.return_value = target
+    # setup args
+    (tmp_path / "test.html").touch()
+    (tmp_path / "prefs.js").touch()
+    args = mocker.Mock(
+        fuzzmanager=False,
+        idle_delay=0,
+        idle_threshold=0,
+        ignore=["fake", "timeout"],
+        input=str(tmp_path / "test.html"),
+        min_crashes=2,
+        no_harness=True,
+        prefs=None,
+        relaunch=1,
+        repeat=1,
+        rr=False,
+        sig=None,
+        test_index=None,
+        timeout=10,
+        valgrind=False)
+    assert ReplayManager.main(args) == Session.EXIT_FAILURE
+    assert target.detect_failure.call_count == 1
+    assert target.close.call_count == 2
+    assert target.cleanup.call_count == 1
+
+def test_main_03(mocker):
+    """test ReplayManager.main() error cases"""
     mocker.patch("grizzly.replay.replay.FuzzManagerReporter", autospec=True)
     fake_load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
     mocker.patch("grizzly.replay.replay.Sapphire", autospec=True)
@@ -167,12 +202,12 @@ def test_main_02(mocker):
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
 
-def test_main_03(mocker, tmp_path):
+def test_main_04(mocker, tmp_path):
     """test ReplayManager.main() target exceptions"""
     mocker.patch("grizzly.replay.replay.FuzzManagerReporter", autospec=True)
     mocker.patch("grizzly.replay.replay.Sapphire", autospec=True)
     mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
-    target = mocker.Mock(spec=Target, forced_close=True, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, launch_timeout=30, rl_reset=1)
     load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
     load_target.return_value.return_value = target
     fake_tmp = (tmp_path / "grz_tmp")
@@ -201,49 +236,12 @@ def test_main_03(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchTimeout)
     assert ReplayManager.main(args) == Session.EXIT_LAUNCH_FAILURE
 
-def test_main_04(mocker):
-    """test ReplayManager.main() loading GRZ_FORCED_CLOSE from selected test case"""
-    # TODO: Remove this test when removing 'target.forced_close'
-    mocker.patch("grizzly.replay.replay.Sapphire.serve_path", return_value=(None, ["x.html"]))
-    target = mocker.Mock(spec=Target, forced_close=True, launch_timeout=30, rl_reset=1)
-    load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
-    load_target.return_value.return_value = target
-    test0 = mocker.Mock(
-        spec=TestCase,
-        env_vars={"GRZ_FORCED_CLOSE": "0"},
-        landing_page="x.html",
-        optional=[])
-    test1 = mocker.Mock(spec=TestCase)
-    mocker.patch("grizzly.replay.replay.TestCase.load", return_value=[test0, test1])
-    # setup args
-    args = mocker.Mock(
-        fuzzmanager=False,
-        idle_delay=0,
-        idle_threshold=0,
-        ignore=None,
-        input="test",
-        min_crashes=1,
-        no_harness=True,
-        prefs=None,
-        relaunch=1,
-        repeat=1,
-        sig=None,
-        test_index=[0],
-        timeout=1)
-    assert ReplayManager.main(args) == Session.EXIT_FAILURE
-    assert test0.cleanup.call_count == 1
-    assert test0.dump.call_count == 1
-    assert test1.cleanup.call_count == 1
-    assert test1.dump.call_count == 0
-    assert target.cleanup.call_count == 1
-    assert not target.forced_close
-
 def test_main_05(mocker, tmp_path):
     """test ReplayManager.main() loading/generating prefs.js"""
     serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
     serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
-    target = mocker.Mock(spec=Target, binary="bin", forced_close=True, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30, rl_reset=1)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index d200ae7e..1bcee84d 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -41,7 +41,7 @@ def test_replay_02(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, forced_close=True, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, rl_reset=1)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
@@ -420,7 +420,7 @@ def test_replay_15(mocker):
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, forced_close=True, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, rl_reset=1)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [
@@ -439,7 +439,7 @@ def test_replay_16(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, forced_close=True, launch_timeout=30, rl_reset=100)
+    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, rl_reset=100)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [
@@ -496,7 +496,7 @@ def test_replay_18(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, forced_close=True, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, rl_reset=1)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
diff --git a/grizzly/session.py b/grizzly/session.py
index a74a459c..34a09bbc 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -143,7 +143,6 @@ def run(self, ignore, iteration_limit=None, display_mode=DISPLAY_NORMAL):
                         "/grz_harness",
                         self.server.port,
                         close_after=self.target.rl_reset,
-                        forced_close=self.target.forced_close,
                         timeout=self.adapter.TEST_DURATION)
                 runner.launch(location, max_retries=3, retry_delay=0)
             self.target.step()
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 34795e37..592ca680 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -103,9 +103,6 @@ def log_length(_, log_id):
 
     def detect_failure(self, ignored, was_timeout):
         status = self.RESULT_NONE
-        if self.expect_close and not was_timeout:
-            # give the browser a moment to close if needed
-            self._puppet.wait(timeout=30)
         is_healthy = self._puppet.is_healthy()
         # check if there has been a crash, hang, etc...
         if not is_healthy or was_timeout:
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 08e3a0af..ec16d5cb 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -53,14 +53,14 @@ class TargetLaunchTimeout(TargetError):
     """Raised if the target does not launch within the defined amount of time"""
 
 
-# TODO: remove forced_close, rl_countdown, rl_reset, relaunch, check_relaunch, expect_close
+# TODO: remove rl_countdown, rl_reset, relaunch, check_relaunch
 class Target(metaclass=ABCMeta):
     RESULT_NONE = 0
     RESULT_FAILURE = 1
     RESULT_IGNORED = 2
 
     __slots__ = (
-        "_lock", "_monitor", "_prefs", "binary", "extension", "forced_close",
+        "_lock", "_monitor", "_prefs", "binary", "extension",
         "launch_timeout", "log_limit", "memory_limit", "rl_countdown", "rl_reset")
 
     def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, relaunch):
@@ -73,7 +73,6 @@ def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, r
         self._prefs = None
         self.binary = binary
         self.extension = extension
-        self.forced_close = getenv("GRZ_FORCED_CLOSE") != "0"
         self.launch_timeout = max(launch_timeout, 300)
         self.log_limit = log_limit
         self.memory_limit = memory_limit
@@ -133,10 +132,6 @@ def detect_failure(self, ignored, was_timeout):
     def dump_coverage(self):  # pylint: disable=no-self-use
         LOG.warning("dump_coverage() is not supported!")
 
-    @property
-    def expect_close(self):
-        # This is used to indicate if the browser will self close after the current iteration
-        return self.rl_countdown < 1 and not self.forced_close
 
     def is_idle(self, threshold):  # pylint: disable=no-self-use,unused-argument
         LOG.debug("Target.is_idle() not implemented! returning False")
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 0ecf0b51..8dc50dde 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -161,16 +161,6 @@ def test_puppet_target_03(mocker, tmp_path):
     fake_ffp.return_value.available_logs.return_value = " ffp_worker_log_size "
     assert target.detect_failure(["log-limit"], False) == Target.RESULT_IGNORED
     assert fake_ffp.return_value.close.call_count == 1
-    fake_ffp.reset_mock()
-    # test browser closing test case
-    fake_ffp.return_value.is_healthy.return_value = False
-    fake_ffp.return_value.is_running.return_value = False
-    fake_ffp.return_value.reason = FFPuppet.RC_EXITED
-    target.forced_close = False
-    target.rl_countdown = 0
-    assert target.detect_failure([], False) == Target.RESULT_NONE
-    assert fake_ffp.return_value.wait.call_count == 1
-    assert fake_ffp.return_value.close.call_count == 1
 
 @mark.skipif(system() == "Windows", reason="Unsupported on Windows")
 def test_puppet_target_04(mocker, tmp_path):
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index 91ae6c5c..a7fbf6ff 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -34,7 +34,6 @@ def test_target_01(tmp_path):
     target = SimpleTarget(str(fake_file), str(fake_file), 321, 2, 3, 25)
     assert target.binary == str(fake_file)
     assert target.extension == str(fake_file)
-    assert target.forced_close
     assert not target.is_idle(0)
     assert target.launch_timeout == 321
     assert target.log_size() == 0
@@ -42,27 +41,12 @@ def test_target_01(tmp_path):
     assert target.memory_limit == 3
     assert target.rl_countdown == 0
     assert target.rl_reset == 25
-    assert not target.expect_close
     # test stubs
     target.add_abort_token("none!")
     target.dump_coverage()
     target.reverse(1, 2)
 
 def test_target_02(mocker, tmp_path):
-    """test setting Target.forced_close"""
-    fake_file = tmp_path / "fake"
-    fake_file.touch()
-    getenv = mocker.patch("grizzly.target.target.getenv", autospec=True, return_value="0")
-    with SimpleTarget(str(fake_file), None, 300, 25, 5000, 25) as target:
-        assert not target.forced_close
-        assert target.extension is None
-        target.rl_countdown = 1
-        assert not target.expect_close
-        target.rl_countdown = 0
-        assert target.expect_close
-    getenv.assert_called_with("GRZ_FORCED_CLOSE")
-
-def test_target_03(mocker, tmp_path):
     """test Target.check_relaunch() and Target.step()"""
     fake_file = tmp_path / "fake"
     fake_file.touch()

From 3cdc52ca67befdc75ebaba28cec7dbcf6548bdb1 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 16 Dec 2020 18:44:10 -0800
Subject: [PATCH 132/531] Fix removing unserved files from test case

---
 grizzly/session.py      | 18 +++++++-----------
 grizzly/test_session.py | 31 +++++++++++++++++--------------
 2 files changed, 24 insertions(+), 25 deletions(-)

diff --git a/grizzly/session.py b/grizzly/session.py
index 34a09bbc..6290c0ad 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -163,16 +163,9 @@ def run(self, ignore, iteration_limit=None, display_mode=DISPLAY_NORMAL):
                 log.debug("calling self.adapter.on_served()")
                 self.adapter.on_served(current_test, result.served)
             # update test case
-            if result.attempted:
-                if not result.served:
-                    # this can happen if the target crashes between serving test cases
-                    log.info("Ignoring test case since nothing was served")
-                    self.iomanager.tests.pop().cleanup()
-                elif self.adapter.IGNORE_UNSERVED:
-                    log.debug("removing unserved files from the test case")
-                    current_test.purge_optional(result.served)
-            else:
-                log.error("Test case was not served")
+            if not result.attempted:
+                log.debug("Ignoring test case since nothing was served")
+                self.iomanager.tests.pop().cleanup()
                 if not current_test.contains(current_test.landing_page):
                     log.warning("Test case is missing landing page")
                 if result.initial:
@@ -183,7 +176,10 @@ def run(self, ignore, iteration_limit=None, display_mode=DISPLAY_NORMAL):
                     log.error("ERROR: Test case was not served. Timeout too short?")
                     log.error("Logs can be found here %r", err_logs)
                     raise SessionError("Please check Adapter and Target")
-
+                log.warning("Test case was not served")
+            elif self.adapter.IGNORE_UNSERVED:
+                log.debug("removing unserved files from the test case")
+                current_test.purge_optional(result.served)
             # process results
             if result.status == RunResult.FAILED:
                 log.debug("result detected")
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 8b696ab9..64ce0a54 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -135,6 +135,7 @@ def test_session_05(tmp_path, mocker):
     """test basic Session functions"""
     Status.PATH = str(tmp_path)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
+    fake_adapter.IGNORE_UNSERVED = True
     fake_adapter.TEST_DURATION = 10
     fake_testcase = mocker.Mock(spec=TestCase, landing_page="page.htm", optional=[])
     fake_iomgr = mocker.Mock(spec=IOManager)
@@ -142,7 +143,6 @@ def test_session_05(tmp_path, mocker):
     fake_iomgr.create_testcase.return_value = fake_testcase
     fake_iomgr.tests = mocker.Mock(spec=deque)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    # return SERVED_TIMEOUT to test IGNORE_UNSERVED code path
     fake_serv.serve_path.return_value = (SERVED_TIMEOUT, [fake_testcase.landing_page])
     fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None, rl_reset=10)
     fake_target.monitor.launches = 1
@@ -180,32 +180,36 @@ def test_session_06(tmp_path, mocker):
         assert testcase.add_meta.call_count == 1
 
 def test_session_07(tmp_path, mocker):
-    """test Session.run() reporting failures"""
+    """test Session.run() - test case was not served - between iterations"""
     Status.PATH = str(tmp_path)
     mocker.patch("grizzly.session.Report", autospec=True)
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
-    fake_runner.return_value.run.return_value = RunResult(["/fake/file"], 1, status=RunResult.FAILED)
+    run_result = RunResult(["/fake/file"], 1, status=RunResult.FAILED)
+    run_result.attempted = False
+    run_result.initial = False
+    fake_runner.return_value.run.return_value = run_result
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
-    fake_adapter.IGNORE_UNSERVED = True
     fake_adapter.TEST_DURATION = 10
-    fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap(), tests=deque())
+    fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
     fake_iomgr.create_testcase.return_value = mocker.Mock(spec=TestCase)
+    fake_iomgr.tests = mocker.Mock(spec=deque)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
     fake_target.monitor.launches = 1
-    reporter = NullReporter()
-    with Session(fake_adapter, fake_iomgr, reporter, fake_serv, fake_target) as session:
+    fake_reporter = mocker.Mock(spec=Reporter)
+    with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
         session.run([], iteration_limit=1)
         assert fake_runner.return_value.run.call_count == 1
         assert fake_adapter.on_served.call_count == 1
         assert fake_adapter.on_timeout.call_count == 0
         assert fake_iomgr.purge_tests.call_count == 1
-        assert fake_runner.return_value.launch.call_count == fake_iomgr.purge_tests.call_count
+        assert fake_runner.return_value.launch.call_count == 1
         assert session.status.iteration == 1
         assert session.status.results == 1
         assert session.status.ignored == 0
-        assert reporter.submit_calls == 1
+        assert fake_reporter.submit.call_count == 1
+        assert fake_iomgr.tests.pop.call_count == 1
 
 def test_session_08(tmp_path, mocker):
     """test Session.run() ignoring failures"""
@@ -216,12 +220,11 @@ def test_session_08(tmp_path, mocker):
     fake_runner.return_value.run.return_value = result
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
-    fake_adapter.IGNORE_UNSERVED = True
+    fake_adapter.IGNORE_UNSERVED = False
     fake_adapter.TEST_DURATION = 10
     fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
-    fake_iomgr.create_testcase.return_value = mocker.Mock(spec=TestCase)
-    fake_iomgr.tests = mocker.Mock(spec=deque)
-    fake_iomgr.tests.pop.return_value = mocker.Mock(spec=TestCase)
+    fake_test = mocker.Mock(spec=TestCase)
+    fake_iomgr.create_testcase.return_value = fake_test
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
     fake_target.monitor.launches = 1
@@ -233,7 +236,7 @@ def test_session_08(tmp_path, mocker):
         assert fake_adapter.on_served.call_count == 1
         assert fake_adapter.on_timeout.call_count == 0
         assert fake_iomgr.purge_tests.call_count == 1
-        assert fake_iomgr.tests.pop.call_count == 1
+        assert fake_test.purge_optional.call_count == 0
         assert fake_runner.return_value.launch.call_count == fake_iomgr.purge_tests.call_count
         assert session.status.iteration == 1
         assert session.status.results == 0

From 736d497949dfda5041ea2bb51450eadabd051986 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 16 Dec 2020 18:45:06 -0800
Subject: [PATCH 133/531] Remove unnecessary try/catch from harness

---
 grizzly/common/harness.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/common/harness.html b/grizzly/common/harness.html
index a22ff1db..c83efc5a 100644
--- a/grizzly/common/harness.html
+++ b/grizzly/common/harness.html
@@ -47,7 +47,7 @@
     try { window.focus() } catch(e) { }
     let xhr = new XMLHttpRequest()
     // indicate test is complete by requesting `/grz_next_test`
-    try { xhr.open('GET', '/grz_next_test', true) } catch (e) {}
+    xhr.open('GET', '/grz_next_test', true)
     xhr.onabort = () => { window.close() }
     xhr.onerror = () => { window.close() }
     xhr.onload = () => { window.close() }

From c0757c23d9ee1d8f011ac13d10665bb182fbf7c0 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 17 Dec 2020 18:31:06 -0800
Subject: [PATCH 134/531] Remove remaining relaunch code from Target

---
 grizzly/common/runner.py             |   2 +-
 grizzly/common/test_runner.py        |   5 +-
 grizzly/main.py                      |  11 ++-
 grizzly/reduce/core.py               |  28 +++---
 grizzly/reduce/test_main.py          |   1 -
 grizzly/reduce/test_reduce.py        |   2 +-
 grizzly/replay/replay.py             |  24 ++++--
 grizzly/replay/test_main.py          |   9 +-
 grizzly/replay/test_replay.py        | 123 +++++++++++++++++----------
 grizzly/session.py                   |  21 +++--
 grizzly/target/__init__.py           |   6 +-
 grizzly/target/puppet_target.py      |   5 +-
 grizzly/target/target.py             |  42 ++-------
 grizzly/target/test_puppet_target.py |  17 ++--
 grizzly/target/test_target.py        |  32 +------
 grizzly/test_main.py                 |  27 ++++--
 grizzly/test_session.py              |  23 ++---
 17 files changed, 190 insertions(+), 188 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 98b48868..fe9e6ae2 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -215,7 +215,7 @@ def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait
                 self._target.dump_coverage()
             # relaunch check
             if self._tests_run >= self._relaunch:
-                assert self._tests_run >= self._relaunch
+                assert self._tests_run == self._relaunch
                 server_map.dynamic.pop("grz_empty", None)
                 LOG.debug("relaunch/shutdown limit hit")
                 # ideally all browser tabs should be closed at this point
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 1f29f9d9..02c029f1 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -170,7 +170,7 @@ def test_runner_04(mocker):
 def test_runner_05(mocker):
     """test reporting failures"""
     server = mocker.Mock(spec=Sapphire)
-    target = mocker.Mock(spec=Target)
+    target = mocker.Mock(spec=Target, launch_timeout=10)
     target.monitor.is_healthy.return_value = False
     serv_files = ["file.bin"]
     server.serve_path.return_value = (SERVED_REQUEST, serv_files)
@@ -178,6 +178,7 @@ def test_runner_05(mocker):
     runner = Runner(server, target)
     # test FAILURE
     target.detect_failure.return_value = target.RESULT_FAILURE
+    runner.launch("http://a/")
     result = runner.run([], ServerMap(), testcase)
     assert result.attempted
     assert result.status == RunResult.FAILED
@@ -185,6 +186,7 @@ def test_runner_05(mocker):
     assert not result.timeout
     # test IGNORED
     target.detect_failure.return_value = target.RESULT_IGNORED
+    runner.launch("http://a/")
     result = runner.run([], ServerMap(), testcase)
     assert result.attempted
     assert result.status == RunResult.IGNORED
@@ -193,6 +195,7 @@ def test_runner_05(mocker):
     # failure before serving landing page
     server.serve_path.return_value = (SERVED_REQUEST, ["harness"])
     target.detect_failure.return_value = target.RESULT_FAILURE
+    runner.launch("http://a/")
     result = runner.run([], ServerMap(), testcase)
     assert not result.attempted
     assert result.status == RunResult.FAILED
diff --git a/grizzly/main.py b/grizzly/main.py
index 00202486..0df24f8d 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -66,7 +66,7 @@ def main(args):
             return Session.EXIT_ARGS
 
         if adapter.RELAUNCH > 0:
-            log.debug("relaunch (%d) set in Adapter", adapter.RELAUNCH)
+            log.info("Relaunch (%d) set in Adapter", adapter.RELAUNCH)
             relaunch = adapter.RELAUNCH
         else:
             relaunch = args.relaunch
@@ -78,7 +78,6 @@ def main(args):
             args.launch_timeout,
             args.log_limit,
             args.memory,
-            relaunch,
             rr=args.rr,
             valgrind=args.valgrind,
             xvfb=args.xvfb)
@@ -87,10 +86,9 @@ def main(args):
             log.info("Using prefs %r", args.prefs)
         adapter.monitor = target.monitor
 
-        if args.coverage and relaunch == 1 and target.forced_close:
+        if args.coverage and relaunch == 1:
             # this is a workaround to avoid not dumping coverage
-            # GRZ_FORCED_CLOSE=0 is also an option but the browser MUST
-            # close itself.
+            # TODO: this may not be needed since moving relaunch into runnner
             raise RuntimeError("Coverage must be run with --relaunch > 1")
 
         log.debug("calling adapter setup()")
@@ -122,7 +120,8 @@ def main(args):
                 reporter,
                 server,
                 target,
-                coverage=args.coverage)
+                coverage=args.coverage,
+                relaunch=relaunch)
             if args.log_level == DEBUG or args.verbose:
                 display_mode = Session.DISPLAY_VERBOSE
             else:
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 7f047892..a92f9836 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -65,9 +65,10 @@ class ReduceManager(object):
     ITER_TIMEOUT_DURATION_MULTIPLIER = 2
 
     def __init__(self, ignore, server, target, testcases, strategies, log_path,
-                 any_crash=False, idle_delay=0, idle_threshold=0, report_period=None,
-                 report_to_fuzzmanager=False, signature=None, signature_desc=None,
-                 static_timeout=False, tool=None, use_analysis=True, use_harness=True):
+                 any_crash=False, idle_delay=0, idle_threshold=0, relaunch=1,
+                 report_period=None, report_to_fuzzmanager=False, signature=None,
+                 signature_desc=None, static_timeout=False, tool=None,
+                 use_analysis=True, use_harness=True):
         """Initialize reduction manager. Many arguments are common with `ReplayManager`.
 
         Args:
@@ -83,6 +84,8 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
                               the specified or first observed signature.
             idle_delay (int): Number of seconds to wait before polling for idle.
             idle_threshold (int): CPU usage threshold to mark the process as idle.
+            relaunch (int): Maximum number of iterations performed by Runner
+                            before Target should be relaunched.
             report_period (int or None): Periodically report best results for
                                          long-running strategies.
             report_to_fuzzmanager (bool): Report to FuzzManager rather than filesystem.
@@ -111,7 +114,7 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
         # pathlib2 rather than pathlib
         self._log_path = Path(log_path) if isinstance(log_path, str) else log_path
         # these parameters may be overwritten during analysis, so keep a copy of them
-        self._original_relaunch = target.relaunch
+        self._original_relaunch = relaunch
         self._original_use_harness = use_harness
         self._report_to_fuzzmanager = report_to_fuzzmanager
         self._report_periodically = report_period
@@ -209,11 +212,11 @@ def run_reliability_analysis(self, stats):
             if last_test and len(self.testcases) == 1:
                 continue
 
-            self.target.relaunch = self.ANALYSIS_ITERATIONS if use_harness else 1
+            relaunch = self.ANALYSIS_ITERATIONS if use_harness else 1
 
             with ReplayManager(
                 self.ignore, self.server, self.target, any_crash=self._any_crash,
-                signature=self._signature, use_harness=use_harness,
+                relaunch=relaunch, signature=self._signature, use_harness=use_harness,
             ) as replay:
                 LOG.info("Running for %d iterations to assess reliability %s harness.",
                          self.ANALYSIS_ITERATIONS,
@@ -348,15 +351,15 @@ def run(self, repeat=1, min_results=1):
                 self._stats.add_info("Analysis", reliability_info)
                 any_success = True  # analysis ran and didn't raise
             if self._use_harness:
-                self.target.relaunch = min(self._original_relaunch, repeat)
+                relaunch = min(self._original_relaunch, repeat)
             else:
-                self.target.relaunch = 1
+                relaunch = 1
             LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
-                     repeat, min_results, self.target.relaunch)
+                     repeat, min_results, relaunch)
             self._stats.add_info("Run Parameters", {
                 "Repeat": repeat,
                 "Min Crashes": min_results,
-                "Relaunch": self.target.relaunch,
+                "Relaunch": relaunch,
                 "Harness": self._use_harness,
             })
 
@@ -622,7 +625,6 @@ def main(cls, args):
                 args.launch_timeout,
                 args.log_limit,
                 args.memory,
-                relaunch,
                 rr=args.rr,
                 valgrind=args.valgrind,
                 xvfb=args.xvfb)
@@ -642,9 +644,6 @@ def main(cls, args):
                         LOG.info("Using prefs.js from testcase")
                         target.prefs = str(tmp_prefs / "prefs.js")
                         break
-            if testcases[0].env_vars.get("GRZ_FORCED_CLOSE") == "0":
-                LOG.debug("setting target.forced_close=False")
-                target.forced_close = False
 
             LOG.debug("starting sapphire server")
             # launch HTTP server used to serve test cases
@@ -660,6 +659,7 @@ def main(cls, args):
                     any_crash=args.any_crash,
                     idle_delay=args.idle_delay,
                     idle_threshold=args.idle_threshold,
+                    relaunch=relaunch,
                     report_period=args.report_period,
                     report_to_fuzzmanager=args.fuzzmanager,
                     signature=signature,
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 46993e37..5ec212d9 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -3,7 +3,6 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Unit tests for `grizzly.reduce.main`."""
-import json
 from logging import getLogger
 from pathlib import Path
 from shutil import rmtree
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 2ee03b2b..55e118ca 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -16,7 +16,7 @@
 from sapphire import Sapphire
 from ..common import TestCase, Report
 from ..replay import ReplayResult
-from ..target import Target, TargetLaunchError, TargetLaunchTimeout
+from ..target import Target
 from . import ReduceManager
 from .exceptions import NotReproducible
 from .strategies import Strategy
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index bb90442a..147fcedb 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -41,22 +41,24 @@ class ReplayManager(object):
     HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
 
     __slots__ = ("ignore", "server", "status", "target", "_any_crash",
-                 "_harness", "_signature", "_unpacked")
+                 "_harness", "_signature", "_relaunch", "_unpacked")
 
-    def __init__(self, ignore, server, target, any_crash=False, signature=None, use_harness=True):
+    def __init__(self, ignore, server, target, any_crash=False,
+                 relaunch=1, signature=None, use_harness=True):
         self.ignore = ignore
         self.server = server
         self.status = None
         self.target = target
         self._any_crash = any_crash
         self._harness = None
+        self._relaunch = relaunch
         self._signature = signature
         if use_harness:
             with open(self.HARNESS_FILE, "rb") as in_fp:
                 self._harness = in_fp.read()
         else:
             # target must relaunch every iteration when not using harness
-            assert target.rl_reset == 1
+            assert relaunch == 1
 
     def __enter__(self):
         return self
@@ -188,12 +190,13 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
                 dst_path = mkdtemp(prefix="tc_", dir=grz_tmp("serve"))
                 unpacked.append(dst_path)
                 test.dump(dst_path)
+            relaunch = min(self._relaunch, repeat)
             runner = Runner(
                 self.server,
                 self.target,
                 idle_threshold=idle_threshold,
                 idle_delay=idle_delay,
-                relaunch=self.target.rl_reset * test_count)
+                relaunch=relaunch * test_count)
             # perform iterations
             for _ in range(repeat):
                 self.status.iteration += 1
@@ -206,14 +209,13 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
                         location = runner.location(
                             "/grz_harness",
                             self.server.port,
-                            close_after=self.target.rl_reset * test_count)
+                            close_after=relaunch * test_count)
                     # The environment from the initial testcase is used because
                     # a sequence of testcases is expected to be run without
                     # relaunching the Target to match the functionality of
                     # Grizzly. If this is not the case each TestCase should
                     # be run individually.
                     runner.launch(location, env_mod=testcases[0].env_vars)
-                self.target.step()
                 # run tests
                 durations = list()
                 served = list()
@@ -310,6 +312,9 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
                         # failed to reproduce issue
                         LOG.debug("results (%d) < minimum (%d), after %d attempts",
                                   self.status.results, min_results, self.status.iteration)
+                        # NOTE: this can be tricky if the harness is used because it can
+                        # skip the shutdown performed in the harness and runner, if this
+                        # is an issue for now use relaunch=1
                         break
                     # check if complete (minimum number of results found)
                     if self.status.results >= min_results:
@@ -343,6 +348,11 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
                         report.report.cleanup()
                         continue
                     results.append(report)
+            # this should only be displayed when both conditions are met:
+            # 1) runner does not close target (no delay was given before shutdown)
+            # 2) result has not been successfully reproduced
+            if self._relaunch > 1 and not self.target.closed and not any(x.expected for x in results):
+                LOG.info("Perhaps try with --relaunch=1")
             # active reports have been moved to results
             # clear reports to avoid cleanup of active reports
             reports.clear()
@@ -410,7 +420,6 @@ def main(cls, args):
                 args.launch_timeout,
                 args.log_limit,
                 args.memory,
-                relaunch,
                 rr=args.rr,
                 valgrind=args.valgrind,
                 xvfb=args.xvfb)
@@ -438,6 +447,7 @@ def main(cls, args):
                     server,
                     target,
                     any_crash=args.any_crash,
+                    relaunch=relaunch,
                     signature=signature,
                     use_harness=not args.no_harness
                 ) as replay:
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 6eeee348..1833f9e4 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -79,7 +79,7 @@ def test_main_01(mocker, tmp_path):
     serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_target")
-    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
@@ -111,7 +111,6 @@ def test_main_01(mocker, tmp_path):
     assert ReplayManager.main(args) == Session.EXIT_SUCCESS
     assert target.reverse.call_count == 1
     assert target.launch.call_count == 3
-    assert target.step.call_count == 3
     assert target.detect_failure.call_count == 3
     assert serve_path.call_count == 3
     assert load_target.call_count == 1
@@ -130,7 +129,7 @@ def test_main_02(mocker, tmp_path):
     serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_target")
-    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     load_target.return_value.return_value = target
@@ -207,7 +206,7 @@ def test_main_04(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.FuzzManagerReporter", autospec=True)
     mocker.patch("grizzly.replay.replay.Sapphire", autospec=True)
     mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
-    target = mocker.Mock(spec=Target, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, launch_timeout=30)
     load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
     load_target.return_value.return_value = target
     fake_tmp = (tmp_path / "grz_tmp")
@@ -241,7 +240,7 @@ def test_main_05(mocker, tmp_path):
     serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
     serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
-    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 1bcee84d..c46f0aa7 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -16,6 +16,8 @@
 from ..target import Target
 
 
+# TODO: also test relaunch < repeat
+
 def _fake_save_logs(result_logs, meta=False):  # pylint: disable=unused-argument
     """write fake log data to disk"""
     with open(pathjoin(result_logs, "log_stderr.txt"), "w") as log_fp:
@@ -37,13 +39,13 @@ def test_replay_01(mocker):
 
 def test_replay_02(mocker, tmp_path):
     """test ReplayManager.run() - no repro"""
-    mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
+    target.monitor.is_healthy.return_value = False
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True) as replay:
             assert not replay.run([testcase])
@@ -51,7 +53,7 @@ def test_replay_02(mocker, tmp_path):
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
             assert replay.status.results == 0
-            assert target.monitor.is_healthy.call_count > 0
+            assert target.monitor.is_healthy.call_count == 1
             assert target.close.call_count == 2
         assert not any(tmp_path.glob("*"))
 
@@ -59,37 +61,61 @@ def test_replay_03(mocker):
     """test ReplayManager.run() - no repro - with repeats"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, rl_reset=100)
+    target = mocker.Mock(spec=Target, closed=False, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
+    target.monitor.is_healthy.return_value = False
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
-        with ReplayManager([], server, target, use_harness=True) as replay:
+        with ReplayManager([], server, target, use_harness=True, relaunch=100) as replay:
             assert not replay.run([testcase], repeat=10, min_results=1)
             assert replay.signature is None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 10
             assert replay.status.results == 0
+            assert target.monitor.is_healthy.call_count == 1
+            assert target.close.call_count == 2
+
+def test_replay_04(mocker):
+    """test ReplayManager.run() - exit - skip shutdown in runner"""
+    # this will make runner appear to have just relaunched the target
+    mocker.patch(
+        "grizzly.common.runner.Runner._tests_run",
+        new_callable=mocker.PropertyMock,
+        return_value=0)
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    target = mocker.Mock(spec=Target, closed=False, launch_timeout=30)
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.detect_failure.return_value = Target.RESULT_NONE
+    with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
+        with ReplayManager([], server, target, use_harness=True, relaunch=100) as replay:
+            assert not replay.run([testcase], repeat=10, min_results=1)
+            assert replay.status.ignored == 0
+            assert replay.status.iteration == 10
+            assert replay.status.results == 0
+            assert target.monitor.is_healthy.call_count == 0
             assert target.close.call_count == 1
 
-def test_replay_04(mocker, tmp_path):
+def test_replay_05(mocker, tmp_path):
     """test ReplayManager.run() - successful repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     served = ["index.html"]
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, served)
-    target = mocker.Mock(spec=Target, binary="C:\\fake_bin", launch_timeout=30, rl_reset=10)
+    target = mocker.Mock(spec=Target, binary="C:\\fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
-        with ReplayManager([], server, target) as replay:
+        with ReplayManager([], server, target, relaunch=10) as replay:
             results = replay.run([testcase])
             assert replay.signature is not None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
             assert replay.status.results == 1
-            assert target.monitor.is_healthy.call_count == 0
-            assert target.close.call_count == 1
+            assert target.monitor.is_healthy.call_count == 1
+            assert target.close.call_count == 2
         assert len(results) == 1
         assert results[0].count == 1
         assert results[0].expected
@@ -100,11 +126,11 @@ def test_replay_04(mocker, tmp_path):
         results[0].report.cleanup()
         assert not any(tmp_path.glob("*"))
 
-def test_replay_05(mocker, tmp_path):
+def test_replay_06(mocker, tmp_path):
     """test ReplayManager.run() - error - landing page not requested on first iteration"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, closed=False, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, closed=False, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -118,18 +144,19 @@ def test_replay_05(mocker, tmp_path):
         assert target.close.call_count == 2
     assert target.save_logs.call_count == 1
 
-def test_replay_06(mocker, tmp_path):
+def test_replay_07(mocker, tmp_path):
     """test ReplayManager.run() - delayed failure - following test landing page not requested"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, binary="bin", closed=False, launch_timeout=30, rl_reset=10)
+    target = mocker.Mock(spec=Target, binary="bin", closed=False, launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.side_effect = (Target.RESULT_NONE, Target.RESULT_FAILURE)
+    target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     server.serve_path.side_effect = ((SERVED_ALL, ["index.html"]), (SERVED_REQUEST, ["x"]))
-    with ReplayManager([], server, target, use_harness=True) as replay:
+    with ReplayManager([], server, target, use_harness=True, relaunch=10) as replay:
         assert replay.run(testcases, repeat=2)
         assert replay.status.ignored == 0
         assert replay.status.iteration == 2
@@ -137,12 +164,12 @@ def test_replay_06(mocker, tmp_path):
         # target.close() called once in runner and once by ReplayManager.run()
         assert target.close.call_count == 2
 
-def test_replay_07(mocker, tmp_path):
+def test_replay_08(mocker, tmp_path):
     """test ReplayManager.run() - ignored"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, launch_timeout=30)
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = Target.RESULT_IGNORED
     target.monitor.is_healthy.return_value = False
@@ -156,13 +183,13 @@ def test_replay_07(mocker, tmp_path):
         assert replay.status.results == 0
     assert not any(tmp_path.glob("*"))
 
-def test_replay_08(mocker, tmp_path):
+def test_replay_09(mocker, tmp_path):
     """test ReplayManager.run() - early exit"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="path/fake_bin", launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="path/fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
@@ -214,7 +241,7 @@ def test_replay_08(mocker, tmp_path):
     assert len(results) == 1
     assert sum(x.count for x in results) == 4
 
-def test_replay_09(mocker, tmp_path):
+def test_replay_10(mocker, tmp_path):
     """test ReplayManager.run() - test signatures - fail to meet minimum"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
@@ -233,7 +260,7 @@ def test_replay_09(mocker, tmp_path):
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, False, False)
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -254,7 +281,7 @@ def test_replay_09(mocker, tmp_path):
     assert report_3.cleanup.call_count == 1
     assert signature.matches.call_count == 3
 
-def test_replay_10(mocker, tmp_path):
+def test_replay_11(mocker, tmp_path):
     """test ReplayManager.run() - test signatures - multiple matches"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
@@ -268,7 +295,7 @@ def test_replay_10(mocker, tmp_path):
     server.serve_path.return_value = (SERVED_ALL, ["a.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, True)
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
@@ -288,7 +315,7 @@ def test_replay_10(mocker, tmp_path):
     assert report_1.cleanup.call_count == 1
     assert signature.matches.call_count == 2
 
-def test_replay_11(mocker, tmp_path):
+def test_replay_12(mocker, tmp_path):
     """test ReplayManager.run() - any crash - success"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report)
@@ -301,7 +328,7 @@ def test_replay_11(mocker, tmp_path):
     fake_report.side_effect = (report_0, report_1, report_2)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
@@ -321,7 +348,7 @@ def test_replay_11(mocker, tmp_path):
     assert report_1.cleanup.call_count == 0
     assert report_2.cleanup.call_count == 0
 
-def test_replay_12(mocker, tmp_path):
+def test_replay_13(mocker, tmp_path):
     """test ReplayManager.run() - any crash - fail to meet minimum"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report)
@@ -336,7 +363,7 @@ def test_replay_12(mocker, tmp_path):
     fake_report.side_effect = (report_0, report_1, report_2, report_3)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
@@ -354,7 +381,7 @@ def test_replay_12(mocker, tmp_path):
     assert report_2.cleanup.call_count == 1
     assert report_3.cleanup.call_count == 1
 
-def test_replay_13(mocker, tmp_path):
+def test_replay_14(mocker, tmp_path):
     """test ReplayManager.run() - no signature - use first crash"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_1 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123", minor="9999")
@@ -370,7 +397,7 @@ def test_replay_13(mocker, tmp_path):
     fake_report.side_effect = (report_1, report_2, report_3)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
@@ -390,7 +417,7 @@ def test_replay_13(mocker, tmp_path):
     assert report_2.cleanup.call_count == 0
     assert report_3.cleanup.call_count == 1
 
-def test_replay_14(mocker, tmp_path):
+def test_replay_15(mocker, tmp_path):
     """test ReplayManager.run() - unexpected exception"""
     mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
     report_0 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
@@ -399,28 +426,28 @@ def test_replay_14(mocker, tmp_path):
     fake_report.side_effect = (report_0,)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.side_effect = ((SERVED_ALL, ["index.html"]), KeyboardInterrupt)
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
-    target.monitor.is_healthy.return_value = False
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
+    with ReplayManager([], server, target, any_crash=True, use_harness=True, relaunch=2) as replay:
         with raises(KeyboardInterrupt):
             replay.run(testcases, repeat=3, min_results=2)
-        assert target.close.call_count == 2
         assert replay.signature is None
         assert replay.status.iteration == 2
         assert replay.status.results == 1
         assert replay.status.ignored == 0
+    assert target.close.call_count == 1
+    assert target.monitor.is_healthy.call_count == 0
     assert fake_report.call_count == 1
     assert report_0.cleanup.call_count == 1
 
-def test_replay_15(mocker):
+def test_replay_16(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [
@@ -429,33 +456,35 @@ def test_replay_15(mocker):
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, use_harness=True) as replay:
         assert not replay.run(testcases)
-        assert target.close.call_count == 2
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 0
+    assert target.close.call_count == 2
     assert all(x.dump.call_count == 1 for x in testcases)
 
-def test_replay_16(mocker):
+def test_replay_17(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, rl_reset=100)
+    target = mocker.Mock(spec=Target, closed=False, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
+    target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, use_harness=True) as replay:
+    with ReplayManager([], server, target, use_harness=True, relaunch=100) as replay:
         assert not replay.run(testcases, repeat=10)
         assert server.serve_path.call_count == 30
-        assert target.close.call_count == 1
+        assert target.close.call_count == 2
         assert replay.status.ignored == 0
         assert replay.status.iteration == 10
         assert replay.status.results == 0
+    assert target.monitor.is_healthy.call_count == 1
     assert all(x.dump.call_count == 1 for x in testcases)
 
-def test_replay_17(mocker, tmp_path):
+def test_replay_18(mocker, tmp_path):
     """test ReplayManager.run() - multiple TestCases - successful repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
@@ -463,7 +492,7 @@ def test_replay_17(mocker, tmp_path):
         (SERVED_ALL, ["a.html"]),
         (SERVED_ALL, ["b.html"]),
         (SERVED_ALL, ["c.html"]))
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.side_effect = (
@@ -490,13 +519,13 @@ def test_replay_17(mocker, tmp_path):
     assert len(results[0].durations) == len(testcases)
     assert all(x.dump.call_count == 1 for x in testcases)
 
-def test_replay_18(mocker, tmp_path):
+def test_replay_19(mocker, tmp_path):
     """test ReplayManager.run() - multiple calls"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, rl_reset=1)
+    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
@@ -509,7 +538,7 @@ def test_replay_18(mocker, tmp_path):
             assert replay.status.iteration == 1
     assert server.serve_path.call_count == 3
 
-def test_replay_19(mocker, tmp_path):
+def test_replay_20(mocker, tmp_path):
     """test ReplayManager.report_to_filesystem()"""
     # no reports
     ReplayManager.report_to_filesystem(str(tmp_path), [])
@@ -555,7 +584,7 @@ def test_replay_19(mocker, tmp_path):
     assert path.is_dir()
     assert (path / "reports" / "expected_logs").is_dir()
 
-def test_replay_20(mocker, tmp_path):
+def test_replay_21(mocker, tmp_path):
     """test ReplayManager.load_testcases()"""
     fake_load = mocker.patch("grizzly.replay.replay.TestCase.load")
     test0 = mocker.Mock(spec=TestCase)
diff --git a/grizzly/session.py b/grizzly/session.py
index 6290c0ad..b12dae86 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -65,9 +65,12 @@ class Session(object):
 
     TARGET_LOG_SIZE_WARN = 0x1900000  # display warning when target log files exceed limit (25MB)
 
-    __slots__ = ("adapter", "coverage", "iomanager", "reporter", "server", "status", "target")
+    __slots__ = ("_relaunch", "adapter", "coverage", "iomanager", "reporter", "server",
+                 "status", "target")
 
-    def __init__(self, adapter, iomanager, reporter, server, target, coverage=False):
+    def __init__(self, adapter, iomanager, reporter, server, target,
+                 coverage=False, relaunch=1):
+        self._relaunch = relaunch
         self.adapter = adapter
         self.coverage = coverage
         self.iomanager = iomanager
@@ -123,7 +126,16 @@ def report_result(self):
 
     def run(self, ignore, iteration_limit=None, display_mode=DISPLAY_NORMAL):
         log_limiter = LogOutputLimiter(verbose=display_mode == self.DISPLAY_VERBOSE)
-        runner = Runner(self.server, self.target, relaunch=self.target.rl_reset)
+        # limit relaunch to max iterations if known
+        if iteration_limit is not None:
+            assert iteration_limit > 0
+            relaunch = min(self._relaunch, iteration_limit)
+        else:
+            relaunch = self._relaunch
+        if self.adapter.remaining is not None:
+            assert self.adapter.remaining > 0
+            relaunch = min(relaunch, self.adapter.remaining)
+        runner = Runner(self.server, self.target, relaunch=relaunch)
         while True:
             self.status.report()
             self.status.iteration += 1
@@ -142,10 +154,9 @@ def run(self, ignore, iteration_limit=None, display_mode=DISPLAY_NORMAL):
                     location = runner.location(
                         "/grz_harness",
                         self.server.port,
-                        close_after=self.target.rl_reset,
+                        close_after=relaunch,
                         timeout=self.adapter.TEST_DURATION)
                 runner.launch(location, max_retries=3, retry_delay=0)
-            self.target.step()
 
             # create and populate a test case
             current_test = self.generate_testcase()
diff --git a/grizzly/target/__init__.py b/grizzly/target/__init__.py
index 5b6e6661..63897969 100644
--- a/grizzly/target/__init__.py
+++ b/grizzly/target/__init__.py
@@ -14,8 +14,8 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
-TARGETS = None
 LOG = getLogger(__name__)
+TARGETS = dict()
 
 
 def _load_targets():
@@ -41,12 +41,12 @@ def _load_targets():
 
 
 def available():
-    if TARGETS is None:
+    if not TARGETS:
         _load_targets()
     return TARGETS.keys()
 
 
 def load(name):
-    if TARGETS is None:
+    if not TARGETS:
         _load_targets()
     return TARGETS[name]
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 592ca680..ea2a37ff 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -35,8 +35,8 @@
 class PuppetTarget(Target):
     __slots__ = ("use_rr", "use_valgrind", "_puppet", "_remove_prefs")
 
-    def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, relaunch, **kwds):
-        super().__init__(binary, extension, launch_timeout, log_limit, memory_limit, relaunch)
+    def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, **kwds):
+        super().__init__(binary, extension, launch_timeout, log_limit, memory_limit)
         self.use_rr = kwds.pop("rr", False)
         self.use_valgrind = kwds.pop("valgrind", False)
         self._remove_prefs = False
@@ -197,7 +197,6 @@ def dump_coverage(self, timeout=15):
             sleep(delay)
 
     def launch(self, location, env_mod=None):
-        self.rl_countdown = self.rl_reset
         # setup environment
         env_mod = dict(env_mod or [])
         # do not allow network connections to non local endpoints
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index ec16d5cb..871f494e 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -4,11 +4,9 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from abc import ABCMeta, abstractmethod, abstractproperty
 from logging import getLogger
-from os import getenv
 from os.path import isfile
 from re import split as resplit
 from threading import Lock
-from time import sleep, time
 
 
 __all__ = ("Target", "sanitizer_opts")
@@ -53,20 +51,18 @@ class TargetLaunchTimeout(TargetError):
     """Raised if the target does not launch within the defined amount of time"""
 
 
-# TODO: remove rl_countdown, rl_reset, relaunch, check_relaunch
 class Target(metaclass=ABCMeta):
     RESULT_NONE = 0
     RESULT_FAILURE = 1
     RESULT_IGNORED = 2
 
     __slots__ = (
-        "_lock", "_monitor", "_prefs", "binary", "extension",
-        "launch_timeout", "log_limit", "memory_limit", "rl_countdown", "rl_reset")
+        "_lock", "_monitor", "_prefs", "binary", "extension", "launch_timeout",
+        "log_limit", "memory_limit")
 
-    def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, relaunch):
+    def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit):
         assert log_limit >= 0
         assert memory_limit >= 0
-        assert relaunch >= 1
         assert binary is not None and isfile(binary)
         self._lock = Lock()
         self._monitor = None
@@ -76,8 +72,6 @@ def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, r
         self.launch_timeout = max(launch_timeout, 300)
         self.log_limit = log_limit
         self.memory_limit = memory_limit
-        self.rl_countdown = 0
-        self.rl_reset = relaunch
 
     def __enter__(self):
         return self
@@ -85,32 +79,9 @@ def __enter__(self):
     def __exit__(self, *exc):
         self.cleanup()
 
-    @property
-    def relaunch(self):
-        return self.rl_reset
-
-    @relaunch.setter
-    def relaunch(self, value):
-        self.rl_reset = value
-        self.rl_countdown = 0
-
     def add_abort_token(self, token):  # pylint: disable=no-self-use,unused-argument
         LOG.warning("add_abort_token() not implemented!")
 
-    def check_relaunch(self, wait=60):
-        if self.rl_countdown > 0:
-            return
-        # if the adapter does not use the default harness
-        # or close the browser it will hang here for 60 seconds
-        LOG.debug("relaunch will be triggered... waiting up to %0.2f seconds", wait)
-        deadline = time() + wait
-        while self.monitor.is_healthy():
-            if time() >= deadline:
-                LOG.info("Forcing target relaunch")
-                break
-            sleep(1)
-        self.close()
-
     @abstractmethod
     def cleanup(self):
         pass
@@ -132,7 +103,7 @@ def detect_failure(self, ignored, was_timeout):
     def dump_coverage(self):  # pylint: disable=no-self-use
         LOG.warning("dump_coverage() is not supported!")
 
-
+    # TODO: move to monitor?
     def is_idle(self, threshold):  # pylint: disable=no-self-use,unused-argument
         LOG.debug("Target.is_idle() not implemented! returning False")
         return False
@@ -149,6 +120,7 @@ def log_size(self):  # pylint: disable=no-self-use
     def monitor(self):
         pass
 
+    # TODO: better meta file handling
     @abstractproperty
     def prefs(self):
         pass
@@ -160,7 +132,3 @@ def reverse(self, remote, local):
     @abstractmethod
     def save_logs(self, *args, **kwargs):
         pass
-
-    def step(self):
-        # this should be called once per iteration
-        self.rl_countdown -= 1
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 8dc50dde..f9585dab 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -19,7 +19,7 @@ def test_puppet_target_01(mocker, tmp_path):
     fake_ffp.return_value.log_length.return_value = 562
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    with PuppetTarget(str(fake_file), None, 300, 25, 5000, 25) as target:
+    with PuppetTarget(str(fake_file), None, 300, 25, 5000) as target:
         assert target.closed
         assert not target._remove_prefs
         prefs_file = target.prefs
@@ -37,7 +37,7 @@ def test_puppet_target_01(mocker, tmp_path):
     assert fake_ffp.return_value.clean_up.call_count == 1
     assert not isfile(prefs_file)
     # with extra args
-    with PuppetTarget(str(fake_file), None, 1, 1, 1, 1, rr=True, fake=1) as target:
+    with PuppetTarget(str(fake_file), None, 1, 1, 1, rr=True, fake=1) as target:
         pass
 
 def test_puppet_target_02(mocker, tmp_path):
@@ -46,7 +46,7 @@ def test_puppet_target_02(mocker, tmp_path):
     fake_file = tmp_path / "fake"
     fake_file.touch()
     # test providing prefs.js
-    with PuppetTarget(str(fake_file), None, 300, 25, 5000, 35) as target:
+    with PuppetTarget(str(fake_file), None, 300, 25, 5000) as target:
         target.prefs = str(fake_file)
         assert not target._remove_prefs
         # launch success
@@ -79,7 +79,7 @@ def test_puppet_target_03(mocker, tmp_path):
     fake_ffp.RC_WORKER = FFPuppet.RC_WORKER
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    target = PuppetTarget(str(fake_file), None, 300, 25, 5000, 25)
+    target = PuppetTarget(str(fake_file), None, 300, 25, 5000)
     # no failures
     fake_ffp.return_value.is_healthy.return_value = True
     fake_ffp.return_value.reason = None
@@ -173,10 +173,9 @@ def test_puppet_target_04(mocker, tmp_path):
     fake_time = mocker.patch("grizzly.target.puppet_target.time", autospec=True)
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    target = PuppetTarget(str(fake_file), None, 300, 25, 5000, 10)
+    target = PuppetTarget(str(fake_file), None, 300, 25, 5000)
     fake_kill = mocker.patch("grizzly.target.puppet_target.kill", autospec=True)
     # not running
-    target.rl_countdown = 1
     fake_ffp.return_value.get_pid.return_value = None
     target.dump_coverage()
     assert not fake_kill.call_count
@@ -247,7 +246,7 @@ def test_puppet_target_05(mocker, tmp_path):
     fake_ffp.return_value.cpu_usage.return_value = [(999, 30), (998, 20), (997, 10)]
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    with PuppetTarget(str(fake_file), None, 300, 25, 5000, 10) as target:
+    with PuppetTarget(str(fake_file), None, 300, 25, 5000) as target:
         assert not target.is_idle(0)
         assert not target.is_idle(25)
         assert target.is_idle(50)
@@ -257,7 +256,7 @@ def test_puppet_target_06(mocker, tmp_path):
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    with PuppetTarget(str(fake_file), None, 300, 25, 5000, 25) as target:
+    with PuppetTarget(str(fake_file), None, 300, 25, 5000) as target:
         fake_ffp.return_value.is_running.return_value = False
         fake_ffp.return_value.is_healthy.return_value = False
         assert target.monitor is not None
@@ -279,7 +278,7 @@ def test_puppet_target_07(mocker, tmp_path):
     mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    with PuppetTarget(str(fake_file), None, 300, 25, 5000, 25) as target:
+    with PuppetTarget(str(fake_file), None, 300, 25, 5000) as target:
         # default temp prefs
         assert not target._remove_prefs
         prefs_file = target.prefs
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index a7fbf6ff..937123b9 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -4,7 +4,6 @@
 # pylint: disable=protected-access
 
 from .target import sanitizer_opts, Target
-from .target_monitor import TargetMonitor
 
 class SimpleTarget(Target):
     def cleanup(self):
@@ -16,7 +15,7 @@ def closed(self):
         pass
     def detect_failure(self, ignored, was_timeout):
         pass
-    def launch(self, location, env_mod=None):
+    def launch(self):
         pass
     @property
     def monitor(self):
@@ -31,7 +30,7 @@ def test_target_01(tmp_path):
     """test creating a simple Target"""
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    target = SimpleTarget(str(fake_file), str(fake_file), 321, 2, 3, 25)
+    target = SimpleTarget(str(fake_file), str(fake_file), 321, 2, 3)
     assert target.binary == str(fake_file)
     assert target.extension == str(fake_file)
     assert not target.is_idle(0)
@@ -39,37 +38,12 @@ def test_target_01(tmp_path):
     assert target.log_size() == 0
     assert target.log_limit == 2
     assert target.memory_limit == 3
-    assert target.rl_countdown == 0
-    assert target.rl_reset == 25
+    assert target.monitor is None
     # test stubs
     target.add_abort_token("none!")
     target.dump_coverage()
     target.reverse(1, 2)
 
-def test_target_02(mocker, tmp_path):
-    """test Target.check_relaunch() and Target.step()"""
-    fake_file = tmp_path / "fake"
-    fake_file.touch()
-    with SimpleTarget(str(fake_file), None, 300, 25, 5000, 1) as target:
-        target._monitor = mocker.Mock(spec=TargetMonitor)
-        target._monitor.is_healthy.return_value = True
-        # test skipping relaunch
-        target.rl_countdown = 2
-        target.step()
-        assert target.rl_countdown == 1
-        target.check_relaunch(wait=60)
-        # test triggering relaunch
-        target.rl_countdown = 1
-        target.step()
-        assert target.rl_countdown == 0
-        target.check_relaunch(wait=0)
-        # test with "crashed" process
-        target._monitor.is_healthy.side_effect = (True, False)
-        target.rl_countdown = 0
-        target.step()
-        mocker.patch("grizzly.target.target.sleep", autospec=True)
-        target.check_relaunch(wait=5)
-
 def test_sanitizer_opts_01(tmp_path):
     """test sanitizer_opts()"""
     # test empty string
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 9508abc5..d666f378 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -10,7 +10,7 @@
 from .common import Adapter, Report
 from .main import main
 from .session import Session
-from .target import TargetLaunchError
+from .target import Target, TargetLaunchError
 
 
 class FakeArgs(object):
@@ -27,7 +27,7 @@ def __init__(self):
         self.log_level = 10  # 10 = DEBUG, 20 = INFO
         self.log_limit = 0
         self.memory = 0
-        self.platform = "test"
+        self.platform = "fake-target"
         self.prefs = None
         self.rr = False
         self.relaunch = 1000
@@ -47,8 +47,7 @@ def test_main_01(mocker):
     fake_adapter.RELAUNCH = 1
     fake_adapter.TEST_DURATION = 10
     mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
-    targets = mocker.patch("grizzly.target.TARGETS")
-    targets.return_value = "fake-target"
+    mocker.patch.dict("grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)})
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.return_value.server = mocker.Mock(spec=Sapphire)
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
@@ -58,19 +57,32 @@ def test_main_01(mocker):
     args.input = "fake"
     args.ignore = ["fake", "fake"]
     args.prefs = "fake"
-    args.rr = True
     args.valgrind = True
     args.xvfb = True
     with raises(RuntimeError, match="Coverage must be run with --relaunch > 1"):
         main(args)
-    fake_adapter.RELAUNCH = 0
+    fake_session.assert_not_called()
+    # successful run
+    fake_adapter.RELAUNCH = 1
+    args.coverage = False
     assert main(args) == Session.EXIT_SUCCESS
+    assert not fake_session.mock_calls[0][-1]["coverage"]
+    assert fake_session.mock_calls[0][-1]["relaunch"] == 1
+    fake_session.reset_mock()
+    # with FM
+    fake_adapter.RELAUNCH = 0
     fake_reporter = mocker.patch("grizzly.main.FuzzManagerReporter", autospec=True)
     fake_reporter.sanity_check.return_value = True
+    args.coverage = True
     args.input = None
     args.log_level = None
     args.fuzzmanager = True
+    args.rr = True
     assert main(args) == Session.EXIT_SUCCESS
+    assert fake_session.mock_calls[0][-1]["coverage"]
+    assert fake_session.mock_calls[0][-1]["relaunch"] == 1000
+    fake_session.reset_mock()
+    # with S3FM
     fake_reporter = mocker.patch("grizzly.main.S3FuzzManagerReporter", autospec=True)
     fake_reporter.sanity_check.return_value = True
     args.fuzzmanager = False
@@ -83,8 +95,7 @@ def test_main_02(mocker, tmp_path):
     fake_adapter.TEST_DURATION = 10
     fake_adapter.RELAUNCH = 0
     mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
-    targets = mocker.patch("grizzly.target.TARGETS")
-    targets.return_value = "fake-target"
+    mocker.patch.dict("grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)})
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     fake_session.EXIT_ABORT = Session.EXIT_ABORT
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 64ce0a54..afa3437b 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -49,12 +49,12 @@ def generate(self, testcase, server_map):
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     prefs = tmp_path / "prefs.js"
     prefs.touch()
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=str(prefs), rl_reset=10)
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=str(prefs))
     # set target.log_size to test warning code path
     fake_target.log_size.return_value = Session.TARGET_LOG_SIZE_WARN + 1
     with IOManager() as iomgr:
         fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
-        with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
+        with Session(adapter, iomgr, None, fake_serv, fake_target, relaunch=10) as session:
             session.run([])
             assert session.status.iteration == 5
             assert session.status.test_name == "file.bin"
@@ -74,13 +74,13 @@ def generate(self, testcase, server_map):
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     prefs = tmp_path / "prefs.js"
     prefs.touch()
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=str(prefs), rl_reset=10)
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=str(prefs))
     fake_target.log_size.return_value = 1000
     fake_target.monitor.launches = 1
     with IOManager() as iomgr:
         iomgr.harness = adapter.get_harness()
         fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
-        with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
+        with Session(adapter, iomgr, None, fake_serv, fake_target, relaunch=10) as session:
             session.run([], iteration_limit=10)
             assert session.status.iteration == 10
             assert session.status.test_name is None
@@ -99,14 +99,14 @@ def generate(self, testcase, server_map):
     adapter = FuzzAdapter()
     adapter.setup(None, None)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target, prefs=None, rl_reset=2)
+    fake_target = mocker.Mock(spec=Target, prefs=None, )
     fake_target.log_size.return_value = 1000
     fake_target.monitor.launches = 1
     # target.launch() call will be skipped
     fake_target.closed = False
     with IOManager() as iomgr:
         fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
-        with Session(adapter, iomgr, None, fake_serv, fake_target, coverage=True) as session:
+        with Session(adapter, iomgr, None, fake_serv, fake_target, coverage=True, relaunch=2) as session:
             session.run([], iteration_limit=2)
             assert session.status.iteration == 2
     assert fake_target.dump_coverage.call_count == 2
@@ -123,11 +123,11 @@ def generate(self, testcase, server_map):
     adapter = FuzzAdapter()
     adapter.setup(None, None)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None, rl_reset=10)
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
     fake_target.monitor.launches = 1
     with IOManager() as iomgr:
         fake_serv.serve_path.return_value = (SERVED_NONE, [])
-        with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
+        with Session(adapter, iomgr, None, fake_serv, fake_target, relaunch=10) as session:
             with raises(SessionError, match="Please check Adapter and Target"):
                 session.run([], iteration_limit=10)
 
@@ -144,8 +144,9 @@ def test_session_05(tmp_path, mocker):
     fake_iomgr.tests = mocker.Mock(spec=deque)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_serv.serve_path.return_value = (SERVED_TIMEOUT, [fake_testcase.landing_page])
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None, rl_reset=10)
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
     fake_target.monitor.launches = 1
+    fake_target.monitor.is_healthy.return_value = False
     with Session(fake_adapter, fake_iomgr, None, fake_serv, fake_target) as session:
         session.run([], iteration_limit=1)
     assert fake_adapter.setup.call_count == 0
@@ -159,7 +160,7 @@ def test_session_05(tmp_path, mocker):
     assert fake_serv.serve_path.call_count == 1
     assert fake_target.launch.call_count == 1
     assert fake_target.detect_failure.call_count == 1
-    assert fake_target.step.call_count == 1
+    assert fake_target.monitor.is_healthy.call_count == 1
 
 def test_session_06(tmp_path, mocker):
     """test Session.generate_testcase()"""
@@ -249,7 +250,7 @@ def test_session_09(tmp_path, mocker):
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
     fake_runner.return_value.launch.side_effect = TargetLaunchError("test", mocker.Mock(spec=Report))
     mocker.patch("grizzly.session.TestFile", autospec=True)
-    fake_adapter = mocker.Mock(spec=Adapter)
+    fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
     fake_iomgr = mocker.Mock(
         spec=IOManager,
         harness=None,

From 62225b2bd0abd7c2cecd600611142358763b848c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 18 Dec 2020 13:55:20 -0800
Subject: [PATCH 135/531] [tests] Update tests

---
 grizzly/common/test_runner.py |  3 ++-
 grizzly/replay/test_replay.py | 24 ++++++++++++++----------
 2 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 02c029f1..11947dcb 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -3,6 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
+from itertools import count
 from os.path import join as pathjoin
 
 from pytest import raises
@@ -16,7 +17,7 @@
 
 def test_runner_01(mocker, tmp_path):
     """test Runner()"""
-    mocker.patch("grizzly.common.runner.time", autospec=True, side_effect=range(10))
+    mocker.patch("grizzly.common.runner.time", autospec=True, side_effect=count())
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
     target.detect_failure.return_value = target.RESULT_NONE
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index c46f0aa7..4e03ad67 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -6,6 +6,7 @@
 """
 unit tests for grizzly.replay
 """
+from itertools import cycle
 from os.path import join as pathjoin
 
 from pytest import raises
@@ -16,8 +17,6 @@
 from ..target import Target
 
 
-# TODO: also test relaunch < repeat
-
 def _fake_save_logs(result_logs, meta=False):  # pylint: disable=unused-argument
     """write fake log data to disk"""
     with open(pathjoin(result_logs, "log_stderr.txt"), "w") as log_fp:
@@ -47,7 +46,7 @@ def test_replay_02(mocker, tmp_path):
     target.detect_failure.return_value = Target.RESULT_NONE
     target.monitor.is_healthy.return_value = False
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
-        with ReplayManager([], server, target, use_harness=True) as replay:
+        with ReplayManager([], server, target, use_harness=True, relaunch=1) as replay:
             assert not replay.run([testcase])
             assert replay.signature is None
             assert replay.status.ignored == 0
@@ -78,6 +77,7 @@ def test_replay_03(mocker):
 def test_replay_04(mocker):
     """test ReplayManager.run() - exit - skip shutdown in runner"""
     # this will make runner appear to have just relaunched the target
+    # and skip the expected shutdown
     mocker.patch(
         "grizzly.common.runner.Runner._tests_run",
         new_callable=mocker.PropertyMock,
@@ -130,7 +130,7 @@ def test_replay_06(mocker, tmp_path):
     """test ReplayManager.run() - error - landing page not requested on first iteration"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, closed=False, launch_timeout=30)
+    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
@@ -148,7 +148,8 @@ def test_replay_07(mocker, tmp_path):
     """test ReplayManager.run() - delayed failure - following test landing page not requested"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, binary="bin", closed=False, launch_timeout=30)
+    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
+    type(target).closed = mocker.PropertyMock(side_effect=(True, False, True))
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.side_effect = (Target.RESULT_NONE, Target.RESULT_FAILURE)
@@ -169,7 +170,7 @@ def test_replay_08(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, launch_timeout=30)
+    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = Target.RESULT_IGNORED
     target.monitor.is_healthy.return_value = False
@@ -466,7 +467,9 @@ def test_replay_17(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=False, launch_timeout=30)
+    target = mocker.Mock(spec=Target, launch_timeout=30)
+    # test relaunch < repeat
+    type(target).closed = mocker.PropertyMock(side_effect=cycle([True, False]))
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     target.monitor.is_healthy.return_value = False
@@ -474,14 +477,15 @@ def test_replay_17(mocker):
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, use_harness=True, relaunch=100) as replay:
+    with ReplayManager([], server, target, use_harness=True, relaunch=2) as replay:
         assert not replay.run(testcases, repeat=10)
         assert server.serve_path.call_count == 30
-        assert target.close.call_count == 2
+        assert target.close.call_count == 6
+        assert target.launch.call_count == 5
         assert replay.status.ignored == 0
         assert replay.status.iteration == 10
         assert replay.status.results == 0
-    assert target.monitor.is_healthy.call_count == 1
+    assert target.monitor.is_healthy.call_count == 5
     assert all(x.dump.call_count == 1 for x in testcases)
 
 def test_replay_18(mocker, tmp_path):

From a73f145dbaec2bc61502ad50ca6945d1a136a7d4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 18 Dec 2020 13:56:54 -0800
Subject: [PATCH 136/531] [reduce] Only allow relaunch > 1 when running a
 single test with the harness

---
 grizzly/reduce/core.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index a92f9836..07aefa18 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -212,7 +212,7 @@ def run_reliability_analysis(self, stats):
             if last_test and len(self.testcases) == 1:
                 continue
 
-            relaunch = self.ANALYSIS_ITERATIONS if use_harness else 1
+            relaunch = self.ANALYSIS_ITERATIONS if last_test else 1
 
             with ReplayManager(
                 self.ignore, self.server, self.target, any_crash=self._any_crash,
@@ -350,7 +350,9 @@ def run(self, repeat=1, min_results=1):
                         self.run_reliability_analysis(stats)
                 self._stats.add_info("Analysis", reliability_info)
                 any_success = True  # analysis ran and didn't raise
-            if self._use_harness:
+            # multi part test cases should always use relaunch == 1
+            # since that usually means there is a timing component
+            if self._use_harness and len(self.testcases) == 1:
                 relaunch = min(self._original_relaunch, repeat)
             else:
                 relaunch = 1
@@ -369,6 +371,7 @@ def run(self, repeat=1, min_results=1):
                          len(self.strategies))
                 replay = ReplayManager(self.ignore, self.server, self.target,
                                        any_crash=self._any_crash,
+                                       relaunch=relaunch,
                                        signature=self._signature,
                                        use_harness=self._use_harness)
                 strategy = STRATEGIES[strategy](self.testcases)

From aa89ad14e68114dfa42fb500ab5c98469d3c0026 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 21 Dec 2020 14:02:48 -0500
Subject: [PATCH 137/531] [reduce] Rework analysis to be more consistent in how
 last_test_only is used.

---
 grizzly/reduce/core.py | 45 +++++++++++++++++++++++++++++-------------
 1 file changed, 31 insertions(+), 14 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 07aefa18..fbd49ff1 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -204,15 +204,32 @@ def run_reliability_analysis(self, stats):
         # We're only using repeat=1 instead of repeat=ITERATIONS so we can get feedback
         #   on every call to interesting.
 
-        for (use_harness, last_test) in [(True, True), (True, False), (False, False)]:
+        # N.B. We only use `last_test_only` if `len(self.testcases) > 1` ..
+        # if `self.testcases` only has 1 entry to begin with, we don't need `last_test_only` to trim it
+        for (use_harness, last_test_only) in [
+                (True, True),
+                (True, False),
+                # only one of the two use_harness=False cases will run:
+                (False, True),  # input is len(self.testcases)>1 and we will only try the last testcase
+                (False, False)]:  # input is len(self.testcases)==1 already and there's no need to trim
             if use_harness and (not self._original_use_harness or harness_crashes):
+                # Don't test with harness again if we already found crashes with the harness (last_test_only)
+                # or if it was disabled by command-line.
                 continue
             if not use_harness and harness_crashes >= self.ANALYSIS_ITERATIONS / 2:
+                # Don't test without harness if harness found > 50% crashes
                 continue
-            if last_test and len(self.testcases) == 1:
+            if last_test_only and len(self.testcases) == 1:
+                # Only set `last_test_only` if we have more than one testcase to begin with
+                continue
+            if not use_harness and len(self.testcases) > 1:
+                # Can't run without harness if we have more than one testcase (`last_test_only` will run)
                 continue
 
-            relaunch = self.ANALYSIS_ITERATIONS if last_test else 1
+            if use_harness and (last_test_only or len(self.testcases) == 1):
+                relaunch = self.ANALYSIS_ITERATIONS
+            else:
+                relaunch = 1
 
             with ReplayManager(
                 self.ignore, self.server, self.target, any_crash=self._any_crash,
@@ -222,12 +239,12 @@ def run_reliability_analysis(self, stats):
                          self.ANALYSIS_ITERATIONS,
                          "using" if use_harness else "without")
                 testcases = self.testcases
-                if last_test:
-                    LOG.warning("Checking reliability with only the last testcase.")
-                    testcases = [testcases[-1]]
-                if not use_harness and len(testcases) > 1:
-                    LOG.warning("Only the last testcase of %d given will be used to "
-                                "assess reliability without harness.", len(testcases))
+                if last_test_only:
+                    if use_harness:
+                        LOG.warning("Checking reliability with only the last testcase.")
+                    else:
+                        LOG.warning("Only the last testcase of %d given will be used to "
+                                    "assess reliability without harness.", len(testcases))
                     testcases = [testcases[-1]]
                 results = replay.run(
                     testcases, repeat=self.ANALYSIS_ITERATIONS, min_results=1,
@@ -250,7 +267,7 @@ def run_reliability_analysis(self, stats):
                         # we only want to iterate through all testcases if the last
                         # testcase alone never reproduced (crashes == 0).
                         harness_crashes = crashes
-                        if last_test:
+                        if last_test_only:
                             harness_last_crashes = crashes
                     else:
                         non_harness_crashes = crashes
@@ -259,7 +276,7 @@ def run_reliability_analysis(self, stats):
                         result.report.cleanup()
                 reliability = crashes / self.ANALYSIS_ITERATIONS
                 key = ("using" if use_harness else "without") + " harness"
-                if last_test or (not use_harness and len(self.testcases) > 1):
+                if last_test_only:
                     key += "/last test only"
                 LOG.info("Testcase was interesting %0.1f%% of %d attempts %s.",
                          100.0 * reliability, self.ANALYSIS_ITERATIONS, key)
@@ -271,8 +288,7 @@ def run_reliability_analysis(self, stats):
             raise NotReproducible("Did not reproduce during analysis")
 
         # if harness is selected, we'll only use the last testcase
-        last_test = bool(harness_last_crashes)
-        if last_test:
+        if harness_last_crashes:
             harness_crashes = harness_last_crashes
 
         # should we use the harness? go with harness unless no-harness crashed 50% more
@@ -283,7 +299,8 @@ def run_reliability_analysis(self, stats):
             )
         )
 
-        if (not self._use_harness or last_test) and len(self.testcases) > 1:
+        if ((self._use_harness and harness_last_crashes)
+                or (not self._use_harness and len(self.testcases) > 1)):
             LOG.warning("Last testcase %s harness was selected, other %d "
                         "testcases in the original will be ignored.",
                         "with" if self._use_harness else "without",

From 3f85ac14ca2a1a20dc130ab0f57e16f49ea9dd1f Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 21 Dec 2020 14:31:42 -0500
Subject: [PATCH 138/531] [reduce] Fix bug preventing analysis from checking
 no-harness case when multi-part testcase is given.

---
 grizzly/reduce/core.py        | 2 +-
 grizzly/reduce/test_reduce.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index fbd49ff1..30cb45c9 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -222,7 +222,7 @@ def run_reliability_analysis(self, stats):
             if last_test_only and len(self.testcases) == 1:
                 # Only set `last_test_only` if we have more than one testcase to begin with
                 continue
-            if not use_harness and len(self.testcases) > 1:
+            if not use_harness and (not last_test_only and len(self.testcases) > 1):
                 # Can't run without harness if we have more than one testcase (`last_test_only` will run)
                 continue
 
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 55e118ca..1212fb02 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -241,7 +241,7 @@ def test_analysis(mocker, tmp_path, harness_last_crashes, harness_crashes,
         expected_iters += 1
     if harness_crashes is not None:
         crashes += [True] * harness_crashes + [False] * (11 - harness_crashes)
-        expected_iters = 1
+        expected_iters += 1
     if no_harness_crashes is not None:
         crashes += [False] * (11 - no_harness_crashes) + [True] * no_harness_crashes
         expected_iters += 1

From fafa334b1a04978b79cae4ad12739a0897fcc30f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 21 Dec 2020 13:28:43 -0800
Subject: [PATCH 139/531] Add/update comments

---
 grizzly/common/runner.py | 2 ++
 grizzly/reduce/core.py   | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index fe9e6ae2..493e4f03 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -227,6 +227,8 @@ def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait
                         break
                     # wait 2 seconds (4 passes) before attempting idle exit
                     if close_delay > 3 and self._target.is_idle(10):
+                        # NOTE: this will always trigger on systems where the
+                        # browser does not exit when the last window is closed
                         LOG.debug("target idle")
                         break
                     # delay to help catch shutdown related crashes, LSan, etc.
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 30cb45c9..9ffdd1d4 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -368,7 +368,7 @@ def run(self, repeat=1, min_results=1):
                 self._stats.add_info("Analysis", reliability_info)
                 any_success = True  # analysis ran and didn't raise
             # multi part test cases should always use relaunch == 1
-            # since that usually means there is a timing component
+            # since that can mean a delay is required
             if self._use_harness and len(self.testcases) == 1:
                 relaunch = min(self._original_relaunch, repeat)
             else:

From 6129a43018663c7adb6120e06f56a8ee2b91b30d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 21 Dec 2020 14:10:28 -0800
Subject: [PATCH 140/531] Remove relaunch restrictions from coverage runs

---
 grizzly/main.py      |  5 -----
 grizzly/test_main.py | 17 ++++++++---------
 2 files changed, 8 insertions(+), 14 deletions(-)

diff --git a/grizzly/main.py b/grizzly/main.py
index 0df24f8d..de1151c5 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -86,11 +86,6 @@ def main(args):
             log.info("Using prefs %r", args.prefs)
         adapter.monitor = target.monitor
 
-        if args.coverage and relaunch == 1:
-            # this is a workaround to avoid not dumping coverage
-            # TODO: this may not be needed since moving relaunch into runnner
-            raise RuntimeError("Coverage must be run with --relaunch > 1")
-
         log.debug("calling adapter setup()")
         adapter.setup(args.input, iomanager.server_map)
         log.debug("configuring harness")
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index d666f378..4579f358 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -3,9 +3,6 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """test Grizzly main"""
-
-from pytest import raises
-
 from sapphire import Sapphire
 from .common import Adapter, Report
 from .main import main
@@ -44,7 +41,6 @@ def test_main_01(mocker):
     """test main()"""
     fake_adapter = mocker.Mock(spec=Adapter)
     fake_adapter.NAME = "fake"
-    fake_adapter.RELAUNCH = 1
     fake_adapter.TEST_DURATION = 10
     mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
     mocker.patch.dict("grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)})
@@ -53,16 +49,19 @@ def test_main_01(mocker):
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     args = FakeArgs()
     args.adapter = "fake"
-    args.coverage = True
     args.input = "fake"
     args.ignore = ["fake", "fake"]
     args.prefs = "fake"
     args.valgrind = True
     args.xvfb = True
-    with raises(RuntimeError, match="Coverage must be run with --relaunch > 1"):
-        main(args)
-    fake_session.assert_not_called()
-    # successful run
+    # successful run (with coverage)
+    fake_adapter.RELAUNCH = 10
+    args.coverage = True
+    assert main(args) == Session.EXIT_SUCCESS
+    assert fake_session.mock_calls[0][-1]["coverage"]
+    assert fake_session.mock_calls[0][-1]["relaunch"] == 10
+    fake_session.reset_mock()
+    # successful run (without coverage)
     fake_adapter.RELAUNCH = 1
     args.coverage = False
     assert main(args) == Session.EXIT_SUCCESS

From 9e5597d33734bc0d4958b7f3b63dd4212b5c1f0f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 21 Dec 2020 17:08:18 -0800
Subject: [PATCH 141/531] Remove GRZ_FORCED_CLOSE from tracked environment
 variables

---
 grizzly/common/iomanager.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/grizzly/common/iomanager.py b/grizzly/common/iomanager.py
index 90053d7b..2f8a8ea9 100644
--- a/grizzly/common/iomanager.py
+++ b/grizzly/common/iomanager.py
@@ -22,7 +22,6 @@ class IOManager(object):
         "ASAN_OPTIONS",
         "LSAN_OPTIONS",
         "GNOME_ACCESSIBILITY",
-        "GRZ_FORCED_CLOSE",
         "MOZ_CHAOSMODE",
         "XPCOM_DEBUG_BREAK")
 

From f2da5f64c0059a69c0fa358d71fe11568e4f4f31 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Dec 2020 16:31:09 -0800
Subject: [PATCH 142/531] [pylint] Add missing return values

---
 grizzly/common/reporter.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 00c662c2..701e3982 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -545,7 +545,7 @@ def _submit_report(self, report, test_cases):
                     LOG.info("Frequent crash matched existing signature: %s",
                              cache_metadata["shortDescription"])
                     if not self.force_report:
-                        return
+                        return None
                 elif "bug__id" in cache_metadata:
                     LOG.info("Crash matched existing signature (bug %s): %s",
                              cache_metadata["bug__id"],
@@ -566,7 +566,7 @@ def _submit_report(self, report, test_cases):
             if cache_sig_file is None:
                 if self._ignored(report):
                     LOG.info("Report is unsupported and is in ignore list")
-                    return
+                    return None
                 LOG.warning("Report is unsupported by FM, saved to %r", report.path)
                 # TODO: we should check if stackhasher failed too
                 raise RuntimeError("Failed to create FM signature")

From df36c00a611e9794db71174bb5f94afa4504be87 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Dec 2020 16:32:03 -0800
Subject: [PATCH 143/531] Add commments to Session.EXIT_* values

---
 grizzly/session.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/grizzly/session.py b/grizzly/session.py
index b12dae86..c5ebc4b8 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -57,11 +57,11 @@ class Session(object):
     DISPLAY_VERBOSE = 0  # display status every iteration
     DISPLAY_NORMAL = 1  # quickly reduce the amount of output
     EXIT_SUCCESS = 0
-    EXIT_ERROR = 1
-    EXIT_ARGS = 2
-    EXIT_ABORT = 3
-    EXIT_LAUNCH_FAILURE = 4
-    EXIT_FAILURE = 5
+    EXIT_ERROR = 1  # unexpected error occurred (invalid input, unhanded exception, etc)
+    EXIT_ARGS = 2  # invalid argument
+    EXIT_ABORT = 3  # run aborted (ctrl+c, etc)
+    EXIT_LAUNCH_FAILURE = 4  # unrelated Target failure (browser startup crash, etc)
+    EXIT_FAILURE = 5  # expected results not reproduced (opposite of EXIT_SUCCESS)
 
     TARGET_LOG_SIZE_WARN = 0x1900000  # display warning when target log files exceed limit (25MB)
 

From f81e3e60d924fa7cfab25d1b591ee676057bde4f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Dec 2020 16:36:23 -0800
Subject: [PATCH 144/531] Rename remaining 'log' to 'LOG'

---
 grizzly/adapters/__init__.py | 14 ++++-----
 grizzly/main.py              | 58 ++++++++++++++++++------------------
 grizzly/session.py           | 38 +++++++++++------------
 3 files changed, 55 insertions(+), 55 deletions(-)

diff --git a/grizzly/adapters/__init__.py b/grizzly/adapters/__init__.py
index 1da3d466..86a913f9 100644
--- a/grizzly/adapters/__init__.py
+++ b/grizzly/adapters/__init__.py
@@ -6,7 +6,7 @@
 
 from grizzly.common import Adapter
 
-log = logging.getLogger(__name__)  # pylint: disable=invalid-name
+LOG = logging.getLogger(__name__)
 
 __all__ = ("get", "load", "names")
 __adapters__ = dict()
@@ -19,12 +19,12 @@ def load(path=None, skip_failures=True):
     if path is None:
         path = os.path.dirname(__file__)
     path = os.path.abspath(path)
-    log.debug("loading adapters from %r", path)
+    LOG.debug("loading adapters from %r", path)
     sys.path.append(path)
     for sub in os.listdir(path):
         if not os.path.isfile(os.path.join(path, sub, "__init__.py")):
             continue
-        log.debug("scanning %r", sub)
+        LOG.debug("scanning %r", sub)
         try:
             lib = importlib.import_module(sub)
         except Exception:  # pylint: disable=broad-except
@@ -32,14 +32,14 @@ def load(path=None, skip_failures=True):
                 raise
             exc_type, exc_obj, exc_tb = sys.exc_info()
             tbinfo = traceback.extract_tb(exc_tb)[-1]
-            log.debug("raised %s: %s (%s:%d)", exc_type.__name__, exc_obj, tbinfo[0], tbinfo[1])
+            LOG.debug("raised %s: %s (%s:%d)", exc_type.__name__, exc_obj, tbinfo[0], tbinfo[1])
             continue
         for clsname in dir(lib):
             cls = getattr(lib, clsname)
             if isinstance(cls, type) and issubclass(cls, Adapter):
                 if clsname == "Adapter":
                     continue
-                log.debug("sanity checking %r", clsname)
+                LOG.debug("sanity checking %r", clsname)
                 if not isinstance(cls.NAME, str):
                     raise RuntimeError(
                         "%s.NAME must be 'str' not %r" % (cls.__name__, type(cls.NAME).__name__))
@@ -54,8 +54,8 @@ def load(path=None, skip_failures=True):
                             cls.__name__))
                 __adapters__[cls.NAME] = cls
         else:
-            log.debug("ignored %r", sub)
-    log.debug("%d adapters loaded", len(__adapters__))
+            LOG.debug("ignored %r", sub)
+    LOG.debug("%d adapters loaded", len(__adapters__))
 
 def names():
     return __adapters__.keys()
diff --git a/grizzly/main.py b/grizzly/main.py
index de1151c5..8df30507 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -20,7 +20,7 @@
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
 
-log = getLogger(__name__)  # pylint: disable=invalid-name
+LOG = getLogger(__name__)
 
 def configure_logging(log_level):
     if log_level == DEBUG:
@@ -33,45 +33,45 @@ def configure_logging(log_level):
 
 def main(args):
     configure_logging(args.log_level)
-    log.info("Starting Grizzly")
+    LOG.info("Starting Grizzly")
     if args.fuzzmanager:
         FuzzManagerReporter.sanity_check(args.binary)
     elif args.s3_fuzzmanager:
         S3FuzzManagerReporter.sanity_check(args.binary)
 
     if args.ignore:
-        log.info("Ignoring: %s", ", ".join(args.ignore))
+        LOG.info("Ignoring: %s", ", ".join(args.ignore))
     if args.xvfb:
-        log.info("Running with Xvfb")
+        LOG.info("Running with Xvfb")
     if args.rr:
-        log.info("Running with RR")
+        LOG.info("Running with RR")
     elif args.valgrind:
-        log.info("Running with Valgrind. This will be SLOW!")
+        LOG.info("Running with Valgrind. This will be SLOW!")
 
     adapter = None
     iomanager = None
     session = None
     target = None
     try:
-        log.debug("initializing the IOManager")
+        LOG.debug("initializing the IOManager")
         # TODO: move this into Session
         iomanager = IOManager(report_size=(max(args.cache, 0) + 1))
 
-        log.debug("initializing Adapter %r", args.adapter)
+        LOG.debug("initializing Adapter %r", args.adapter)
         adapter = get_adapter(args.adapter)()
 
         if adapter.TEST_DURATION >= args.timeout:
-            log.error("Test duration (%ds) must be less than --timeout (%ds)",
+            LOG.error("Test duration (%ds) must be less than --timeout (%ds)",
                       adapter.TEST_DURATION, args.timeout)
             return Session.EXIT_ARGS
 
         if adapter.RELAUNCH > 0:
-            log.info("Relaunch (%d) set in Adapter", adapter.RELAUNCH)
+            LOG.info("Relaunch (%d) set in Adapter", adapter.RELAUNCH)
             relaunch = adapter.RELAUNCH
         else:
             relaunch = args.relaunch
 
-        log.debug("initializing the Target")
+        LOG.debug("initializing the Target")
         target = load_target(args.platform)(
             args.binary,
             args.extension,
@@ -83,32 +83,32 @@ def main(args):
             xvfb=args.xvfb)
         if args.prefs:
             target.prefs = args.prefs
-            log.info("Using prefs %r", args.prefs)
+            LOG.info("Using prefs %r", args.prefs)
         adapter.monitor = target.monitor
 
-        log.debug("calling adapter setup()")
+        LOG.debug("calling adapter setup()")
         adapter.setup(args.input, iomanager.server_map)
-        log.debug("configuring harness")
+        LOG.debug("configuring harness")
         iomanager.harness = adapter.get_harness()
 
-        log.debug("initializing the Reporter")
+        LOG.debug("initializing the Reporter")
         if args.fuzzmanager:
-            log.info("Results will be reported via FuzzManager")
+            LOG.info("Results will be reported via FuzzManager")
             reporter = FuzzManagerReporter(tool=args.tool)
         elif args.s3_fuzzmanager:
-            log.info("Results will be reported via FuzzManager w/ large attachments in S3")
+            LOG.info("Results will be reported via FuzzManager w/ large attachments in S3")
             reporter = S3FuzzManagerReporter(tool=args.tool)
         else:
             reporter = FilesystemReporter(pathjoin(getcwd(), "results"))
-            log.info("Results will be stored in %r", reporter.report_path)
+            LOG.info("Results will be stored in %r", reporter.report_path)
 
         # set 'auto_close=1' so the client error pages (code 4XX) will
         # call 'window.close()' after a second.
         # launch http server used to serve test cases
-        log.debug("starting Sapphire server")
+        LOG.debug("starting Sapphire server")
         with Sapphire(auto_close=1, timeout=args.timeout) as server:
             target.reverse(server.port, server.port)
-            log.debug("initializing the Session")
+            LOG.debug("initializing the Session")
             session = Session(
                 adapter,
                 iomanager,
@@ -124,32 +124,32 @@ def main(args):
             session.run(args.ignore, display_mode=display_mode)
 
     except KeyboardInterrupt:
-        log.info("Ctrl+C detected.")
+        LOG.info("Ctrl+C detected.")
         return Session.EXIT_ABORT
 
     except (TargetLaunchError, TargetLaunchTimeout) as exc:
-        log.error(str(exc))
+        LOG.error(str(exc))
         if isinstance(exc, TargetLaunchError) and exc.report:
             path = grz_tmp("launch_failures")
-            log.error("Logs can be found here %r", path)
+            LOG.error("Logs can be found here %r", path)
             reporter = FilesystemReporter(path, major_bucket=False)
             reporter.submit([], exc.report)
         return Session.EXIT_LAUNCH_FAILURE
 
     finally:
-        log.info("Shutting down...")
+        LOG.info("Shutting down...")
         if session is not None:
-            log.debug("calling session.close()")
+            LOG.debug("calling session.close()")
             session.close()
         if target is not None:
-            log.debug("calling target.cleanup()")
+            LOG.debug("calling target.cleanup()")
             target.cleanup()
         if adapter is not None:
-            log.debug("calling adapter.cleanup()")
+            LOG.debug("calling adapter.cleanup()")
             adapter.cleanup()
         if iomanager is not None:
-            log.debug("calling iomanager.cleanup()")
+            LOG.debug("calling iomanager.cleanup()")
             iomanager.cleanup()
-        log.info("Done.")
+        LOG.info("Done.")
 
     return Session.EXIT_SUCCESS
diff --git a/grizzly/session.py b/grizzly/session.py
index c5ebc4b8..f5edcf6a 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -17,7 +17,7 @@
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
 
-log = getLogger(__name__)  # pylint: disable=invalid-name
+LOG = getLogger(__name__)
 
 
 class SessionError(Exception):
@@ -90,19 +90,19 @@ def close(self):
 
     def display_status(self, log_limiter):
         if self.adapter.remaining is not None:
-            log.info(
+            LOG.info(
                 "[I%04d-L%02d-R%02d] %s",
                 self.status.iteration,
                 self.adapter.remaining,
                 self.status.results,
                 self.status.test_name)
         elif log_limiter.ready(self.status.iteration, self.target.monitor.launches):
-            log.info("I%04d-R%02d ", self.status.iteration, self.status.results)
+            LOG.info("I%04d-R%02d ", self.status.iteration, self.status.results)
 
     def generate_testcase(self):
-        log.debug("calling iomanager.create_testcase()")
+        LOG.debug("calling iomanager.create_testcase()")
         test = self.iomanager.create_testcase(self.adapter.NAME)
-        log.debug("calling self.adapter.generate()")
+        LOG.debug("calling self.adapter.generate()")
         self.adapter.generate(test, self.iomanager.server_map)
         self.status.test_name = test.input_fname
         if self.target.prefs is not None:
@@ -116,7 +116,7 @@ def report_result(self):
         self.target.save_logs(result_logs)
         report = Report(result_logs, self.target.binary)
         short_sig = report.crash_info.createShortSignature()
-        log.info("Result: %s (%s:%s)", short_sig, report.major[:8], report.minor[:8])
+        LOG.info("Result: %s (%s:%s)", short_sig, report.major[:8], report.minor[:8])
         # order test cases newest to oldest
         self.iomanager.tests.reverse()
         self.reporter.submit(self.iomanager.tests, report)
@@ -168,47 +168,47 @@ def run(self, ignore, iteration_limit=None, display_mode=DISPLAY_NORMAL):
             current_test.duration = result.duration
             # adapter callbacks
             if result.timeout:
-                log.debug("calling self.adapter.on_timeout()")
+                LOG.debug("calling self.adapter.on_timeout()")
                 self.adapter.on_timeout(current_test, result.served)
             else:
-                log.debug("calling self.adapter.on_served()")
+                LOG.debug("calling self.adapter.on_served()")
                 self.adapter.on_served(current_test, result.served)
             # update test case
             if not result.attempted:
-                log.debug("Ignoring test case since nothing was served")
+                LOG.debug("Ignoring test case since nothing was served")
                 self.iomanager.tests.pop().cleanup()
                 if not current_test.contains(current_test.landing_page):
-                    log.warning("Test case is missing landing page")
+                    LOG.warning("Test case is missing landing page")
                 if result.initial:
                     # since this is the first iteration since the Target launched
                     # something is likely wrong with the Target or Adapter
                     err_logs = mkdtemp(prefix="error_", dir=grz_tmp("logs"))
                     self.target.save_logs(err_logs)
-                    log.error("ERROR: Test case was not served. Timeout too short?")
-                    log.error("Logs can be found here %r", err_logs)
+                    LOG.error("ERROR: Test case was not served. Timeout too short?")
+                    LOG.error("Logs can be found here %r", err_logs)
                     raise SessionError("Please check Adapter and Target")
-                log.warning("Test case was not served")
+                LOG.warning("Test case was not served")
             elif self.adapter.IGNORE_UNSERVED:
-                log.debug("removing unserved files from the test case")
+                LOG.debug("removing unserved files from the test case")
                 current_test.purge_optional(result.served)
             # process results
             if result.status == RunResult.FAILED:
-                log.debug("result detected")
+                LOG.debug("result detected")
                 self.report_result()
             elif result.status == RunResult.IGNORED:
                 self.status.ignored += 1
-                log.info("Ignored (%d)", self.status.ignored)
+                LOG.info("Ignored (%d)", self.status.ignored)
 
             if self.adapter.remaining is not None and self.adapter.remaining < 1:
                 # all test cases have been replayed
-                log.info("Replay Complete")
+                LOG.info("Replay Complete")
                 break
 
             if iteration_limit is not None and self.status.iteration == iteration_limit:
-                log.info("Hit iteration limit")
+                LOG.info("Hit iteration limit")
                 break
 
             # warn about large browser logs
             self.status.log_size = self.target.log_size()
             if self.status.log_size > self.TARGET_LOG_SIZE_WARN:
-                log.warning("Large browser logs: %dMBs", (self.status.log_size / 0x100000))
+                LOG.warning("Large browser logs: %dMBs", (self.status.log_size / 0x100000))

From 7740315f8d650941e66666592cc7d2c6207ab177 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Dec 2020 17:14:12 -0800
Subject: [PATCH 145/531] Update some import statements

---
 grizzly/adapters/__init__.py | 29 +++++++------
 grizzly/common/adapter.py    | 21 ++++-----
 grizzly/common/storage.py    | 82 ++++++++++++++++++------------------
 3 files changed, 68 insertions(+), 64 deletions(-)

diff --git a/grizzly/adapters/__init__.py b/grizzly/adapters/__init__.py
index 86a913f9..a07d6cf4 100644
--- a/grizzly/adapters/__init__.py
+++ b/grizzly/adapters/__init__.py
@@ -1,12 +1,13 @@
-import importlib
-import logging
-import os
-import sys
-import traceback
+from importlib import import_module
+from logging import getLogger
+from os import listdir
+from os.path import abspath, dirname, isfile, join as pathjoin
+from sys import exc_info, path as syspath
+from traceback import extract_tb
 
 from grizzly.common import Adapter
 
-LOG = logging.getLogger(__name__)
+LOG = getLogger(__name__)
 
 __all__ = ("get", "load", "names")
 __adapters__ = dict()
@@ -17,21 +18,21 @@ def get(name):
 def load(path=None, skip_failures=True):
     assert not __adapters__, "adapters have already been loaded"
     if path is None:
-        path = os.path.dirname(__file__)
-    path = os.path.abspath(path)
+        path = dirname(__file__)
+    path = abspath(path)
     LOG.debug("loading adapters from %r", path)
-    sys.path.append(path)
-    for sub in os.listdir(path):
-        if not os.path.isfile(os.path.join(path, sub, "__init__.py")):
+    syspath.append(path)
+    for sub in listdir(path):
+        if not isfile(pathjoin(path, sub, "__init__.py")):
             continue
         LOG.debug("scanning %r", sub)
         try:
-            lib = importlib.import_module(sub)
+            lib = import_module(sub)
         except Exception:  # pylint: disable=broad-except
             if not skip_failures:
                 raise
-            exc_type, exc_obj, exc_tb = sys.exc_info()
-            tbinfo = traceback.extract_tb(exc_tb)[-1]
+            exc_type, exc_obj, exc_tb = exc_info()
+            tbinfo = extract_tb(exc_tb)[-1]
             LOG.debug("raised %s: %s (%s:%d)", exc_type.__name__, exc_obj, tbinfo[0], tbinfo[1])
             continue
         for clsname in dir(lib):
diff --git a/grizzly/common/adapter.py b/grizzly/common/adapter.py
index cfc46f4f..9dfbf246 100644
--- a/grizzly/common/adapter.py
+++ b/grizzly/common/adapter.py
@@ -2,8 +2,9 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-import abc
-import os
+from abc import ABCMeta, abstractmethod
+from os import walk
+from os.path import abspath, dirname, isdir, isfile, join as pathjoin
 
 
 __all__ = ("Adapter", "AdapterError")
@@ -15,8 +16,8 @@ class AdapterError(Exception):
     """The base class for exceptions raised by an Adapter"""
 
 
-class Adapter(metaclass=abc.ABCMeta):
-    HARNESS_FILE = os.path.join(os.path.dirname(__file__), "harness.html")
+class Adapter(metaclass=ABCMeta):
+    HARNESS_FILE = pathjoin(dirname(__file__), "harness.html")
     IGNORE_UNSERVED = True  # Only report test cases with served content
     NAME = None  # must be a unique string
     RELAUNCH = 0  # maximum iterations between Target relaunches (<1 use default)
@@ -85,24 +86,24 @@ def scan_path(path, ignore=("desktop.ini", "thumbs.db"), recursive=False):
         Yields:
             str: Absolute path to files.
         """
-        full_path = os.path.abspath(path)
-        if os.path.isdir(full_path):
-            for root, _, files in os.walk(full_path):
+        full_path = abspath(path)
+        if isdir(full_path):
+            for root, _, files in walk(full_path):
                 for fname in files:
                     if fname in ignore or fname.startswith("."):
                         # skip ignored and hidden system files
                         continue
-                    yield os.path.join(root, fname)
+                    yield pathjoin(root, fname)
                 if not recursive:
                     break
-        elif os.path.isfile(full_path):
+        elif isfile(full_path):
             yield full_path
 
     #############################
     # Methods to overload
     #############################
 
-    @abc.abstractmethod
+    @abstractmethod
     def generate(self, testcase, server_map):
         """Automatically called. Populate testcase here.
 
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index cb00b97e..6af56a47 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -6,8 +6,10 @@
 from collections import namedtuple
 from itertools import chain
 import json
-import os
-import shutil
+from os import listdir, makedirs, SEEK_END, walk
+from os.path import abspath, basename, dirname, isfile, isdir, join as pathjoin, \
+    normpath, relpath
+from shutil import copyfileobj, rmtree
 from tempfile import mkdtemp, SpooledTemporaryFile
 from time import time
 from zipfile import BadZipfile, ZipFile
@@ -88,9 +90,9 @@ def add_batch(self, path, include_files, prefix=None):
         Returns:
             None
         """
-        path = os.path.abspath(path)
+        path = abspath(path)
         for fname in (x for x in include_files if x.startswith(path)):
-            test_path = os.path.relpath(fname, path)
+            test_path = relpath(fname, path)
             if test_path.startswith(".."):
                 continue
             if prefix:
@@ -196,8 +198,8 @@ def clone(self):
         Returns:
             TestCase: A copy of the TestCase instance
         """
-        result = type(self)(self.landing_page, self.redirect_page, self.adapter_name, self.input_fname,
-                            self.timestamp)
+        result = type(self)(self.landing_page, self.redirect_page, self.adapter_name,
+                            self.input_fname, self.timestamp)
         result.duration = self.duration
         result.env_vars.update(self.env_vars)
         for entry in self._files.meta:
@@ -256,10 +258,10 @@ def dump(self, out_path, include_details=False):
                 "adapter": self.adapter_name,
                 "duration": self.duration,
                 "env": self.env_vars,
-                "input": os.path.basename(self.input_fname) if self.input_fname else None,
+                "input": basename(self.input_fname) if self.input_fname else None,
                 "target": self.landing_page,
                 "timestamp": self.timestamp}
-            with open(os.path.join(out_path, "test_info.json"), "w") as out_fp:
+            with open(pathjoin(out_path, "test_info.json"), "w") as out_fp:
                 json.dump(info, out_fp, indent=2, sort_keys=True)
             # save meta files
             for meta_file in self._files.meta:
@@ -305,16 +307,16 @@ def load(cls, path, load_prefs, adjacent=False):
                 with ZipFile(path) as zip_fp:
                     zip_fp.extractall(path=unpacked)
             except (BadZipfile, zlib_error):
-                shutil.rmtree(unpacked, ignore_errors=True)
+                rmtree(unpacked, ignore_errors=True)
                 raise TestCaseLoadFailure("Testcase archive is corrupted") from None
             path = unpacked
         else:
             unpacked = None
         # load testcase data from disk
         try:
-            if os.path.isfile(path):
+            if isfile(path):
                 tests = [cls.load_single(path, load_prefs, adjacent=adjacent)]
-            elif os.path.isdir(path):
+            elif isdir(path):
                 tests = list()
                 for tc_path in TestCase.scan_path(path):
                     tests.append(cls.load_single(tc_path, load_prefs))
@@ -323,7 +325,7 @@ def load(cls, path, load_prefs, adjacent=False):
                 raise TestCaseLoadFailure("Invalid TestCase path")
         finally:
             if unpacked is not None:
-                shutil.rmtree(unpacked, ignore_errors=True)
+                rmtree(unpacked, ignore_errors=True)
         return tests
 
     def load_environ(self, path, env_data):
@@ -333,12 +335,12 @@ def load_environ(self, path, env_data):
                 raise TestCaseLoadFailure("'env_data' contains invalid 'env' entries")
         self.env_vars = env_data
         known_suppressions = ("lsan.supp", "tsan.supp", "ubsan.supp")
-        for supp in os.listdir(path):
+        for supp in listdir(path):
             if supp.lower() in known_suppressions:
                 # Update *SAN_OPTIONS environment variable to use provided suppression files.
                 opt_key = "%s_OPTIONS" % (supp.split(".")[0].upper(),)
                 opts = sanitizer_opts(self.env_vars.get(opt_key, ""))
-                opts["suppressions"] = "'%s'" % (os.path.join(path, supp),)
+                opts["suppressions"] = "'%s'" % (pathjoin(path, supp),)
                 self.env_vars[opt_key] = ":".join("=".join((k, v)) for k, v in opts.items())
 
     @classmethod
@@ -356,11 +358,11 @@ def load_single(cls, path, load_prefs, adjacent=False):
         Returns:
             TestCase: A TestCase.
         """
-        path = os.path.abspath(path)
-        if os.path.isdir(path):
+        path = abspath(path)
+        if isdir(path):
             # load using test_info.json
             try:
-                with open(os.path.join(path, "test_info.json"), "r") as in_fp:
+                with open(pathjoin(path, "test_info.json"), "r") as in_fp:
                     info = json.load(in_fp)
             except IOError:
                 raise TestCaseLoadFailure("Missing 'test_info.json'") from None
@@ -368,22 +370,22 @@ def load_single(cls, path, load_prefs, adjacent=False):
                 raise TestCaseLoadFailure("Invalid 'test_info.json'") from None
             if not isinstance(info.get("target"), str):
                 raise TestCaseLoadFailure("'test_info.json' has invalid 'target' entry")
-            entry_point = os.path.basename(info["target"])
-            if not os.path.isfile(os.path.join(path, entry_point)):
+            entry_point = basename(info["target"])
+            if not isfile(pathjoin(path, entry_point)):
                 raise TestCaseLoadFailure("Entry point %r not found in '%s'" % (entry_point, path))
             # always load all contents of a directory if a 'test_info.json' is loaded
             adjacent = True
-        elif os.path.isfile(path):
-            entry_point = os.path.basename(path)
+        elif isfile(path):
+            entry_point = basename(path)
             info = dict()
-            path = os.path.dirname(path)
+            path = dirname(path)
         else:
             raise TestCaseLoadFailure("Missing or invalid TestCase %r" % (path,))
         # create testcase and add data
         test = cls(None, None, info.get("adapter", None), timestamp=info.get("timestamp", 0))
-        if load_prefs and os.path.isfile(os.path.join(path, "prefs.js")):
-            test.add_meta(TestFile.from_file(os.path.join(path, "prefs.js")))
-        test.add_from_file(os.path.join(path, entry_point))
+        if load_prefs and isfile(pathjoin(path, "prefs.js")):
+            test.add_meta(TestFile.from_file(pathjoin(path, "prefs.js")))
+        test.add_from_file(pathjoin(path, entry_point))
         test.landing_page = entry_point
         # load environment variables
         if info:
@@ -394,14 +396,14 @@ def load_single(cls, path, load_prefs, adjacent=False):
                 raise
         # load all adjacent data from directory
         if adjacent:
-            for dpath, _, files in os.walk(path):
+            for dpath, _, files in walk(path):
                 for fname in files:
                     # ignore files that have been previously loaded
                     if fname in (entry_point, "prefs.js", "test_info.json"):
                         continue
                     location = "/".join((dpath.split(path, 1)[-1], fname))
                     test.add_from_file(
-                        os.path.join(dpath, fname),
+                        pathjoin(dpath, fname),
                         file_name=location,
                         required=False)
         return test
@@ -457,13 +459,13 @@ def scan_path(path):
         Yields:
             str: Path to what appears to be a valid testcase.
         """
-        contents = os.listdir(path)
+        contents = listdir(path)
         if "test_info.json" in contents:
             yield path
         else:
             for entry in contents:
-                tc_path = os.path.join(path, entry)
-                if os.path.isfile(os.path.join(tc_path, "test_info.json")):
+                tc_path = pathjoin(path, entry)
+                if isfile(pathjoin(tc_path, "test_info.json")):
                     yield tc_path
 
 
@@ -489,7 +491,7 @@ def __init__(self, file_name):
                 or file_name.startswith("../"):
             raise TypeError("file_name is invalid %r" % (file_name,))
         # name including path relative to wwwroot
-        self._file_name = os.path.normpath(file_name)
+        self._file_name = normpath(file_name)
         self._fp = SpooledTemporaryFile(
             dir=grz_tmp("storage"),
             max_size=self.CACHE_LIMIT,
@@ -512,7 +514,7 @@ def clone(self):
         """
         cloned = type(self)(self._file_name)
         self._fp.seek(0)
-        shutil.copyfileobj(self._fp, cloned._fp, self.XFER_BUF)  # pylint: disable=protected-access
+        copyfileobj(self._fp, cloned._fp, self.XFER_BUF)  # pylint: disable=protected-access
         return cloned
 
     def close(self):
@@ -551,12 +553,12 @@ def dump(self, path):
         Returns:
             None
         """
-        target_path = os.path.join(path, os.path.dirname(self._file_name))
-        if not os.path.isdir(target_path):
-            os.makedirs(target_path)
+        target_path = pathjoin(path, dirname(self._file_name))
+        if not isdir(target_path):
+            makedirs(target_path)
         self._fp.seek(0)
-        with open(os.path.join(path, self._file_name), "wb") as dst_fp:
-            shutil.copyfileobj(self._fp, dst_fp, self.XFER_BUF)
+        with open(pathjoin(path, self._file_name), "wb") as dst_fp:
+            copyfileobj(self._fp, dst_fp, self.XFER_BUF)
 
     @property
     def file_name(self):
@@ -596,10 +598,10 @@ def from_file(cls, input_file, file_name=None):
             TestFile: A TestFile.
         """
         if file_name is None:
-            file_name = os.path.basename(input_file)
+            file_name = basename(input_file)
         t_file = cls(file_name)
         with open(input_file, "rb") as src_fp:
-            shutil.copyfileobj(src_fp, t_file._fp, cls.XFER_BUF)  # pylint: disable=protected-access
+            copyfileobj(src_fp, t_file._fp, cls.XFER_BUF)  # pylint: disable=protected-access
         return t_file
 
     @property
@@ -613,7 +615,7 @@ def size(self):
             int: Size in bytes.
         """
         pos = self._fp.tell()
-        self._fp.seek(0, os.SEEK_END)
+        self._fp.seek(0, SEEK_END)
         size = self._fp.tell()
         self._fp.seek(pos)
         return size

From 34101706bec806b77fd046bec81fae7e8434b027 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 24 Dec 2020 16:54:56 -0800
Subject: [PATCH 146/531] [replay] Pass timeout harness

---
 grizzly/replay/replay.py      |  3 ++-
 grizzly/replay/test_replay.py | 18 +++++++++---------
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 147fcedb..dc7ca8db 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -209,7 +209,8 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
                         location = runner.location(
                             "/grz_harness",
                             self.server.port,
-                            close_after=relaunch * test_count)
+                            close_after=relaunch * test_count,
+                            timeout=self.server.timeout)
                     # The environment from the initial testcase is used because
                     # a sequence of testcases is expected to be run without
                     # relaunching the Target to match the functionality of
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 4e03ad67..36c79a5f 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -39,7 +39,7 @@ def test_replay_01(mocker):
 def test_replay_02(mocker, tmp_path):
     """test ReplayManager.run() - no repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
@@ -100,7 +100,7 @@ def test_replay_05(mocker, tmp_path):
     """test ReplayManager.run() - successful repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     served = ["index.html"]
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_ALL, served)
     target = mocker.Mock(spec=Target, binary="C:\\fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
@@ -147,7 +147,7 @@ def test_replay_06(mocker, tmp_path):
 def test_replay_07(mocker, tmp_path):
     """test ReplayManager.run() - delayed failure - following test landing page not requested"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     type(target).closed = mocker.PropertyMock(side_effect=(True, False, True))
     target.RESULT_FAILURE = Target.RESULT_FAILURE
@@ -362,7 +362,7 @@ def test_replay_13(mocker, tmp_path):
     report_3.crash_info.createShortSignature.return_value = "No crash detected"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1, report_2, report_3)
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
@@ -425,7 +425,7 @@ def test_replay_15(mocker, tmp_path):
     report_0.crash_info.createShortSignature.return_value = "[@ test1]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0,)
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
     server.serve_path.side_effect = ((SERVED_ALL, ["index.html"]), KeyboardInterrupt)
     target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
@@ -446,7 +446,7 @@ def test_replay_15(mocker, tmp_path):
 def test_replay_16(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
@@ -465,7 +465,7 @@ def test_replay_16(mocker):
 
 def test_replay_17(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target, launch_timeout=30)
     # test relaunch < repeat
@@ -491,7 +491,7 @@ def test_replay_17(mocker):
 def test_replay_18(mocker, tmp_path):
     """test ReplayManager.run() - multiple TestCases - successful repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
     server.serve_path.side_effect = (
         (SERVED_ALL, ["a.html"]),
         (SERVED_ALL, ["b.html"]),
@@ -527,7 +527,7 @@ def test_replay_19(mocker, tmp_path):
     """test ReplayManager.run() - multiple calls"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE

From 4affd8f90fcc4d125dd5b45cb4c5918624840f4f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 24 Dec 2020 16:56:21 -0800
Subject: [PATCH 147/531] Handle XHR timeout when server is not available

---
 grizzly/common/harness.html | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/grizzly/common/harness.html b/grizzly/common/harness.html
index c83efc5a..6aa8af3c 100644
--- a/grizzly/common/harness.html
+++ b/grizzly/common/harness.html
@@ -35,6 +35,7 @@
 
 let main = () => {
   // poll sub and wait until closed
+  // sub should be closed by either the test case or setTestTimeout
   if (sub && !sub.closed) {
     setTimeout(main, 50)
     return
@@ -48,11 +49,14 @@
     let xhr = new XMLHttpRequest()
     // indicate test is complete by requesting `/grz_next_test`
     xhr.open('GET', '/grz_next_test', true)
+    // if web server goes away don't hang (sapphire times out)
+    xhr.timeout = 250
+    // close the harness to catch crashes that are triggered when the browser closes
     xhr.onabort = () => { window.close() }
     xhr.onerror = () => { window.close() }
-    xhr.onload = () => { window.close() }
-    // close the harness to catch crashes that are triggered when the browser closes
-    setTimeout(() => { xhr.send() }, 100)
+    xhr.onload = () => { setTimeout(window.close, 100) }
+    xhr.ontimeout = () => { window.close() }
+    xhr.send()
     return
   }
 

From 1b970e72bbaf661541cb1b11f11653ffd8430bfd Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 24 Dec 2020 16:59:12 -0800
Subject: [PATCH 148/531] Increase idle polling delay when shutdown is expected

---
 grizzly/common/runner.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 493e4f03..ee3be4a5 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -225,8 +225,8 @@ def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait
                 for close_delay in range(max(int(self._close_delay / 0.5), 1)):
                     if not self._target.monitor.is_healthy():
                         break
-                    # wait 2 seconds (4 passes) before attempting idle exit
-                    if close_delay > 3 and self._target.is_idle(10):
+                    # wait 3 seconds (6 passes) before attempting idle exit
+                    if close_delay > 5 and self._target.is_idle(10):
                         # NOTE: this will always trigger on systems where the
                         # browser does not exit when the last window is closed
                         LOG.debug("target idle")

From e284e0aa8f2f87c52375ed5d08b378cdfe0eb336 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 4 Jan 2021 13:03:50 -0800
Subject: [PATCH 149/531] Use adapter.TEST_DURATION as minimum allowed timeout
 when fuzzing

---
 grizzly/common/adapter.py   |  5 +++--
 grizzly/common/iomanager.py |  1 -
 grizzly/main.py             | 14 +++++++++-----
 grizzly/session.py          |  8 ++++----
 grizzly/test_main.py        |  8 +++-----
 5 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/grizzly/common/adapter.py b/grizzly/common/adapter.py
index 9dfbf246..3b184576 100644
--- a/grizzly/common/adapter.py
+++ b/grizzly/common/adapter.py
@@ -21,7 +21,7 @@ class Adapter(metaclass=ABCMeta):
     IGNORE_UNSERVED = True  # Only report test cases with served content
     NAME = None  # must be a unique string
     RELAUNCH = 0  # maximum iterations between Target relaunches (<1 use default)
-    TEST_DURATION = 30  # maximum execution time per test
+    TEST_DURATION = 30  # maximum execution time per test (used as minimum timeout)
 
     __slots__ = ("_harness", "fuzz", "monitor", "remaining")
 
@@ -53,7 +53,8 @@ def enable_harness(self, file_path=None):
         """Enable use of a harness during fuzzing. By default no harness is used.
 
         Args:
-            file_path (str): Path to file to use as a harness. If None the default harness is used.
+            file_path (str): Path to file to use as a harness. If None the default
+                             harness is used.
 
         Returns:
             None
diff --git a/grizzly/common/iomanager.py b/grizzly/common/iomanager.py
index 2f8a8ea9..f6a9f88d 100644
--- a/grizzly/common/iomanager.py
+++ b/grizzly/common/iomanager.py
@@ -76,7 +76,6 @@ def create_testcase(self, adapter_name):
         self.server_map.set_redirect("grz_current_test", self.page_name(), required=False)
         self.server_map.set_redirect("grz_next_test", self.page_name(offset=1))
         if self.harness is not None:
-            # add harness to testcase
             self.server_map.set_dynamic_response(
                 "grz_harness",
                 lambda: self.harness,
diff --git a/grizzly/main.py b/grizzly/main.py
index 8df30507..44bf479d 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -60,10 +60,14 @@ def main(args):
         LOG.debug("initializing Adapter %r", args.adapter)
         adapter = get_adapter(args.adapter)()
 
-        if adapter.TEST_DURATION >= args.timeout:
-            LOG.error("Test duration (%ds) must be less than --timeout (%ds)",
-                      adapter.TEST_DURATION, args.timeout)
-            return Session.EXIT_ARGS
+        if args.timeout <= adapter.TEST_DURATION:
+            LOG.info("Using minimum adapter timeout: %ds", adapter.TEST_DURATION)
+            if adapter.HARNESS_FILE:
+                LOG.info("To avoid Target relaunches due to tests failing to close"
+                         " themselves use a timeout > 'adapter.TEST_DURATION'")
+            timeout = adapter.TEST_DURATION
+        else:
+            timeout = args.timeout
 
         if adapter.RELAUNCH > 0:
             LOG.info("Relaunch (%d) set in Adapter", adapter.RELAUNCH)
@@ -106,7 +110,7 @@ def main(args):
         # call 'window.close()' after a second.
         # launch http server used to serve test cases
         LOG.debug("starting Sapphire server")
-        with Sapphire(auto_close=1, timeout=args.timeout) as server:
+        with Sapphire(auto_close=1, timeout=timeout) as server:
             target.reverse(server.port, server.port)
             LOG.debug("initializing the Session")
             session = Session(
diff --git a/grizzly/session.py b/grizzly/session.py
index f5edcf6a..3a6f6018 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -146,11 +146,11 @@ def run(self, ignore, iteration_limit=None, display_mode=DISPLAY_NORMAL):
                 self.adapter.pre_launch()
                 if self.iomanager.harness is None:
                     # harness is not in use, open the test case
-                    location = runner.location(
-                        "/grz_current_test",
-                        self.server.port)
+                    location = runner.location("/grz_current_test", self.server.port)
                 else:
-                    # harness is in use, open it and it will open the test case
+                    # harness is in use, open it and it will open the test case.
+                    # use adapter.TEST_DURATION to allow the harness to attempt to
+                    # close test cases when server timeout is greater.
                     location = runner.location(
                         "/grz_harness",
                         self.server.port,
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 4579f358..12ae026d 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -54,9 +54,10 @@ def test_main_01(mocker):
     args.prefs = "fake"
     args.valgrind = True
     args.xvfb = True
-    # successful run (with coverage)
+    # successful run (with coverage, short timeout)
     fake_adapter.RELAUNCH = 10
     args.coverage = True
+    args.timeout = 1
     assert main(args) == Session.EXIT_SUCCESS
     assert fake_session.mock_calls[0][-1]["coverage"]
     assert fake_session.mock_calls[0][-1]["relaunch"] == 10
@@ -64,6 +65,7 @@ def test_main_01(mocker):
     # successful run (without coverage)
     fake_adapter.RELAUNCH = 1
     args.coverage = False
+    args.timeout = 60
     assert main(args) == Session.EXIT_SUCCESS
     assert not fake_session.mock_calls[0][-1]["coverage"]
     assert fake_session.mock_calls[0][-1]["relaunch"] == 1
@@ -117,7 +119,3 @@ def test_main_02(mocker, tmp_path):
     assert main(args) == Session.EXIT_LAUNCH_FAILURE
     assert any(fake_tmp.glob("fake_report_logs"))
     assert not fake_logs.is_dir()
-    # invalid timeout arg
-    fake_adapter.TEST_DURATION = args.timeout + 10
-    assert main(args) == Session.EXIT_ARGS
-    fake_session.EXIT_ARGS = Session.EXIT_ARGS

From ed5db6b800d0e04c2c9b9beca6bade53d3c9e073 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 30 Dec 2020 15:43:51 -0800
Subject: [PATCH 150/531] [loki] Globally disable 'protected-access' pylint
 check in tests

---
 loki/test_loki.py | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/loki/test_loki.py b/loki/test_loki.py
index b20e25bd..e8d94af8 100644
--- a/loki/test_loki.py
+++ b/loki/test_loki.py
@@ -2,6 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# pylint: disable=protected-access
 import os
 import random
 import struct
@@ -121,39 +122,39 @@ def test_loki_06():
 def test_loki_07():
     """test invalid data sizes"""
     with pytest.raises(RuntimeError, match=r"Unsupported data size:"):
-        Loki._fuzz_data(b"")  # pylint: disable=protected-access
+        Loki._fuzz_data(b"")
 
     with pytest.raises(RuntimeError, match=r"Unsupported data size:"):
-        Loki._fuzz_data(b"123")  # pylint: disable=protected-access
+        Loki._fuzz_data(b"123")
 
     with pytest.raises(RuntimeError, match=r"Unsupported data size:"):
-        Loki._fuzz_data(b"12345")  # pylint: disable=protected-access
+        Loki._fuzz_data(b"12345")
 
 
 def test_loki_08():
     """test endian support"""
-    Loki._fuzz_data(b"1", ">")  # pylint: disable=protected-access
-    Loki._fuzz_data(b"1", "<")  # pylint: disable=protected-access
+    Loki._fuzz_data(b"1", ">")
+    Loki._fuzz_data(b"1", "<")
     with pytest.raises(RuntimeError, match=r"Unsupported byte order"):
-        Loki._fuzz_data(b"1", "BAD")  # pylint: disable=protected-access
+        Loki._fuzz_data(b"1", "BAD")
 
 
 def test_loki_stress_01():
     """test with single byte"""
     for _ in range(1000):
         in_data = struct.pack("B", random.getrandbits(8))
-        assert len(Loki._fuzz_data(in_data)) == 1  # pylint: disable=protected-access
+        assert len(Loki._fuzz_data(in_data)) == 1
 
 
 def test_loki_stress_02():
     """test with two bytes"""
     in_data = b"\xff\xff"
     for _ in range(1000):
-        assert len(Loki._fuzz_data(in_data)) == 2  # pylint: disable=protected-access
+        assert len(Loki._fuzz_data(in_data)) == 2
 
 
 def test_loki_stress_03():
     """test with four bytes"""
     in_data = b"TEST"
     for _ in range(1000):
-        assert len(Loki._fuzz_data(in_data)) == 4  # pylint: disable=protected-access
+        assert len(Loki._fuzz_data(in_data)) == 4

From 0ee3b46d8d7a3daf944cfce4e47a4f393fffbf12 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 30 Dec 2020 16:30:26 -0800
Subject: [PATCH 151/531] [loki] Update imports

---
 loki/loki.py      | 104 ++++++++++++++++++++++------------------------
 loki/test_loki.py |  21 +++++-----
 2 files changed, 61 insertions(+), 64 deletions(-)

diff --git a/loki/loki.py b/loki/loki.py
index 536e9749..151ca836 100644
--- a/loki/loki.py
+++ b/loki/loki.py
@@ -2,20 +2,20 @@
 """
 Loki fuzzing library
 """
-from __future__ import print_function
-import argparse
-import logging
-import logging.handlers
-import os
-import random
-import struct
+from argparse import ArgumentParser
+from logging import basicConfig, getLogger, ERROR, INFO
+from os import mkdir, SEEK_END
+from os.path import abspath, getsize, isdir, splitext, join as pathjoin
+from random import choice, getrandbits, randint
+from struct import pack, unpack
 import shutil
-import tempfile
-import time
+from tempfile import mkdtemp, SpooledTemporaryFile
+from time import strftime, time
 
 
 __author__ = "Tyson Smith"
-LOG = logging.getLogger(__name__)
+
+LOG = getLogger(__name__)
 
 
 class Loki(object):
@@ -39,56 +39,57 @@ def _fuzz_data(in_data, byte_order=None):
             raise RuntimeError("Unsupported data size: %d" % data_size)
 
         if byte_order is None:
-            byte_order = "<" if random.getrandbits(5) else ">"  # prefer little-endian
+            # prefer little-endian
+            byte_order = "<" if getrandbits(5) else ">"
         elif byte_order not in (">", "<"):
             raise RuntimeError("Unsupported byte order %r" % byte_order)
         pack_unit = "".join([byte_order, pack_unit])
 
-        fuzz_op = random.randint(0, 4)
+        fuzz_op = randint(0, 4)
         if fuzz_op == 0:  # boundary
-            out_data = (2**random.randint(2, (data_size * 8))) + random.randint(-2, 2)
+            out_data = (2 ** randint(2, (data_size * 8))) + randint(-2, 2)
         elif fuzz_op == 1:  # arithmetic
-            out_data = struct.unpack(pack_unit, in_data)[0] + random.randint(-10, 10)
+            out_data = unpack(pack_unit, in_data)[0] + randint(-10, 10)
         elif fuzz_op == 2:  # interesting byte, short or int
-            out_data = random.choice((0, 1, int(mask / 2), int(mask / 2) + 1, mask))
+            out_data = choice((0, 1, int(mask / 2), int(mask / 2) + 1, mask))
         elif fuzz_op == 3:  # random byte, short or int
-            out_data = random.getrandbits(32)
+            out_data = getrandbits(32)
         elif fuzz_op == 4 and data_size == 1:  # toggle
-            out_data = struct.unpack(pack_unit, in_data)[0] ^ (2 ** random.getrandbits(3))
+            out_data = unpack(pack_unit, in_data)[0] ^ (2 ** getrandbits(3))
         elif fuzz_op == 4 and data_size == 2:  # multiple of a data size
-            if random.getrandbits(1):
-                out_data = random.randint(1, 0x1FFF) * 8
+            if getrandbits(1):
+                out_data = randint(1, 0x1FFF) * 8
             else:
-                out_data = random.randint(1, 0xFFF) * 16
+                out_data = randint(1, 0xFFF) * 16
         elif fuzz_op == 4 and data_size == 4:  # multiple of a data size
-            fuzz_op = random.randint(0, 2)
+            fuzz_op = randint(0, 2)
             if fuzz_op == 0:
-                out_data = random.randint(1, 0x1FFFFFFF) * 8
+                out_data = randint(1, 0x1FFFFFFF) * 8
             elif fuzz_op == 1:
-                out_data = random.randint(1, 0xFFFFFFF) * 16
+                out_data = randint(1, 0xFFFFFFF) * 16
             elif fuzz_op == 2:
-                out_data = random.randint(1, 0x7FFFFFF) * 32
+                out_data = randint(1, 0x7FFFFFF) * 32
 
-        return struct.pack(pack_unit, out_data & mask)
+        return pack(pack_unit, out_data & mask)
 
     def _fuzz(self, tgt_fp):
-        tgt_fp.seek(0, os.SEEK_END)
+        tgt_fp.seek(0, SEEK_END)
         length = tgt_fp.tell()
         if length < 1:
             raise RuntimeError("Zero length file cannot be fuzzed.")
 
         # minimum number of max passes should be 1
         max_passes = max(int(round(length * self.aggr)), 1)
-        fuzz_passes = random.randint(1, max_passes)
+        fuzz_passes = randint(1, max_passes)
         LOG.debug("%d of a possible %d fuzz passes will be performed", fuzz_passes, max_passes)
 
         max_bytes = min(length, 2) if length < 4 else 4
         for _ in range(fuzz_passes):
-            if max_bytes > 1 and not random.getrandbits(4):  # 6.25%
-                fuzz_size = max_bytes >> 1 if random.getrandbits(1) else max_bytes
+            if max_bytes > 1 and not getrandbits(4):  # 6.25%
+                fuzz_size = max_bytes >> 1 if getrandbits(1) else max_bytes
             else:
                 fuzz_size = 1
-            target = random.randint(0, length-fuzz_size)
+            target = randint(0, length - fuzz_size)
 
             tgt_fp.seek(target)
             out_data = self._fuzz_data(tgt_fp.read(fuzz_size))
@@ -98,20 +99,20 @@ def _fuzz(self, tgt_fp):
     def fuzz_data(self, data):
         assert isinstance(data, bytes)
         # open a temp file in memory for fuzzing
-        with tempfile.SpooledTemporaryFile(max_size=0x800000, mode="r+b") as tmp_fp:
+        with SpooledTemporaryFile(max_size=0x800000, mode="r+b") as tmp_fp:
             tmp_fp.write(data)
             self._fuzz(tmp_fp)
             tmp_fp.seek(0)
             return tmp_fp.read()
 
     def fuzz_file(self, in_file, count, ext=None, out_dir=None):
-        start_time = time.time()
-        LOG.info("Starting Loki @ %s", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
+        start_time = time()
+        LOG.info("Starting Loki @ %s", strftime("%Y-%m-%d %H:%M:%S"))
 
         # Analyze input test case
-        LOG.info("Target template is %r", os.path.abspath(in_file))
+        LOG.info("Target template is %r", abspath(in_file))
         try:
-            length = os.path.getsize(in_file)
+            length = getsize(in_file)
         except OSError:
             LOG.error("%r does not exists!", in_file)
             return False
@@ -122,29 +123,29 @@ def fuzz_file(self, in_file, count, ext=None, out_dir=None):
 
         LOG.info("Template size in bytes is %d", length)
         if ext is None:
-            ext = os.path.splitext(in_file)[1]
+            ext = splitext(in_file)[1]
 
         # Checking output directory
         if out_dir is None:
-            out_dir = tempfile.mkdtemp(
-                prefix=time.strftime("loki_%m%d%H%M_", time.localtime()),
+            out_dir = mkdtemp(
+                prefix=strftime("loki_%m%d%H%M_"),
                 dir=".")
-        elif not os.path.isdir(out_dir):
-            os.mkdir(out_dir)
-        LOG.info("Output directory is %s", os.path.abspath(out_dir))
+        elif not isdir(out_dir):
+            mkdir(out_dir)
+        LOG.info("Output directory is %s", abspath(out_dir))
 
         LOG.info("Generating %s fuzzed test cases...", count)
         for i in range(count):
-            out_file = os.path.join(out_dir, "".join(("%06d_fuzzed" % i, ext)))
+            out_file = pathjoin(out_dir, "".join(("%06d_fuzzed" % i, ext)))
             shutil.copy(in_file, out_file)
 
             with open(out_file, "r+b") as out_fp:
                 self._fuzz(out_fp)
 
-        finish_time = time.time()-start_time
+        finish_time = time() - start_time
         LOG.info("Total run time %gs", finish_time)
         if count > 0:
-            LOG.info("About %gs per file", finish_time/count)
+            LOG.info("About %gs per file", finish_time / count)
 
         return True
 
@@ -154,14 +155,14 @@ def splice_data(data_chunks):
             return None  # one or two data blobs are required (one truncates)
 
         blob_pass = 1
-        with tempfile.SpooledTemporaryFile(max_size=0x800000, mode="r+b") as tmp_fp:
+        with SpooledTemporaryFile(max_size=0x800000, mode="r+b") as tmp_fp:
             for chunk in data_chunks:
                 length = len(chunk)
 
                 if length < 1:
                     return None  # not enough data chunks to work with
 
-                target = random.randint(0, length-1)
+                target = randint(0, length - 1)
 
                 if blob_pass == 1:
                     tmp_fp.write(chunk[:target])
@@ -175,7 +176,7 @@ def splice_data(data_chunks):
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Loki fuzzing library")
+    parser = ArgumentParser(description="Loki fuzzing library")
     parser.add_argument(
         "input",
         help="Output will be generated based on this file")
@@ -191,17 +192,12 @@ def main():
     parser.add_argument(
         "-o", "--output", default=None,
         help="Output directory for fuzzed test cases")
-
     args = parser.parse_args()
 
-    # setup logging
-    hnd = logging.StreamHandler()
-    hnd.setFormatter(logging.Formatter("[%(levelname).1s] %(message)s"))
-    LOG.addHandler(hnd)
-    LOG.setLevel(logging.INFO if not args.quiet else logging.ERROR)
+    basicConfig(level=INFO if not args.quiet else ERROR)
 
     loki = Loki(aggression=args.aggression)
     try:
         loki.fuzz_file(args.input, args.count, out_dir=args.output)
     except KeyboardInterrupt:
-        print("Ctrl+C detected.")
+        LOG.info("Ctrl+C detected.")
diff --git a/loki/test_loki.py b/loki/test_loki.py
index e8d94af8..6ef2f3fd 100644
--- a/loki/test_loki.py
+++ b/loki/test_loki.py
@@ -3,10 +3,11 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
-import os
-import random
-import struct
-import pytest
+from os import SEEK_END
+from random import getrandbits
+from struct import pack
+
+from pytest import raises
 
 from .loki import Loki
 
@@ -91,7 +92,7 @@ def test_loki_05(tmp_path):
         out_files = list(out_path.iterdir())
         assert len(out_files) == 1
         with out_files[0].open("rb") as out_fp:
-            out_fp.seek(0, os.SEEK_END)
+            out_fp.seek(0, SEEK_END)
             assert out_fp.tell() == in_size
             out_fp.seek(0)
             for out_byte in out_fp:
@@ -121,13 +122,13 @@ def test_loki_06():
 
 def test_loki_07():
     """test invalid data sizes"""
-    with pytest.raises(RuntimeError, match=r"Unsupported data size:"):
+    with raises(RuntimeError, match=r"Unsupported data size:"):
         Loki._fuzz_data(b"")
 
-    with pytest.raises(RuntimeError, match=r"Unsupported data size:"):
+    with raises(RuntimeError, match=r"Unsupported data size:"):
         Loki._fuzz_data(b"123")
 
-    with pytest.raises(RuntimeError, match=r"Unsupported data size:"):
+    with raises(RuntimeError, match=r"Unsupported data size:"):
         Loki._fuzz_data(b"12345")
 
 
@@ -135,14 +136,14 @@ def test_loki_08():
     """test endian support"""
     Loki._fuzz_data(b"1", ">")
     Loki._fuzz_data(b"1", "<")
-    with pytest.raises(RuntimeError, match=r"Unsupported byte order"):
+    with raises(RuntimeError, match=r"Unsupported byte order"):
         Loki._fuzz_data(b"1", "BAD")
 
 
 def test_loki_stress_01():
     """test with single byte"""
     for _ in range(1000):
-        in_data = struct.pack("B", random.getrandbits(8))
+        in_data = pack("B", getrandbits(8))
         assert len(Loki._fuzz_data(in_data)) == 1
 
 

From e5cacd816a4d55e438b98f1b7d3cc8d628b96622 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 30 Dec 2020 17:59:41 -0800
Subject: [PATCH 152/531] [loki] Move argument parsing to separate file

---
 loki/__init__.py | 11 +++++------
 loki/__main__.py | 11 ++++++-----
 loki/args.py     | 28 ++++++++++++++++++++++++++++
 loki/loki.py     | 35 ++++++++---------------------------
 4 files changed, 47 insertions(+), 38 deletions(-)
 create mode 100644 loki/args.py

diff --git a/loki/__init__.py b/loki/__init__.py
index 0e737b08..abafea7f 100644
--- a/loki/__init__.py
+++ b/loki/__init__.py
@@ -1,13 +1,12 @@
 # coding=utf-8
-"""
-Loki fuzzing library
-"""
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""
+Loki fuzzing library
+"""
+from .loki import Loki
 
-from .loki import Loki  # noqa
-
-__all__ = ("Loki")
+__all__ = ("Loki",)
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
diff --git a/loki/__main__.py b/loki/__main__.py
index 3e238eb5..a22b6b72 100644
--- a/loki/__main__.py
+++ b/loki/__main__.py
@@ -1,11 +1,12 @@
 # coding=utf-8
-"""
-Loki fuzzing library
-"""
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from .loki import main
+"""
+Loki fuzzing library
+"""
+from .args import parse_args
+from .loki import Loki
 
 
-main()
+Loki.main(parse_args())
diff --git a/loki/args.py b/loki/args.py
new file mode 100644
index 00000000..9f442e78
--- /dev/null
+++ b/loki/args.py
@@ -0,0 +1,28 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from argparse import ArgumentParser
+
+
+__author__ = "Tyson Smith"
+
+
+def parse_args(argv=None):
+    parser = ArgumentParser(description="Loki fuzzing library")
+    parser.add_argument(
+        "input",
+        help="Output will be generated based on this file")
+    parser.add_argument(
+        "-a", "--aggression", default=0.001, type=float,
+        help="Controls how much fuzzing is done on the output file")
+    parser.add_argument(
+        "-c", "--count", default=100, type=int,
+        help="Number test cases to generate")
+    parser.add_argument(
+        "-q", "--quiet", default=False, action="store_true",
+        help="Display limited output")
+    parser.add_argument(
+        "-o", "--output", default=None,
+        help="Output directory for fuzzed test cases")
+    return parser.parse_args(argv)
diff --git a/loki/loki.py b/loki/loki.py
index 151ca836..19bcb4e9 100644
--- a/loki/loki.py
+++ b/loki/loki.py
@@ -2,7 +2,6 @@
 """
 Loki fuzzing library
 """
-from argparse import ArgumentParser
 from logging import basicConfig, getLogger, ERROR, INFO
 from os import mkdir, SEEK_END
 from os.path import abspath, getsize, isdir, splitext, join as pathjoin
@@ -174,30 +173,12 @@ def splice_data(data_chunks):
             tmp_fp.seek(0)
             return tmp_fp.read()
 
+    @classmethod
+    def main(cls, args):
+        basicConfig(format="", level=INFO if not args.quiet else ERROR)
 
-def main():
-    parser = ArgumentParser(description="Loki fuzzing library")
-    parser.add_argument(
-        "input",
-        help="Output will be generated based on this file")
-    parser.add_argument(
-        "-a", "--aggression", default=0.001, type=float,
-        help="Controls how much fuzzing is done on the output file")
-    parser.add_argument(
-        "-c", "--count", default=100, type=int,
-        help="Number test cases to generate")
-    parser.add_argument(
-        "-q", "--quiet", default=False, action="store_true",
-        help="Display limited output")
-    parser.add_argument(
-        "-o", "--output", default=None,
-        help="Output directory for fuzzed test cases")
-    args = parser.parse_args()
-
-    basicConfig(level=INFO if not args.quiet else ERROR)
-
-    loki = Loki(aggression=args.aggression)
-    try:
-        loki.fuzz_file(args.input, args.count, out_dir=args.output)
-    except KeyboardInterrupt:
-        LOG.info("Ctrl+C detected.")
+        loki = Loki(aggression=args.aggression)
+        try:
+            loki.fuzz_file(args.input, args.count, out_dir=args.output)
+        except KeyboardInterrupt:  # pragma: no cover
+            LOG.info("Ctrl+C detected.")

From 717e206b0bb0eac8f729b66f242c8dd385256e7b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 30 Dec 2020 18:00:23 -0800
Subject: [PATCH 153/531] [loki] Add test coverage for arguments

---
 loki/test_loki.py | 50 ++++++++++++++++++++++++++++++++---------------
 1 file changed, 34 insertions(+), 16 deletions(-)

diff --git a/loki/test_loki.py b/loki/test_loki.py
index 6ef2f3fd..9cc62e19 100644
--- a/loki/test_loki.py
+++ b/loki/test_loki.py
@@ -9,6 +9,7 @@
 
 from pytest import raises
 
+from .args import parse_args
 from .loki import Loki
 
 
@@ -18,7 +19,6 @@ def test_loki_01(tmp_path):
     fuzzer.fuzz_file("nofile.test", 1, out_dir=str(tmp_path))
     assert not list(tmp_path.iterdir())
 
-
 def test_loki_02(tmp_path):
     """test an empty file"""
     tmp_fn = tmp_path / "input"
@@ -31,19 +31,24 @@ def test_loki_02(tmp_path):
     fuzzer.fuzz_file(str(tmp_fn), 1, out_dir=str(out_path))
     assert not list(out_path.iterdir())
 
-
-def test_loki_03(tmp_path):
+def test_loki_03(mocker, tmp_path):
     """test a single byte file"""
+    out_path = tmp_path / "out"
+    out_path.mkdir()
+    # no output path provided
+    fake_mkdtemp = mocker.patch(
+        "loki.loki.mkdtemp",
+        autospec=True,
+        return_value=str(out_path)
+    )
+
     in_data = b"A"
     tmp_fn = tmp_path / "input"
     tmp_fn.write_bytes(in_data)
 
-    out_path = tmp_path / "out"
-    out_path.mkdir()
-
     fuzzer = Loki(aggression=0.1)
     for _ in range(100):
-        fuzzer.fuzz_file(str(tmp_fn), 1, out_dir=str(out_path))
+        fuzzer.fuzz_file(str(tmp_fn), 1, out_dir=None)
         out_files = list(out_path.iterdir())
         assert len(out_files) == 1
         out_data = out_files[0].read_bytes()
@@ -51,7 +56,7 @@ def test_loki_03(tmp_path):
         if out_data != in_data:
             break
     assert out_data != in_data
-
+    assert fake_mkdtemp.call_count == 1
 
 def test_loki_04(tmp_path):
     """test a two byte file"""
@@ -73,7 +78,6 @@ def test_loki_04(tmp_path):
             break
     assert out_data != in_data
 
-
 def test_loki_05(tmp_path):
     """test a multi byte file"""
     in_size = 100
@@ -84,7 +88,6 @@ def test_loki_05(tmp_path):
     tmp_fn.write_bytes(in_data)
 
     out_path = tmp_path / "out"
-    out_path.mkdir()
 
     fuzzer = Loki(aggression=0.01)
     for _ in range(100):
@@ -102,7 +105,7 @@ def test_loki_05(tmp_path):
         if fuzz_found:
             break
     assert fuzz_found
-
+    assert out_path.is_dir()
 
 def test_loki_06():
     """test fuzz_data()"""
@@ -119,7 +122,6 @@ def test_loki_06():
             break
     assert fuzz_found
 
-
 def test_loki_07():
     """test invalid data sizes"""
     with raises(RuntimeError, match=r"Unsupported data size:"):
@@ -131,7 +133,6 @@ def test_loki_07():
     with raises(RuntimeError, match=r"Unsupported data size:"):
         Loki._fuzz_data(b"12345")
 
-
 def test_loki_08():
     """test endian support"""
     Loki._fuzz_data(b"1", ">")
@@ -139,23 +140,40 @@ def test_loki_08():
     with raises(RuntimeError, match=r"Unsupported byte order"):
         Loki._fuzz_data(b"1", "BAD")
 
-
 def test_loki_stress_01():
     """test with single byte"""
     for _ in range(1000):
         in_data = pack("B", getrandbits(8))
         assert len(Loki._fuzz_data(in_data)) == 1
 
-
 def test_loki_stress_02():
     """test with two bytes"""
     in_data = b"\xff\xff"
     for _ in range(1000):
         assert len(Loki._fuzz_data(in_data)) == 2
 
-
 def test_loki_stress_03():
     """test with four bytes"""
     in_data = b"TEST"
     for _ in range(1000):
         assert len(Loki._fuzz_data(in_data)) == 4
+
+def test_main_01(mocker, tmp_path):
+    """test main"""
+    out_path = tmp_path / "out"
+    out_path.mkdir()
+
+    sample = tmp_path / "file.bin"
+    sample.write_bytes(b"test!")
+
+    args = mocker.Mock(
+        aggression=0.1,
+        count=15,
+        input=str(sample),
+        output=str(out_path)
+    )
+    Loki.main(args)
+
+def test_args_01():
+    """test parse_args()"""
+    assert parse_args(argv=["sample"])

From c13fbbaf923b607ab477a5f0579189b7582640c3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 1 Jan 2021 20:05:46 -0800
Subject: [PATCH 154/531] [loki] Cleanups and move log output to main()

---
 loki/loki.py      |  89 ++++++++++++++++++---------------------
 loki/test_loki.py | 105 ++++++++++++++++++++++++++++++----------------
 2 files changed, 111 insertions(+), 83 deletions(-)

diff --git a/loki/loki.py b/loki/loki.py
index 19bcb4e9..3c7297a4 100644
--- a/loki/loki.py
+++ b/loki/loki.py
@@ -1,10 +1,13 @@
-# coding: utf-8
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """
 Loki fuzzing library
 """
 from logging import basicConfig, getLogger, ERROR, INFO
-from os import mkdir, SEEK_END
-from os.path import abspath, getsize, isdir, splitext, join as pathjoin
+from os import makedirs, SEEK_END
+from os.path import abspath, getsize, splitext, join as pathjoin
 from random import choice, getrandbits, randint
 from struct import pack, unpack
 import shutil
@@ -19,6 +22,8 @@
 
 class Loki(object):
 
+    __slots__ = ("aggr",)
+
     def __init__(self, aggression=0.0):
         self.aggr = min(max(aggression, 0.0), 1.0)
 
@@ -42,11 +47,11 @@ def _fuzz_data(in_data, byte_order=None):
             byte_order = "<" if getrandbits(5) else ">"
         elif byte_order not in (">", "<"):
             raise RuntimeError("Unsupported byte order %r" % byte_order)
-        pack_unit = "".join([byte_order, pack_unit])
+        pack_unit = "%s%s" % (byte_order, pack_unit)
 
         fuzz_op = randint(0, 4)
         if fuzz_op == 0:  # boundary
-            out_data = (2 ** randint(2, (data_size * 8))) + randint(-2, 2)
+            out_data = (2 ** randint(2, data_size * 8)) + randint(-2, 2)
         elif fuzz_op == 1:  # arithmetic
             out_data = unpack(pack_unit, in_data)[0] + randint(-10, 10)
         elif fuzz_op == 2:  # interesting byte, short or int
@@ -55,19 +60,13 @@ def _fuzz_data(in_data, byte_order=None):
             out_data = getrandbits(32)
         elif fuzz_op == 4 and data_size == 1:  # toggle
             out_data = unpack(pack_unit, in_data)[0] ^ (2 ** getrandbits(3))
-        elif fuzz_op == 4 and data_size == 2:  # multiple of a data size
-            if getrandbits(1):
+        elif fuzz_op == 4:  # multiple of 8
+            if data_size == 2:
                 out_data = randint(1, 0x1FFF) * 8
-            else:
-                out_data = randint(1, 0xFFF) * 16
-        elif fuzz_op == 4 and data_size == 4:  # multiple of a data size
-            fuzz_op = randint(0, 2)
-            if fuzz_op == 0:
+            elif data_size == 4:
                 out_data = randint(1, 0x1FFFFFFF) * 8
-            elif fuzz_op == 1:
-                out_data = randint(1, 0xFFFFFFF) * 16
-            elif fuzz_op == 2:
-                out_data = randint(1, 0x7FFFFFF) * 32
+            else:  # pragma: no cover
+                raise AssertionError("invalid data size")
 
         return pack(pack_unit, out_data & mask)
 
@@ -80,8 +79,11 @@ def _fuzz(self, tgt_fp):
         # minimum number of max passes should be 1
         max_passes = max(int(round(length * self.aggr)), 1)
         fuzz_passes = randint(1, max_passes)
-        LOG.debug("%d of a possible %d fuzz passes will be performed", fuzz_passes, max_passes)
-
+        LOG.debug(
+            "%d of a possible %d fuzz passes will be performed",
+            fuzz_passes,
+            max_passes
+        )
         max_bytes = min(length, 2) if length < 4 else 4
         for _ in range(fuzz_passes):
             if max_bytes > 1 and not getrandbits(4):  # 6.25%
@@ -104,48 +106,24 @@ def fuzz_data(self, data):
             tmp_fp.seek(0)
             return tmp_fp.read()
 
-    def fuzz_file(self, in_file, count, ext=None, out_dir=None):
-        start_time = time()
-        LOG.info("Starting Loki @ %s", strftime("%Y-%m-%d %H:%M:%S"))
-
-        # Analyze input test case
-        LOG.info("Target template is %r", abspath(in_file))
+    def fuzz_file(self, in_file, count, out_dir, ext=None):
         try:
-            length = getsize(in_file)
+            if getsize(in_file) < 1:
+                LOG.error("Input must be at least 1 byte long")
+                return False
         except OSError:
             LOG.error("%r does not exists!", in_file)
             return False
 
-        if length < 1:
-            LOG.error("Input must be at least 1 byte long")
-            return False
-
-        LOG.info("Template size in bytes is %d", length)
         if ext is None:
             ext = splitext(in_file)[1]
 
-        # Checking output directory
-        if out_dir is None:
-            out_dir = mkdtemp(
-                prefix=strftime("loki_%m%d%H%M_"),
-                dir=".")
-        elif not isdir(out_dir):
-            mkdir(out_dir)
-        LOG.info("Output directory is %s", abspath(out_dir))
-
-        LOG.info("Generating %s fuzzed test cases...", count)
         for i in range(count):
             out_file = pathjoin(out_dir, "".join(("%06d_fuzzed" % i, ext)))
             shutil.copy(in_file, out_file)
-
             with open(out_file, "r+b") as out_fp:
                 self._fuzz(out_fp)
 
-        finish_time = time() - start_time
-        LOG.info("Total run time %gs", finish_time)
-        if count > 0:
-            LOG.info("About %gs per file", finish_time / count)
-
         return True
 
     @staticmethod
@@ -176,9 +154,24 @@ def splice_data(data_chunks):
     @classmethod
     def main(cls, args):
         basicConfig(format="", level=INFO if not args.quiet else ERROR)
-
+        LOG.info("Starting Loki @ %s", strftime("%Y-%m-%d %H:%M:%S"))
+        LOG.info("Target template is %r", abspath(args.input))
+        out_dir = args.output
+        if out_dir is None:
+            out_dir = mkdtemp(prefix=strftime("loki_%m-%d_%H-%M_"), dir=".")
+        makedirs(out_dir, exist_ok=True)
+        LOG.info("Output directory is %r", abspath(out_dir))
+        count = max(args.count, 1)
+        LOG.info("Generating %d fuzzed test cases...", count)
         loki = Loki(aggression=args.aggression)
         try:
-            loki.fuzz_file(args.input, args.count, out_dir=args.output)
+            start_time = time()
+            success = loki.fuzz_file(args.input, count, out_dir)
+            finish_time = time() - start_time
+            LOG.info("Done. Total run time %gs", finish_time)
+            if success:
+                LOG.info("About %gs per file", finish_time / count)
         except KeyboardInterrupt:  # pragma: no cover
             LOG.info("Ctrl+C detected.")
+            success = False
+        return 0 if success else 1
diff --git a/loki/test_loki.py b/loki/test_loki.py
index 9cc62e19..b1e34521 100644
--- a/loki/test_loki.py
+++ b/loki/test_loki.py
@@ -4,8 +4,9 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
 from os import SEEK_END
-from random import getrandbits
+from random import choice, getrandbits
 from struct import pack
+from tempfile import SpooledTemporaryFile
 
 from pytest import raises
 
@@ -16,7 +17,7 @@
 def test_loki_01(tmp_path):
     """test a missing file"""
     fuzzer = Loki(aggression=0.1)
-    fuzzer.fuzz_file("nofile.test", 1, out_dir=str(tmp_path))
+    assert not fuzzer.fuzz_file("nofile.test", 1, str(tmp_path))
     assert not list(tmp_path.iterdir())
 
 def test_loki_02(tmp_path):
@@ -28,19 +29,13 @@ def test_loki_02(tmp_path):
     out_path.mkdir()
 
     fuzzer = Loki(aggression=0.1)
-    fuzzer.fuzz_file(str(tmp_fn), 1, out_dir=str(out_path))
+    assert not fuzzer.fuzz_file(str(tmp_fn), 1, str(out_path))
     assert not list(out_path.iterdir())
 
-def test_loki_03(mocker, tmp_path):
+def test_loki_03(tmp_path):
     """test a single byte file"""
     out_path = tmp_path / "out"
     out_path.mkdir()
-    # no output path provided
-    fake_mkdtemp = mocker.patch(
-        "loki.loki.mkdtemp",
-        autospec=True,
-        return_value=str(out_path)
-    )
 
     in_data = b"A"
     tmp_fn = tmp_path / "input"
@@ -48,7 +43,7 @@ def test_loki_03(mocker, tmp_path):
 
     fuzzer = Loki(aggression=0.1)
     for _ in range(100):
-        fuzzer.fuzz_file(str(tmp_fn), 1, out_dir=None)
+        assert fuzzer.fuzz_file(str(tmp_fn), 1, str(out_path))
         out_files = list(out_path.iterdir())
         assert len(out_files) == 1
         out_data = out_files[0].read_bytes()
@@ -56,7 +51,6 @@ def test_loki_03(mocker, tmp_path):
         if out_data != in_data:
             break
     assert out_data != in_data
-    assert fake_mkdtemp.call_count == 1
 
 def test_loki_04(tmp_path):
     """test a two byte file"""
@@ -69,7 +63,7 @@ def test_loki_04(tmp_path):
 
     fuzzer = Loki(aggression=0.1)
     for _ in range(100):
-        fuzzer.fuzz_file(str(tmp_fn), 1, out_dir=str(out_path))
+        assert fuzzer.fuzz_file(str(tmp_fn), 1, str(out_path))
         out_files = list(out_path.iterdir())
         assert len(out_files) == 1
         out_data = out_files[0].read_bytes()
@@ -88,10 +82,11 @@ def test_loki_05(tmp_path):
     tmp_fn.write_bytes(in_data)
 
     out_path = tmp_path / "out"
+    out_path.mkdir()
 
     fuzzer = Loki(aggression=0.01)
     for _ in range(100):
-        fuzzer.fuzz_file(str(tmp_fn), 1, out_dir=str(out_path))
+        assert fuzzer.fuzz_file(str(tmp_fn), 1, str(out_path))
         out_files = list(out_path.iterdir())
         assert len(out_files) == 1
         with out_files[0].open("rb") as out_fp:
@@ -105,7 +100,6 @@ def test_loki_05(tmp_path):
         if fuzz_found:
             break
     assert fuzz_found
-    assert out_path.is_dir()
 
 def test_loki_06():
     """test fuzz_data()"""
@@ -140,39 +134,80 @@ def test_loki_08():
     with raises(RuntimeError, match=r"Unsupported byte order"):
         Loki._fuzz_data(b"1", "BAD")
 
+def test_loki_fuzz_01(mocker):
+    """test _fuzz() paths"""
+    mocker.patch("loki.loki.randint", autospec=True, side_effect=max)
+    loki = Loki(aggression=1)
+    with SpooledTemporaryFile(max_size=0x800000, mode="r+b") as tmp_fp:
+        # test empty input sample
+        with raises(RuntimeError):
+            loki._fuzz(tmp_fp)
+        tmp_fp.write(b"123456789")
+        # try getrandbits returning 0
+        mocker.patch("loki.loki.getrandbits", autospec=True, return_value=0)
+        loki._fuzz(tmp_fp)
+        # try getrandbits returning 1
+        mocker.patch("loki.loki.getrandbits", autospec=True, return_value=1)
+        loki._fuzz(tmp_fp)
+
+def test_loki_fuzz_02(mocker):
+    """test Loki._fuzz_data() paths"""
+    fake_randint = mocker.patch("loki.loki.randint", autospec=True)
+    # fuzz op 0
+    fake_randint.side_effect = (0, 1, 1)
+    Loki._fuzz_data(b"1")
+    # fuzz op 1
+    fake_randint.side_effect = (1, 0)
+    Loki._fuzz_data(b"1")
+    # fuzz op 2
+    fake_randint.side_effect = (2,)
+    Loki._fuzz_data(b"1")
+    # fuzz op 3
+    fake_randint.side_effect = (3,)
+    Loki._fuzz_data(b"1")
+    # fuzz op 4 & test data size 1
+    fake_randint.side_effect = max
+    Loki._fuzz_data(b"1")
+    # fuzz op 4 & test data size 2
+    Loki._fuzz_data(b"12")
+    # fuzz op 4 & test data size 4
+    fake_randint.side_effect = (4, 1)
+    Loki._fuzz_data(b"1234")
+
 def test_loki_stress_01():
-    """test with single byte"""
-    for _ in range(1000):
-        in_data = pack("B", getrandbits(8))
-        assert len(Loki._fuzz_data(in_data)) == 1
-
-def test_loki_stress_02():
-    """test with two bytes"""
-    in_data = b"\xff\xff"
-    for _ in range(1000):
-        assert len(Loki._fuzz_data(in_data)) == 2
-
-def test_loki_stress_03():
-    """test with four bytes"""
-    in_data = b"TEST"
-    for _ in range(1000):
-        assert len(Loki._fuzz_data(in_data)) == 4
+    """test Loki._fuzz_data() with random input"""
+    orders = ("<", ">", None)
+    sizes = (1, 2, 4)
+    for _ in range(5000):
+        size = choice(sizes)
+        if size == 1:
+            in_data = pack("B", getrandbits(8))
+        elif size == 2:
+            in_data = pack("H", getrandbits(16))
+        elif size == 4:
+            in_data = pack("I", getrandbits(32))
+        assert len(Loki._fuzz_data(in_data, byte_order=choice(orders))) == size
 
 def test_main_01(mocker, tmp_path):
     """test main"""
     out_path = tmp_path / "out"
     out_path.mkdir()
-
+    # no output path provided
+    fake_mkdtemp = mocker.patch(
+        "loki.loki.mkdtemp",
+        autospec=True,
+        return_value=str(out_path)
+    )
     sample = tmp_path / "file.bin"
     sample.write_bytes(b"test!")
-
     args = mocker.Mock(
         aggression=0.1,
         count=15,
         input=str(sample),
-        output=str(out_path)
+        output=None
     )
-    Loki.main(args)
+    assert Loki.main(args) == 0
+    assert fake_mkdtemp.call_count == 1
 
 def test_args_01():
     """test parse_args()"""

From be8ae0cca5d0a1827a45157f9f19acf0e7cd8bd6 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 1 Jan 2021 20:07:06 -0800
Subject: [PATCH 155/531] [loki] Set proper exit code

---
 loki/__main__.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/loki/__main__.py b/loki/__main__.py
index a22b6b72..8ee08a1f 100644
--- a/loki/__main__.py
+++ b/loki/__main__.py
@@ -5,8 +5,8 @@
 """
 Loki fuzzing library
 """
+from sys import exit as sysexit
 from .args import parse_args
 from .loki import Loki
 
-
-Loki.main(parse_args())
+sysexit(Loki.main(parse_args()))

From 7aaad0ae029fed98f6f3090cb8cf9ac3618d693a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 1 Jan 2021 20:08:09 -0800
Subject: [PATCH 156/531] [loki] Update argument help

---
 loki/args.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/loki/args.py b/loki/args.py
index 9f442e78..1b04cf94 100644
--- a/loki/args.py
+++ b/loki/args.py
@@ -15,14 +15,14 @@ def parse_args(argv=None):
         help="Output will be generated based on this file")
     parser.add_argument(
         "-a", "--aggression", default=0.001, type=float,
-        help="Controls how much fuzzing is done on the output file")
+        help="Maximum fuzz rate. 1.0 == 100% (default: %(default)s)")
     parser.add_argument(
-        "-c", "--count", default=100, type=int,
-        help="Number test cases to generate")
+        "-c", "--count", default=1, type=int,
+        help="Number test cases to generate, minimum 1 (default: %(default)s)")
     parser.add_argument(
         "-q", "--quiet", default=False, action="store_true",
-        help="Display limited output")
+        help="Display limited output (default: %(default)s)")
     parser.add_argument(
         "-o", "--output", default=None,
-        help="Output directory for fuzzed test cases")
+        help="Output directory for fuzzed test cases (default: '.')")
     return parser.parse_args(argv)

From e5f01a16b0a82c8af9a41fb3181a1d9805a56a32 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Sat, 2 Jan 2021 14:09:39 -0800
Subject: [PATCH 157/531] [loki] Avoid mutating the same location multiple
 times

---
 loki/loki.py      | 42 ++++++++++++++++++++++++------------------
 loki/test_loki.py | 30 +++++++++++++++++++++---------
 2 files changed, 45 insertions(+), 27 deletions(-)

diff --git a/loki/loki.py b/loki/loki.py
index 3c7297a4..5312fc6a 100644
--- a/loki/loki.py
+++ b/loki/loki.py
@@ -8,7 +8,7 @@
 from logging import basicConfig, getLogger, ERROR, INFO
 from os import makedirs, SEEK_END
 from os.path import abspath, getsize, splitext, join as pathjoin
-from random import choice, getrandbits, randint
+from random import choice, getrandbits, randint, sample
 from struct import pack, unpack
 import shutil
 from tempfile import mkdtemp, SpooledTemporaryFile
@@ -75,26 +75,32 @@ def _fuzz(self, tgt_fp):
         length = tgt_fp.tell()
         if length < 1:
             raise RuntimeError("Zero length file cannot be fuzzed.")
-
-        # minimum number of max passes should be 1
-        max_passes = max(int(round(length * self.aggr)), 1)
-        fuzz_passes = randint(1, max_passes)
+        # minimum number of mutations should be 1
+        max_mutations = max(int(round(length * self.aggr)), 1)
+        mutations = randint(1, max_mutations)
         LOG.debug(
-            "%d of a possible %d fuzz passes will be performed",
-            fuzz_passes,
-            max_passes
+            "%d of a possible %d mutations will be performed",
+            mutations,
+            max_mutations
         )
-        max_bytes = min(length, 2) if length < 4 else 4
-        for _ in range(fuzz_passes):
-            if max_bytes > 1 and not getrandbits(4):  # 6.25%
-                fuzz_size = max_bytes >> 1 if getrandbits(1) else max_bytes
+        for count, idx in enumerate(sample(range(length), k=mutations)):
+            # every few iterations randomly attempt multi-byte mutations
+            if count % 10 == 0 and getrandbits(1):
+                max_size = length - idx
+                # target multiple bytes if possible
+                if max_size > 3 and getrandbits(1):
+                    size = 4
+                elif max_size > 1:
+                    size = 2
+                else:
+                    size = 1
             else:
-                fuzz_size = 1
-            target = randint(0, length - fuzz_size)
-
-            tgt_fp.seek(target)
-            out_data = self._fuzz_data(tgt_fp.read(fuzz_size))
-            tgt_fp.seek(target)
+                # target single byte
+                size = 1
+            # perform mutation
+            tgt_fp.seek(idx)
+            out_data = self._fuzz_data(tgt_fp.read(size))
+            tgt_fp.seek(idx)
             tgt_fp.write(out_data)
 
     def fuzz_data(self, data):
diff --git a/loki/test_loki.py b/loki/test_loki.py
index b1e34521..d1970077 100644
--- a/loki/test_loki.py
+++ b/loki/test_loki.py
@@ -135,19 +135,31 @@ def test_loki_08():
         Loki._fuzz_data(b"1", "BAD")
 
 def test_loki_fuzz_01(mocker):
-    """test _fuzz() paths"""
-    mocker.patch("loki.loki.randint", autospec=True, side_effect=max)
+    """test Loki._fuzz()"""
     loki = Loki(aggression=1)
-    with SpooledTemporaryFile(max_size=0x800000, mode="r+b") as tmp_fp:
-        # test empty input sample
+    # test empty input sample
+    with SpooledTemporaryFile(max_size=10, mode="r+b") as tmp_fp:
         with raises(RuntimeError):
             loki._fuzz(tmp_fp)
-        tmp_fp.write(b"123456789")
-        # try getrandbits returning 0
-        mocker.patch("loki.loki.getrandbits", autospec=True, return_value=0)
+    # test multiple mutations
+    with SpooledTemporaryFile(max_size=10, mode="r+b") as tmp_fp:
+        tmp_fp.write(b"12345678")
         loki._fuzz(tmp_fp)
-        # try getrandbits returning 1
-        mocker.patch("loki.loki.getrandbits", autospec=True, return_value=1)
+    # make remaining tests deterministic
+    mocker.patch("loki.loki.getrandbits", autospec=True, return_value=1)
+    mocker.patch("loki.loki.randint", autospec=True, side_effect=min)
+    mocker.patch("loki.loki.sample", autospec=True, return_value=[0])
+    # test multi-byte with > 3 bytes
+    with SpooledTemporaryFile(max_size=10, mode="r+b") as tmp_fp:
+        tmp_fp.write(b"1234")
+        loki._fuzz(tmp_fp)
+    # test multi-byte with > 1 byte
+    with SpooledTemporaryFile(max_size=10, mode="r+b") as tmp_fp:
+        tmp_fp.write(b"12")
+        loki._fuzz(tmp_fp)
+    # test multi-byte with 1 byte
+    with SpooledTemporaryFile(max_size=10, mode="r+b") as tmp_fp:
+        tmp_fp.write(b"1")
         loki._fuzz(tmp_fp)
 
 def test_loki_fuzz_02(mocker):

From ed8ca1267d9bbcd9cddff95f3c515ba1531730f8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Sun, 3 Jan 2021 12:39:24 -0800
Subject: [PATCH 158/531] [loki] Make byte order more accessible

---
 loki/args.py      | 14 ++++++++--
 loki/loki.py      | 60 ++++++++++++++++++++++--------------------
 loki/test_loki.py | 67 ++++++++++++++++++++---------------------------
 3 files changed, 71 insertions(+), 70 deletions(-)

diff --git a/loki/args.py b/loki/args.py
index 1b04cf94..ecba9014 100644
--- a/loki/args.py
+++ b/loki/args.py
@@ -3,6 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from argparse import ArgumentParser
+from loki import Loki
 
 
 __author__ = "Tyson Smith"
@@ -15,7 +16,11 @@ def parse_args(argv=None):
         help="Output will be generated based on this file")
     parser.add_argument(
         "-a", "--aggression", default=0.001, type=float,
-        help="Maximum fuzz rate. 1.0 == 100% (default: %(default)s)")
+        help="Maximum fuzz rate. 1.0 == 100%% (default: %(default)s)")
+    parser.add_argument(
+        "-b", "--byte-order", default=None,
+        help="Byte order to use when mutating multiple bytes at once. " \
+             "Use '>' for big-endian or '<' for little-endian (default: random)")
     parser.add_argument(
         "-c", "--count", default=1, type=int,
         help="Number test cases to generate, minimum 1 (default: %(default)s)")
@@ -25,4 +30,9 @@ def parse_args(argv=None):
     parser.add_argument(
         "-o", "--output", default=None,
         help="Output directory for fuzzed test cases (default: '.')")
-    return parser.parse_args(argv)
+    args = parser.parse_args(argv)
+
+    if args.byte_order and args.byte_order not in Loki.BYTE_ORDERS:
+        parser.error("Invalid byte order %r" % (args.byte_order,))
+
+    return args
diff --git a/loki/loki.py b/loki/loki.py
index 5312fc6a..c956b18e 100644
--- a/loki/loki.py
+++ b/loki/loki.py
@@ -9,8 +9,8 @@
 from os import makedirs, SEEK_END
 from os.path import abspath, getsize, splitext, join as pathjoin
 from random import choice, getrandbits, randint, sample
+from shutil import copy
 from struct import pack, unpack
-import shutil
 from tempfile import mkdtemp, SpooledTemporaryFile
 from time import strftime, time
 
@@ -20,34 +20,29 @@
 LOG = getLogger(__name__)
 
 
-class Loki(object):
+class Loki():
+    BYTE_ORDERS = ("<", ">", "@", "!", "=")
 
-    __slots__ = ("aggr",)
+    __slots__ = ("aggr", "byte_order")
 
-    def __init__(self, aggression=0.0):
+    def __init__(self, aggression=0.0, byte_order=None):
         self.aggr = min(max(aggression, 0.0), 1.0)
+        self.byte_order = byte_order
 
     @staticmethod
-    def _fuzz_data(in_data, byte_order=None):
+    def _fuzz_data(in_data, byte_order):
         data_size = len(in_data)
         if data_size == 1:
             pack_unit = "B"
             mask = 0xFF
         elif data_size == 2:
-            pack_unit = "H"
+            pack_unit = "%sH" % (byte_order,)
             mask = 0xFFFF
         elif data_size == 4:
-            pack_unit = "I"
+            pack_unit = "%sI" % (byte_order,)
             mask = 0xFFFFFFFF
         else:
-            raise RuntimeError("Unsupported data size: %d" % data_size)
-
-        if byte_order is None:
-            # prefer little-endian
-            byte_order = "<" if getrandbits(5) else ">"
-        elif byte_order not in (">", "<"):
-            raise RuntimeError("Unsupported byte order %r" % byte_order)
-        pack_unit = "%s%s" % (byte_order, pack_unit)
+            raise AssertionError("Unsupported data size: %d" % data_size)
 
         fuzz_op = randint(0, 4)
         if fuzz_op == 0:  # boundary
@@ -58,15 +53,13 @@ def _fuzz_data(in_data, byte_order=None):
             out_data = choice((0, 1, int(mask / 2), int(mask / 2) + 1, mask))
         elif fuzz_op == 3:  # random byte, short or int
             out_data = getrandbits(32)
-        elif fuzz_op == 4 and data_size == 1:  # toggle
-            out_data = unpack(pack_unit, in_data)[0] ^ (2 ** getrandbits(3))
-        elif fuzz_op == 4:  # multiple of 8
-            if data_size == 2:
+        elif fuzz_op == 4:
+            if data_size == 1:  # toggle
+                out_data = unpack(pack_unit, in_data)[0] ^ (2 ** getrandbits(3))
+            elif data_size == 2:  # multiple of 8
                 out_data = randint(1, 0x1FFF) * 8
-            elif data_size == 4:
+            elif data_size == 4:  # multiple of 8
                 out_data = randint(1, 0x1FFFFFFF) * 8
-            else:  # pragma: no cover
-                raise AssertionError("invalid data size")
 
         return pack(pack_unit, out_data & mask)
 
@@ -74,7 +67,8 @@ def _fuzz(self, tgt_fp):
         tgt_fp.seek(0, SEEK_END)
         length = tgt_fp.tell()
         if length < 1:
-            raise RuntimeError("Zero length file cannot be fuzzed.")
+            LOG.debug("cannot fuzz empty file")
+            return
         # minimum number of mutations should be 1
         max_mutations = max(int(round(length * self.aggr)), 1)
         mutations = randint(1, max_mutations)
@@ -83,6 +77,11 @@ def _fuzz(self, tgt_fp):
             mutations,
             max_mutations
         )
+        if self.byte_order is not None:
+            assert self.byte_order in ("<", ">", "@", "!", "=")
+            byte_order = self.byte_order
+        else:
+            LOG.debug("using random byte order")
         for count, idx in enumerate(sample(range(length), k=mutations)):
             # every few iterations randomly attempt multi-byte mutations
             if count % 10 == 0 and getrandbits(1):
@@ -97,13 +96,16 @@ def _fuzz(self, tgt_fp):
             else:
                 # target single byte
                 size = 1
+            if self.byte_order is None:
+                byte_order = "<" if getrandbits(1) else ">"
             # perform mutation
             tgt_fp.seek(idx)
-            out_data = self._fuzz_data(tgt_fp.read(size))
+            out_data = self._fuzz_data(tgt_fp.read(size), byte_order)
             tgt_fp.seek(idx)
             tgt_fp.write(out_data)
 
     def fuzz_data(self, data):
+        assert data
         assert isinstance(data, bytes)
         # open a temp file in memory for fuzzing
         with SpooledTemporaryFile(max_size=0x800000, mode="r+b") as tmp_fp:
@@ -120,16 +122,13 @@ def fuzz_file(self, in_file, count, out_dir, ext=None):
         except OSError:
             LOG.error("%r does not exists!", in_file)
             return False
-
         if ext is None:
             ext = splitext(in_file)[1]
-
         for i in range(count):
             out_file = pathjoin(out_dir, "".join(("%06d_fuzzed" % i, ext)))
-            shutil.copy(in_file, out_file)
+            copy(in_file, out_file)
             with open(out_file, "r+b") as out_fp:
                 self._fuzz(out_fp)
-
         return True
 
     @staticmethod
@@ -169,7 +168,10 @@ def main(cls, args):
         LOG.info("Output directory is %r", abspath(out_dir))
         count = max(args.count, 1)
         LOG.info("Generating %d fuzzed test cases...", count)
-        loki = Loki(aggression=args.aggression)
+        loki = Loki(
+            aggression=args.aggression,
+            byte_order=args.byte_order
+        )
         try:
             start_time = time()
             success = loki.fuzz_file(args.input, count, out_dir)
diff --git a/loki/test_loki.py b/loki/test_loki.py
index d1970077..1af3222a 100644
--- a/loki/test_loki.py
+++ b/loki/test_loki.py
@@ -15,13 +15,13 @@
 
 
 def test_loki_01(tmp_path):
-    """test a missing file"""
+    """test Loki.fuzz_file() with a missing file"""
     fuzzer = Loki(aggression=0.1)
     assert not fuzzer.fuzz_file("nofile.test", 1, str(tmp_path))
     assert not list(tmp_path.iterdir())
 
 def test_loki_02(tmp_path):
-    """test an empty file"""
+    """test Loki.fuzz_file() with an empty file"""
     tmp_fn = tmp_path / "input"
     tmp_fn.touch()
 
@@ -33,7 +33,7 @@ def test_loki_02(tmp_path):
     assert not list(out_path.iterdir())
 
 def test_loki_03(tmp_path):
-    """test a single byte file"""
+    """test Loki.fuzz_file() with a single byte file"""
     out_path = tmp_path / "out"
     out_path.mkdir()
 
@@ -41,7 +41,7 @@ def test_loki_03(tmp_path):
     tmp_fn = tmp_path / "input"
     tmp_fn.write_bytes(in_data)
 
-    fuzzer = Loki(aggression=0.1)
+    fuzzer = Loki(aggression=0.1, byte_order=">")
     for _ in range(100):
         assert fuzzer.fuzz_file(str(tmp_fn), 1, str(out_path))
         out_files = list(out_path.iterdir())
@@ -53,7 +53,7 @@ def test_loki_03(tmp_path):
     assert out_data != in_data
 
 def test_loki_04(tmp_path):
-    """test a two byte file"""
+    """test Loki.fuzz_file() with a two byte file"""
     in_data = b"AB"
     tmp_fn = tmp_path / "input"
     tmp_fn.write_bytes(in_data)
@@ -73,13 +73,12 @@ def test_loki_04(tmp_path):
     assert out_data != in_data
 
 def test_loki_05(tmp_path):
-    """test a multi byte file"""
+    """test Loki.fuzz_file() with a multi byte file"""
     in_size = 100
     in_byte = b"A"
-    in_data = in_byte * in_size
     fuzz_found = False
     tmp_fn = tmp_path / "input"
-    tmp_fn.write_bytes(in_data)
+    tmp_fn.write_bytes(in_byte * in_size)
 
     out_path = tmp_path / "out"
     out_path.mkdir()
@@ -116,31 +115,12 @@ def test_loki_06():
             break
     assert fuzz_found
 
-def test_loki_07():
-    """test invalid data sizes"""
-    with raises(RuntimeError, match=r"Unsupported data size:"):
-        Loki._fuzz_data(b"")
-
-    with raises(RuntimeError, match=r"Unsupported data size:"):
-        Loki._fuzz_data(b"123")
-
-    with raises(RuntimeError, match=r"Unsupported data size:"):
-        Loki._fuzz_data(b"12345")
-
-def test_loki_08():
-    """test endian support"""
-    Loki._fuzz_data(b"1", ">")
-    Loki._fuzz_data(b"1", "<")
-    with raises(RuntimeError, match=r"Unsupported byte order"):
-        Loki._fuzz_data(b"1", "BAD")
-
 def test_loki_fuzz_01(mocker):
     """test Loki._fuzz()"""
     loki = Loki(aggression=1)
     # test empty input sample
     with SpooledTemporaryFile(max_size=10, mode="r+b") as tmp_fp:
-        with raises(RuntimeError):
-            loki._fuzz(tmp_fp)
+        loki._fuzz(tmp_fp)
     # test multiple mutations
     with SpooledTemporaryFile(max_size=10, mode="r+b") as tmp_fp:
         tmp_fp.write(b"12345678")
@@ -157,7 +137,8 @@ def test_loki_fuzz_01(mocker):
     with SpooledTemporaryFile(max_size=10, mode="r+b") as tmp_fp:
         tmp_fp.write(b"12")
         loki._fuzz(tmp_fp)
-    # test multi-byte with 1 byte
+    # test multi-byte with 1 byte and byte order set
+    loki.byte_order = ">"
     with SpooledTemporaryFile(max_size=10, mode="r+b") as tmp_fp:
         tmp_fp.write(b"1")
         loki._fuzz(tmp_fp)
@@ -167,28 +148,31 @@ def test_loki_fuzz_02(mocker):
     fake_randint = mocker.patch("loki.loki.randint", autospec=True)
     # fuzz op 0
     fake_randint.side_effect = (0, 1, 1)
-    Loki._fuzz_data(b"1")
+    Loki._fuzz_data(b"1", "<")
     # fuzz op 1
     fake_randint.side_effect = (1, 0)
-    Loki._fuzz_data(b"1")
+    Loki._fuzz_data(b"1", "<")
     # fuzz op 2
     fake_randint.side_effect = (2,)
-    Loki._fuzz_data(b"1")
+    Loki._fuzz_data(b"1", ">")
     # fuzz op 3
     fake_randint.side_effect = (3,)
-    Loki._fuzz_data(b"1")
+    Loki._fuzz_data(b"1", ">")
     # fuzz op 4 & test data size 1
     fake_randint.side_effect = max
-    Loki._fuzz_data(b"1")
+    Loki._fuzz_data(b"1", "<")
     # fuzz op 4 & test data size 2
-    Loki._fuzz_data(b"12")
+    Loki._fuzz_data(b"12", "<")
     # fuzz op 4 & test data size 4
     fake_randint.side_effect = (4, 1)
-    Loki._fuzz_data(b"1234")
+    Loki._fuzz_data(b"1234", ">")
+    # invalid data size
+    with raises(AssertionError, match=r"Unsupported data size:"):
+        Loki._fuzz_data(b"", ">")
 
 def test_loki_stress_01():
     """test Loki._fuzz_data() with random input"""
-    orders = ("<", ">", None)
+    orders = ("<", ">")
     sizes = (1, 2, 4)
     for _ in range(5000):
         size = choice(sizes)
@@ -198,7 +182,7 @@ def test_loki_stress_01():
             in_data = pack("H", getrandbits(16))
         elif size == 4:
             in_data = pack("I", getrandbits(32))
-        assert len(Loki._fuzz_data(in_data, byte_order=choice(orders))) == size
+        assert len(Loki._fuzz_data(in_data, choice(orders))) == size
 
 def test_main_01(mocker, tmp_path):
     """test main"""
@@ -214,6 +198,7 @@ def test_main_01(mocker, tmp_path):
     sample.write_bytes(b"test!")
     args = mocker.Mock(
         aggression=0.1,
+        byte_order=None,
         count=15,
         input=str(sample),
         output=None
@@ -221,6 +206,10 @@ def test_main_01(mocker, tmp_path):
     assert Loki.main(args) == 0
     assert fake_mkdtemp.call_count == 1
 
-def test_args_01():
+def test_args_01(capsys):
     """test parse_args()"""
     assert parse_args(argv=["sample"])
+    # invalid byte order
+    with raises(SystemExit):
+        parse_args(argv=["sample", "-b", "a"])
+    assert "Invalid byte order" in capsys.readouterr()[1]

From 959ed856060a275235acd7592ff1b960711c355a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Sun, 3 Jan 2021 12:42:32 -0800
Subject: [PATCH 159/531] [loki] Remove splice_data() since it is outside the
 scope of Loki

---
 loki/loki.py | 25 -------------------------
 1 file changed, 25 deletions(-)

diff --git a/loki/loki.py b/loki/loki.py
index c956b18e..90bafd3b 100644
--- a/loki/loki.py
+++ b/loki/loki.py
@@ -131,31 +131,6 @@ def fuzz_file(self, in_file, count, out_dir, ext=None):
                 self._fuzz(out_fp)
         return True
 
-    @staticmethod
-    def splice_data(data_chunks):
-        if len(data_chunks) not in (1, 2):
-            return None  # one or two data blobs are required (one truncates)
-
-        blob_pass = 1
-        with SpooledTemporaryFile(max_size=0x800000, mode="r+b") as tmp_fp:
-            for chunk in data_chunks:
-                length = len(chunk)
-
-                if length < 1:
-                    return None  # not enough data chunks to work with
-
-                target = randint(0, length - 1)
-
-                if blob_pass == 1:
-                    tmp_fp.write(chunk[:target])
-                elif blob_pass == 2:
-                    tmp_fp.write(chunk[target:])
-
-                blob_pass += 1
-
-            tmp_fp.seek(0)
-            return tmp_fp.read()
-
     @classmethod
     def main(cls, args):
         basicConfig(format="", level=INFO if not args.quiet else ERROR)

From 171ee19aedb94e0b5b93ee24bf67c66646899028 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 4 Jan 2021 14:36:36 -0800
Subject: [PATCH 160/531] [loki] Update tests

---
 loki/test_loki.py | 112 +++++++++++++++-------------------------------
 1 file changed, 35 insertions(+), 77 deletions(-)

diff --git a/loki/test_loki.py b/loki/test_loki.py
index 1af3222a..4dbea7d1 100644
--- a/loki/test_loki.py
+++ b/loki/test_loki.py
@@ -3,117 +3,75 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
-from os import SEEK_END
 from random import choice, getrandbits
 from struct import pack
 from tempfile import SpooledTemporaryFile
 
-from pytest import raises
+from pytest import mark, raises
 
 from .args import parse_args
 from .loki import Loki
 
 
-def test_loki_01(tmp_path):
-    """test Loki.fuzz_file() with a missing file"""
-    fuzzer = Loki(aggression=0.1)
-    assert not fuzzer.fuzz_file("nofile.test", 1, str(tmp_path))
-    assert not list(tmp_path.iterdir())
-
-def test_loki_02(tmp_path):
-    """test Loki.fuzz_file() with an empty file"""
-    tmp_fn = tmp_path / "input"
-    tmp_fn.touch()
-
-    out_path = tmp_path / "out"
-    out_path.mkdir()
-
-    fuzzer = Loki(aggression=0.1)
-    assert not fuzzer.fuzz_file(str(tmp_fn), 1, str(out_path))
-    assert not list(out_path.iterdir())
-
-def test_loki_03(tmp_path):
-    """test Loki.fuzz_file() with a single byte file"""
-    out_path = tmp_path / "out"
-    out_path.mkdir()
-
-    in_data = b"A"
-    tmp_fn = tmp_path / "input"
-    tmp_fn.write_bytes(in_data)
-
-    fuzzer = Loki(aggression=0.1, byte_order=">")
-    for _ in range(100):
-        assert fuzzer.fuzz_file(str(tmp_fn), 1, str(out_path))
-        out_files = list(out_path.iterdir())
-        assert len(out_files) == 1
-        out_data = out_files[0].read_bytes()
-        assert len(out_data) == 1
-        if out_data != in_data:
-            break
-    assert out_data != in_data
-
-def test_loki_04(tmp_path):
-    """test Loki.fuzz_file() with a two byte file"""
-    in_data = b"AB"
+@mark.parametrize(
+    "in_size, aggression, byte_order",
+    [
+        (1, 0.1, ">"),
+        (2, 0.1, "<"),
+        (3, 0.1, None),
+        (4, 0.1, None),
+        (5, 0.5, None),
+        (100, 0.2, None),
+    ]
+)
+def test_loki_fuzz_file(tmp_path, in_size, aggression, byte_order):
+    """test Loki.fuzz_file() with different file sizes"""
+    in_data = b"A" * in_size
     tmp_fn = tmp_path / "input"
     tmp_fn.write_bytes(in_data)
 
     out_path = tmp_path / "out"
     out_path.mkdir()
 
-    fuzzer = Loki(aggression=0.1)
+    fuzzer = Loki(aggression=aggression, byte_order=byte_order)
     for _ in range(100):
         assert fuzzer.fuzz_file(str(tmp_fn), 1, str(out_path))
         out_files = list(out_path.iterdir())
         assert len(out_files) == 1
         out_data = out_files[0].read_bytes()
-        assert len(out_data) == 2
+        assert len(out_data) == in_size
         if out_data != in_data:
             break
-    assert out_data != in_data
+    else:
+        raise AssertionError("failed to fuzz data")
 
-def test_loki_05(tmp_path):
-    """test Loki.fuzz_file() with a multi byte file"""
-    in_size = 100
-    in_byte = b"A"
-    fuzz_found = False
+def test_loki_01(tmp_path):
+    """test Loki.fuzz_file() error cases"""
+    fuzzer = Loki(aggression=0.1)
+    # test missing file
+    assert not fuzzer.fuzz_file("nofile.test", 1, str(tmp_path))
+    assert not list(tmp_path.iterdir())
+    # test empty file
     tmp_fn = tmp_path / "input"
-    tmp_fn.write_bytes(in_byte * in_size)
-
+    tmp_fn.touch()
     out_path = tmp_path / "out"
     out_path.mkdir()
+    assert not fuzzer.fuzz_file(str(tmp_fn), 1, str(out_path))
+    assert not list(out_path.iterdir())
 
-    fuzzer = Loki(aggression=0.01)
-    for _ in range(100):
-        assert fuzzer.fuzz_file(str(tmp_fn), 1, str(out_path))
-        out_files = list(out_path.iterdir())
-        assert len(out_files) == 1
-        with out_files[0].open("rb") as out_fp:
-            out_fp.seek(0, SEEK_END)
-            assert out_fp.tell() == in_size
-            out_fp.seek(0)
-            for out_byte in out_fp:
-                if out_byte != in_byte:
-                    fuzz_found = True
-                    break
-        if fuzz_found:
-            break
-    assert fuzz_found
-
-def test_loki_06():
-    """test fuzz_data()"""
+def test_loki_02():
+    """test Loki.fuzz_data()"""
     in_data = b"This is test DATA!"
     in_size = len(in_data)
 
-    fuzz_found = False
     fuzzer = Loki(aggression=0.1)
     for _ in range(100):
         out_data = fuzzer.fuzz_data(in_data)
         assert len(out_data) == in_size
         if in_data not in out_data:
-            fuzz_found = True
             break
-    assert fuzz_found
+    else:
+        raise AssertionError("failed to fuzz data")
 
 def test_loki_fuzz_01(mocker):
     """test Loki._fuzz()"""
@@ -174,7 +132,7 @@ def test_loki_stress_01():
     """test Loki._fuzz_data() with random input"""
     orders = ("<", ">")
     sizes = (1, 2, 4)
-    for _ in range(5000):
+    for _ in range(3000):
         size = choice(sizes)
         if size == 1:
             in_data = pack("B", getrandbits(8))
@@ -185,7 +143,7 @@ def test_loki_stress_01():
         assert len(Loki._fuzz_data(in_data, choice(orders))) == size
 
 def test_main_01(mocker, tmp_path):
-    """test main"""
+    """test main()"""
     out_path = tmp_path / "out"
     out_path.mkdir()
     # no output path provided

From 79e4e8767e9aa5a33f5948c11eeaccf544cdccaf Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 4 Jan 2021 15:41:58 -0800
Subject: [PATCH 161/531] [loki] Add README.md

---
 loki/README.md | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 loki/README.md

diff --git a/loki/README.md b/loki/README.md
new file mode 100644
index 00000000..11d85aff
--- /dev/null
+++ b/loki/README.md
@@ -0,0 +1,4 @@
+Loki
+====
+
+Loki is a simple fuzzing library that provides basic data mutation capabilities. Loki can be helpful when creating basic fuzzers or proof-of-concepts by providing functionality that has been successfully used to find bugs in the past. It is by no means a complete fuzzing or data manipulation solution. There are other faster, more intelligent solutions out there.

From e451214aae3c3229525be799052cedc92a6f0b1e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 7 Jan 2021 17:01:18 -0800
Subject: [PATCH 162/531] Add additional console scripts

---
 setup.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 3c104f35..7318b290 100755
--- a/setup.py
+++ b/setup.py
@@ -36,7 +36,9 @@
         description='A framework for developing and running browser fuzzers',
         entry_points={
             'console_scripts': [
-                'grizzly = grizzly.main:console_main',
+                'grizzly = grizzly.__main__',
+                'grizzly.reduce = grizzly.reduce.__main__',
+                'grizzly.replay = grizzly.replay.__main__',
                 'grizzly.status = grizzly.common.status_reporter:main',
             ],
             'grizzly_targets': [

From dafa316f640e6707719c2a38c3657f5f70599d3d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 8 Jan 2021 10:12:20 -0800
Subject: [PATCH 163/531] Replace sys.exit() with raise SystemExit()

---
 grizzly/__main__.py               | 3 +--
 grizzly/common/status_reporter.py | 4 +---
 grizzly/reduce/__main__.py        | 5 +----
 grizzly/reduce/bucket.py          | 3 +--
 grizzly/reduce/crash.py           | 3 +--
 grizzly/replay/__main__.py        | 4 +---
 loki/__main__.py                  | 4 ++--
 7 files changed, 8 insertions(+), 18 deletions(-)

diff --git a/grizzly/__main__.py b/grizzly/__main__.py
index 1dbd9537..191dd7a6 100644
--- a/grizzly/__main__.py
+++ b/grizzly/__main__.py
@@ -4,7 +4,6 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import basicConfig, DEBUG
 from os import getenv
-from sys import exit as sysexit
 
 from .adapters import load
 from .args import GrizzlyArgs
@@ -24,4 +23,4 @@
         level=DEBUG)
 # load Adapters
 load()
-sysexit(main(GrizzlyArgs().parse_args()))
+raise SystemExit(main(GrizzlyArgs().parse_args()))
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 7d4b1403..e9a12ee2 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -4,14 +4,12 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Manage Grizzly status reports."""
-
 import argparse
 from datetime import timedelta
 from functools import partial
 import logging
 import os
 import re
-import sys
 import time
 
 import psutil
@@ -418,4 +416,4 @@ def main(args=None):
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    raise SystemExit(main())
diff --git a/grizzly/reduce/__main__.py b/grizzly/reduce/__main__.py
index cf65162b..0becd66e 100644
--- a/grizzly/reduce/__main__.py
+++ b/grizzly/reduce/__main__.py
@@ -4,11 +4,8 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Grizzly reducer CLI.
 """
-
-import sys
-
 from .args import ReduceArgs
 from . import ReduceManager
 
 
-sys.exit(ReduceManager.main(ReduceArgs().parse_args()))
+raise SystemExit(ReduceManager.main(ReduceArgs().parse_args()))
diff --git a/grizzly/reduce/bucket.py b/grizzly/reduce/bucket.py
index cf63a447..f03ae439 100644
--- a/grizzly/reduce/bucket.py
+++ b/grizzly/reduce/bucket.py
@@ -3,7 +3,6 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
-import sys
 
 from .args import ReduceFuzzManagerIDQualityArgs
 from .crash import main as crash_main
@@ -53,4 +52,4 @@ def main(args):
 
 
 if __name__ == "__main__":
-    sys.exit(main(ReduceFuzzManagerIDQualityArgs().parse_args()))
+    raise SystemExit(main(ReduceFuzzManagerIDQualityArgs().parse_args()))
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index d2f57c6b..75795e30 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -3,7 +3,6 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
-import sys
 
 from .args import ReduceFuzzManagerIDArgs
 from .core import ReduceManager
@@ -72,4 +71,4 @@ def main(args):
 
 
 if __name__ == "__main__":
-    sys.exit(main(ReduceFuzzManagerIDArgs().parse_args()))
+    raise SystemExit(main(ReduceFuzzManagerIDArgs().parse_args()))
diff --git a/grizzly/replay/__main__.py b/grizzly/replay/__main__.py
index a99603c9..9d7a2bdd 100644
--- a/grizzly/replay/__main__.py
+++ b/grizzly/replay/__main__.py
@@ -2,10 +2,8 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from sys import exit as sysexit
-
 from .args import ReplayArgs
 from .replay import ReplayManager
 
 
-sysexit(ReplayManager.main(ReplayArgs().parse_args()))
+raise SystemExit(ReplayManager.main(ReplayArgs().parse_args()))
diff --git a/loki/__main__.py b/loki/__main__.py
index 8ee08a1f..854fc8b1 100644
--- a/loki/__main__.py
+++ b/loki/__main__.py
@@ -5,8 +5,8 @@
 """
 Loki fuzzing library
 """
-from sys import exit as sysexit
 from .args import parse_args
 from .loki import Loki
 
-sysexit(Loki.main(parse_args()))
+
+raise SystemExit(Loki.main(parse_args()))

From 693e799309b0b51e6261a76fe0e4ae2d35e1ebfe Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 8 Jan 2021 11:52:27 -0800
Subject: [PATCH 164/531] [pylint] Fix 'super-with-arguments' reports

---
 .pylintrc                       |  1 -
 grizzly/args.py                 | 14 +++++++-------
 grizzly/common/test_reporter.py |  2 +-
 grizzly/replay/args.py          |  4 ++--
 tox.ini                         |  2 +-
 5 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/.pylintrc b/.pylintrc
index f0ff07d9..dc676a7f 100644
--- a/.pylintrc
+++ b/.pylintrc
@@ -3,7 +3,6 @@ disable=
     duplicate-code,
     fixme,
     missing-docstring,
-    super-with-arguments,
     too-few-public-methods,
     too-many-arguments,
     too-many-branches,
diff --git a/grizzly/args.py b/grizzly/args.py
index 796ea32b..4cd9ad62 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -21,11 +21,11 @@ def __sort_key(action):
 
     def add_usage(self, usage, actions, groups, prefix=None):
         actions = sorted(actions, key=self.__sort_key)
-        super(SortingHelpFormatter, self).add_usage(usage, actions, groups, prefix)
+        super().add_usage(usage, actions, groups, prefix)
 
     def add_arguments(self, actions):
         actions = sorted(actions, key=self.__sort_key)
-        super(SortingHelpFormatter, self).add_arguments(actions)
+        super().add_arguments(actions)
 
 
 class CommonArgs(object):
@@ -33,7 +33,7 @@ class CommonArgs(object):
     IGNORE = ("log-limit", "timeout")
 
     def __init__(self):
-        super(CommonArgs, self).__init__()
+        super().__init__()
         # log levels for console logging
         self._level_map = {
             "CRIT": CRITICAL,
@@ -113,8 +113,8 @@ def parse_args(self, argv=None):
         return args
 
     def sanity_check(self, args):
-        if hasattr(super(CommonArgs, self), 'sanity_check'):
-            super(CommonArgs, self).sanity_check(args)
+        if hasattr(super(), 'sanity_check'):
+            super().sanity_check(args)
 
         if "binary" not in self._sanity_skip and not isfile(args.binary):
             self.parser.error("file not found: %r" % args.binary)
@@ -168,7 +168,7 @@ def sanity_check(self, args):
 
 class GrizzlyArgs(CommonArgs):
     def __init__(self):
-        super(GrizzlyArgs, self).__init__()
+        super().__init__()
         self._adapters = sorted(adapter_names())
         self._sanity_skip.add("tool")
         self.parser.add_argument(
@@ -199,7 +199,7 @@ def __init__(self):
             help="Report large attachments (if any) to S3 and then the crash & S3 link to FuzzManager")
 
     def sanity_check(self, args):
-        super(GrizzlyArgs, self).sanity_check(args)
+        super().sanity_check(args)
 
         if args.adapter.lower() not in self._adapters:
             msg = ["Adapter %r does not exist." % args.adapter.lower()]
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 5804dafd..ef17772a 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -546,7 +546,7 @@ def test_s3fuzzmanager_reporter_02(mocker, tmp_path):
     (trace_dir / "trace-file").touch()
     class FakeClientError(Exception):
         def __init__(self, message, response):
-            super(FakeClientError, self).__init__(message)
+            super().__init__(message)
             self.response = response
     mocker.patch("grizzly.common.reporter.ClientError", new=FakeClientError)
     fake_resource.return_value.Object.side_effect = FakeClientError("test", {"Error": {"Code": "404"}})
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index 579db5c6..2dcbc995 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -10,7 +10,7 @@
 class ReplayArgs(CommonArgs):
 
     def __init__(self):
-        super(ReplayArgs, self).__init__()
+        super().__init__()
         self.parser.add_argument(
             "input",
             help="Accepted input includes: " \
@@ -63,7 +63,7 @@ def __init__(self):
             help="Include the testcase when reporting results.")
 
     def sanity_check(self, args):
-        super(ReplayArgs, self).sanity_check(args)
+        super().sanity_check(args)
 
         if args.any_crash and args.sig is not None:
             self.parser.error("signature is ignored when running with '--any-crash'")
diff --git a/tox.ini b/tox.ini
index fedec355..3b7059d9 100644
--- a/tox.ini
+++ b/tox.ini
@@ -41,7 +41,7 @@ extras =
 usedevelop = true
 
 [tox]
-envlist = py35,py36,py37,py38
+envlist = py35,py36,py37,py38,py39
 minversion = 3.5
 skip_missing_interpreters = true
 tox_pip_extensions_ext_venv_update = true

From 1b7c2259c225e98a064ce27540fc0486da7ab69f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 8 Jan 2021 12:45:47 -0800
Subject: [PATCH 165/531] Update class definitions

---
 grizzly/args.py                      |  2 +-
 grizzly/common/fuzzmanager.py        |  4 ++--
 grizzly/common/iomanager.py          |  2 +-
 grizzly/common/reporter.py           |  2 +-
 grizzly/common/runner.py             |  6 +++---
 grizzly/common/stack_hasher.py       |  4 ++--
 grizzly/common/status.py             |  2 +-
 grizzly/common/status_reporter.py    |  4 ++--
 grizzly/common/storage.py            |  4 ++--
 grizzly/reduce/core.py               |  2 +-
 grizzly/reduce/stats.py              |  6 +++---
 grizzly/reduce/test_strategies.py    |  4 ++--
 grizzly/replay/replay.py             |  4 ++--
 grizzly/session.py                   |  4 ++--
 grizzly/target/test_target_loader.py | 16 ++++++++--------
 grizzly/test_main.py                 |  2 +-
 loki/loki.py                         |  2 +-
 sapphire/conftest.py                 |  2 +-
 sapphire/connection_manager.py       |  2 +-
 sapphire/core.py                     |  2 +-
 sapphire/job.py                      |  2 +-
 sapphire/server_map.py               |  4 ++--
 sapphire/test_sapphire.py            |  2 +-
 sapphire/worker.py                   |  2 +-
 24 files changed, 43 insertions(+), 43 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 4cd9ad62..8e4a2751 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -28,7 +28,7 @@ def add_arguments(self, actions):
         super().add_arguments(actions)
 
 
-class CommonArgs(object):
+class CommonArgs:
     IGNORABLE = ("log-limit", "memory", "timeout")
     IGNORE = ("log-limit", "timeout")
 
diff --git a/grizzly/common/fuzzmanager.py b/grizzly/common/fuzzmanager.py
index 5c6d48d3..acf4f009 100644
--- a/grizzly/common/fuzzmanager.py
+++ b/grizzly/common/fuzzmanager.py
@@ -18,7 +18,7 @@
 LOG = getLogger(__name__)
 
 
-class Bucket(object):
+class Bucket:
     """Get Bucket data for a specified CrashManager bucket."""
 
     def __init__(self, bucket_id):
@@ -170,7 +170,7 @@ def signature_path(self):
         return self._sig_filename
 
 
-class CrashEntry(object):
+class CrashEntry:
     """Get the CrashEntry data for the specified CrashManager crash.
 
     Attributes:
diff --git a/grizzly/common/iomanager.py b/grizzly/common/iomanager.py
index f6a9f88d..c48b567e 100644
--- a/grizzly/common/iomanager.py
+++ b/grizzly/common/iomanager.py
@@ -17,7 +17,7 @@
 __credits__ = ["Tyson Smith"]
 
 
-class IOManager(object):
+class IOManager:
     TRACKED_ENVVARS = (
         "ASAN_OPTIONS",
         "LSAN_OPTIONS",
diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 701e3982..203964fc 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -50,7 +50,7 @@
 LogMap = namedtuple("LogMap", "aux stderr stdout")
 
 
-class Report(object):
+class Report:
     DEFAULT_MAJOR = "NO_STACK"
     DEFAULT_MINOR = "0"
     MAX_LOG_SIZE = 1048576  # 1MB
diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index ee3be4a5..e4cebcf5 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -23,7 +23,7 @@
 # long running test cases.
 # This is not perfect! It is to be used AFTER the test case timeout
 # (initial_delay) has elapsed.
-class _IdleChecker(object):
+class _IdleChecker:
     __slots__ = ("_check_cb", "_init_delay", "_poll_delay", "_threshold", "_next_poll")
 
     def __init__(self, check_cb, threshold, initial_delay, poll_delay=1):
@@ -73,7 +73,7 @@ def schedule_poll(self, initial=False, now=None):
             self._next_poll = now + self._poll_delay
 
 
-class Runner(object):
+class Runner:
     __slots__ = ("_close_delay", "_idle", "_relaunch", "_server", "_target", "_tests_run")
 
     def __init__(self, server, target, close_delay=30, idle_threshold=0, idle_delay=0, relaunch=1):
@@ -266,7 +266,7 @@ def _keep_waiting(self):
         return self._target.monitor.is_healthy()
 
 
-class RunResult(object):
+class RunResult:
     FAILED = 1
     IGNORED = 2
 
diff --git a/grizzly/common/stack_hasher.py b/grizzly/common/stack_hasher.py
index 4664871f..8f59d6c2 100644
--- a/grizzly/common/stack_hasher.py
+++ b/grizzly/common/stack_hasher.py
@@ -27,7 +27,7 @@
 MAJOR_DEPTH_RUST = 10
 
 
-class StackFrame(object):
+class StackFrame:
     MODE_GDB = 0
     MODE_MINIDUMP = 1
     MODE_RR = 2
@@ -250,7 +250,7 @@ def _parse_valgrind(cls, input_line):
         return sframe
 
 
-class Stack(object):
+class Stack:
     __slots__ = ("frames", "_major", "_major_depth", "_minor")
 
     def __init__(self, frames=None, major_depth=MAJOR_DEPTH):
diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 0ebf6a0b..7246c182 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -22,7 +22,7 @@
 LOG = getLogger(__name__)
 
 
-class Status(object):
+class Status:
     """Status holds status information for the Grizzly session.
     There can be multiple readers of the data but only a single writer.
     """
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index e9a12ee2..70351ae6 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -20,7 +20,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
-class StatusReporter(object):
+class StatusReporter:
     """Read and merge Grizzly status reports, including tracebacks if found.
     Output is a single textual report, e.g. for submission to EC2SpotManager.
     """
@@ -268,7 +268,7 @@ def _tracebacks(path, ignore_kbi=True, max_preceeding=5):
         return tracebacks
 
 
-class TracebackReport(object):
+class TracebackReport:
     """Read Python tracebacks from log files and store it in a manner that is helpful
     when generating reports.
     """
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 6af56a47..0fb69f8b 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -35,7 +35,7 @@ class TestFileExists(Exception):
 TestFileMap = namedtuple("TestFileMap", "meta optional required")
 
 
-class TestCase(object):
+class TestCase:
     __slots__ = (
         "adapter_name", "duration", "env_vars", "input_fname", "landing_page",
         "redirect_page", "timestamp", "_existing_paths", "_files")
@@ -469,7 +469,7 @@ def scan_path(path):
                     yield tc_path
 
 
-class TestFile(object):
+class TestFile:
     CACHE_LIMIT = 0x80000  # data cache limit per file: 512KB
     XFER_BUF = 0x10000  # transfer buffer size: 64KB
 
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 9ffdd1d4..d40bdb34 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -37,7 +37,7 @@
 LOG = getLogger(__name__)
 
 
-class ReduceManager(object):
+class ReduceManager:
     """Manage reduction of one or more testcases to find the smallest testcase
     that reproduces a given issue.
 
diff --git a/grizzly/reduce/stats.py b/grizzly/reduce/stats.py
index 956dd1c8..962b9fa3 100644
--- a/grizzly/reduce/stats.py
+++ b/grizzly/reduce/stats.py
@@ -16,7 +16,7 @@
     "ReductionStat", "name, duration, successes, attempts, size, iterations")
 
 
-class _FormatTable(object):
+class _FormatTable:
     """Format tabular data in a table.
     """
     def __init__(self, columns, formatters, vsep=" | ", hsep="-"):
@@ -106,7 +106,7 @@ def _format_number(number, total=0):
     return result
 
 
-class ReductionStats(object):
+class ReductionStats:
     """Statistics about reduction"""
 
     def __init__(self):
@@ -196,7 +196,7 @@ def add_timed(self, name, testcase_size_cb):
                         successes (int): # of successful attempts during period
         """
         # pylint: disable=no-self-argument
-        class _MilestoneTimer(object):
+        class _MilestoneTimer:
             def __init__(sub, sub_name, parent=None):
                 sub._name = sub_name
                 sub._start = None
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index b88a8e70..2c3e971d 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -40,7 +40,7 @@ def _fake_save_logs_foo(result_logs):
 
 def test_strategy_load_fail(mocker):
     """test that a broken strategy doesn't block other strategies"""
-    class _GoodStrategy(object):
+    class _GoodStrategy:
         name = "good"
         @classmethod
         def sanity_check_cls_attrs(cls):
@@ -50,7 +50,7 @@ def sanity_check_cls_attrs(cls):
         def load(cls):
             return cls
 
-    class _BadStrategy(object):
+    class _BadStrategy:
         name = "bad"
         @classmethod
         def load(cls):
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index dc7ca8db..2ca8d4ad 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -26,7 +26,7 @@
 LOG = getLogger(__name__)
 
 
-class ReplayResult(object):
+class ReplayResult:
     __slots__ = ("count", "durations", "expected", "report", "served")
 
     def __init__(self, report, served, durations, expected):
@@ -37,7 +37,7 @@ def __init__(self, report, served, durations, expected):
         self.served = served
 
 
-class ReplayManager(object):
+class ReplayManager:
     HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
 
     __slots__ = ("ignore", "server", "status", "target", "_any_crash",
diff --git a/grizzly/session.py b/grizzly/session.py
index 3a6f6018..ee6d47c3 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -24,7 +24,7 @@ class SessionError(Exception):
     """The base class for exceptions raised by Session"""
 
 
-class LogOutputLimiter(object):
+class LogOutputLimiter:
     __slots__ = ("_delay", "_iterations", "_launches", "_multiplier", "_time", "_verbose")
 
     def __init__(self, delay=300, delta_multiplier=2, verbose=False):
@@ -53,7 +53,7 @@ def ready(self, cur_iter, launches):
         return ready
 
 
-class Session(object):
+class Session:
     DISPLAY_VERBOSE = 0  # display status every iteration
     DISPLAY_NORMAL = 1  # quickly reduce the amount of output
     EXIT_SUCCESS = 0
diff --git a/grizzly/target/test_target_loader.py b/grizzly/target/test_target_loader.py
index 8c4fa1e5..49ca2a0d 100644
--- a/grizzly/target/test_target_loader.py
+++ b/grizzly/target/test_target_loader.py
@@ -30,14 +30,14 @@ def test_target_load_02(mocker):
     '''Loading targets works.'''
     mocker.patch('grizzly.target.TARGETS', None)
 
-    class _FakeEntryPoint1(object):
+    class _FakeEntryPoint1:
         name = 'test1'
 
         @staticmethod
         def load():
             return _FakeTarget1
 
-    class _FakeEntryPoint2(object):
+    class _FakeEntryPoint2:
         name = 'test2'
 
         @staticmethod
@@ -54,14 +54,14 @@ def test_target_load_03(mocker):
     '''Non-Target will be skipped.'''
     mocker.patch('grizzly.target.TARGETS', None)
 
-    class _FakeEntryPoint1(object):
+    class _FakeEntryPoint1:
         name = 'test1'
 
         @staticmethod
         def load():
             return Target
 
-    class _FakeEntryPoint2(object):
+    class _FakeEntryPoint2:
         name = 'test2'
 
         @staticmethod
@@ -77,14 +77,14 @@ def test_target_load_04(mocker):
     '''test load() with name collision'''
     mocker.patch('grizzly.target.TARGETS', None)
 
-    class _FakeEntryPoint1(object):
+    class _FakeEntryPoint1:
         name = 'test'
 
         @staticmethod
         def load():
             return _FakeTarget1
 
-    class _FakeEntryPoint2(object):
+    class _FakeEntryPoint2:
         name = 'test'
 
         @staticmethod
@@ -100,14 +100,14 @@ def test_target_load_05(mocker):
     '''test load() with broken Target'''
     mocker.patch('grizzly.target.TARGETS', None)
 
-    class _FakeEntryPoint1(object):
+    class _FakeEntryPoint1:
         name = 'test1'
 
         @staticmethod
         def load():
             return Target
 
-    class _FakeEntryPoint2(object):
+    class _FakeEntryPoint2:
         name = 'test2'
 
         @staticmethod
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 12ae026d..776e8f84 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -10,7 +10,7 @@
 from .target import Target, TargetLaunchError
 
 
-class FakeArgs(object):
+class FakeArgs:
     def __init__(self):
         self.binary = None
         self.input = None
diff --git a/loki/loki.py b/loki/loki.py
index 90bafd3b..bf3f8b1c 100644
--- a/loki/loki.py
+++ b/loki/loki.py
@@ -20,7 +20,7 @@
 LOG = getLogger(__name__)
 
 
-class Loki():
+class Loki:
     BYTE_ORDERS = ("<", ">", "@", "!", "=")
 
     __slots__ = ("aggr", "byte_order")
diff --git a/sapphire/conftest.py b/sapphire/conftest.py
index 97877c76..eab968d9 100644
--- a/sapphire/conftest.py
+++ b/sapphire/conftest.py
@@ -28,7 +28,7 @@ def client_factory():
     """
     clients = []
 
-    class _SimpleClient(object):
+    class _SimpleClient:
         # pylint: disable=missing-docstring
 
         def __init__(self, rx_size=0x10000):
diff --git a/sapphire/connection_manager.py b/sapphire/connection_manager.py
index 3d1035d4..d6cd7e79 100644
--- a/sapphire/connection_manager.py
+++ b/sapphire/connection_manager.py
@@ -16,7 +16,7 @@
 LOG = getLogger(__name__)
 
 
-class ConnectionManager(object):
+class ConnectionManager:
     SHUTDOWN_DELAY = 0.5  # allow extra time before closing socket if needed
 
     __slots__ = ("_job", "_listener", "_socket", "_workers")
diff --git a/sapphire/core.py b/sapphire/core.py
index a686273d..bd4be651 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -24,7 +24,7 @@
 LOG = getLogger(__name__)
 
 
-class Sapphire(object):
+class Sapphire:
     LISTEN_TIMEOUT = 0.25
 
     __slots__ = ("_auto_close", "_max_workers", "_socket", "_timeout")
diff --git a/sapphire/job.py b/sapphire/job.py
index d2e4773d..f7a0f5a9 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -31,7 +31,7 @@
 Tracker = namedtuple("Tracker", "files lock")
 
 
-class Job(object):
+class Job:
     # MIME_MAP is used to support new or uncommon mime types.
     # Definitions in here take priority over mimetypes.guess_type().
     MIME_MAP = {
diff --git a/sapphire/server_map.py b/sapphire/server_map.py
index b0021949..c96c196f 100644
--- a/sapphire/server_map.py
+++ b/sapphire/server_map.py
@@ -22,7 +22,7 @@ class MapCollisionError(Exception):
     """Raised when a URL is already in use by ServerMap"""
 
 
-class Resource(object):
+class Resource:
     URL_DYNAMIC = 0
     URL_FILE = 1
     URL_INCLUDE = 2
@@ -37,7 +37,7 @@ def __init__(self, resource_type, target, mime=None, required=False):
         self.type = resource_type
 
 
-class ServerMap(object):
+class ServerMap:
     __slots__ = ("dynamic", "include", "redirect")
 
     def __init__(self):
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 9ef706c5..233abffd 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -18,7 +18,7 @@
 from .server_map import ServerMap
 
 
-class _TestFile(object):
+class _TestFile:
     def __init__(self, url):
         self.code = None
         self.content_type = None
diff --git a/sapphire/worker.py b/sapphire/worker.py
index c06fa4dd..9991da3d 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -27,7 +27,7 @@ class WorkerError(Exception):
     """Raised by Worker"""
 
 
-class Worker(object):
+class Worker:
     DEFAULT_REQUEST_LIMIT = 0x1000  # 4KB
     DEFAULT_TX_SIZE = 0x10000  # 64KB
     REQ_PATTERN = re_compile(b"^GET\\s/(?P<request>\\S*)\\sHTTP/1")

From c2016852c11d1400809f1b0d4d889c9786acbfd1 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 8 Jan 2021 14:23:54 -0800
Subject: [PATCH 166/531] Handle potential OSError when sending signals

---
 grizzly/target/puppet_target.py      | 20 ++++++++++++++++----
 grizzly/target/test_puppet_target.py | 21 ++++++++++++++++++++-
 2 files changed, 36 insertions(+), 5 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index ea2a37ff..57f73584 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -54,7 +54,10 @@ def _abort_hung_proc(self):
             proc_usage = self._puppet.cpu_usage()
         for pid, cpu in sorted(proc_usage, reverse=True, key=lambda x: x[1]):
             LOG.debug("sending SIGABRT to pid: %r, cpu: %0.2f%%", pid, cpu)
-            kill(pid, SIGABRT)
+            try:
+                kill(pid, SIGABRT)
+            except OSError:
+                LOG.warning("Failed to send SIGABRT to pid %d", pid)
             break
 
     def add_abort_token(self, token):
@@ -148,11 +151,17 @@ def dump_coverage(self, timeout=15):
         try:
             for child in Process(pid).children(recursive=True):
                 LOG.debug("Sending SIGUSR1 to %d (child)", child.pid)
-                kill(child.pid, SIGUSR1)
+                try:
+                    kill(child.pid, SIGUSR1)
+                except OSError:
+                    LOG.warning("Failed to send SIGUSR1 to pid %d", child.pid)
         except (AccessDenied, NoSuchProcess):  # pragma: no cover
             pass
         LOG.debug("Sending SIGUSR1 to %d (parent)", pid)
-        kill(pid, SIGUSR1)
+        try:
+            kill(pid, SIGUSR1)
+        except OSError:
+            LOG.warning("Failed to send SIGUSR1 to pid %d", pid)
         start_time = time()
         gcda_found = False
         delay = 0.1
@@ -180,7 +189,10 @@ def dump_coverage(self, timeout=15):
                 if elapsed >= timeout:
                     # timeout failure
                     LOG.warning("gcda file open by pid %d after %0.2fs", gcda_open, elapsed)
-                    kill(gcda_open, SIGABRT)
+                    try:
+                        kill(gcda_open, SIGABRT)
+                    except OSError:
+                        pass
                     sleep(1)
                     self.close()
                     break
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index f9585dab..e56d00e9 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -2,6 +2,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
+from itertools import count
 from os.path import isfile
 from platform import system
 
@@ -122,7 +123,11 @@ def test_puppet_target_03(mocker, tmp_path):
     fake_ffp.return_value.is_running.return_value = True
     fake_ffp.return_value.reason = None
     fake_ffp.return_value.cpu_usage.return_value = ((1234, 10), (1236, 75), (1238, 60))
-    fake_kill = mocker.patch("grizzly.target.puppet_target.kill", autospec=True)
+    # raise OSError for code coverage
+    fake_kill = mocker.patch(
+        "grizzly.target.puppet_target.kill",
+        autospec=True,
+        side_effect=OSError)
     assert target.detect_failure([], True) == Target.RESULT_FAILURE
     if system() == "Linux":
         assert fake_kill.call_count == 1
@@ -239,6 +244,20 @@ def test_puppet_target_04(mocker, tmp_path):
     target.dump_coverage()
     assert fake_proc_iter.call_count == 3
     assert fake_kill.call_count == 2
+    fake_ffp.reset_mock()
+    fake_kill.reset_mock()
+    fake_proc_iter.reset_mock()
+    # kill calls raise OSError
+    fake_kill.side_effect = OSError
+    fake_ffp.return_value.is_healthy.return_value = True
+    fake_ffp.return_value.get_pid.return_value = 100
+    fake_proc_iter.side_effect = None
+    fake_time.side_effect = count()
+    target.dump_coverage()
+    assert fake_kill.call_count == 3
+    fake_ffp.reset_mock()
+    fake_kill.reset_mock()
+    fake_proc_iter.reset_mock()
 
 def test_puppet_target_05(mocker, tmp_path):
     """test is_idle()"""

From 15a3efc1fab1a12145eebde089a39a91a478c83b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 11 Jan 2021 09:53:22 -0800
Subject: [PATCH 167/531] Bump version to 0.11.0

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 7318b290..e37cd96b 100755
--- a/setup.py
+++ b/setup.py
@@ -84,4 +84,4 @@
         ],
         package_data={"grizzly.common": ["harness.html"]},
         url='https://github.com/MozillaSecurity/grizzly',
-        version='0.10.0')
+        version='0.11.0')

From 13526c5e912d4241f4d2f768f652e731f969fa1c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 12 Jan 2021 10:29:08 -0800
Subject: [PATCH 168/531] Add --limit to set a maximum number of iterations

---
 grizzly/args.py      |  6 ++++++
 grizzly/main.py      |  8 +++++++-
 grizzly/session.py   | 15 ++++++---------
 grizzly/test_main.py |  4 +++-
 4 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 8e4a2751..ed4b1aeb 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -177,6 +177,9 @@ def __init__(self):
         self.parser.add_argument(
             "-i", "--input",
             help="Test case or directory containing test cases")
+        self.parser.add_argument(
+            "--limit", type=int, default=0,
+            help="Maximum number of iterations to be performed. (default: no limit)")
         self.parser.add_argument(
             "-v", "--verbose", action="store_true",
             help="Output console updates every iteration. By default the number"
@@ -212,6 +215,9 @@ def sanity_check(self, args):
         if args.fuzzmanager and args.s3_fuzzmanager:
             self.parser.error("--fuzzmanager and --s3-fuzzmanager are mutually exclusive")
 
+        if args.limit < 0:
+            self.parser.error("--limit must be >= 0 (0 = no limit)")
+
         if args.tool is not None and not (args.fuzzmanager or args.s3_fuzzmanager):
             self.parser.error("--tool can only be given with --fuzzmanager/--s3-fuzzmanager")
 
diff --git a/grizzly/main.py b/grizzly/main.py
index 44bf479d..64db31df 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -106,6 +106,9 @@ def main(args):
             reporter = FilesystemReporter(pathjoin(getcwd(), "results"))
             LOG.info("Results will be stored in %r", reporter.report_path)
 
+        if args.limit > 0:
+            LOG.info("%r iteration(s) will be attempted", args.limit)
+
         # set 'auto_close=1' so the client error pages (code 4XX) will
         # call 'window.close()' after a second.
         # launch http server used to serve test cases
@@ -125,7 +128,10 @@ def main(args):
                 display_mode = Session.DISPLAY_VERBOSE
             else:
                 display_mode = Session.DISPLAY_NORMAL
-            session.run(args.ignore, display_mode=display_mode)
+            session.run(
+                args.ignore,
+                iteration_limit=args.limit,
+                display_mode=display_mode)
 
     except KeyboardInterrupt:
         LOG.info("Ctrl+C detected.")
diff --git a/grizzly/session.py b/grizzly/session.py
index ee6d47c3..d170fc88 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -124,14 +124,11 @@ def report_result(self):
             rmtree(result_logs)
         self.status.count_result(short_sig)
 
-    def run(self, ignore, iteration_limit=None, display_mode=DISPLAY_NORMAL):
+    def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
+        assert iteration_limit >= 0
         log_limiter = LogOutputLimiter(verbose=display_mode == self.DISPLAY_VERBOSE)
-        # limit relaunch to max iterations if known
-        if iteration_limit is not None:
-            assert iteration_limit > 0
-            relaunch = min(self._relaunch, iteration_limit)
-        else:
-            relaunch = self._relaunch
+        # limit relaunch to max iterations if needed
+        relaunch = min(self._relaunch, iteration_limit) or self._relaunch
         if self.adapter.remaining is not None:
             assert self.adapter.remaining > 0
             relaunch = min(relaunch, self.adapter.remaining)
@@ -204,8 +201,8 @@ def run(self, ignore, iteration_limit=None, display_mode=DISPLAY_NORMAL):
                 LOG.info("Replay Complete")
                 break
 
-            if iteration_limit is not None and self.status.iteration == iteration_limit:
-                LOG.info("Hit iteration limit")
+            if iteration_limit and self.status.iteration >= iteration_limit:
+                LOG.info("Hit iteration limit (%d)", iteration_limit)
                 break
 
             # warn about large browser logs
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 776e8f84..27fd9863 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -21,6 +21,7 @@ def __init__(self):
         self.fuzzmanager = False
         self.ignore = list()
         self.launch_timeout = 300
+        self.limit = 0
         self.log_level = 10  # 10 = DEBUG, 20 = INFO
         self.log_limit = 0
         self.memory = 0
@@ -83,10 +84,11 @@ def test_main_01(mocker):
     assert fake_session.mock_calls[0][-1]["coverage"]
     assert fake_session.mock_calls[0][-1]["relaunch"] == 1000
     fake_session.reset_mock()
-    # with S3FM
+    # with S3FM (with iteration limit)
     fake_reporter = mocker.patch("grizzly.main.S3FuzzManagerReporter", autospec=True)
     fake_reporter.sanity_check.return_value = True
     args.fuzzmanager = False
+    args.limit = 10
     args.s3_fuzzmanager = True
     assert main(args) == Session.EXIT_SUCCESS
 

From 29a677070407346a725f7455e494ab62efdfa6e6 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 12 Jan 2021 15:35:59 -0800
Subject: [PATCH 169/531] Remove broken console_scripts until cross platform
 support is fixed

---
 setup.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/setup.py b/setup.py
index e37cd96b..da1a7eb1 100755
--- a/setup.py
+++ b/setup.py
@@ -36,9 +36,6 @@
         description='A framework for developing and running browser fuzzers',
         entry_points={
             'console_scripts': [
-                'grizzly = grizzly.__main__',
-                'grizzly.reduce = grizzly.reduce.__main__',
-                'grizzly.replay = grizzly.replay.__main__',
                 'grizzly.status = grizzly.common.status_reporter:main',
             ],
             'grizzly_targets': [

From b9fcc3190e1ee5958b6c7a0489bab02433d15894 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 12 Jan 2021 15:36:53 -0800
Subject: [PATCH 170/531] Bump version to 0.11.1

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index da1a7eb1..977d1a4f 100755
--- a/setup.py
+++ b/setup.py
@@ -81,4 +81,4 @@
         ],
         package_data={"grizzly.common": ["harness.html"]},
         url='https://github.com/MozillaSecurity/grizzly',
-        version='0.11.0')
+        version='0.11.1')

From 8d27c70929389955ba9b6b6d70b50e3349a1786e Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 11 Jan 2021 22:30:02 -0500
Subject: [PATCH 171/531] Add the `TestcaseAttrs` splitter from lithium.

---
 grizzly/reduce/strategies/lithium.py | 9 ++++++++-
 setup.py                             | 3 ++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/grizzly/reduce/strategies/lithium.py b/grizzly/reduce/strategies/lithium.py
index 15496108..c95e6e12 100644
--- a/grizzly/reduce/strategies/lithium.py
+++ b/grizzly/reduce/strategies/lithium.py
@@ -10,7 +10,7 @@
 from lithium.strategies import CheckOnly, \
     CollapseEmptyBraces as LithCollapseEmptyBraces, Minimize, Strategy as LithStrategy
 from lithium.testcases import TestcaseChar, TestcaseJsStr, TestcaseLine, \
-    Testcase as LithTestcase
+    Testcase as LithTestcase, TestcaseAttrs
 
 from ...common.storage import TestCase
 from . import Strategy, _contains_dd
@@ -234,3 +234,10 @@ class MinimizeLines(_LithiumStrategy):
     name = "lines"
     strategy_cls = Minimize
     testcase_cls = TestcaseLine
+
+
+class MinimizeAttrs(_LithiumStrategy):
+    """Remove HTML/XML attributes and their values."""
+    name = "attrs"
+    strategy_cls = Minimize
+    testcase_cls = TestcaseAttrs
diff --git a/setup.py b/setup.py
index 977d1a4f..b2f11ec7 100755
--- a/setup.py
+++ b/setup.py
@@ -10,7 +10,7 @@
 
 
 EXTRAS = {
-    'reduce': ['cssbeautifier', 'lithium-reducer>=0.4.3', 'jsbeautifier'],
+    'reduce': ['cssbeautifier', 'lithium-reducer>=0.5', 'jsbeautifier'],
     's3': ['boto3'],
 }
 EXTRAS['all'] = list(set(chain.from_iterable(EXTRAS.values())))
@@ -50,6 +50,7 @@
                 'jschars = grizzly.reduce.strategies.lithium:MinimizeJSChars',
                 'lines = grizzly.reduce.strategies.lithium:MinimizeLines',
                 'list = grizzly.reduce.strategies.testcases:MinimizeTestcaseList',
+                'attrs = grizzly.reduce.strategies.lithium:MinimizeAttrs',
             ],
         },
         extras_require=EXTRAS,

From e85273eae0611c892a465d4eb2a150f4279cd1d2 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 13 Jan 2021 13:48:31 -0800
Subject: [PATCH 172/531] [reduce] Add 'attrs' to default strategies

---
 grizzly/reduce/strategies/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/grizzly/reduce/strategies/__init__.py b/grizzly/reduce/strategies/__init__.py
index 007d9a0a..49f58200 100644
--- a/grizzly/reduce/strategies/__init__.py
+++ b/grizzly/reduce/strategies/__init__.py
@@ -36,6 +36,7 @@
     "cssbeautify",
     "jsbeautify",
     "collapsebraces",
+    "attrs",
 )
 
 

From d58f4a4c7b08e46bfc8a351f7638944e97a71950 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 15 Jan 2021 14:08:13 -0500
Subject: [PATCH 173/531] [reduce] Handle Ctrl+C in `grizzly.reduce.bucket`

Ctrl+C is handled by `grizzly.reduce.crash`, but `grizzly.reduce.bucket`
sees it as a failure to reduce, and moves on to the next crash. Instead
it should abort too.
---
 grizzly/reduce/bucket.py       | 2 +-
 grizzly/reduce/test_main_fm.py | 8 +++++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/grizzly/reduce/bucket.py b/grizzly/reduce/bucket.py
index f03ae439..e33ecfad 100644
--- a/grizzly/reduce/bucket.py
+++ b/grizzly/reduce/bucket.py
@@ -43,7 +43,7 @@ def main(args):
 
             # call grizzly.reduce.crash
             result = crash_main(args)
-            if result == 0:
+            if result in {Session.EXIT_SUCCESS, Session.EXIT_ABORT}:
                 break
 
     finally:
diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
index 48a18a40..b3de0241 100644
--- a/grizzly/reduce/test_main_fm.py
+++ b/grizzly/reduce/test_main_fm.py
@@ -99,10 +99,12 @@ def test_crash_main_quality(mocker, mgr_exit_code, pre_quality, post_quality):
         ([(123, "test-tool")], [0], 0, "test_sig2.json", None),
         # --tool is respected
         ([(123, "test-tool")], [0], 0, None, "test-tool-arg"),
+        # abort in crash main should also abort bucket main
+        ([(123, "test-tool")], [3], 3, None, None),
     ]
 )
 def test_bucket_main(mocker, crashes, main_exit_codes, result, arg_sig, arg_tool):
-    """tests for `grizzly.reduce.crash.main`"""
+    """tests for `grizzly.reduce.bucket.main`"""
     call_args = []
 
     def copy_args(args):
@@ -122,9 +124,9 @@ def copy_args(args):
         sig=arg_sig,
         tool=arg_tool,
     )
-    bucket_main(args)
+    assert bucket_main(args) == result
     assert main.call_count == len(main_exit_codes)
-    for idx, (crash, tool) in enumerate(crashes[:main.call_count]):
+    for idx, (crash, _tool) in enumerate(crashes[:main.call_count]):
         assert call_args[idx].input == crash
         if arg_tool is not None:
             assert call_args[idx].tool == arg_tool

From abedb34d0bbc2ed276159f4cd24cfc660e3b430c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 15 Jan 2021 11:26:22 -0800
Subject: [PATCH 174/531] Add support for DEBUG=1 shortcut

---
 grizzly/main.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/grizzly/main.py b/grizzly/main.py
index 64db31df..f40df8f3 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -4,7 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import basicConfig, DEBUG, getLogger
 from os.path import join as pathjoin
-from os import getcwd
+from os import getcwd, getenv
 
 from sapphire import Sapphire
 
@@ -23,7 +23,7 @@
 LOG = getLogger(__name__)
 
 def configure_logging(log_level):
-    if log_level == DEBUG:
+    if log_level == DEBUG or getenv("DEBUG") == "1":
         date_fmt = None
         log_fmt = "%(asctime)s %(levelname).1s %(name)s | %(message)s"
     else:

From 114477a4175bc776b22636e48248fab3a883db59 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 15 Jan 2021 11:44:11 -0800
Subject: [PATCH 175/531] [reduce] Output crash ID in crash_main()

---
 grizzly/reduce/crash.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index 75795e30..dc2b08f2 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -26,6 +26,7 @@ def main(args):
     """
     configure_logging(args.log_level)
     crash = CrashEntry(args.input)
+    LOG.info("Loaded crash %d", crash.crash_id)
     bucket = None
     try:
         # download the crash

From f272120d244cf0979512a21044356f9ca23b8dbf Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 15 Jan 2021 11:55:46 -0800
Subject: [PATCH 176/531] DEBUG=1 should set log_level not just change
 formating

---
 grizzly/main.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/grizzly/main.py b/grizzly/main.py
index f40df8f3..7f9b2ef0 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -23,7 +23,9 @@
 LOG = getLogger(__name__)
 
 def configure_logging(log_level):
-    if log_level == DEBUG or getenv("DEBUG") == "1":
+    if getenv("DEBUG") == "1":
+        log_level = DEBUG
+    if log_level == DEBUG:
         date_fmt = None
         log_fmt = "%(asctime)s %(levelname).1s %(name)s | %(message)s"
     else:

From a236220128a138e202145ca0d4b9a2d5a1ed59aa Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 18 Jan 2021 19:39:59 -0800
Subject: [PATCH 177/531] Update some user facing docs

---
 grizzly/adapters/NoOpAdapter/__init__.py | 49 ++++++++++++++++-----
 grizzly/common/adapter.py                | 54 +++++++++++++++---------
 grizzly/common/storage.py                |  9 ++--
 3 files changed, 77 insertions(+), 35 deletions(-)

diff --git a/grizzly/adapters/NoOpAdapter/__init__.py b/grizzly/adapters/NoOpAdapter/__init__.py
index 91ab9a84..271d49d1 100644
--- a/grizzly/adapters/NoOpAdapter/__init__.py
+++ b/grizzly/adapters/NoOpAdapter/__init__.py
@@ -1,7 +1,6 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
 from grizzly.common import Adapter
 
 __author__ = "Tyson Smith"
@@ -9,20 +8,48 @@
 
 
 class NoOpAdapter(Adapter):
+    """This is a simple adapter that has very little overhead. It can be used
+    to help measure a baseline iteration rate for Grizzly.
     """
-    This is an simple adapter that has very little overhead. It can be used
-    to get a baseline iteration rate for Grizzly.
-    """
+
     NAME = "no-op"
 
-    def setup(self, *_):
+    def setup(self, _input, _server_map):
+        """Generate a static test case that calls `window.close()` when run.
+        Normally this is done in generate() but since the test is static only
+        do it once. Use the default harness to allow running multiple test cases
+        in a row without closing the browser after each one.
+
+        Args:
+            _input (str): Unused.
+            _server_map (sapphire.server_map.ServerMap): Unused.
+
+        Returns:
+            None
+        """
         self.enable_harness()
-        self.fuzz["test"] = "<!DOCTYPE html>\n" \
-            "<html>\n" \
-            "<head>\n" \
-            "<script>window.close()</script>\n" \
-            "</head>\n" \
+        self.fuzz["test"] = (
+            "<!DOCTYPE html>\n"
+            "<html>\n"
+            "<head>\n"
+            "<script>window.close()</script>\n"
+            "</head>\n"
             "</html>"
+        )
+
+    def generate(self, testcase, _server_map):
+        """Since the test case has already been created just add the data to the
+        TestCase.
+
+        Also all TestCases require an entry point and the one expected by Grizzly
+        is provided in `testcase.landing_page` so use it as the file name for
+        the test.
+
+        Args:
+            testcase (grizzly.common.storage.TestCase): TestCase to be populated.
+            _server_map (sapphire.server_map.ServerMap): Unused.
 
-    def generate(self, testcase, _):
+        Returns:
+            None
+        """
         testcase.add_from_data(self.fuzz["test"], testcase.landing_page)
diff --git a/grizzly/common/adapter.py b/grizzly/common/adapter.py
index 3b184576..0ba7c850 100644
--- a/grizzly/common/adapter.py
+++ b/grizzly/common/adapter.py
@@ -17,6 +17,24 @@ class AdapterError(Exception):
 
 
 class Adapter(metaclass=ABCMeta):
+    """An Adapter is an interface between Grizzly and a fuzzer. A subclass must
+    be created in order to add support for additional fuzzers. The Adapter is
+    responsible for handling input/output data and executing the fuzzer.
+    It is expected that any processes launched or file created on file system
+    in the adapter will also be cleaned up in the adapter.
+    NOTE: Some methods must not be overloaded doing so will prevent Grizzly from
+    operating correctly.
+
+    Attributes:
+        _harness (str): Path to harness file that will be used. If None, no
+                        harness will be used.
+        fuzz (dict): Available as a safe scratch pad for the end-user.
+        monitor (TargetMonitor): Used to provide Target status information to
+                                 the adapter.
+        remaining (int): Can be used to indicate the number of TestCases
+                         remaining to process.
+    """
+
     HARNESS_FILE = pathjoin(dirname(__file__), "harness.html")
     IGNORE_UNSERVED = True  # Only report test cases with served content
     NAME = None  # must be a unique string
@@ -25,21 +43,17 @@ class Adapter(metaclass=ABCMeta):
 
     __slots__ = ("_harness", "fuzz", "monitor", "remaining")
 
-    #############################
-    # Built-ins do NOT overload!
-    #############################
-
     def __init__(self):
         if not isinstance(self.NAME, str):
             raise AdapterError("%s.NAME must be a string" % (type(self).__name__,))
         self._harness = None
         self.fuzz = dict()
         self.monitor = None
-        # remaining can be used to indicate the number of TestCases remaining to process
         self.remaining = None
 
     def cleanup(self):
-        """Automatically called once at shutdown.
+        """Automatically called once at shutdown. Used internally by Grizzly.
+        *** DO NOT OVERLOAD! ***
 
         Args:
             None
@@ -51,6 +65,7 @@ def cleanup(self):
 
     def enable_harness(self, file_path=None):
         """Enable use of a harness during fuzzing. By default no harness is used.
+        *** DO NOT OVERLOAD! ***
 
         Args:
             file_path (str): Path to file to use as a harness. If None the default
@@ -66,22 +81,24 @@ def enable_harness(self, file_path=None):
 
     def get_harness(self):
         """Get the harness. Used internally by Grizzly.
+        *** DO NOT OVERLOAD! ***
 
         Args:
             None
 
         Returns:
-            TestFile: The current harness
+            TestFile: The active harness.
         """
         return self._harness
 
     @staticmethod
     def scan_path(path, ignore=("desktop.ini", "thumbs.db"), recursive=False):
-        """Scan a path and yield the files within it.
+        """Scan a path and yield the files within it. This is available as
+        a helper method.
 
         Args:
             path (str): Path to file or directory.
-            ignore (iterable): Filenames to ignore.
+            ignore (iterable(str)): Files to ignore.
             recursive (bool): Scan recursively into directories.
 
         Yields:
@@ -100,17 +117,13 @@ def scan_path(path, ignore=("desktop.ini", "thumbs.db"), recursive=False):
         elif isfile(full_path):
             yield full_path
 
-    #############################
-    # Methods to overload
-    #############################
-
     @abstractmethod
     def generate(self, testcase, server_map):
         """Automatically called. Populate testcase here.
 
         Args:
-            testcase (TestCase): TestCase intended to be populated
-            server_map (ServerMap): A ServerMap
+            testcase (TestCase): TestCase intended to be populated.
+            server_map (ServerMap): A ServerMap.
 
         Returns:
             None
@@ -120,19 +133,20 @@ def on_served(self, testcase, served):
         """Optional. Automatically called after a test case is successfully served.
 
         Args:
-            testcase (TestCase): TestCase that was served
-            served (list): A list of file names served from testcase
+            testcase (TestCase): TestCase that was served.
+            served (list(str)): Files served from testcase.
 
         Returns:
             None
         """
 
     def on_timeout(self, testcase, served):
-        """Optional. Automatically called if timeout occurs attempting to serve a test case.
+        """Optional. Automatically called if timeout occurs while attempting to
+        serve a test case. By default it calls `self.on_served()`.
 
         Args:
-            testcase (TestCase): TestCase that was served
-            served (list): A list of file names served from testcase
+            testcase (TestCase): TestCase that was served.
+            served (list(str)): Files served from testcase.
 
         Returns:
             None
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 0fb69f8b..7ee65ec9 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -29,7 +29,8 @@ class TestCaseLoadFailure(Exception):
 
 
 class TestFileExists(Exception):
-    """Raised when adding a TestFile to a TestCase that has an existing TestFile with the same name"""
+    """Raised when adding a TestFile to a TestCase that has an existing
+    TestFile with the same name"""
 
 
 TestFileMap = namedtuple("TestFileMap", "meta optional required")
@@ -82,8 +83,8 @@ def add_batch(self, path, include_files, prefix=None):
 
         Args:
             path (str): Path to the root of the directory that contains files.
-            include_files (iterable): Paths of the files to be added to the
-                                      TestCase if they exist in path.
+            include_files (iterable(str)): Paths of the files to be added to the
+                                           TestCase if they exist in path.
             prefix (str): Path prefix to prepend to file when adding to
                           the TestCase.
 
@@ -425,7 +426,7 @@ def purge_optional(self, keep):
         """Remove optional files (by name) that are not in keep.
 
         Args:
-            keep (iterable): Filenames that will not be removed.
+            keep (iterable(str)): Files that will not be removed.
 
         Returns:
             None

From c1829b4814f7a89b2e3a623c04ebbcfbc5a2a9fe Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 22 Jan 2021 14:52:02 -0800
Subject: [PATCH 178/531] Add Status.signatures()

---
 grizzly/common/status.py      | 18 ++++++++++++++++--
 grizzly/common/test_status.py | 19 +++++++++++++++++++
 2 files changed, 35 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 7246c182..38340b80 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -177,8 +177,9 @@ def rate(self):
         return self.iteration / float(self.duration) if self.duration > 0 else 0
 
     def report(self, force=False, report_freq=REPORT_FREQ):
-        """Write status report. Reports are only written when the time since the
-        previous report was created exceeds `report_freq` seconds.
+        """Write status report to disk. Reports are only written periodically.
+        It is limited by `report_freq`. The specified number of seconds must
+        elapse before another write will be performed unless `force` is True.
 
         Args:
             force (bool): Ignore report frequently limiting.
@@ -209,6 +210,19 @@ def results(self):
         """
         return sum(self._results.values())
 
+    def signatures(self):
+        """Provide the signature and the number of times it has been found for
+        each result.
+
+        Args:
+            None
+
+        Yields:
+            tuples: Containing signature and count.
+        """
+        for sig, count in self._results.items():
+            yield (sig, count)
+
     @classmethod
     def start(cls):
         """Create a unique Status object.
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 53113015..d577b712 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -172,3 +172,22 @@ def test_status_08(tmp_path):
                 proc.join()
     # verify cleanup
     assert not any(Status.loadall())
+
+def test_status_09(tmp_path):
+    """test Status.count_result() and Status.signatures()"""
+    Status.PATH = str(tmp_path)
+    status = Status.start()
+    status.count_result("sig1")
+    status.count_result("sig2")
+    status.count_result("sig1")
+    status.count_result("sig3")
+    assert status.results == 4
+    found = dict()
+    for sig, count in status.signatures():
+        found[sig] = count
+    assert "sig1" in found
+    assert found["sig1"] == 2
+    assert "sig2" in found
+    assert found["sig2"] == 1
+    assert "sig3" in found
+    assert found["sig3"] == 1

From 6cbcaee58f0f1f1c4b3bbb35841113a5b87dac96 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 22 Jan 2021 16:52:34 -0800
Subject: [PATCH 179/531] Add profiling support to Status

---
 grizzly/common/status.py      | 47 ++++++++++++++++++++++++++++-
 grizzly/common/test_status.py | 56 +++++++++++++++++++++++++++++++++--
 2 files changed, 99 insertions(+), 4 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 38340b80..b426022a 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -4,6 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Manage Grizzly status reports."""
 from collections import defaultdict
+from contextlib import contextmanager
 from json import dump, load
 from logging import getLogger
 from os import close, listdir, unlink
@@ -30,13 +31,14 @@ class Status:
     REPORT_FREQ = 60
 
     __slots__ = (
-        "_lock", "_results", "data_file", "ignored", "iteration",
+        "_lock", "_profile", "_results", "data_file", "ignored", "iteration",
         "log_size", "start_time", "test_name", "timestamp")
 
     def __init__(self, data_file, start_time=None):
         assert ".json" in data_file
         assert start_time is None or isinstance(start_time, float)
         self._lock = InterProcessLock("%s.lock" % (data_file,))
+        self._profile = dict()
         self._results = defaultdict(int)
         # if data_file is None the status report is read only (no reporting)
         self.data_file = data_file
@@ -83,6 +85,7 @@ def count_result(self, signature):
     @property
     def _data(self):
         return {
+            "_profile": self._profile,
             "_results": self._results,
             "ignored": self.ignored,
             "iteration": self.iteration,
@@ -163,6 +166,20 @@ def loadall(cls):
                     continue
                 yield status
 
+    @contextmanager
+    def measure(self, name):
+        """Used to simplify collecting profiling data.
+
+        Args:
+            name (str): Used to group the entries.
+
+        Returns:
+            None
+        """
+        mark = time()
+        yield
+        self.record(name, time() - mark)
+
     @property
     def rate(self):
         """Calculate the number of iterations performed per second since start()
@@ -176,6 +193,34 @@ def rate(self):
         """
         return self.iteration / float(self.duration) if self.duration > 0 else 0
 
+    def record(self, name, duration):
+        """Used to add profiling data. This is intended to be used to make rough
+        calculations to identify major configuration issues.
+
+        Args:
+            name (str): Used to group the entries.
+            duration (int, float): Stored to be later used for measurements.
+
+        Returns:
+            None
+        """
+        assert isinstance(duration, (float, int))
+        try:
+            self._profile[name]["count"] += 1
+            if self._profile[name]["max"] < duration:
+                self._profile[name]["max"] = duration
+            elif self._profile[name]["min"] > duration:
+                self._profile[name]["min"] = duration
+            self._profile[name]["total"] += duration
+        except KeyError:
+            # add profile entry
+            self._profile[name] = {
+                "count": 1,
+                "max": duration,
+                "min": duration,
+                "total": duration,
+            }
+
     def report(self, force=False, report_freq=REPORT_FREQ):
         """Write status report to disk. Reports are only written periodically.
         It is limited by `report_freq`. The specified number of seconds must
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index d577b712..a1710d9e 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -29,6 +29,7 @@ def test_status_01(tmp_path):
     assert status.log_size == 0
     assert status.rate == 0
     assert status.results == 0
+    assert not status._profile
 
 def test_status_02(tmp_path):
     """test Status.cleanup()"""
@@ -82,10 +83,9 @@ def test_status_05(tmp_path):
     # create simple entry
     status = Status.start()
     status.count_result("sig1")
-    status.count_result("sig2")
-    status.count_result("sig1")
+    status.record("test", 123.45)
     status.report(force=True)
-    assert status.results == 3
+    assert status.results == 1
     loaded = Status.load(status.data_file)
     assert loaded.data_file is None
     assert status.start_time == loaded.start_time
@@ -95,6 +95,7 @@ def test_status_05(tmp_path):
     assert status.iteration == loaded.iteration
     assert status.log_size == loaded.log_size
     assert status.results == loaded.results
+    assert "test" in loaded._profile
     loaded.cleanup()
     assert isfile(status.data_file)
     data_file = status.data_file
@@ -191,3 +192,52 @@ def test_status_09(tmp_path):
     assert found["sig2"] == 1
     assert "sig3" in found
     assert found["sig3"] == 1
+
+def test_status_10(tmp_path):
+    """test Status.measure() and Status.record() - profiling support"""
+    Status.PATH = str(tmp_path)
+    status = Status.start()
+    assert not status._profile
+    # initial entry
+    status.record("test1", 10.1)
+    assert "test1" in status._profile
+    assert status._profile["test1"]["count"] == 1
+    assert status._profile["test1"]["max"] == 10.1
+    assert status._profile["test1"]["min"] == 10.1
+    assert status._profile["test1"]["total"] == 10.1
+    # new min
+    status.record("test1", 0.4)
+    assert status._profile["test1"]["count"] == 2
+    assert status._profile["test1"]["max"] == 10.1
+    assert status._profile["test1"]["min"] == 0.4
+    assert status._profile["test1"]["total"] == 10.5
+    # entry
+    status.record("test1", 2)
+    assert status._profile["test1"]["count"] == 3
+    assert status._profile["test1"]["max"] == 10.1
+    assert status._profile["test1"]["min"] == 0.4
+    assert status._profile["test1"]["total"] == 12.5
+    # new max
+    status.record("test1", 99.12)
+    assert status._profile["test1"]["count"] == 4
+    assert status._profile["test1"]["max"] == 99.12
+    assert status._profile["test1"]["min"] == 0.4
+    assert status._profile["test1"]["total"] == 111.62
+    # new name
+    status.record("test2", 1)
+    assert "test2" in status._profile
+    assert len(status._profile) == 2
+    assert status._profile["test2"]["count"] == 1
+    assert status._profile["test2"]["max"] == 1
+    assert status._profile["test2"]["min"] == 1
+    assert status._profile["test2"]["total"] == 1
+    status.record("test2", 1)
+    assert status._profile["test2"]["count"] == 2
+    assert status._profile["test2"]["max"] == 1
+    assert status._profile["test2"]["min"] == 1
+    assert status._profile["test2"]["total"] == 2
+    # test measure
+    with status.measure("no-op"):
+        pass
+    assert len(status._profile) == 3
+    assert "no-op" in status._profile

From e968fd1af67f08dd87d19d35ae5c0f470a78f7b6 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 22 Jan 2021 17:18:22 -0800
Subject: [PATCH 180/531] Include result signatures in status reports

---
 grizzly/common/status_reporter.py      | 24 +++++++++++++++
 grizzly/common/test_status_reporter.py | 41 ++++++++++++++++++++++++--
 2 files changed, 63 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 70351ae6..c3e84b26 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -5,6 +5,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Manage Grizzly status reports."""
 import argparse
+from collections import defaultdict
 from datetime import timedelta
 from functools import partial
 import logging
@@ -61,6 +62,10 @@ def dump_summary(self, filename, runtime=False, sysinfo=True, timestamp=True):
         with open(filename, "w") as ofp:
             ofp.write(self._summary(runtime=runtime, sysinfo=sysinfo, timestamp=timestamp))
 
+    @property
+    def has_results(self):
+        return any(x.results for x in self.reports)
+
     @classmethod
     def load(cls, tb_path=None):
         """Read Grizzly status reports and create a StatusReporter object
@@ -76,12 +81,27 @@ def load(cls, tb_path=None):
         tracebacks = None if tb_path is None else cls._tracebacks(tb_path)
         return cls(list(Status.loadall()), tracebacks=tracebacks)
 
+    def print_results(self):
+        print(self._results())
+
     def print_specific(self):
         print(self._specific())
 
     def print_summary(self, runtime=True, sysinfo=False, timestamp=False):
         print(self._summary(runtime=runtime, sysinfo=sysinfo, timestamp=timestamp))
 
+    def _results(self):
+        signatures = defaultdict(int)
+        # calculate totals
+        for result in self.reports:
+            for sig, count in result.signatures():
+                signatures[sig] += count
+        # generate output
+        txt = list()
+        for sig, count in sorted(signatures.items(), key=lambda x: x[1], reverse=True):
+            txt.append("%d: %s\n" % (count, sig))
+        return "".join(txt)
+
     @staticmethod
     def _scan(path, fname_pattern):
         abs_path = os.path.abspath(path)
@@ -409,6 +429,10 @@ def main(args=None):
     print("---------------------")
     print("Status report frequency: %ds\n" % (Status.REPORT_FREQ,))
     reporter.print_specific()
+    if reporter.has_results:
+        print("Result Signatures")
+        print("-----------------")
+        reporter.print_results()
     print("Summary")
     print("-------")
     reporter.print_summary(sysinfo=args.system_report)
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index a3532965..36c64bc7 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -19,6 +19,7 @@ def _fake_sys_info():
 def test_status_reporter_01(tmp_path):
     """test basic StatusReporter"""
     st_rpt = StatusReporter(list())
+    assert not st_rpt.has_results
     st_rpt._sys_info = _fake_sys_info
     assert "No status reports available" in st_rpt._specific()
     report = tmp_path / "output.txt"
@@ -178,6 +179,41 @@ def test_status_reporter_06(mocker, tmp_path):
     assert "EXPIRED" in output
 
 def test_status_reporter_07(tmp_path):
+    """test StatusReporter._results()"""
+    Status.PATH = str(tmp_path)
+    # single report without results
+    status = Status.start()
+    status.ignored = 0
+    status.iteration = 1
+    status.log_size = 0
+    status.report(force=True)
+    rptr = StatusReporter.load()
+    assert rptr.reports is not None
+    assert len(rptr.reports) == 1
+    assert not rptr.has_results
+    assert not rptr._results()
+    # multiple reports with results
+    status = Status.start()
+    status.iteration = 1
+    status.count_result("[@ test1]")
+    status.count_result("[@ test2]")
+    status.count_result("[@ test1]")
+    status.report(force=True)
+    status = Status.start()
+    status.iteration = 1
+    status.count_result("[@ test1]")
+    status.count_result("[@ test3]")
+    status.report(force=True)
+    rptr = StatusReporter.load()
+    assert rptr.has_results
+    assert len(rptr.reports) == 3
+    output = rptr._results()
+    assert "3: [@ test1]" in output
+    assert "1: [@ test2]" in output
+    assert "1: [@ test3]" in output
+    assert len(output.split("\n")[:-1]) == 3
+
+def test_status_reporter_08(tmp_path):
     """test StatusReporter.load() with traceback"""
     (tmp_path / "status").mkdir()
     Status.PATH = str(tmp_path / "status")
@@ -217,7 +253,7 @@ def test_status_reporter_07(tmp_path):
     assert "foo.bar.error" in merged_log
     assert "screenlog.3" not in merged_log
 
-def test_status_reporter_08(tmp_path):
+def test_status_reporter_09(tmp_path):
     """test StatusReporter.load() no reports with traceback"""
     (tmp_path / "status").mkdir()
     Status.PATH = str(tmp_path / "status")
@@ -234,7 +270,7 @@ def test_status_reporter_08(tmp_path):
     assert "No status reports available" in output
     assert "IndexError" in output
 
-def test_status_reporter_09(tmp_path):
+def test_status_reporter_10(tmp_path):
     """test StatusReporter.summary() limit with traceback"""
     (tmp_path / "status").mkdir()
     Status.PATH = str(tmp_path / "status")
@@ -440,6 +476,7 @@ def test_main_02(tmp_path):
     StatusReporter.CPU_POLL_INTERVAL = 0.01
     status = Status.start()
     status.iteration = 1
+    status.count_result("[@ test]")
     status.report(force=True)
     assert main([]) == 0
 

From c69c51108364661923b89dafa47b1579cfa78284 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 25 Jan 2021 12:57:01 -0800
Subject: [PATCH 181/531] Add ability to enable profiling and collect entries

---
 grizzly/common/status.py      | 74 +++++++++++++++++++----------
 grizzly/common/test_status.py | 89 ++++++++++++++++++++++-------------
 2 files changed, 104 insertions(+), 59 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index b426022a..36a94a09 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -3,7 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Manage Grizzly status reports."""
-from collections import defaultdict
+from collections import defaultdict, namedtuple
 from contextlib import contextmanager
 from json import dump, load
 from logging import getLogger
@@ -22,6 +22,7 @@
 
 LOG = getLogger(__name__)
 
+ProfileEntry = namedtuple("ProfileEntry", "count max min name total")
 
 class Status:
     """Status holds status information for the Grizzly session.
@@ -31,14 +32,15 @@ class Status:
     REPORT_FREQ = 60
 
     __slots__ = (
-        "_lock", "_profile", "_results", "data_file", "ignored", "iteration",
-        "log_size", "start_time", "test_name", "timestamp")
+        "_enable_profiling", "_lock", "_profiles", "_results", "data_file", "ignored",
+        "iteration", "log_size", "start_time", "test_name", "timestamp")
 
-    def __init__(self, data_file, start_time=None):
+    def __init__(self, data_file, enable_profiling=False, start_time=None):
         assert ".json" in data_file
         assert start_time is None or isinstance(start_time, float)
         self._lock = InterProcessLock("%s.lock" % (data_file,))
-        self._profile = dict()
+        self._enable_profiling = enable_profiling
+        self._profiles = dict()
         self._results = defaultdict(int)
         # if data_file is None the status report is read only (no reporting)
         self.data_file = data_file
@@ -85,7 +87,7 @@ def count_result(self, signature):
     @property
     def _data(self):
         return {
-            "_profile": self._profile,
+            "_profiles": self._profiles,
             "_results": self._results,
             "ignored": self.ignored,
             "iteration": self.iteration,
@@ -176,9 +178,30 @@ def measure(self, name):
         Returns:
             None
         """
-        mark = time()
-        yield
-        self.record(name, time() - mark)
+        if self._enable_profiling:
+            mark = time()
+            yield
+            self.record(name, time() - mark)
+        else:
+            yield
+
+    def profile_entries(self):
+        """
+
+        Args:
+            None
+
+        Yields:
+            ProfileEntry: Contains recoded profiling data.
+        """
+        for name, entry in self._profiles.items():
+            yield ProfileEntry(
+                entry["count"],
+                entry["max"],
+                entry["min"],
+                name,
+                entry["total"],
+            )
 
     @property
     def rate(self):
@@ -206,20 +229,21 @@ def record(self, name, duration):
         """
         assert isinstance(duration, (float, int))
         try:
-            self._profile[name]["count"] += 1
-            if self._profile[name]["max"] < duration:
-                self._profile[name]["max"] = duration
-            elif self._profile[name]["min"] > duration:
-                self._profile[name]["min"] = duration
-            self._profile[name]["total"] += duration
+            self._profiles[name]["count"] += 1
+            if self._profiles[name]["max"] < duration:
+                self._profiles[name]["max"] = duration
+            elif self._profiles[name]["min"] > duration:
+                self._profiles[name]["min"] = duration
+            self._profiles[name]["total"] += duration
         except KeyError:
-            # add profile entry
-            self._profile[name] = {
-                "count": 1,
-                "max": duration,
-                "min": duration,
-                "total": duration,
-            }
+            if self._enable_profiling:
+                # add profile entry
+                self._profiles[name] = {
+                    "count": 1,
+                    "max": duration,
+                    "min": duration,
+                    "total": duration,
+                }
 
     def report(self, force=False, report_freq=REPORT_FREQ):
         """Write status report to disk. Reports are only written periodically.
@@ -269,17 +293,17 @@ def signatures(self):
             yield (sig, count)
 
     @classmethod
-    def start(cls):
+    def start(cls, enable_profiling=False):
         """Create a unique Status object.
 
         Args:
-            None
+            enable_profiling (bool): Record profiling data.
 
         Returns:
             Status: Active status report.
         """
         tfd, filepath = mkstemp(dir=cls.PATH, prefix="grzstatus_", suffix=".json")
         close(tfd)
-        status = cls(filepath, start_time=time())
+        status = cls(filepath, enable_profiling=enable_profiling, start_time=time())
         status.report(force=True)
         return status
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index a1710d9e..86d266eb 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -29,7 +29,8 @@ def test_status_01(tmp_path):
     assert status.log_size == 0
     assert status.rate == 0
     assert status.results == 0
-    assert not status._profile
+    assert not status._enable_profiling
+    assert not status._profiles
 
 def test_status_02(tmp_path):
     """test Status.cleanup()"""
@@ -81,7 +82,7 @@ def test_status_05(tmp_path):
     """test Status.load()"""
     Status.PATH = str(tmp_path)
     # create simple entry
-    status = Status.start()
+    status = Status.start(enable_profiling=True)
     status.count_result("sig1")
     status.record("test", 123.45)
     status.report(force=True)
@@ -95,7 +96,8 @@ def test_status_05(tmp_path):
     assert status.iteration == loaded.iteration
     assert status.log_size == loaded.log_size
     assert status.results == loaded.results
-    assert "test" in loaded._profile
+    assert not loaded._enable_profiling
+    assert "test" in loaded._profiles
     loaded.cleanup()
     assert isfile(status.data_file)
     data_file = status.data_file
@@ -196,48 +198,67 @@ def test_status_09(tmp_path):
 def test_status_10(tmp_path):
     """test Status.measure() and Status.record() - profiling support"""
     Status.PATH = str(tmp_path)
-    status = Status.start()
-    assert not status._profile
+    # profiling disabled
+    status = Status.start(enable_profiling=False)
+    status.record("x", 10.1)
+    assert not status._profiles
+    with status.measure("x"):
+        pass
+    assert not status._profiles
+    status.cleanup()
+    # profiling enabled
+    status = Status.start(enable_profiling=True)
+    assert not status._profiles
     # initial entry
     status.record("test1", 10.1)
-    assert "test1" in status._profile
-    assert status._profile["test1"]["count"] == 1
-    assert status._profile["test1"]["max"] == 10.1
-    assert status._profile["test1"]["min"] == 10.1
-    assert status._profile["test1"]["total"] == 10.1
+    assert "test1" in status._profiles
+    assert status._profiles["test1"]["count"] == 1
+    assert status._profiles["test1"]["max"] == 10.1
+    assert status._profiles["test1"]["min"] == 10.1
+    assert status._profiles["test1"]["total"] == 10.1
+    entry = next(status.profile_entries())
+    assert entry.name == "test1"
+    assert entry.count == 1
+    assert entry.max == 10.1
+    assert entry.min == 10.1
+    assert entry.total == 10.1
     # new min
     status.record("test1", 0.4)
-    assert status._profile["test1"]["count"] == 2
-    assert status._profile["test1"]["max"] == 10.1
-    assert status._profile["test1"]["min"] == 0.4
-    assert status._profile["test1"]["total"] == 10.5
+    entry = next(status.profile_entries())
+    assert entry.count == 2
+    assert entry.max == 10.1
+    assert entry.min == 0.4
+    assert entry.total == 10.5
     # entry
     status.record("test1", 2)
-    assert status._profile["test1"]["count"] == 3
-    assert status._profile["test1"]["max"] == 10.1
-    assert status._profile["test1"]["min"] == 0.4
-    assert status._profile["test1"]["total"] == 12.5
+    entry = next(status.profile_entries())
+    assert entry.count == 3
+    assert entry.max == 10.1
+    assert entry.min == 0.4
+    assert entry.total == 12.5
     # new max
     status.record("test1", 99.12)
-    assert status._profile["test1"]["count"] == 4
-    assert status._profile["test1"]["max"] == 99.12
-    assert status._profile["test1"]["min"] == 0.4
-    assert status._profile["test1"]["total"] == 111.62
+    entry = next(status.profile_entries())
+    assert entry.count == 4
+    assert entry.max == 99.12
+    assert entry.min == 0.4
+    assert entry.total == 111.62
     # new name
     status.record("test2", 1)
-    assert "test2" in status._profile
-    assert len(status._profile) == 2
-    assert status._profile["test2"]["count"] == 1
-    assert status._profile["test2"]["max"] == 1
-    assert status._profile["test2"]["min"] == 1
-    assert status._profile["test2"]["total"] == 1
+    assert "test2" in status._profiles
+    assert len(status._profiles) == 2
+    assert status._profiles["test2"]["count"] == 1
+    assert status._profiles["test2"]["max"] == 1
+    assert status._profiles["test2"]["min"] == 1
+    assert status._profiles["test2"]["total"] == 1
     status.record("test2", 1)
-    assert status._profile["test2"]["count"] == 2
-    assert status._profile["test2"]["max"] == 1
-    assert status._profile["test2"]["min"] == 1
-    assert status._profile["test2"]["total"] == 2
+    assert status._profiles["test2"]["count"] == 2
+    assert status._profiles["test2"]["max"] == 1
+    assert status._profiles["test2"]["min"] == 1
+    assert status._profiles["test2"]["total"] == 2
     # test measure
     with status.measure("no-op"):
         pass
-    assert len(status._profile) == 3
-    assert "no-op" in status._profile
+    assert len(status._profiles) == 3
+    assert "no-op" in status._profiles
+    assert len(tuple(status.profile_entries())) == 3

From 41d07c7a2b45018897c61eb92d14fa50ab75c373 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 25 Jan 2021 17:11:31 -0800
Subject: [PATCH 182/531] Include profile data in reports

---
 grizzly/common/status_reporter.py      | 33 ++++++++++++++++++--------
 grizzly/common/test_status_reporter.py | 24 ++++++++++++-------
 2 files changed, 39 insertions(+), 18 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index c3e84b26..cb64cc28 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -11,7 +11,7 @@
 import logging
 import os
 import re
-import time
+from time import gmtime, strftime, time
 
 import psutil
 
@@ -99,7 +99,7 @@ def _results(self):
         # generate output
         txt = list()
         for sig, count in sorted(signatures.items(), key=lambda x: x[1], reverse=True):
-            txt.append("%d: %s\n" % (count, sig))
+            txt.append("%d: %r\n" % (count, sig))
         return "".join(txt)
 
     @staticmethod
@@ -125,7 +125,7 @@ def _specific(self):
         """
         if not self.reports:
             return "No status reports available"
-        exp = int(time.time()) - self.EXP_LIMIT
+        exp = int(time()) - self.EXP_LIMIT
         self.reports.sort(key=lambda x: x.duration, reverse=True)
         self.reports.sort(key=lambda x: x.timestamp < exp)
         txt = list()
@@ -134,12 +134,25 @@ def _specific(self):
             if report.timestamp < exp:
                 txt.append(" (EXPIRED)\n")
                 continue
-            txt.append(" Runtime %s\n" % str(timedelta(seconds=int(report.duration))))
-            txt.append(" * Iterations: %03d" % report.iteration)
-            txt.append(" - Rate: %0.2f" % report.rate)
-            txt.append(" - Ignored: %02d" % report.ignored)
-            txt.append(" - Results: %d" % report.results)
+            txt.append(" Runtime %s\n" % (timedelta(seconds=int(report.duration)),))
+            txt.append(" * Iterations: %03d" % (report.iteration,))
+            txt.append(" @ %0.2f" % (round(report.rate, 2),))
+            txt.append(" - Ignored: %02d" % (report.ignored,))
+            txt.append(" - Results: %d" % (report.results,))
             txt.append("\n")
+            # add profiling data if it exists
+            for entry in sorted(report.profile_entries(), key=lambda x: x.total, reverse=True):
+                avg = entry.total / float(entry.count)
+                txt.append(" * Profile %r: " % (entry.name,))
+                if entry.total > 300:
+                    txt.append(str(timedelta(seconds=int(entry.total))))
+                else:
+                    txt.append("%0.3fs" % (round(entry.total, 3),))
+                txt.append(" (%0.2f%%) " % (round(entry.total / report.duration * 100.0, 2),))
+                txt.append("%d @ %0.3f avg " % (entry.count, round(avg, 3)))
+                txt.append("(%0.3f, %0.3f)" % (round(entry.max, 3), round(entry.min, 3)))
+                txt.append("\n")
+
         return "".join(txt)
 
     def _summary(self, runtime=True, sysinfo=False, timestamp=False):
@@ -156,7 +169,7 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
         """
         txt = list()
         # Job specific status
-        exp = int(time.time()) - self.EXP_LIMIT
+        exp = int(time()) - self.EXP_LIMIT
         reports = tuple(x for x in self.reports if x.timestamp > exp)
         if reports:
             # calculate totals
@@ -203,7 +216,7 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
             txt.append(self._sys_info())
         if timestamp:
             txt.append("\n")
-            txt.append(time.strftime(" Timestamp : %Y/%m/%d %X %z", time.gmtime()))
+            txt.append(strftime(" Timestamp : %Y/%m/%d %X %z", gmtime()))
         msg = "".join(txt)
         if self.tracebacks:
             txt = self._merge_tracebacks(self.tracebacks, self.SUMMARY_LIMIT - len(msg))
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 36c64bc7..1f15ff05 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -5,6 +5,7 @@
 """test Grizzly status reporter"""
 # pylint: disable=protected-access
 
+from itertools import count
 import re
 
 import pytest
@@ -136,7 +137,9 @@ def test_status_reporter_05(tmp_path):
 def test_status_reporter_06(mocker, tmp_path):
     """test StatusReporter._specific()"""
     Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.common.status_reporter.time", return_value=3661.0)
     # single report
+    mocker.patch("grizzly.common.status.time", side_effect=count(start=0.0, step=3600.0))
     status = Status.start()
     status.ignored = 0
     status.iteration = 1
@@ -148,23 +151,28 @@ def test_status_reporter_06(mocker, tmp_path):
     assert len(output.split("\n")[:-1]) == 2
     assert "Ignored" in output
     assert "Iteration" in output
-    assert "Rate" in output
     assert "Results" in output
     assert "EXPIRED" not in output
     # multiple reports
-    status = Status.start()
+    mocker.patch("grizzly.common.status.time", side_effect=count(start=0.0, step=3661.0))
+    status = Status.start(enable_profiling=True)
     status.ignored = 1
     status.iteration = 432422
     status._results = {"sig": 123}
+    status.record("test1", 0.91)
+    status.record("test1", 1.0)
+    status.record("test1", 1.23456)
+    status.record("test2", 1201.1)
     status.report(force=True)
     rptr = StatusReporter.load()
     assert len(rptr.reports) == 2
     output = rptr._specific()
-    assert len(output.split("\n")[:-1]) == 4
+    assert len(output.split("\n")[:-1]) == 6
     assert "Ignored" in output
     assert "Iteration" in output
-    assert "Rate" in output
     assert "Results" in output
+    assert "Profile 'test1'" in output
+    assert "Profile 'test2'" in output
     assert "EXPIRED" not in output
     # expired report
     mocker.patch("grizzly.common.status.time", return_value=1.0)
@@ -175,7 +183,7 @@ def test_status_reporter_06(mocker, tmp_path):
     rptr = StatusReporter.load()
     assert len(rptr.reports) == 3
     output = rptr._specific()
-    assert len(output.split("\n")[:-1]) == 5
+    assert len(output.split("\n")[:-1]) == 7
     assert "EXPIRED" in output
 
 def test_status_reporter_07(tmp_path):
@@ -208,9 +216,9 @@ def test_status_reporter_07(tmp_path):
     assert rptr.has_results
     assert len(rptr.reports) == 3
     output = rptr._results()
-    assert "3: [@ test1]" in output
-    assert "1: [@ test2]" in output
-    assert "1: [@ test3]" in output
+    assert "3: '[@ test1]'" in output
+    assert "1: '[@ test2]'" in output
+    assert "1: '[@ test3]'" in output
     assert len(output.split("\n")[:-1]) == 3
 
 def test_status_reporter_08(tmp_path):

From cec674cf0493c81fd90f1b7ad59ec8b206bc4de8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 25 Jan 2021 17:48:52 -0800
Subject: [PATCH 183/531] Add PID to status report entries

---
 grizzly/common/status.py          | 11 +++++++----
 grizzly/common/status_reporter.py |  2 +-
 grizzly/common/test_status.py     |  2 ++
 3 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 36a94a09..da90365e 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -7,7 +7,7 @@
 from contextlib import contextmanager
 from json import dump, load
 from logging import getLogger
-from os import close, listdir, unlink
+from os import close, getpid, listdir, unlink
 from os.path import isdir, isfile, join as pathjoin
 from tempfile import mkstemp
 from time import time
@@ -33,7 +33,7 @@ class Status:
 
     __slots__ = (
         "_enable_profiling", "_lock", "_profiles", "_results", "data_file", "ignored",
-        "iteration", "log_size", "start_time", "test_name", "timestamp")
+        "iteration", "log_size", "pid", "start_time", "test_name", "timestamp")
 
     def __init__(self, data_file, enable_profiling=False, start_time=None):
         assert ".json" in data_file
@@ -47,6 +47,7 @@ def __init__(self, data_file, enable_profiling=False, start_time=None):
         self.ignored = 0
         self.iteration = 0
         self.log_size = 0
+        self.pid = None
         self.start_time = start_time
         self.test_name = None
         self.timestamp = start_time
@@ -92,6 +93,7 @@ def _data(self):
             "ignored": self.ignored,
             "iteration": self.iteration,
             "log_size": self.log_size,
+            "pid": self.pid,
             "start_time": self.start_time,
             "test_name": self.test_name,
             "timestamp": self.timestamp}
@@ -186,13 +188,13 @@ def measure(self, name):
             yield
 
     def profile_entries(self):
-        """
+        """Used to retrieve profiling data.
 
         Args:
             None
 
         Yields:
-            ProfileEntry: Contains recoded profiling data.
+            ProfileEntry: Containing recorded profiling data.
         """
         for name, entry in self._profiles.items():
             yield ProfileEntry(
@@ -305,5 +307,6 @@ def start(cls, enable_profiling=False):
         tfd, filepath = mkstemp(dir=cls.PATH, prefix="grzstatus_", suffix=".json")
         close(tfd)
         status = cls(filepath, enable_profiling=enable_profiling, start_time=time())
+        status.pid = getpid()
         status.report(force=True)
         return status
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index cb64cc28..7a6f4fe5 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -130,7 +130,7 @@ def _specific(self):
         self.reports.sort(key=lambda x: x.timestamp < exp)
         txt = list()
         for num, report in enumerate(self.reports, start=1):
-            txt.append("#%02d" % (num,))
+            txt.append("#%02d - %d -" % (num, report.pid))
             if report.timestamp < exp:
                 txt.append(" (EXPIRED)\n")
                 continue
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 86d266eb..cf1af9c6 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -29,6 +29,7 @@ def test_status_01(tmp_path):
     assert status.log_size == 0
     assert status.rate == 0
     assert status.results == 0
+    assert status.pid is not None
     assert not status._enable_profiling
     assert not status._profiles
 
@@ -95,6 +96,7 @@ def test_status_05(tmp_path):
     assert status.ignored == loaded.ignored
     assert status.iteration == loaded.iteration
     assert status.log_size == loaded.log_size
+    assert status.pid == loaded.pid
     assert status.results == loaded.results
     assert not loaded._enable_profiling
     assert "test" in loaded._profiles

From 59149898643f96072f1ef2dcdb0baef28fb0e523 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 25 Jan 2021 18:02:24 -0800
Subject: [PATCH 184/531] Use round() when creating reports

---
 grizzly/common/status_reporter.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 7a6f4fe5..5d1046dd 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -135,10 +135,10 @@ def _specific(self):
                 txt.append(" (EXPIRED)\n")
                 continue
             txt.append(" Runtime %s\n" % (timedelta(seconds=int(report.duration)),))
-            txt.append(" * Iterations: %03d" % (report.iteration,))
-            txt.append(" @ %0.2f" % (round(report.rate, 2),))
-            txt.append(" - Ignored: %02d" % (report.ignored,))
-            txt.append(" - Results: %d" % (report.results,))
+            txt.append(" * Iterations: %d" % (report.iteration,))
+            txt.append(" @ %0.2f," % (round(report.rate, 2),))
+            txt.append(" Ignored: %d," % (report.ignored,))
+            txt.append(" Results: %d" % (report.results,))
             txt.append("\n")
             # add profiling data if it exists
             for entry in sorted(report.profile_entries(), key=lambda x: x.total, reverse=True):
@@ -183,23 +183,23 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
             # Iterations
             txt.append("Iterations : %d" % (total_iters,))
             if count > 1:
-                txt.append(" (%s, %s)" % (max(iterations), min(iterations)))
+                txt.append(" (%d, %d)" % (max(iterations), min(iterations)))
             txt.append("\n")
             # Rate
-            txt.append("      Rate : %d @ %0.2f" % (count, sum(rates)))
+            txt.append("      Rate : %d @ %0.2f" % (count, round(sum(rates), 2)))
             if count > 1:
-                txt.append(" (%0.2f, %0.2f)" % (max(rates), min(rates)))
+                txt.append(" (%0.2f, %0.2f)" % (round(max(rates), 2), round(min(rates), 2)))
             txt.append("\n")
             # Results / Signature mismatch
             txt.append("   Results : %d" % (sum(results),))
             if total_ignored:
-                ignore_pct = (total_ignored / float(total_iters)) * 100
-                txt.append(" (%d ignored @ %0.2f%%)" % (total_ignored, ignore_pct))
+                ignore_pct = total_ignored / float(total_iters) * 100
+                txt.append(" (%d ignored @ %0.2f%%)" % (total_ignored, round(ignore_pct, 2)))
             # Runtime
             if runtime:
                 txt.append("\n")
                 total_runtime = sum(x.duration for x in reports)
-                txt.append("   Runtime : %s" % (str(timedelta(seconds=int(total_runtime))),))
+                txt.append("   Runtime : %s" % (timedelta(seconds=int(total_runtime)),))
             # Log size
             log_usage = sum(log_sizes) / 1048576.0
             if log_usage > self.DISPLAY_LIMIT_LOG:

From e4164468c16f51e9617840edf8afde15231e2c5b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 25 Jan 2021 18:13:39 -0800
Subject: [PATCH 185/531] Update status report profile formatting

---
 grizzly/common/status_reporter.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 5d1046dd..0a77777f 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -148,9 +148,11 @@ def _specific(self):
                     txt.append(str(timedelta(seconds=int(entry.total))))
                 else:
                     txt.append("%0.3fs" % (round(entry.total, 3),))
-                txt.append(" (%0.2f%%) " % (round(entry.total / report.duration * 100.0, 2),))
-                txt.append("%d @ %0.3f avg " % (entry.count, round(avg, 3)))
-                txt.append("(%0.3f, %0.3f)" % (round(entry.max, 3), round(entry.min, 3)))
+                txt.append(" (%0.2f%%)" % (round(entry.total / report.duration * 100, 2),))
+                txt.append(" - %d" % (entry.count,))
+                txt.append(" (%0.3f avg," % (round(avg, 3),))
+                txt.append(" %0.3f max," % (round(entry.max, 3),))
+                txt.append(" %0.3f min)" % (round(entry.min, 3),))
                 txt.append("\n")
 
         return "".join(txt)

From c5222442001df5d7c94a31bba2cd3810b02383f3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 25 Jan 2021 18:56:32 -0800
Subject: [PATCH 186/531] Add --enable-profiling

---
 grizzly/args.py         |  4 ++++
 grizzly/main.py         |  5 +++--
 grizzly/session.py      | 17 ++++++++++++-----
 grizzly/test_main.py    |  1 +
 grizzly/test_session.py |  3 ++-
 5 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index ed4b1aeb..cc1b85f4 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -174,6 +174,10 @@ def __init__(self):
         self.parser.add_argument(
             "adapter",
             help="Available adapters: %s" % ", ".join(self._adapters))
+        self.parser.add_argument(
+            "--enable-profiling", action="store_true",
+            help="Record profiling data. The data can be viewed by running the"
+                 " status reporter while running Grizzly.")
         self.parser.add_argument(
             "-i", "--input",
             help="Test case or directory containing test cases")
diff --git a/grizzly/main.py b/grizzly/main.py
index 7f9b2ef0..f40850f5 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -4,7 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import basicConfig, DEBUG, getLogger
 from os.path import join as pathjoin
-from os import getcwd, getenv
+from os import getcwd, getenv, getpid
 
 from sapphire import Sapphire
 
@@ -35,7 +35,7 @@ def configure_logging(log_level):
 
 def main(args):
     configure_logging(args.log_level)
-    LOG.info("Starting Grizzly")
+    LOG.info("Starting Grizzly (%d)", getpid())
     if args.fuzzmanager:
         FuzzManagerReporter.sanity_check(args.binary)
     elif args.s3_fuzzmanager:
@@ -125,6 +125,7 @@ def main(args):
                 server,
                 target,
                 coverage=args.coverage,
+                enable_profiling=args.enable_profiling,
                 relaunch=relaunch)
             if args.log_level == DEBUG or args.verbose:
                 display_mode = Session.DISPLAY_VERBOSE
diff --git a/grizzly/session.py b/grizzly/session.py
index d170fc88..ae64ed71 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -69,14 +69,14 @@ class Session:
                  "status", "target")
 
     def __init__(self, adapter, iomanager, reporter, server, target,
-                 coverage=False, relaunch=1):
+                 coverage=False, enable_profiling=True, relaunch=1):
         self._relaunch = relaunch
         self.adapter = adapter
         self.coverage = coverage
         self.iomanager = iomanager
         self.reporter = reporter
         self.server = server
-        self.status = Status.start()
+        self.status = Status.start(enable_profiling=enable_profiling)
         self.target = target
 
     def __enter__(self):
@@ -103,7 +103,8 @@ def generate_testcase(self):
         LOG.debug("calling iomanager.create_testcase()")
         test = self.iomanager.create_testcase(self.adapter.NAME)
         LOG.debug("calling self.adapter.generate()")
-        self.adapter.generate(test, self.iomanager.server_map)
+        with self.status.measure("generate"):
+            self.adapter.generate(test, self.iomanager.server_map)
         self.status.test_name = test.input_fname
         if self.target.prefs is not None:
             # TODO: this can likely be improved
@@ -153,7 +154,8 @@ def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
                         self.server.port,
                         close_after=relaunch,
                         timeout=self.adapter.TEST_DURATION)
-                runner.launch(location, max_retries=3, retry_delay=0)
+                with self.status.measure("launch"):
+                    runner.launch(location, max_retries=3, retry_delay=0)
 
             # create and populate a test case
             current_test = self.generate_testcase()
@@ -161,7 +163,12 @@ def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
             self.display_status(log_limiter=log_limiter)
 
             # run test case
-            result = runner.run(ignore, self.iomanager.server_map, current_test, coverage=self.coverage)
+            with self.status.measure("execute"):
+                result = runner.run(
+                    ignore,
+                    self.iomanager.server_map,
+                    current_test,
+                    coverage=self.coverage)
             current_test.duration = result.duration
             # adapter callbacks
             if result.timeout:
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 27fd9863..31cf5345 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -17,6 +17,7 @@ def __init__(self):
         self.adapter = None
         self.cache = 0
         self.coverage = False
+        self.enable_profiling = False
         self.extension = None
         self.fuzzmanager = False
         self.ignore = list()
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index afa3437b..e77f25a6 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -80,7 +80,8 @@ def generate(self, testcase, server_map):
     with IOManager() as iomgr:
         iomgr.harness = adapter.get_harness()
         fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
-        with Session(adapter, iomgr, None, fake_serv, fake_target, relaunch=10) as session:
+        # enable profiling for test coverage
+        with Session(adapter, iomgr, None, fake_serv, fake_target, enable_profiling=True, relaunch=10) as session:
             session.run([], iteration_limit=10)
             assert session.status.iteration == 10
             assert session.status.test_name is None

From 9c4b30166e97d177d3a00f144647512c50c9e428 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 27 Jan 2021 17:29:09 -0800
Subject: [PATCH 187/531] Update status report formatting

---
 grizzly/common/status_reporter.py      | 28 +++++++++++++-------------
 grizzly/common/test_status_reporter.py | 15 +++++++-------
 2 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 0a77777f..3df3d2ed 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -90,7 +90,7 @@ def print_specific(self):
     def print_summary(self, runtime=True, sysinfo=False, timestamp=False):
         print(self._summary(runtime=runtime, sysinfo=sysinfo, timestamp=timestamp))
 
-    def _results(self):
+    def _results(self, max_len=85):
         signatures = defaultdict(int)
         # calculate totals
         for result in self.reports:
@@ -99,7 +99,10 @@ def _results(self):
         # generate output
         txt = list()
         for sig, count in sorted(signatures.items(), key=lambda x: x[1], reverse=True):
-            txt.append("%d: %r\n" % (count, sig))
+            if len(sig) > max_len:
+                txt.append("%d: '%s...'\n" % (count, sig[:max_len]))
+            else:
+                txt.append("%d: %r\n" % (count, sig))
         return "".join(txt)
 
     @staticmethod
@@ -141,20 +144,20 @@ def _specific(self):
             txt.append(" Results: %d" % (report.results,))
             txt.append("\n")
             # add profiling data if it exists
+            if any(report.profile_entries()):
+                txt.append(" * Profiling entries *\n")
             for entry in sorted(report.profile_entries(), key=lambda x: x.total, reverse=True):
                 avg = entry.total / float(entry.count)
-                txt.append(" * Profile %r: " % (entry.name,))
+                txt.append(" > %s: %dx " % (entry.name, entry.count))
                 if entry.total > 300:
                     txt.append(str(timedelta(seconds=int(entry.total))))
                 else:
                     txt.append("%0.3fs" % (round(entry.total, 3),))
-                txt.append(" (%0.2f%%)" % (round(entry.total / report.duration * 100, 2),))
-                txt.append(" - %d" % (entry.count,))
+                txt.append(" %0.2f%%" % (round(entry.total / report.duration * 100, 2),))
                 txt.append(" (%0.3f avg," % (round(avg, 3),))
                 txt.append(" %0.3f max," % (round(entry.max, 3),))
                 txt.append(" %0.3f min)" % (round(entry.min, 3),))
                 txt.append("\n")
-
         return "".join(txt)
 
     def _summary(self, runtime=True, sysinfo=False, timestamp=False):
@@ -438,18 +441,15 @@ def main(args=None):
         reporter.dump_summary(args.dump)
         return 0
     if not reporter.reports:
-        print("No status reports to display")
+        print("Grizzly Status - No status reports to display")
         return 0
-    print("Grizzly Status Report")
-    print("---------------------")
-    print("Status report frequency: %ds\n" % (Status.REPORT_FREQ,))
+    print("Grizzly Status - Instance report frequency: %ds\n" % (Status.REPORT_FREQ,))
+    print("[Reports]")
     reporter.print_specific()
     if reporter.has_results:
-        print("Result Signatures")
-        print("-----------------")
+        print("[Result Signatures]")
         reporter.print_results()
-    print("Summary")
-    print("-------")
+    print("[Summary]")
     reporter.print_summary(sysinfo=args.system_report)
     return 0
 
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 1f15ff05..956884b1 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -167,12 +167,13 @@ def test_status_reporter_06(mocker, tmp_path):
     rptr = StatusReporter.load()
     assert len(rptr.reports) == 2
     output = rptr._specific()
-    assert len(output.split("\n")[:-1]) == 6
+    assert len(output.split("\n")[:-1]) == 7
     assert "Ignored" in output
     assert "Iteration" in output
     assert "Results" in output
-    assert "Profile 'test1'" in output
-    assert "Profile 'test2'" in output
+    assert "Profiling entries" in output
+    assert "> test1:" in output
+    assert "> test2:" in output
     assert "EXPIRED" not in output
     # expired report
     mocker.patch("grizzly.common.status.time", return_value=1.0)
@@ -183,7 +184,7 @@ def test_status_reporter_06(mocker, tmp_path):
     rptr = StatusReporter.load()
     assert len(rptr.reports) == 3
     output = rptr._specific()
-    assert len(output.split("\n")[:-1]) == 7
+    assert len(output.split("\n")[:-1]) == 8
     assert "EXPIRED" in output
 
 def test_status_reporter_07(tmp_path):
@@ -210,15 +211,15 @@ def test_status_reporter_07(tmp_path):
     status = Status.start()
     status.iteration = 1
     status.count_result("[@ test1]")
-    status.count_result("[@ test3]")
+    status.count_result("[@ longsignature123]")
     status.report(force=True)
     rptr = StatusReporter.load()
     assert rptr.has_results
     assert len(rptr.reports) == 3
-    output = rptr._results()
+    output = rptr._results(max_len=16)
     assert "3: '[@ test1]'" in output
     assert "1: '[@ test2]'" in output
-    assert "1: '[@ test3]'" in output
+    assert "1: '[@ longsignature...'" in output
     assert len(output.split("\n")[:-1]) == 3
 
 def test_status_reporter_08(tmp_path):

From e40a329da4e4fe24e4f17292bda03987aea7ceb0 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 28 Jan 2021 16:24:20 -0800
Subject: [PATCH 188/531] [sapphire] Fix some comments

---
 sapphire/core.py | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/sapphire/core.py b/sapphire/core.py
index bd4be651..1eaa8734 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -46,13 +46,13 @@ def __exit__(self, *exc):
     def _create_listening_socket(cls, remote, port=None, retries=20):
         """Create listening socket. Search for an open socket if needed and
         and configure the socket. If a specific port is unavailable or no
-        available ports can be found a socket.error will be raised.
+        available ports can be found socket.error will be raised.
 
         Args:
             remote (bool): Accept all (non-local) incoming connections.
             port (int): Port to listen on. If None is given a random port will
                         be used.
-            retries (int): Number of attempts to the socket.
+            retries (int): Number of attempts to configure the socket.
 
         Returns:
             socket: A listening socket.
@@ -137,16 +137,17 @@ def serve_path(self, path, continue_cb=None, forever=False, optional_files=None,
             - SERVED_REQUEST: Some files were requested
 
         Args:
-            path (str): Directory to use a wwwroot.
-            continue_cb (str): A callback that can be used to exit the serve loop.
-                               This should a function that returns a bool.
+            path (str): Directory to use as wwwroot.
+            continue_cb (callable): A callback that can be used to exit the serve loop.
+                                    This must be a callable that returns a bool.
             forever (bool): Continue to handle requests even after all files have
                             been served. This is meant to be used with continue_cb.
-            optional_files (list): Files that do not need to be served in order
-                                   to exit the serve loop.
+            optional_files (list(str)): Files that do not need to be served in order
+                                        to exit the serve loop.
             server_map (ServerMap):
+
         Returns:
-            tuple: Files served and status code
+            tuple(int, tuple(str)): Status code and files served.
         """
         LOG.debug("serving %r (forever=%r)", path, forever)
         job = Job(
@@ -166,7 +167,7 @@ def serve_path(self, path, continue_cb=None, forever=False, optional_files=None,
 
     @property
     def timeout(self):
-        """The amount of time that must pass before exit the serve loop and
+        """The amount of time that must pass before exiting the serve loop and
         indicating a timeout.
 
         Args:
@@ -179,7 +180,7 @@ def timeout(self):
 
     @timeout.setter
     def timeout(self, value):
-        """The amount of time that must pass before exit the serve loop and
+        """The amount of time that must pass before exiting the serve loop and
         indicating a timeout.
 
         Args:

From a3e05699fd788106d3e128d436b62064bb263b67 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 28 Jan 2021 16:50:29 -0800
Subject: [PATCH 189/531] Update some formatting and comments

---
 grizzly/common/runner.py | 41 ++++++++++++++++++++++++++++++++++------
 1 file changed, 35 insertions(+), 6 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index e4cebcf5..c78551c0 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -74,9 +74,18 @@ def schedule_poll(self, initial=False, now=None):
 
 
 class Runner:
-    __slots__ = ("_close_delay", "_idle", "_relaunch", "_server", "_target", "_tests_run")
+    __slots__ = (
+        "_close_delay",
+        "_idle",
+        "_relaunch",
+        "_server",
+        "_target",
+        "_tests_run",
+    )
 
-    def __init__(self, server, target, close_delay=30, idle_threshold=0, idle_delay=0, relaunch=1):
+    def __init__(
+        self, server, target, close_delay=30, idle_threshold=0, idle_delay=0, relaunch=1
+    ):
         self._close_delay = close_delay
         if idle_threshold > 0:
             assert idle_delay > 0
@@ -159,7 +168,15 @@ def location(srv_path, srv_port, close_after=None, timeout=None):
             return "?".join([location, "&".join(args)])
         return location
 
-    def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait_for_callback=False):
+    def run(
+        self,
+        ignore,
+        server_map,
+        testcase,
+        test_path=None,
+        coverage=False,
+        wait_for_callback=False,
+    ):
         """Serve a testcase and monitor the target for results.
 
         Args:
@@ -194,7 +211,8 @@ def run(self, ignore, server_map, testcase, test_path=None, coverage=False, wait
                 continue_cb=self._keep_waiting,
                 forever=wait_for_callback,
                 optional_files=tuple(testcase.optional),
-                server_map=server_map)
+                server_map=server_map,
+            )
             duration = time() - serve_start
         finally:
             # remove temporary files
@@ -267,15 +285,26 @@ def _keep_waiting(self):
 
 
 class RunResult:
+    """A RunResult holds result details from a call to Runner.run().
+
+    Attributes:
+        attempted (bool): Test landing page (entry point) was requested.
+        duration (float): Time spent waiting for test contents to be served.
+        initial (bool): Target was (re)launched prior to run attempt.
+        served (tuple(str)): Files that were served.
+        status (int): Result status of test.
+        timeout (bool): A timeout occurred waiting for test to complete.
+    """
+
     FAILED = 1
     IGNORED = 2
 
     __slots__ = ("attempted", "duration", "initial", "served", "status", "timeout")
 
     def __init__(self, served, duration, status=None, timeout=False):
-        self.attempted = False  # entry point/landing page was requested
+        self.attempted = False
         self.duration = duration
-        self.initial = False  # target was (re)launched prior to attempt
+        self.initial = False
         self.served = served
         self.status = status
         self.timeout = timeout

From cbc63559fac0ae87e631265a68b677d0d34b0329 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 28 Jan 2021 16:54:44 -0800
Subject: [PATCH 190/531] Report delayed startup crashes

* Also only raise when it happens early on
---
 grizzly/session.py      | 22 ++++++++++++-------
 grizzly/test_session.py | 48 +++++++++++++++++++++++++++++++++++------
 2 files changed, 55 insertions(+), 15 deletions(-)

diff --git a/grizzly/session.py b/grizzly/session.py
index ae64ed71..827ff1c6 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -179,19 +179,25 @@ def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
                 self.adapter.on_served(current_test, result.served)
             # update test case
             if not result.attempted:
-                LOG.debug("Ignoring test case since nothing was served")
+                LOG.warning("Test case was not served")
+                LOG.debug("ignoring test case since nothing was served")
                 self.iomanager.tests.pop().cleanup()
                 if not current_test.contains(current_test.landing_page):
-                    LOG.warning("Test case is missing landing page")
+                    raise SessionError("Test case is missing landing page")
                 if result.initial:
                     # since this is the first iteration since the Target launched
                     # something is likely wrong with the Target or Adapter
-                    err_logs = mkdtemp(prefix="error_", dir=grz_tmp("logs"))
-                    self.target.save_logs(err_logs)
-                    LOG.error("ERROR: Test case was not served. Timeout too short?")
-                    LOG.error("Logs can be found here %r", err_logs)
-                    raise SessionError("Please check Adapter and Target")
-                LOG.warning("Test case was not served")
+                    if result.status == RunResult.FAILED:
+                        LOG.warning("Delayed startup failure detected")
+                        self.report_result()
+                    else:
+                        LOG.warning("Timeout too short? System too busy?")
+                        err_logs = mkdtemp(prefix="error_", dir=grz_tmp("logs"))
+                        self.target.save_logs(err_logs)
+                        LOG.error("Logs can be found here %r", err_logs)
+                    # only raise if this is a potential blocker
+                    if self.status.iteration < 100:
+                        raise SessionError("Please check Adapter and Target")
             elif self.adapter.IGNORE_UNSERVED:
                 LOG.debug("removing unserved files from the test case")
                 current_test.purge_optional(result.served)
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index e77f25a6..3c13b274 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -100,7 +100,7 @@ def generate(self, testcase, server_map):
     adapter = FuzzAdapter()
     adapter.setup(None, None)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target, prefs=None, )
+    fake_target = mocker.Mock(spec=Target, prefs=None)
     fake_target.log_size.return_value = 1000
     fake_target.monitor.launches = 1
     # target.launch() call will be skipped
@@ -129,7 +129,7 @@ def generate(self, testcase, server_map):
     with IOManager() as iomgr:
         fake_serv.serve_path.return_value = (SERVED_NONE, [])
         with Session(adapter, iomgr, None, fake_serv, fake_target, relaunch=10) as session:
-            with raises(SessionError, match="Please check Adapter and Target"):
+            with raises(SessionError, match="Test case is missing landing page"):
                 session.run([], iteration_limit=10)
 
 def test_session_05(tmp_path, mocker):
@@ -182,14 +182,10 @@ def test_session_06(tmp_path, mocker):
         assert testcase.add_meta.call_count == 1
 
 def test_session_07(tmp_path, mocker):
-    """test Session.run() - test case was not served - between iterations"""
+    """test Session.run() - test case was not served"""
     Status.PATH = str(tmp_path)
     mocker.patch("grizzly.session.Report", autospec=True)
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
-    run_result = RunResult(["/fake/file"], 1, status=RunResult.FAILED)
-    run_result.attempted = False
-    run_result.initial = False
-    fake_runner.return_value.run.return_value = run_result
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
     fake_adapter.TEST_DURATION = 10
@@ -200,6 +196,11 @@ def test_session_07(tmp_path, mocker):
     fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
     fake_target.monitor.launches = 1
     fake_reporter = mocker.Mock(spec=Reporter)
+    # between iterations
+    run_result = RunResult([], 1, status=RunResult.FAILED)
+    run_result.attempted = False
+    run_result.initial = False
+    fake_runner.return_value.run.return_value = run_result
     with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
         session.run([], iteration_limit=1)
         assert fake_runner.return_value.run.call_count == 1
@@ -212,6 +213,39 @@ def test_session_07(tmp_path, mocker):
         assert session.status.ignored == 0
         assert fake_reporter.submit.call_count == 1
         assert fake_iomgr.tests.pop.call_count == 1
+    fake_reporter.reset_mock()
+    fake_runner.reset_mock()
+    # delayed startup crash
+    run_result = RunResult([], 1, status=RunResult.FAILED)
+    run_result.attempted = False
+    run_result.initial = True
+    fake_runner.return_value.run.return_value = run_result
+    with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
+        with raises(SessionError, match="Please check Adapter and Target"):
+            session.run([], iteration_limit=1)
+        assert fake_runner.return_value.run.call_count == 1
+        assert fake_runner.return_value.launch.call_count == 1
+        assert session.status.iteration == 1
+        assert session.status.results == 1
+        assert session.status.ignored == 0
+        assert fake_reporter.submit.call_count == 1
+    fake_reporter.reset_mock()
+    fake_runner.reset_mock()
+    # startup hang/unresponsive
+    mocker.patch("grizzly.session.grz_tmp", autospec=True, return_value=str(tmp_path))
+    run_result = RunResult([], 1)
+    run_result.attempted = False
+    run_result.initial = True
+    fake_runner.return_value.run.return_value = run_result
+    with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
+        with raises(SessionError, match="Please check Adapter and Target"):
+            session.run([], iteration_limit=1)
+        assert fake_runner.return_value.run.call_count == 1
+        assert fake_runner.return_value.launch.call_count == 1
+        assert session.status.iteration == 1
+        assert session.status.results == 0
+        assert session.status.ignored == 0
+        assert fake_reporter.submit.call_count == 0
 
 def test_session_08(tmp_path, mocker):
     """test Session.run() ignoring failures"""

From 6660f2f23fa2bb695107790888d6c2a7a4e4178c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 28 Jan 2021 16:57:05 -0800
Subject: [PATCH 191/531] [replay] Update log output for delayed startup
 failures

---
 grizzly/replay/replay.py      |  8 ++++++--
 grizzly/replay/test_replay.py | 25 +++++++++++++++++++------
 2 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 2ca8d4ad..c896eabe 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -249,13 +249,17 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
                     if run_result.status is not None or not run_result.attempted:
                         break
                 if not run_result.attempted:
+                    LOG.warning("Test case was not served")
                     if run_result.initial:
+                        if run_result.status == RunResult.FAILED:
+                            # TODO: what is to best action to take in this case?
+                            LOG.warning("Delayed startup failure detected")
+                        else:
+                            LOG.warning("Timeout too short? System too busy?")
                         err_logs = mkdtemp(prefix="error_", dir=grz_tmp("logs"))
                         self.target.save_logs(err_logs)
-                        LOG.error("ERROR: Test case was not served. Timeout too short?")
                         LOG.error("Logs can be found here %r", err_logs)
                         break
-                    LOG.warning("Test case was not served")
                 # process run results
                 if run_result.status == RunResult.FAILED:
                     log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 36c79a5f..67e55a0e 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -54,7 +54,7 @@ def test_replay_02(mocker, tmp_path):
             assert replay.status.results == 0
             assert target.monitor.is_healthy.call_count == 1
             assert target.close.call_count == 2
-        assert not any(tmp_path.glob("*"))
+        assert not any(tmp_path.iterdir())
 
 def test_replay_03(mocker):
     """test ReplayManager.run() - no repro - with repeats"""
@@ -124,16 +124,18 @@ def test_replay_05(mocker, tmp_path):
         assert results[0].served[0] == served
         assert len(results[0].durations) == 1
         results[0].report.cleanup()
-        assert not any(tmp_path.glob("*"))
+        assert not any(tmp_path.iterdir())
 
 def test_replay_06(mocker, tmp_path):
-    """test ReplayManager.run() - error - landing page not requested on first iteration"""
+    """test ReplayManager.run() - error - landing page not requested"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
-    target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+    # test target unresponsive
+    target.detect_failure.return_value = Target.RESULT_NONE
     server.serve_path.return_value = (SERVED_REQUEST, ["x"])
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases, repeat=2)
@@ -143,6 +145,17 @@ def test_replay_06(mocker, tmp_path):
         # target.close() called once in runner and once by ReplayManager.run()
         assert target.close.call_count == 2
     assert target.save_logs.call_count == 1
+    target.reset_mock()
+    # test target crashed
+    target.detect_failure.return_value = Target.RESULT_FAILURE
+    with ReplayManager([], server, target, use_harness=False) as replay:
+        assert not replay.run(testcases, repeat=2)
+        assert replay.status.ignored == 0
+        assert replay.status.iteration == 1
+        assert replay.status.results == 0
+        # target.close() called once in runner and once by ReplayManager.run()
+        assert target.close.call_count == 2
+    assert target.save_logs.call_count == 1
 
 def test_replay_07(mocker, tmp_path):
     """test ReplayManager.run() - delayed failure - following test landing page not requested"""
@@ -182,7 +195,7 @@ def test_replay_08(mocker, tmp_path):
         assert replay.status.ignored == 1
         assert replay.status.iteration == 1
         assert replay.status.results == 0
-    assert not any(tmp_path.glob("*"))
+    assert not any(tmp_path.iterdir())
 
 def test_replay_09(mocker, tmp_path):
     """test ReplayManager.run() - early exit"""
@@ -546,7 +559,7 @@ def test_replay_20(mocker, tmp_path):
     """test ReplayManager.report_to_filesystem()"""
     # no reports
     ReplayManager.report_to_filesystem(str(tmp_path), [])
-    assert not any(tmp_path.glob("*"))
+    assert not any(tmp_path.iterdir())
     # with reports and tests
     (tmp_path / "report_expected").mkdir()
     result0 = mocker.Mock(ReplayResult, count=1, durations=[1], expected=True, served=[])

From b4fb1709a2aceb977929d8b6000f8ec3861f1a45 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 28 Jan 2021 17:16:23 -0800
Subject: [PATCH 192/531] [status_reporter] Add time-stamp to console output

---
 grizzly/common/status_reporter.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 3df3d2ed..ba3f0103 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -11,7 +11,7 @@
 import logging
 import os
 import re
-from time import gmtime, strftime, time
+from time import gmtime, localtime, strftime, time
 
 import psutil
 
@@ -443,7 +443,10 @@ def main(args=None):
     if not reporter.reports:
         print("Grizzly Status - No status reports to display")
         return 0
-    print("Grizzly Status - Instance report frequency: %ds\n" % (Status.REPORT_FREQ,))
+    print(
+        "Grizzly Status - %s - Instance report frequency: %ds\n" %
+        (strftime("%Y/%m/%d %X", localtime()), Status.REPORT_FREQ)
+    )
     print("[Reports]")
     reporter.print_specific()
     if reporter.has_results:

From c9ca63e902a8fc7a0785557860a540da63dc641f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 29 Jan 2021 16:02:38 -0800
Subject: [PATCH 193/531] Replace a few calls to listdir() with scandir()

---
 grizzly/common/reporter.py | 33 +++++++++++++++------------------
 1 file changed, 15 insertions(+), 18 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 203964fc..5bcf13f0 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -9,7 +9,7 @@
 from json import dump, dumps, loads
 from logging import getLogger, WARNING
 from platform import machine, system
-from os import listdir, getcwd, getenv, makedirs, mkdir, SEEK_END, stat, unlink, walk
+from os import getcwd, getenv, makedirs, mkdir, scandir, SEEK_END, stat, unlink, walk
 from os.path import basename, expanduser, isdir, isfile, join as pathjoin, realpath, relpath
 from re import compile as re_compile, DOTALL, VERBOSE
 from shutil import copyfile, copyfileobj, move, rmtree
@@ -70,10 +70,10 @@ def __init__(self, log_path, target_binary, size_limit=MAX_LOG_SIZE):
         if size_limit < 1:
             LOG.warning("No limit set on report log size!")
         else:
-            for fname in listdir(log_path):
-                log_file_path = pathjoin(log_path, fname)
-                if isfile(log_file_path):
-                    Report.tail(log_file_path, size_limit)
+            with scandir(path=log_path) as contents:
+                for log in contents:
+                    if log.is_file() and log.stat().st_size > size_limit:
+                        Report.tail(log.path, size_limit)
         # look through logs one by one until we find a stack
         for log_file in (x for x in self._logs if x is not None):
             with open(log_file, "rb") as log_fp:
@@ -241,19 +241,15 @@ def select_logs(log_path):
         Returns:
             LogMap: A LogMap pointing to files or None if log_path is empty.
         """
-        # scan path for files
-        to_scan = list()
-        for entry in listdir(log_path):
-            full_path = pathjoin(log_path, entry)
-            if isfile(full_path):
-                to_scan.append(full_path)
+        to_scan = None
+        with scandir(path=log_path) as contents:
+            files = (x for x in contents if x.is_file())
+            # order by date hopefully the oldest log is the cause of the issue
+            to_scan = [x.path for x in sorted(files, key=lambda x: x.stat().st_mtime)]
         if not to_scan:
             LOG.warning("No files found in %r", log_path)
             return None
 
-        # order by creation date because the oldest log is likely the cause of the issue
-        to_scan.sort(key=lambda x: stat(x).st_mtime)
-
         # pattern to identify the ASan crash triggered when the parent process goes away
         # TODO: this may no longer be required
         re_e10s_forced = re_compile(r"""
@@ -338,7 +334,7 @@ def select_logs(log_path):
 
     @staticmethod
     def tail(in_file, size_limit):
-        """Tail the given file. This is destructive.
+        """Tail the given file. WARNING: This is destructive!
 
         Args:
             in_file (str): Path to file to work with.
@@ -348,11 +344,12 @@ def tail(in_file, size_limit):
             None
         """
         assert size_limit > 0
-        if stat(in_file).st_size <= size_limit:
-            return
         with open(in_file, "rb") as in_fp:
             in_fp.seek(0, SEEK_END)
-            dump_pos = max((in_fp.tell() - size_limit), 0)
+            end = in_fp.tell()
+            if end <= size_limit:
+                return
+            dump_pos = max((end - size_limit), 0)
             in_fp.seek(dump_pos)
             out_fd, out_file = mkstemp(prefix="taillog_", dir=grz_tmp())
             with open(out_fd, "wb") as out_fp:

From 8221362c00b1c06e74cf27393302121b3f9f069b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 29 Jan 2021 18:12:10 -0800
Subject: [PATCH 194/531] Move log type detection to individual functions

---
 grizzly/common/reporter.py      | 181 ++++++++++++++++++++------------
 grizzly/common/test_reporter.py |  68 +++++++-----
 2 files changed, 151 insertions(+), 98 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 5bcf13f0..8bcf4796 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -188,6 +188,111 @@ def crash_signature_max_frames(crash_info, suggested_frames=8):
             suggested_frames += 6
         return suggested_frames
 
+    @staticmethod
+    def _find_ffpuppet_worker(logs):
+        """Search through list of log files for a ffpuppet worker log.
+
+        Args:
+            logs (list(str)): List of log files to search.
+
+        Returns:
+            str: The full file path if a match is found otherwise None.
+        """
+        found = None
+        for fname in (x for x in logs if "ffp_worker" in x):
+            if found is not None:
+                # we only expect one log here...
+                LOG.warning("overwriting previously selected %r", found)
+            found = fname
+        return found
+
+    @staticmethod
+    def _find_minidump(logs):
+        """Search through list of log files for a minidump log.
+
+        Args:
+            logs (list(str)): List of log files to search.
+
+        Returns:
+            str: The full file path if a match is found otherwise None.
+        """
+        re_dump_req = re_compile(r"\d+\|0\|.+?\|google_breakpad::ExceptionHandler::WriteMinidump")
+        for fname in (x for x in logs if "minidump" in x):
+            with open(fname, "r") as log_fp:
+                data = log_fp.read(65536)
+                # this will select log that contains "Crash|SIGSEGV|" or
+                # the desired "DUMP_REQUESTED" log
+                # TODO: review this it may be too strict
+                # see mozilla-central/source/accessible/ipc/DocAccessibleParent.cpp#452
+                if "Crash|DUMP_REQUESTED|" not in data or re_dump_req.search(data):
+                    return fname
+        return None
+
+    @staticmethod
+    def _find_sanitizer(logs):
+        """Search through list of log files for a sanitizer (ASan, UBSan, etc...) log.
+
+        Args:
+            logs (list(str)): List of log files to search.
+
+        Returns:
+            str: The full file path if a match is found otherwise None.
+        """
+        # pattern to identify the ASan crash triggered when the parent process goes away
+        # TODO: this may no longer be required
+        re_e10s_forced = re_compile(r"""
+            ==\d+==ERROR:.+?SEGV\son.+?0x[0]+\s\(.+?T2\).+?
+            #0\s+0x[0-9a-f]+\sin\s+mozilla::ipc::MessageChannel::OnChannelErrorFromLink
+            """, DOTALL | VERBOSE)
+        # this is a list of Sanitizer error reports to prioritize
+        # Sanitizer reports not included below are deprioritized
+        prioritize_tokens = (
+            "use-after-",
+            "-buffer-overflow on",
+            ": SEGV on ",
+            "access-violation on ",
+            "attempting free on ",
+            "negative-size-param",
+            "-param-overlap")
+        found = None
+        for fname in (x for x in logs if "asan" in x):
+            with open(fname, "r") as log_fp:
+                data = log_fp.read(65536)
+            # look for interesting crash info in the log
+            if "==ERROR:" in data:
+                # check for e10s forced crash
+                if re_e10s_forced.search(data) is not None:
+                    continue
+                # make sure there is something that looks like a stack frame
+                if "#0 " in data:
+                    found = fname
+                    if any(x in data for x in prioritize_tokens):
+                        # this is the likely cause of the crash
+                        break
+            if found is None:
+                # UBSan error (non-ASan builds)
+                if ": runtime error: " in data:
+                    found = fname
+                # catch all (choose the one with info for now)
+                elif data:
+                    found = fname
+        return found
+
+    @staticmethod
+    def _find_valgrind(logs):
+        """Search through list of log files for a Valgrind worker log.
+
+        Args:
+            logs (list(str)): List of log files to search.
+
+        Returns:
+            str: The full file path if a match is found otherwise None.
+        """
+        for fname in (x for x in logs if "valgrind" in x):
+            if stat(fname).st_size:
+                return fname
+        return None
+
     @property
     def major(self):
         """The inclusive bucketing hash based on the stack trace
@@ -230,8 +335,8 @@ def preferred(self):
         """
         return self._logs.aux or self._logs.stderr
 
-    @staticmethod
-    def select_logs(log_path):
+    @classmethod
+    def select_logs(cls, log_path):
         """Scan log_path for file containing stderr, stdout and other (aux)
         data and build a LogMap.
 
@@ -249,75 +354,14 @@ def select_logs(log_path):
         if not to_scan:
             LOG.warning("No files found in %r", log_path)
             return None
-
-        # pattern to identify the ASan crash triggered when the parent process goes away
-        # TODO: this may no longer be required
-        re_e10s_forced = re_compile(r"""
-            ==\d+==ERROR:.+?SEGV\son.+?0x[0]+\s\(.+?T2\).+?
-            #0\s+0x[0-9a-f]+\sin\s+mozilla::ipc::MessageChannel::OnChannelErrorFromLink
-            """, DOTALL | VERBOSE)
-
-        # this is a list of *San error reports to prioritize
-        # ASan reports not included below (deprioritized):
-        # stack-overflow, BUS, failed to allocate, detected memory leaks
-        interesting_sanitizer_tokens = (
-            "use-after-", "-buffer-overflow on", ": SEGV on ", "access-violation on ",
-            "negative-size-param", "attempting free on ", "-param-overlap")
-
-        log_aux = None
-        # look for sanitizer (ASan, UBSan, etc...) logs
-        for fname in (x for x in to_scan if "asan" in x):
-            # grab first chunk of log to help triage
-            with open(fname, "r") as log_fp:
-                log_data = log_fp.read(65536)
-            # look for interesting crash info in the log
-            if "==ERROR:" in log_data:
-                # check for e10s forced crash
-                if re_e10s_forced.search(log_data) is not None:
-                    continue
-                # make sure there is something that looks like a stack frame in the log
-                if "#0 " in log_data:
-                    log_aux = fname
-                    if any(x in log_data for x in interesting_sanitizer_tokens):
-                        break  # this is the likely cause of the crash
-                    continue  # probably the most interesting but lets keep looking
-            if log_aux is None:
-                # UBSan error (non-ASan builds)
-                if ": runtime error: " in log_data:
-                    log_aux = fname
-                # catch all (choose the one with info for now)
-                elif log_data:
-                    log_aux = fname
-
-        # look for Valgrind logs
+        # look for file to use as aux log
+        log_aux = cls._find_sanitizer(to_scan)
         if log_aux is None:
-            for fname in (x for x in to_scan if "valgrind" in x):
-                if stat(fname).st_size:
-                    log_aux = fname
-                    break
-
-        # prefer ASan logs over minidump logs
+            log_aux = cls._find_valgrind(to_scan)
         if log_aux is None:
-            re_dump_req = re_compile(r"\d+\|0\|.+?\|google_breakpad::ExceptionHandler::WriteMinidump")
-            for fname in (x for x in to_scan if "minidump" in x):
-                with open(fname, "r") as log_fp:
-                    log_data = log_fp.read(65536)
-                    # this will select log that contains "Crash|SIGSEGV|" or
-                    # the desired "DUMP_REQUESTED" log
-                    # TODO: review this it may be too strict
-                    # see https://searchfox.org/mozilla-central/source/accessible/ipc/DocAccessibleParent.cpp#452
-                    if "Crash|DUMP_REQUESTED|" not in log_data or re_dump_req.search(log_data):
-                        log_aux = fname
-                        break
-
-        # look for ffpuppet worker logs, worker logs should be used if nothing else is available
+            log_aux = cls._find_minidump(to_scan)
         if log_aux is None:
-            for fname in (x for x in to_scan if "ffp_worker" in x):
-                if log_aux is not None:
-                    # we only expect one log here...
-                    LOG.warning("aux log previously selected: %s, overwriting!", log_aux)
-                log_aux = fname
-
+            log_aux = cls._find_ffpuppet_worker(to_scan)
         # look for stderr and stdout log files
         log_err = None
         log_out = None
@@ -326,7 +370,6 @@ def select_logs(log_path):
                 log_err = fname
             elif "stdout" in fname:
                 log_out = fname
-
         result = LogMap(log_aux, log_err, log_out)
         if not any(result):
             LOG.warning("No logs found in %r", log_path)
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index ef17772a..5e7480b1 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -6,6 +6,7 @@
 # pylint: disable=protected-access
 
 import os
+from pathlib import Path
 import sys
 import tarfile
 
@@ -165,37 +166,46 @@ def test_report_08(tmp_path):
     assert "worker log" in (tmp_path / log_map.aux).read_text()
 
 def test_report_09(tmp_path):
-    """test prioritizing *San logs with Report.select_logs()"""
-    # crash
-    with (tmp_path / "log_asan.txt.1").open("wb") as log_fp:
-        log_fp.write(b"GOOD LOG\n")
-        log_fp.write(b"==1942==ERROR: AddressSanitizer: heap-use-after-free on ... blah\n")  # must be 2nd line
-        # pad out to 6 lines
-        for l_no in range(4):
-            log_fp.write(b"    #%d blah...\n" % l_no)
-    # crash missing trace
+    """test prioritizing sanitizer logs with Report._find_sanitizer()"""
+    # NOTE: ordered by selection priority in order to use previously added logs
+    # test empty
+    (tmp_path / "log_asan.txt.0").touch()
+    assert Report._find_sanitizer([str(x) for x in tmp_path.iterdir()]) is None
+    # test *San log with data
+    (tmp_path / "log_asan.txt.1").write_text("test")
+    selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
+    assert selected is not None
+    assert "test" in Path(selected).read_text()
+    # test UBSan log
+    (tmp_path / "log_asan.txt.1").write_text(
+        "test.cc:3:5: runtime error: signed integer overflow: ...")
+    selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
+    assert selected is not None
+    assert "runtime error: signed integer overflow" in Path(selected).read_text()
+    # test selecting ASan report
     with (tmp_path / "log_asan.txt.2").open("wb") as log_fp:
-        log_fp.write(b"BAD LOG\n")
-        log_fp.write(b"==1984==ERROR: AddressSanitizer: SEGV on ... blah\n")  # must be 2nd line
-        log_fp.write(b"missing trace...\n")
-    # child log that should be ignored (created when parent crashes)
+        # missing stack
+        log_fp.write(b"==1184==ERROR: AddressSanitizer: BUS on ... blah\n")
     with (tmp_path / "log_asan.txt.3").open("wb") as log_fp:
-        log_fp.write(b"BAD LOG\n")
-        log_fp.write(b"==1184==ERROR: AddressSanitizer: BUS on ... blah\n")  # must be 2nd line
-        # pad out to 6 lines
+        log_fp.write(b"==9482==ERROR: AddressSanitizer: stack-overflow on ...\n")
         for l_no in range(4):
-            log_fp.write(b"    #%d blah...\n" % l_no)
+            log_fp.write(b"    #%d blah...\n" % (l_no,))
+    selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
+    assert selected is not None
+    assert "AddressSanitizer: stack-overflow" in Path(selected).read_text()
+    # test selecting prioritized
     with (tmp_path / "log_asan.txt.4").open("wb") as log_fp:
-        log_fp.write(b"BAD LOG\n")
-        log_fp.write(b"==9482==ERROR: AddressSanitizer: stack-overflow on ...\n")  # must be 2nd line
-        # pad out to 6 lines
+        log_fp.write(b"==1942==ERROR: AddressSanitizer: heap-use-after-free on ... blah\n")
         for l_no in range(4):
-            log_fp.write(b"    #%d blah...\n" % l_no)
+            log_fp.write(b"    #%d blah...\n" % (l_no,))
     with (tmp_path / "log_asan.txt.5").open("wb") as log_fp:
-        log_fp.write(b"BAD LOG\n")
-        log_fp.write(b"ERROR: Failed to mmap\n")  # must be 2nd line
-    log_map = Report.select_logs(str(tmp_path))
-    assert "GOOD LOG" in (tmp_path / log_map.aux).read_text()
+        log_fp.write(b"==1984==ERROR: AddressSanitizer: SEGV on ... blah\n")
+        log_fp.write(b"missing trace...\n")
+    with (tmp_path / "log_asan.txt.6").open("wb") as log_fp:
+        log_fp.write(b"ERROR: Failed to mmap\n")
+    selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
+    assert selected is not None
+    assert "heap-use-after-free" in Path(selected).read_text()
 
 def test_report_10(tmp_path):
     """test Report() size_limit"""
@@ -316,7 +326,7 @@ def test_filesystem_reporter_02(tmp_path, mocker):
     reporter.submit(tests, Report(str(log_path), "fake_bin"))
     assert not log_path.exists()
     assert report_path.exists()
-    assert len(tuple(report_path.glob("*"))) == 1
+    assert len(tuple(report_path.iterdir())) == 1
     assert all(x.dump.call_count == 1 for x in tests)
     # call report a 2nd time
     log_path.mkdir()
@@ -325,7 +335,7 @@ def test_filesystem_reporter_02(tmp_path, mocker):
     tests = list(mocker.Mock(spec=TestCase) for _ in range(2))
     reporter.submit(tests, Report(str(log_path), "fake_bin"))
     assert all(x.dump.call_count == 1 for x in tests)
-    assert len(tuple(report_path.glob("*"))) == 2
+    assert len(tuple(report_path.iterdir())) == 2
     assert len(tuple(report_path.glob("NO_STACK"))) == 1
 
 def test_filesystem_reporter_03(tmp_path):
@@ -535,7 +545,7 @@ def test_s3fuzzmanager_reporter_02(mocker, tmp_path):
     fake_report.minor = "1234abcd"
     fake_report.path = str(tmp_path)
     reporter._pre_submit(fake_report)
-    assert not any(tmp_path.glob("*"))
+    assert not any(tmp_path.iterdir())
     assert "rr-trace" in reporter._extra_metadata
     assert fake_report.minor in reporter._extra_metadata["rr-trace"]
     fake_resource.return_value.meta.client.upload_file.assert_not_called()
@@ -551,7 +561,7 @@ def __init__(self, message, response):
     mocker.patch("grizzly.common.reporter.ClientError", new=FakeClientError)
     fake_resource.return_value.Object.side_effect = FakeClientError("test", {"Error": {"Code": "404"}})
     reporter._pre_submit(fake_report)
-    assert not any(tmp_path.glob("*"))
+    assert not any(tmp_path.iterdir())
     assert "rr-trace" in reporter._extra_metadata
     assert fake_report.minor in reporter._extra_metadata["rr-trace"]
     assert fake_resource.return_value.meta.client.upload_file.call_count == 1

From f921dd365177f993144a9b0555fb9c2d20f49b14 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 1 Feb 2021 09:26:29 -0800
Subject: [PATCH 195/531] Remove Python 3.5 support

---
 .travis.yml            | 1 -
 grizzly/reduce/core.py | 3 ---
 setup.py               | 1 -
 tox.ini                | 4 ++--
 4 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 0d40ba58..0980405f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -3,7 +3,6 @@ cache: pip
 language: python
 os: linux
 python:
-  - 3.5
   - 3.6
   - 3.7
   - 3.8
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index d40bdb34..c11c99d0 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -109,9 +109,6 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
         self._any_crash = any_crash
         self._idle_delay = idle_delay
         self._idle_threshold = idle_threshold
-        # only coerce `log_path` to `Path` if it's a string
-        # this caution is only necessary in python3.5 where pytest uses
-        # pathlib2 rather than pathlib
         self._log_path = Path(log_path) if isinstance(log_path, str) else log_path
         # these parameters may be overwritten during analysis, so keep a copy of them
         self._original_relaunch = relaunch
diff --git a/setup.py b/setup.py
index b2f11ec7..5ce5da7b 100755
--- a/setup.py
+++ b/setup.py
@@ -27,7 +27,6 @@
             'Topic :: Security',
             'License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)',
             'Programming Language :: Python :: 3',
-            'Programming Language :: Python :: 3.5',
             'Programming Language :: Python :: 3.6',
             'Programming Language :: Python :: 3.7',
             'Programming Language :: Python :: 3.8',
diff --git a/tox.ini b/tox.ini
index 3b7059d9..ead47f73 100644
--- a/tox.ini
+++ b/tox.ini
@@ -41,7 +41,7 @@ extras =
 usedevelop = true
 
 [tox]
-envlist = py35,py36,py37,py38,py39
-minversion = 3.5
+envlist = py36,py37,py38,py39
+minversion = 3.6
 skip_missing_interpreters = true
 tox_pip_extensions_ext_venv_update = true

From 5086764da498f4c75fab8c94688fcac9190a28e8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 1 Feb 2021 12:54:47 -0800
Subject: [PATCH 196/531] Update Report.select_logs() sanity checks

---
 grizzly/common/reporter.py      | 18 ++++++++----------
 grizzly/common/test_reporter.py |  2 +-
 2 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 8bcf4796..23129640 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -58,7 +58,7 @@ class Report:
     __slots__ = ("_crash_info", "_logs", "_signature", "_target_binary", "path", "prefix", "stack")
 
     def __init__(self, log_path, target_binary, size_limit=MAX_LOG_SIZE):
-        assert isinstance(log_path, str) and isdir(log_path)
+        assert isinstance(log_path, str)
         assert isinstance(target_binary, str)
         self._crash_info = None
         self._logs = self.select_logs(log_path)
@@ -336,23 +336,23 @@ def preferred(self):
         return self._logs.aux or self._logs.stderr
 
     @classmethod
-    def select_logs(cls, log_path):
-        """Scan log_path for file containing stderr, stdout and other (aux)
+    def select_logs(cls, path):
+        """Scan path for file containing stderr, stdout and other (aux)
         data and build a LogMap.
 
         Args:
-            log_path (str): Path to scan for log files.
+            path (str): Path to scan for log files.
 
         Returns:
-            LogMap: A LogMap pointing to files or None if log_path is empty.
+            LogMap: A LogMap pointing to log files or None if path is empty.
         """
         to_scan = None
-        with scandir(path=log_path) as contents:
+        with scandir(path=path) as contents:
             files = (x for x in contents if x.is_file())
             # order by date hopefully the oldest log is the cause of the issue
             to_scan = [x.path for x in sorted(files, key=lambda x: x.stat().st_mtime)]
         if not to_scan:
-            LOG.warning("No files found in %r", log_path)
+            LOG.warning("No files found in %r", path)
             return None
         # look for file to use as aux log
         log_aux = cls._find_sanitizer(to_scan)
@@ -371,9 +371,7 @@ def select_logs(cls, log_path):
             elif "stdout" in fname:
                 log_out = fname
         result = LogMap(log_aux, log_err, log_out)
-        if not any(result):
-            LOG.warning("No logs found in %r", log_path)
-        return result
+        return result if any(result) else None
 
     @staticmethod
     def tail(in_file, size_limit):
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 5e7480b1..424da61a 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -81,7 +81,7 @@ def test_report_04(tmp_path):
     assert Report.select_logs(str(tmp_path)) is None
     # empty file
     (tmp_path / "not_a_log.txt").touch()
-    assert not any(Report.select_logs(str(tmp_path)))
+    assert Report.select_logs(str(tmp_path)) is None
 
 def test_report_05(tmp_path):
     """test Report.select_logs()"""

From 28e0c0fbd10f5df2df81d4e3d88057b0e466b71d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 1 Feb 2021 13:13:35 -0800
Subject: [PATCH 197/531] Add Target.create_report()

---
 grizzly/target/puppet_target.py | 9 ++++++---
 grizzly/target/target.py        | 4 +++-
 grizzly/target/test_target.py   | 2 ++
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 57f73584..07fdb9ef 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -85,6 +85,11 @@ def is_idle(self, threshold):
                 return False
         return True
 
+    def create_report(self):
+        logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
+        self.save_logs(logs)
+        return Report(logs, self.binary)
+
     @property
     def monitor(self):
         if self._monitor is None:
@@ -229,9 +234,7 @@ def launch(self, location, env_mod=None):
             self.close()
             if isinstance(exc, BrowserTimeoutError):
                 raise TargetLaunchTimeout(str(exc)) from None
-            log_path = mkdtemp(prefix="launch_fail_", dir=grz_tmp("logs"))
-            self.save_logs(log_path)
-            raise TargetLaunchError(str(exc), Report(log_path, self.binary)) from None
+            raise TargetLaunchError(str(exc), self.create_report()) from None
 
     def log_size(self):
         return self._puppet.log_length("stderr") + self._puppet.log_length("stdout")
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 871f494e..0e91bb49 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -94,7 +94,9 @@ def close(self):
     def closed(self):
         pass
 
-    # TODO: add collect_report()?
+    @abstractmethod
+    def create_report(self):
+        pass
 
     @abstractmethod
     def detect_failure(self, ignored, was_timeout):
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index 937123b9..f639c26c 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -13,6 +13,8 @@ def close(self):
     @property
     def closed(self):
         pass
+    def create_report(self):
+        pass
     def detect_failure(self, ignored, was_timeout):
         pass
     def launch(self):

From 4e1e69caa9f37b42051ec411b92e9ef19f3b359d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 1 Feb 2021 13:24:12 -0800
Subject: [PATCH 198/531] Use Target.create_report() in grizzly.session

---
 grizzly/main.py         |  6 ----
 grizzly/session.py      | 62 ++++++++++++++++++++++-------------------
 grizzly/test_main.py    | 12 ++------
 grizzly/test_session.py | 45 ++++++------------------------
 4 files changed, 44 insertions(+), 81 deletions(-)

diff --git a/grizzly/main.py b/grizzly/main.py
index f40850f5..0bbd583c 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -11,7 +11,6 @@
 from .adapters import get as get_adapter
 from .common.iomanager import IOManager
 from .common.reporter import FilesystemReporter, FuzzManagerReporter, S3FuzzManagerReporter
-from .common.utils import grz_tmp
 from .session import Session
 from .target import load as load_target, TargetLaunchError, TargetLaunchTimeout
 
@@ -142,11 +141,6 @@ def main(args):
 
     except (TargetLaunchError, TargetLaunchTimeout) as exc:
         LOG.error(str(exc))
-        if isinstance(exc, TargetLaunchError) and exc.report:
-            path = grz_tmp("launch_failures")
-            LOG.error("Logs can be found here %r", path)
-            reporter = FilesystemReporter(path, major_bucket=False)
-            reporter.submit([], exc.report)
         return Session.EXIT_LAUNCH_FAILURE
 
     finally:
diff --git a/grizzly/session.py b/grizzly/session.py
index 827ff1c6..00d99f95 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -2,14 +2,11 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
 from logging import getLogger
-from os.path import isdir
-from shutil import rmtree
-from tempfile import mkdtemp
 from time import time
 
-from .common import grz_tmp, Report, Runner, RunResult, Status, TestFile
+from .common import Runner, RunResult, Status, TestFile
+from .target import TargetLaunchError
 
 
 __all__ = ("SessionError", "LogOutputLimiter", "Session")
@@ -111,20 +108,6 @@ def generate_testcase(self):
             test.add_meta(TestFile.from_file(self.target.prefs, "prefs.js"))
         return test
 
-    def report_result(self):
-        # create working directory for target logs
-        result_logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
-        self.target.save_logs(result_logs)
-        report = Report(result_logs, self.target.binary)
-        short_sig = report.crash_info.createShortSignature()
-        LOG.info("Result: %s (%s:%s)", short_sig, report.major[:8], report.minor[:8])
-        # order test cases newest to oldest
-        self.iomanager.tests.reverse()
-        self.reporter.submit(self.iomanager.tests, report)
-        if isdir(result_logs):
-            rmtree(result_logs)
-        self.status.count_result(short_sig)
-
     def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
         assert iteration_limit >= 0
         log_limiter = LogOutputLimiter(verbose=display_mode == self.DISPLAY_VERBOSE)
@@ -134,6 +117,7 @@ def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
             assert self.adapter.remaining > 0
             relaunch = min(relaunch, self.adapter.remaining)
         runner = Runner(self.server, self.target, relaunch=relaunch)
+        startup_error = False
         while True:
             self.status.report()
             self.status.iteration += 1
@@ -154,8 +138,19 @@ def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
                         self.server.port,
                         close_after=relaunch,
                         timeout=self.adapter.TEST_DURATION)
-                with self.status.measure("launch"):
-                    runner.launch(location, max_retries=3, retry_delay=0)
+                try:
+                    with self.status.measure("launch"):
+                        runner.launch(location, max_retries=3, retry_delay=0)
+                except TargetLaunchError as exc:
+                    short_sig = exc.report.crash_info.createShortSignature()
+                    LOG.info("Result: %s (%s:%s)",
+                        short_sig,
+                        exc.report.major[:8],
+                        exc.report.minor[:8])
+                    self.reporter.submit([], exc.report)
+                    exc.report.cleanup()
+                    self.status.count_result(short_sig)
+                    raise TargetLaunchError(str(exc), None) from None
 
             # create and populate a test case
             current_test = self.generate_testcase()
@@ -177,7 +172,6 @@ def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
             else:
                 LOG.debug("calling self.adapter.on_served()")
                 self.adapter.on_served(current_test, result.served)
-            # update test case
             if not result.attempted:
                 LOG.warning("Test case was not served")
                 LOG.debug("ignoring test case since nothing was served")
@@ -189,26 +183,36 @@ def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
                     # something is likely wrong with the Target or Adapter
                     if result.status == RunResult.FAILED:
                         LOG.warning("Delayed startup failure detected")
-                        self.report_result()
                     else:
                         LOG.warning("Timeout too short? System too busy?")
-                        err_logs = mkdtemp(prefix="error_", dir=grz_tmp("logs"))
-                        self.target.save_logs(err_logs)
-                        LOG.error("Logs can be found here %r", err_logs)
-                    # only raise if this is a potential blocker
+                    # ignore this if it did not happen early on
+                    # to avoid aborting a fuzzing session unnecessarily
                     if self.status.iteration < 100:
-                        raise SessionError("Please check Adapter and Target")
+                        startup_error = True
             elif self.adapter.IGNORE_UNSERVED:
                 LOG.debug("removing unserved files from the test case")
                 current_test.purge_optional(result.served)
             # process results
             if result.status == RunResult.FAILED:
                 LOG.debug("result detected")
-                self.report_result()
+                report = self.target.create_report()
+                short_sig = report.crash_info.createShortSignature()
+                LOG.info("Result: %s (%s:%s)",
+                    short_sig,
+                    report.major[:8],
+                    report.minor[:8])
+                # order test cases newest to oldest
+                self.iomanager.tests.reverse()
+                self.reporter.submit(self.iomanager.tests, report)
+                report.cleanup()
+                self.status.count_result(short_sig)
             elif result.status == RunResult.IGNORED:
                 self.status.ignored += 1
                 LOG.info("Ignored (%d)", self.status.ignored)
 
+            if startup_error:
+                raise SessionError("Please check Adapter and Target")
+
             if self.adapter.remaining is not None and self.adapter.remaining < 1:
                 # all test cases have been replayed
                 LOG.info("Replay Complete")
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 31cf5345..ca86ed53 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -93,7 +93,7 @@ def test_main_01(mocker):
     args.s3_fuzzmanager = True
     assert main(args) == Session.EXIT_SUCCESS
 
-def test_main_02(mocker, tmp_path):
+def test_main_02(mocker):
     """test main() exit codes"""
     fake_adapter = mocker.Mock(spec=Adapter)
     fake_adapter.TEST_DURATION = 10
@@ -112,13 +112,5 @@ def test_main_02(mocker, tmp_path):
     fake_session.return_value.run.side_effect = KeyboardInterrupt
     assert main(args) == Session.EXIT_ABORT
     # test TargetLaunchError
-    fake_tmp = (tmp_path / "grz_tmp")
-    fake_tmp.mkdir()
-    mocker.patch("grizzly.main.grz_tmp", return_value=str(fake_tmp))
-    fake_logs = (tmp_path / "report")
-    report = mocker.Mock(spec=Report, prefix="fake_report", path=str(fake_logs))
-    fake_logs.mkdir()
-    fake_session.return_value.run.side_effect = TargetLaunchError("test", report)
+    fake_session.return_value.run.side_effect = TargetLaunchError("test", None)
     assert main(args) == Session.EXIT_LAUNCH_FAILURE
-    assert any(fake_tmp.glob("fake_report_logs"))
-    assert not fake_logs.is_dir()
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 3c13b274..fcb62d57 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -184,7 +184,6 @@ def test_session_06(tmp_path, mocker):
 def test_session_07(tmp_path, mocker):
     """test Session.run() - test case was not served"""
     Status.PATH = str(tmp_path)
-    mocker.patch("grizzly.session.Report", autospec=True)
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
@@ -192,9 +191,12 @@ def test_session_07(tmp_path, mocker):
     fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
     fake_iomgr.create_testcase.return_value = mocker.Mock(spec=TestCase)
     fake_iomgr.tests = mocker.Mock(spec=deque)
+    fake_report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    fake_report.crash_info.createShortSignature.return_value = "[@ sig]"
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
     fake_target.monitor.launches = 1
+    fake_target.create_report.return_value = fake_report
     fake_reporter = mocker.Mock(spec=Reporter)
     # between iterations
     run_result = RunResult([], 1, status=RunResult.FAILED)
@@ -232,7 +234,6 @@ def test_session_07(tmp_path, mocker):
     fake_reporter.reset_mock()
     fake_runner.reset_mock()
     # startup hang/unresponsive
-    mocker.patch("grizzly.session.grz_tmp", autospec=True, return_value=str(tmp_path))
     run_result = RunResult([], 1)
     run_result.attempted = False
     run_result.initial = True
@@ -264,8 +265,6 @@ def test_session_08(tmp_path, mocker):
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
     fake_target.monitor.launches = 1
-    # ignored results should not be reported so raise AssertionError if report_result is called
-    mocker.patch.object(Session, 'report_result', side_effect=AssertionError)
     with Session(fake_adapter, fake_iomgr, None, fake_serv, fake_target) as session:
         session.run([], iteration_limit=1)
         assert fake_runner.return_value.run.call_count == 1
@@ -274,6 +273,7 @@ def test_session_08(tmp_path, mocker):
         assert fake_iomgr.purge_tests.call_count == 1
         assert fake_test.purge_optional.call_count == 0
         assert fake_runner.return_value.launch.call_count == fake_iomgr.purge_tests.call_count
+        assert fake_target.create_report.call_count == 0
         assert session.status.iteration == 1
         assert session.status.results == 0
         assert session.status.ignored == 1
@@ -281,17 +281,13 @@ def test_session_08(tmp_path, mocker):
 def test_session_09(tmp_path, mocker):
     """test Session.run() handle TargetLaunchError"""
     Status.PATH = str(tmp_path)
-    mocker.patch("grizzly.session.Report", autospec=True)
+    fake_report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    fake_report.crash_info.createShortSignature.return_value = "[@ sig]"
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
-    fake_runner.return_value.launch.side_effect = TargetLaunchError("test", mocker.Mock(spec=Report))
+    fake_runner.return_value.launch.side_effect = TargetLaunchError("test", fake_report)
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
-    fake_iomgr = mocker.Mock(
-        spec=IOManager,
-        harness=None,
-        input_files=[],
-        server_map=ServerMap(),
-        tests=deque())
+    fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_target = mocker.Mock(spec=Target)
     fake_target.monitor.launches = 1
@@ -299,32 +295,9 @@ def test_session_09(tmp_path, mocker):
         with raises(TargetLaunchError, match="test"):
             session.run([], iteration_limit=1)
         assert session.status.iteration == 1
-        assert session.status.results == 0
+        assert session.status.results == 1
         assert session.status.ignored == 0
 
-def test_session_10(tmp_path, mocker):
-    """test Session.report_result()"""
-    tmpd = tmp_path / "fake_temp_path"
-    tmpd.mkdir()
-    (tmpd / "log_stderr.txt").write_bytes(b"STDERR log\n")
-    (tmpd / "log_stdout.txt").write_bytes(b"STDOUT log\n")
-    with (tmpd / "log_asan_blah.txt").open("wb") as log_fp:
-        log_fp.write(b"==1==ERROR: AddressSanitizer: ")
-        log_fp.write(b"SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n")
-        log_fp.write(b"    #0 0xbad000 in foo /file1.c:123:234\n")
-        log_fp.write(b"    #1 0x1337dd in bar /file2.c:1806:19\n")
-    mocker.patch("grizzly.session.mkdtemp", autospec=True, return_value=str(tmpd))
-    Status.PATH = str(tmp_path)
-    fake_iomgr = mocker.Mock(spec=IOManager, tests=deque())
-    fake_target = mocker.Mock(spec=Target, binary="bin")
-    reporter = NullReporter()
-    with Session(None, fake_iomgr, reporter, None, fake_target) as session:
-        session.report_result()
-    assert fake_target.save_logs.call_count == 1
-    fake_target.save_logs.assert_called_with(str(tmpd))
-    assert reporter.submit_calls == 1
-    assert not tmpd.is_dir()
-
 def test_log_output_limiter_01(mocker):
     """test LogOutputLimiter.ready() not ready"""
     fake_time = mocker.patch("grizzly.session.time", autospec=True)

From e5940b9b4ab925b5d22839b62b44f55356e8f975 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 1 Feb 2021 14:27:50 -0800
Subject: [PATCH 199/531] [replay] Report delayed startup failures as
 unexpected results

---
 grizzly/replay/replay.py      | 19 +++++++++++++------
 grizzly/replay/test_replay.py | 19 +++++++++++--------
 2 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index c896eabe..b876538d 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -211,6 +211,7 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
                             self.server.port,
                             close_after=relaunch * test_count,
                             timeout=self.server.timeout)
+                    startup_error = False
                     # The environment from the initial testcase is used because
                     # a sequence of testcases is expected to be run without
                     # relaunching the Target to match the functionality of
@@ -251,30 +252,36 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
                 if not run_result.attempted:
                     LOG.warning("Test case was not served")
                     if run_result.initial:
+                        startup_error = True
                         if run_result.status == RunResult.FAILED:
                             # TODO: what is to best action to take in this case?
                             LOG.warning("Delayed startup failure detected")
                         else:
                             LOG.warning("Timeout too short? System too busy?")
-                        err_logs = mkdtemp(prefix="error_", dir=grz_tmp("logs"))
-                        self.target.save_logs(err_logs)
-                        LOG.error("Logs can be found here %r", err_logs)
-                        break
                 # process run results
                 if run_result.status == RunResult.FAILED:
+                    # TODO: use self.target.create_report here
                     log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
                     self.target.save_logs(log_path)
                     report = Report(log_path, self.target.binary)
                     # check signatures
                     short_sig = report.crash_info.createShortSignature()
-                    if not self._any_crash and self._signature is None and short_sig != "No crash detected":
+                    if (
+                        not startup_error
+                        and not self._any_crash
+                        and self._signature is None
+                        and short_sig != "No crash detected"
+                    ):
                         LOG.debug("no signature given, using %r", short_sig)
                         self._signature = report.crash_signature
                     if short_sig == "No crash detected":
                         # TODO: verify report.major == "NO_STACK" otherwise FM failed to parse the logs
                         # TODO: change this to support hangs/timeouts, etc
                         LOG.info("Result: No crash detected")
-                    elif self._any_crash or self._signature.matches(report.crash_info):
+                    elif (
+                        not startup_error
+                        and (self._any_crash or self._signature.matches(report.crash_info))
+                    ):
                         self.status.count_result(short_sig)
                         LOG.info("Result: %s (%s:%s)",
                                  short_sig, report.major[:8], report.minor[:8])
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 67e55a0e..bdcc51db 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -11,7 +11,7 @@
 
 from pytest import raises
 
-from sapphire import Sapphire, SERVED_ALL, SERVED_REQUEST
+from sapphire import Sapphire, SERVED_ALL, SERVED_NONE, SERVED_REQUEST
 from .replay import ReplayManager, ReplayResult
 from ..common import Report, Status, TestCase, TestCaseLoadFailure
 from ..target import Target
@@ -130,32 +130,35 @@ def test_replay_06(mocker, tmp_path):
     """test ReplayManager.run() - error - landing page not requested"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
+    target = mocker.Mock(spec=Target, binary="bin", closed=True, launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     # test target unresponsive
     target.detect_failure.return_value = Target.RESULT_NONE
-    server.serve_path.return_value = (SERVED_REQUEST, ["x"])
+    server.serve_path.return_value = (SERVED_NONE, [])
     with ReplayManager([], server, target, use_harness=False) as replay:
-        assert not replay.run(testcases, repeat=2)
+        assert not replay.run(testcases, repeat=1)
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 0
         # target.close() called once in runner and once by ReplayManager.run()
         assert target.close.call_count == 2
-    assert target.save_logs.call_count == 1
     target.reset_mock()
     # test target crashed
     target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.save_logs = _fake_save_logs
     with ReplayManager([], server, target, use_harness=False) as replay:
-        assert not replay.run(testcases, repeat=2)
-        assert replay.status.ignored == 0
+        results = replay.run(testcases, repeat=1)
+        assert replay.status.ignored == 1
         assert replay.status.iteration == 1
         assert replay.status.results == 0
+        assert replay._signature is None
         # target.close() called once in runner and once by ReplayManager.run()
         assert target.close.call_count == 2
-    assert target.save_logs.call_count == 1
+    assert len(results) == 1
+    assert results[0].count == 1
+    assert not results[0].expected
 
 def test_replay_07(mocker, tmp_path):
     """test ReplayManager.run() - delayed failure - following test landing page not requested"""

From f9393ab4b3bf767e6e81a2fda4d5da7c20002bca Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 23 Feb 2021 17:20:38 -0800
Subject: [PATCH 200/531] [sapphire] Fix detecting nested optional files

---
 sapphire/job.py      | 10 ++++++----
 sapphire/test_job.py | 32 +++++++++++++++++++++-----------
 2 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/sapphire/job.py b/sapphire/job.py
index f7a0f5a9..759f9dec 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -66,16 +66,18 @@ def _build_queue(self, optional_files):
         # this is intended to only be called once by __init__()
         for d_name, _, filenames in walk(self.base_path, followlinks=False):
             for f_name in filenames:
+                file_path = pathjoin(d_name, f_name)
+                location = relpath(file_path, start=self.base_path).replace("\\", "/")
                 # do not add optional files to queue of required files
-                if optional_files and f_name in optional_files:
-                    LOG.debug("optional: %r", f_name)
+                if optional_files and location in optional_files:
+                    LOG.debug("optional: %r", location)
                     continue
-                file_path = abspath(pathjoin(d_name, f_name))
+                file_path = abspath(file_path)
                 if "?" in file_path:
                     LOG.warning("Cannot add files with '?' in path. Skipping %r", file_path)
                     continue
                 self._pending.files.add(file_path)
-                LOG.debug("required: %r", f_name)
+                LOG.debug("required: %r", location)
         # if nothing was found check if the path exists
         if not self._pending.files and not isdir(self.base_path):
             raise OSError("%r does not exist" % (self.base_path),)
diff --git a/sapphire/test_job.py b/sapphire/test_job.py
index 205fb215..0894adec 100644
--- a/sapphire/test_job.py
+++ b/sapphire/test_job.py
@@ -31,19 +31,25 @@ def test_job_01(tmp_path):
     assert job.is_complete()
 
 def test_job_02(tmp_path):
-    """test Job two required files and one optional file"""
-    opt_path = tmp_path / "opt_file.txt"
-    opt_path.write_bytes(b"a")
+    """test Job proper handling of required and optional files"""
+    opt1_path = tmp_path / "opt_file_1.txt"
+    opt1_path.write_bytes(b"a")
     req1_path = tmp_path / "req_file_1.txt"
-    req1_path.write_bytes(b"a")
-    (tmp_path / "test").mkdir()
-    req2_path = tmp_path / "test" / "req_file_2.txt"
-    req2_path.write_bytes(b"a")
-    job = Job(str(tmp_path), optional_files=[opt_path.name])
+    req1_path.write_bytes(b"b")
+    (tmp_path / "nested").mkdir()
+    opt2_path = tmp_path / "nested" / "opt_file_2.txt"
+    opt2_path.write_bytes(b"c")
+    req2_path = tmp_path / "nested" / "req_file_2.txt"
+    req2_path.write_bytes(b"d")
+    job = Job(
+        str(tmp_path),
+        optional_files=[opt1_path.name, "nested/%s" % (opt2_path.name,)]
+    )
     assert job.status == SERVED_NONE
     assert not job.is_complete()
     resource = job.check_request("req_file_1.txt")
     assert resource.required
+    assert job.pending == 2
     assert resource.target == str(tmp_path / "req_file_1.txt")
     assert resource.type == Resource.URL_FILE
     assert not job.is_forbidden(str(req1_path))
@@ -56,11 +62,15 @@ def test_job_02(tmp_path):
     assert job.status == SERVED_ALL
     assert job.pending == 0
     assert job.remove_pending(str(req1_path))
-    resource = job.check_request("opt_file.txt")
+    resource = job.check_request("opt_file_1.txt")
     assert not resource.required
-    assert resource.target == str(tmp_path / "opt_file.txt")
+    assert resource.target == str(opt1_path)
+    assert resource.type == Resource.URL_FILE
+    assert job.remove_pending(str(opt1_path))
+    resource = job.check_request("nested/opt_file_2.txt")
+    assert resource.target == str(opt2_path)
     assert resource.type == Resource.URL_FILE
-    assert job.remove_pending(str(opt_path))
+    assert not resource.required
     job.finish()
     assert job.is_complete()
 

From 20e1cb84fb596172312c6a787c4c52ef9d026d60 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 11 Feb 2021 17:28:52 -0800
Subject: [PATCH 201/531] [stack_hasher] Add optional max stack height

* This can be useful when bucketing hangs
---
 grizzly/common/stack_hasher.py      | 31 ++++++++++++++++++++++-------
 grizzly/common/test_stack_hasher.py | 24 ++++++++++++++++++++++
 2 files changed, 48 insertions(+), 7 deletions(-)

diff --git a/grizzly/common/stack_hasher.py b/grizzly/common/stack_hasher.py
index 8f59d6c2..9f41f549 100644
--- a/grizzly/common/stack_hasher.py
+++ b/grizzly/common/stack_hasher.py
@@ -251,11 +251,12 @@ def _parse_valgrind(cls, input_line):
 
 
 class Stack:
-    __slots__ = ("frames", "_major", "_major_depth", "_minor")
+    __slots__ = ("frames", "_height_limit", "_major", "_major_depth", "_minor")
 
-    def __init__(self, frames=None, major_depth=MAJOR_DEPTH):
+    def __init__(self, frames=None, hight_limit=None, major_depth=MAJOR_DEPTH):
         assert frames is None or isinstance(frames, list)
         self.frames = list() if frames is None else frames
+        self._height_limit = hight_limit
         self._major_depth = major_depth
         self._major = None
         self._minor = None
@@ -267,16 +268,18 @@ def _calculate_hash(self, major=False):
         if not self.frames or (major and self._major_depth < 1):
             return None
         h = sha1()
-        current_depth = 0
-        for frame in self.frames:
-            current_depth += 1
-            if major and current_depth > self._major_depth:
+        if self._height_limit is None:
+            offset = 0
+        else:
+            offset = max(len(self.frames) - self._height_limit, 0)
+        for depth, frame in enumerate(self.frames[offset:], start=1):
+            if major and depth > self._major_depth:
                 break
             if frame.location is not None:
                 h.update(frame.location.encode("utf-8", errors="ignore"))
             if frame.function is not None:
                 h.update(frame.function.encode("utf-8", errors="ignore"))
-            if major and current_depth > 1:
+            if major and depth > 1:
                 # only add the offset from the top frame when calculating
                 # the major hash and skip the rest
                 continue
@@ -340,6 +343,20 @@ def from_text(cls, input_text, major_depth=MAJOR_DEPTH, parse_mode=None):
 
         return cls(frames=frames, major_depth=major_depth)
 
+    @property
+    def height_limit(self):
+        return self._height_limit
+
+    @height_limit.setter
+    def height_limit(self, value):
+        if value is not None:
+            assert isinstance(value, int)
+            assert value > 0
+        self._height_limit = value
+        # force recalculation of hashes
+        self._major = None
+        self._minor = None
+
     @property
     def major(self):
         if self._major is None:
diff --git a/grizzly/common/test_stack_hasher.py b/grizzly/common/test_stack_hasher.py
index 5255c2a0..04a09e4d 100644
--- a/grizzly/common/test_stack_hasher.py
+++ b/grizzly/common/test_stack_hasher.py
@@ -217,6 +217,30 @@ def test_stack_13():
     assert stack.minor != stack.major
     assert stack.frames[0].mode == StackFrame.MODE_RUST
 
+def test_stack_14():
+    """test Stack.height_limit"""
+    frames = list()
+    for num in range(10):
+        frames.append(StackFrame(function=str(num), location="b", offset="c", stack_line=str(num)))
+    stack = Stack(frames=frames, major_depth=3)
+    assert stack.height_limit is None
+    no_lim_minor = stack.minor
+    assert no_lim_minor is not None
+    no_lim_major = stack.major
+    assert no_lim_major is not None
+    # set height limit and check hash recalculations
+    stack.height_limit = 5
+    assert stack.height_limit == 5
+    assert stack.minor is not None
+    assert no_lim_minor != stack.minor
+    assert stack.major is not None
+    assert no_lim_major != stack.major
+    # remove height limit and check hash recalculations
+    stack.height_limit = None
+    assert stack.height_limit is None
+    assert no_lim_minor == stack.minor
+    assert no_lim_major == stack.major
+
 def test_stackframe_01():
     """test creating an empty StackFrame"""
     stack = StackFrame()

From 270ea49a1c8ccefd631f1588b49997783fc2a033 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 11 Feb 2021 17:33:47 -0800
Subject: [PATCH 202/531] Add Report.is_hang

---
 grizzly/common/reporter.py      | 15 ++++++++++++---
 grizzly/common/test_reporter.py |  2 +-
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 23129640..fedad40d 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -53,11 +53,13 @@
 class Report:
     DEFAULT_MAJOR = "NO_STACK"
     DEFAULT_MINOR = "0"
+    HANG_STACK_HEIGHT = 10
     MAX_LOG_SIZE = 1048576  # 1MB
 
-    __slots__ = ("_crash_info", "_logs", "_signature", "_target_binary", "path", "prefix", "stack")
+    __slots__ = ("_crash_info", "_logs", "_signature",  "_target_binary",
+                 "is_hang", "path", "prefix", "stack")
 
-    def __init__(self, log_path, target_binary, size_limit=MAX_LOG_SIZE):
+    def __init__(self, log_path, target_binary, is_hang=False, size_limit=MAX_LOG_SIZE):
         assert isinstance(log_path, str)
         assert isinstance(target_binary, str)
         self._crash_info = None
@@ -65,6 +67,7 @@ def __init__(self, log_path, target_binary, size_limit=MAX_LOG_SIZE):
         assert self._logs is not None
         self._signature = None
         self._target_binary = target_binary
+        self.is_hang = is_hang
         self.path = log_path
         # tail files in log_path if needed
         if size_limit < 1:
@@ -79,6 +82,9 @@ def __init__(self, log_path, target_binary, size_limit=MAX_LOG_SIZE):
             with open(log_file, "rb") as log_fp:
                 stack = Stack.from_text(log_fp.read().decode("utf-8", errors="ignore"))
             if stack.frames:
+                # limit the hash calculations to the first n frames if a hang
+                # was detected to attempt to help local bucketing
+                stack.height_limit = self.HANG_STACK_HEIGHT if is_hang else None
                 self.prefix = "%s_%s" % (stack.minor[:8], strftime("%Y-%m-%d_%H-%M-%S"))
                 self.stack = stack
                 break
@@ -390,7 +396,7 @@ def tail(in_file, size_limit):
             end = in_fp.tell()
             if end <= size_limit:
                 return
-            dump_pos = max((end - size_limit), 0)
+            dump_pos = end - size_limit
             in_fp.seek(dump_pos)
             out_fd, out_file = mkstemp(prefix="taillog_", dir=grz_tmp())
             with open(out_fd, "wb") as out_fp:
@@ -617,6 +623,9 @@ def _submit_report(self, report, test_cases):
             with open(metadata_file, "w") as meta_fp:
                 dump(cache_metadata, meta_fp)
 
+        if report.is_hang:
+            self.add_extra_metadata("is_hang", True)
+
         # dump test cases and the contained files to working directory
         test_case_meta = []
         for test_number, test_case in enumerate(test_cases):
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 424da61a..630eff98 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -406,7 +406,7 @@ def test_fuzzmanager_reporter_02(mocker, tmp_path):
         env_vars={"TEST": "1"},
         input_fname="input")
     reporter = FuzzManagerReporter("fake_bin")
-    reporter.submit([fake_test], Report(str(log_path), "fake_bin"))
+    reporter.submit([fake_test], Report(str(log_path), "fake_bin", is_hang=True))
     assert not log_path.is_dir()
     assert fake_test.dump.call_count == 1
     assert fake_collector.return_value.submit.call_count == 1

From a5b044c417bfb710e6b24ba673b29559f841f573 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 11 Feb 2021 18:22:07 -0800
Subject: [PATCH 203/531] Add TestCase.hang

---
 grizzly/common/storage.py      |  7 +++++-
 grizzly/common/test_storage.py | 46 +++++++++++++++++++++++++---------
 2 files changed, 40 insertions(+), 13 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 7ee65ec9..83e6e43b 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -38,13 +38,14 @@ class TestFileExists(Exception):
 
 class TestCase:
     __slots__ = (
-        "adapter_name", "duration", "env_vars", "input_fname", "landing_page",
+        "adapter_name", "duration", "env_vars", "hang", "input_fname", "landing_page",
         "redirect_page", "timestamp", "_existing_paths", "_files")
 
     def __init__(self, landing_page, redirect_page, adapter_name, input_fname=None, timestamp=None):
         self.adapter_name = adapter_name
         self.duration = None
         self.env_vars = dict()  # environment variables
+        self.hang = False
         self.input_fname = input_fname  # file that was used to create the test case
         self.landing_page = landing_page
         self.redirect_page = redirect_page
@@ -259,6 +260,7 @@ def dump(self, out_path, include_details=False):
                 "adapter": self.adapter_name,
                 "duration": self.duration,
                 "env": self.env_vars,
+                "hang": self.hang,
                 "input": basename(self.input_fname) if self.input_fname else None,
                 "target": self.landing_page,
                 "timestamp": self.timestamp}
@@ -384,6 +386,9 @@ def load_single(cls, path, load_prefs, adjacent=False):
             raise TestCaseLoadFailure("Missing or invalid TestCase %r" % (path,))
         # create testcase and add data
         test = cls(None, None, info.get("adapter", None), timestamp=info.get("timestamp", 0))
+        test.duration = info.get("duration", None)
+        test.hang = info.get("hang", False)
+        test.input_fname = info.get("input", None)
         if load_prefs and isfile(pathjoin(path, "prefs.js")):
             test.add_meta(TestFile.from_file(pathjoin(path, "prefs.js")))
         test.add_from_file(pathjoin(path, entry_point))
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 1980ebd7..3bd2012b 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -36,7 +36,7 @@ def test_testcase_01(tmp_path):
         assert not tcase.contains("no_file")
         assert not any(tcase.optional)
         tcase.dump(str(tmp_path))
-        assert not any(tmp_path.glob("*"))
+        assert not any(tmp_path.iterdir())
         tcase.dump(str(tmp_path), include_details=True)
         assert (tmp_path / "test_info.json").is_file()
 
@@ -137,7 +137,7 @@ def test_testcase_06():
         assert tcase.data_size == 6
 
 def test_testcase_07(tmp_path):
-    """test TestCase.load_single() using a directory fail cases"""
+    """test TestCase.load_single() using a directory - fail cases"""
     # missing test_info.json
     with pytest.raises(TestCaseLoadFailure, match="Missing 'test_info.json'"):
         TestCase.load_single(str(tmp_path), True)
@@ -227,6 +227,28 @@ def test_testcase_09(tmp_path):
         assert "optional.bin" in (x.file_name for x in tcase._files.optional)
 
 def test_testcase_10(tmp_path):
+    """test TestCase - dump, load and compare"""
+    with TestCase("a.html", "b.html", "adpt") as org:
+        org.duration = 1.23
+        org.env_vars = {"en1": "1", "en2": "2"}
+        org.hang = True
+        org.input_fname = "infile"
+        org.add_from_data("a", "a.html")
+        org.dump(str(tmp_path), include_details=True)
+        loaded = TestCase.load_single(str(tmp_path), False)
+        try:
+            assert org.adapter_name == loaded.adapter_name
+            assert org.duration == loaded.duration
+            assert org.env_vars == loaded.env_vars
+            assert org.hang == loaded.hang
+            assert org.input_fname == loaded.input_fname
+            assert org.landing_page == loaded.landing_page
+            assert org.timestamp == loaded.timestamp
+            assert org._existing_paths == loaded._existing_paths
+        finally:
+            loaded.cleanup()
+
+def test_testcase_11(tmp_path):
     """test TestCase.load() - missing file and empty directory"""
     # missing file
     with pytest.raises(TestCaseLoadFailure, match="Invalid TestCase path"):
@@ -234,7 +256,7 @@ def test_testcase_10(tmp_path):
     # empty path
     assert not TestCase.load(str(tmp_path), True)
 
-def test_testcase_11(tmp_path):
+def test_testcase_12(tmp_path):
     """test TestCase.load() - single file"""
     tfile = (tmp_path / "testcase.html")
     tfile.touch()
@@ -244,7 +266,7 @@ def test_testcase_11(tmp_path):
     finally:
         map(lambda x: x.cleanup, testcases)
 
-def test_testcase_12(tmp_path):
+def test_testcase_13(tmp_path):
     """test TestCase.load() - single directory"""
     with TestCase("target.bin", None, "test-adapter") as src:
         src.add_from_data("test", "target.bin")
@@ -255,7 +277,7 @@ def test_testcase_12(tmp_path):
     finally:
         map(lambda x: x.cleanup, testcases)
 
-def test_testcase_13(tmp_path):
+def test_testcase_14(tmp_path):
     """test TestCase.load() - multiple directories"""
     nested = (tmp_path / "nested")
     nested.mkdir()
@@ -272,7 +294,7 @@ def test_testcase_13(tmp_path):
     # try loading testcases that are nested too deep
     assert not TestCase.load(str(tmp_path), False)
 
-def test_testcase_14(tmp_path):
+def test_testcase_15(tmp_path):
     """test TestCase.load() - archive"""
     archive = tmp_path / "testcase.zip"
     # bad archive
@@ -302,7 +324,7 @@ def test_testcase_14(tmp_path):
     finally:
         map(lambda x: x.cleanup, testcases)
 
-def test_testcase_15(tmp_path):
+def test_testcase_16(tmp_path):
     """test TestCase.load_environ()"""
     (tmp_path / "ubsan.supp").touch()
     (tmp_path / "other_file").touch()
@@ -319,7 +341,7 @@ def test_testcase_15(tmp_path):
         assert "b=2" in opts
         assert len(opts) == 3
 
-def test_testcase_16(tmp_path):
+def test_testcase_17(tmp_path):
     """test TestCase.add_batch()"""
     include = (tmp_path / "inc_path")
     include.mkdir()
@@ -355,11 +377,11 @@ def test_testcase_16(tmp_path):
         with pytest.raises(TestFileExists, match="'file.bin' exists in test"):
             tcase.add_batch(str(include), [str(inc_1)])
 
-def test_testcase_17(tmp_path):
+def test_testcase_18(tmp_path):
     """test TestCase.scan_path()"""
     # empty path
     (tmp_path / "not-test").mkdir()
-    assert not tuple(TestCase.scan_path(str(tmp_path)))
+    assert not any(TestCase.scan_path(str(tmp_path)))
     # multiple test case directories
     paths = [str(tmp_path / ("test-%d" % i)) for i in range(3)]
     with TestCase("test.htm", None, "test-adapter") as src:
@@ -372,14 +394,14 @@ def test_testcase_17(tmp_path):
     tc_paths = list(TestCase.scan_path(str(paths[0])))
     assert len(tc_paths) == 1
 
-def test_testcase_18():
+def test_testcase_19():
     """test TestCase.get_file()"""
     with TestCase("test.htm", None, "test-adapter") as src:
         src.add_from_data("test", "test.htm")
         assert src.get_file("missing") is None
         assert src.get_file("test.htm").data == b"test"
 
-def test_testcase_19():
+def test_testcase_20():
     """test TestCase.clone()"""
     with TestCase("test.htm", "redirect.htm", "test-adaptor", "input.py") as src:
         src.add_from_data("123", "test.htm")

From 4a6bc97ca036a3db6d9bf145aadd06c3b5aecb0a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 11 Feb 2021 18:29:45 -0800
Subject: [PATCH 204/531] Add Target.handle_hang()

---
 grizzly/target/puppet_target.py      |  80 +++++++++++---------
 grizzly/target/target.py             |   8 +-
 grizzly/target/test_puppet_target.py | 108 +++++++++++++++------------
 grizzly/target/test_target.py        |   8 +-
 4 files changed, 117 insertions(+), 87 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 07fdb9ef..25403458 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -48,18 +48,6 @@ def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, *
         if kwds:
             LOG.warning("PuppetTarget ignoring unsupported arguments: %s", ", ".join(kwds))
 
-    def _abort_hung_proc(self):
-        # send SIGABRT to the busiest process
-        with self._lock:
-            proc_usage = self._puppet.cpu_usage()
-        for pid, cpu in sorted(proc_usage, reverse=True, key=lambda x: x[1]):
-            LOG.debug("sending SIGABRT to pid: %r, cpu: %0.2f%%", pid, cpu)
-            try:
-                kill(pid, SIGABRT)
-            except OSError:
-                LOG.warning("Failed to send SIGABRT to pid %d", pid)
-            break
-
     def add_abort_token(self, token):
         self._puppet.add_abort_token(token)
 
@@ -85,10 +73,10 @@ def is_idle(self, threshold):
                 return False
         return True
 
-    def create_report(self):
+    def create_report(self, is_hang=False):
         logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
         self.save_logs(logs)
-        return Report(logs, self.binary)
+        return Report(logs, self.binary, is_hang=is_hang)
 
     @property
     def monitor(self):
@@ -109,42 +97,64 @@ def log_length(_, log_id):
             self._monitor = _PuppetMonitor()
         return self._monitor
 
-    def detect_failure(self, ignored, was_timeout):
+    def detect_failure(self, ignored):
         status = self.RESULT_NONE
-        is_healthy = self._puppet.is_healthy()
-        # check if there has been a crash, hang, etc...
-        if not is_healthy or was_timeout:
+        # check if there has been a crash, hangs will appear as SIGABRT
+        if not self._puppet.is_healthy():
             if self._puppet.is_running():
-                LOG.debug("terminating browser...")
-                if was_timeout and "timeout" not in ignored and system() == "Linux":
-                    self._abort_hung_proc()
-                    # give the process a moment to start dump
-                    self._puppet.wait(timeout=1)
-            self.close()
-        # if something has happened figure out what
-        if not is_healthy:
+                LOG.debug("browser in bad state, closing...")
+                self.close()
+            # if something has happened figure out what
             if self._puppet.reason == FFPuppet.RC_CLOSED:
                 LOG.debug("target.close() was called")
             elif self._puppet.reason == FFPuppet.RC_EXITED:
                 LOG.debug("target closed itself")
-            elif (self._puppet.reason == FFPuppet.RC_WORKER
-                  and "memory" in ignored
-                  and "ffp_worker_memory_usage" in self._puppet.available_logs()):
+            elif (
+                self._puppet.reason == FFPuppet.RC_WORKER
+                and "memory" in ignored
+                and "ffp_worker_memory_usage" in self._puppet.available_logs()
+            ):
                 status = self.RESULT_IGNORED
                 LOG.debug("memory limit exceeded")
-            elif (self._puppet.reason == FFPuppet.RC_WORKER
-                  and "log-limit" in ignored
-                  and "ffp_worker_log_size" in self._puppet.available_logs()):
+            elif (
+                self._puppet.reason == FFPuppet.RC_WORKER
+                and "log-limit" in ignored
+                and "ffp_worker_log_size" in self._puppet.available_logs()
+            ):
                 status = self.RESULT_IGNORED
                 LOG.debug("log size limit exceeded")
             else:
+                # crash or hang (forced SIGABRT) has been detected
                 LOG.debug("failure detected, ffpuppet reason %r", self._puppet.reason)
                 status = self.RESULT_FAILURE
-        elif was_timeout:
-            LOG.debug("timeout detected")
-            status = self.RESULT_IGNORED if "timeout" in ignored else self.RESULT_FAILURE
         return status
 
+    def handle_hang(self, ignore_idle=True):
+        was_idle = False
+        if system() != "Linux":
+            # sending SIGABRT is only supported on Linux for now
+            # TODO: add/test on other OSs
+            self.close()
+        elif self._puppet.is_healthy():
+            with self._lock:
+                proc_usage = self._puppet.cpu_usage()
+            for pid, cpu in sorted(proc_usage, reverse=True, key=lambda x: x[1]):
+                if ignore_idle and cpu < 15:
+                    # don't send SIGABRT if process is idle
+                    LOG.debug("ignoring idle hang (%0.1f%%)", cpu)
+                    was_idle = True
+                    break
+                LOG.debug("sending SIGABRT to busy process: %r (%0.1f%%)", pid, cpu)
+                try:
+                    kill(pid, SIGABRT)
+                except OSError:
+                    LOG.warning("Failed to send SIGABRT to pid %d", pid)
+                self._puppet.wait(timeout=10)
+                break
+            # always close target when hung
+            self.close()
+        return was_idle
+
     def dump_coverage(self, timeout=15):
         assert SIGUSR1 is not None
         pid = self._puppet.get_pid()
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 0e91bb49..348fde20 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -95,16 +95,20 @@ def closed(self):
         pass
 
     @abstractmethod
-    def create_report(self):
+    def create_report(self, is_hang=False):
         pass
 
     @abstractmethod
-    def detect_failure(self, ignored, was_timeout):
+    def detect_failure(self, ignored):
         pass
 
     def dump_coverage(self):  # pylint: disable=no-self-use
         LOG.warning("dump_coverage() is not supported!")
 
+    @abstractmethod
+    def handle_hang(self, ignore_idle=True):
+        pass
+
     # TODO: move to monitor?
     def is_idle(self, threshold):  # pylint: disable=no-self-use,unused-argument
         LOG.debug("Target.is_idle() not implemented! returning False")
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index e56d00e9..432a9279 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -26,7 +26,7 @@ def test_puppet_target_01(mocker, tmp_path):
         prefs_file = target.prefs
         assert isfile(prefs_file)
         assert target._remove_prefs
-        assert target.detect_failure([], False) == Target.RESULT_NONE
+        assert target.detect_failure([]) == Target.RESULT_NONE
         assert target.log_size() == 1124
         fake_ffp.return_value.log_length.assert_any_call("stderr")
         fake_ffp.return_value.log_length.assert_any_call("stdout")
@@ -84,91 +84,105 @@ def test_puppet_target_03(mocker, tmp_path):
     # no failures
     fake_ffp.return_value.is_healthy.return_value = True
     fake_ffp.return_value.reason = None
-    assert target.detect_failure([], False) == Target.RESULT_NONE
-    assert target.detect_failure(["memory"], False) == Target.RESULT_NONE
+    assert target.detect_failure([]) == Target.RESULT_NONE
+    assert fake_ffp.return_value.is_running.call_count == 0
     assert not target.closed
     fake_ffp.reset_mock()
     # test close
     fake_ffp.return_value.is_healthy.return_value = False
     fake_ffp.return_value.is_running.return_value = False
     fake_ffp.return_value.reason = FFPuppet.RC_CLOSED
-    assert target.detect_failure([], False) == Target.RESULT_NONE
-    assert fake_ffp.return_value.is_running.call_count == 1
+    assert target.detect_failure([]) == Target.RESULT_NONE
     assert fake_ffp.return_value.is_healthy.call_count == 1
-    assert fake_ffp.return_value.close.call_count == 1
+    assert fake_ffp.return_value.is_running.call_count == 1
+    assert fake_ffp.return_value.close.call_count == 0
     fake_ffp.reset_mock()
     # test single process crash
     fake_ffp.return_value.is_healthy.return_value = False
     fake_ffp.return_value.is_running.return_value = False
     fake_ffp.return_value.reason = FFPuppet.RC_ALERT
-    assert target.detect_failure([], False) == Target.RESULT_FAILURE
-    assert fake_ffp.return_value.close.call_count == 1
+    assert target.detect_failure([]) == Target.RESULT_FAILURE
+    assert fake_ffp.return_value.close.call_count == 0
     fake_ffp.reset_mock()
     # test multiprocess crash
     fake_ffp.return_value.is_healthy.return_value = False
     fake_ffp.return_value.is_running.return_value = True
     fake_ffp.return_value.reason = FFPuppet.RC_ALERT
-    assert target.detect_failure([], False) == Target.RESULT_FAILURE
+    assert target.detect_failure([]) == Target.RESULT_FAILURE
     assert fake_ffp.return_value.close.call_count == 1
     fake_ffp.reset_mock()
     # test exit with no crash logs
     fake_ffp.return_value.is_healthy.return_value = False
     fake_ffp.return_value.is_running.return_value = False
     fake_ffp.return_value.reason = FFPuppet.RC_EXITED
-    assert target.detect_failure([], False) == Target.RESULT_NONE
-    assert fake_ffp.return_value.close.call_count == 1
-    fake_ffp.reset_mock()
-    # test timeout
-    fake_ffp.return_value.is_healthy.return_value = True
-    fake_ffp.return_value.is_running.return_value = True
-    fake_ffp.return_value.reason = None
-    fake_ffp.return_value.cpu_usage.return_value = ((1234, 10), (1236, 75), (1238, 60))
-    # raise OSError for code coverage
-    fake_kill = mocker.patch(
-        "grizzly.target.puppet_target.kill",
-        autospec=True,
-        side_effect=OSError)
-    assert target.detect_failure([], True) == Target.RESULT_FAILURE
-    if system() == "Linux":
-        assert fake_kill.call_count == 1
-        assert fake_ffp.return_value.wait.call_count == 1
-    else:
-        assert fake_kill.call_count == 0
-        assert fake_ffp.return_value.wait.call_count == 0
-    assert fake_ffp.return_value.close.call_count == 1
-    fake_ffp.reset_mock()
-    # test timeout ignored
-    fake_ffp.return_value.is_healthy.return_value = True
-    fake_ffp.return_value.is_running.return_value = True
-    fake_ffp.return_value.reason = None
-    assert target.detect_failure(["timeout"], True) == Target.RESULT_IGNORED
-    assert fake_ffp.return_value.close.call_count == 1
+    assert target.detect_failure([]) == Target.RESULT_NONE
+    assert fake_ffp.return_value.close.call_count == 0
     fake_ffp.reset_mock()
     # test worker
     fake_ffp.return_value.is_healthy.return_value = False
     fake_ffp.return_value.is_running.return_value = False
     fake_ffp.return_value.reason = FFPuppet.RC_WORKER
-    assert target.detect_failure([], False) == Target.RESULT_FAILURE
-    assert fake_ffp.return_value.close.call_count == 1
+    assert target.detect_failure([]) == Target.RESULT_FAILURE
+    assert fake_ffp.return_value.close.call_count == 0
     fake_ffp.reset_mock()
     # test memory ignored
     fake_ffp.return_value.is_healthy.return_value = False
     fake_ffp.return_value.is_running.return_value = False
     fake_ffp.return_value.reason = FFPuppet.RC_WORKER
     fake_ffp.return_value.available_logs.return_value = " ffp_worker_memory_usage "
-    assert target.detect_failure(["memory"], False) == Target.RESULT_IGNORED
-    assert fake_ffp.return_value.close.call_count == 1
+    assert target.detect_failure(["memory"]) == Target.RESULT_IGNORED
+    assert fake_ffp.return_value.close.call_count == 0
     fake_ffp.reset_mock()
     # test log-limit ignored
     fake_ffp.return_value.is_healthy.return_value = False
     fake_ffp.return_value.is_running.return_value = False
     fake_ffp.return_value.reason = FFPuppet.RC_WORKER
     fake_ffp.return_value.available_logs.return_value = " ffp_worker_log_size "
-    assert target.detect_failure(["log-limit"], False) == Target.RESULT_IGNORED
+    assert target.detect_failure(["log-limit"]) == Target.RESULT_IGNORED
+    assert fake_ffp.return_value.close.call_count == 0
+
+def test_puppet_target_04(mocker, tmp_path):
+    """test PuppetTarget.handle_hang()"""
+    fake_system = mocker.patch("grizzly.target.puppet_target.system", autospec=True)
+    fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
+    fake_file = tmp_path / "fake"
+    fake_file.touch()
+    target = PuppetTarget(str(fake_file), None, 300, 25, 5000)
+    # test skipping unsupported OSs
+    fake_system.return_value = "Window"
+    target.handle_hang()
+    assert fake_ffp.return_value.is_healthy.call_count == 0
+    assert fake_ffp.return_value.close.call_count == 1
+    fake_ffp.reset_mock()
+    # test skipping closing target if it is in a bad state
+    fake_system.return_value = "Linux"
+    fake_ffp.return_value.is_healthy.return_value = False
+    target.handle_hang()
+    assert fake_ffp.return_value.close.call_count == 0
+    fake_ffp.reset_mock()
+    # test timeout
+    fake_ffp.return_value.is_healthy.return_value = True
+    fake_ffp.return_value.cpu_usage.return_value = ((1234, 10), (1236, 75), (1238, 60))
+    # raise OSError for code coverage
+    fake_kill = mocker.patch(
+        "grizzly.target.puppet_target.kill",
+        autospec=True,
+        side_effect=OSError)
+    target.handle_hang()
+    assert fake_kill.call_count == 1
+    assert fake_ffp.return_value.wait.call_count == 1
+    assert fake_ffp.return_value.close.call_count == 1
+    fake_ffp.reset_mock()
+    fake_kill.reset_mock()
+    # test ignore idle timeout (close don't abort)
+    fake_ffp.return_value.is_healthy.return_value = True
+    fake_ffp.return_value.cpu_usage.return_value = ((1234, 10),)
+    target.handle_hang(ignore_idle=True)
+    assert fake_kill.call_count == 0
     assert fake_ffp.return_value.close.call_count == 1
 
 @mark.skipif(system() == "Windows", reason="Unsupported on Windows")
-def test_puppet_target_04(mocker, tmp_path):
+def test_puppet_target_05(mocker, tmp_path):
     """test PuppetTarget.dump_coverage()"""
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_proc = mocker.patch("grizzly.target.puppet_target.Process", autospec=True)
@@ -259,8 +273,8 @@ def test_puppet_target_04(mocker, tmp_path):
     fake_kill.reset_mock()
     fake_proc_iter.reset_mock()
 
-def test_puppet_target_05(mocker, tmp_path):
-    """test is_idle()"""
+def test_puppet_target_06(mocker, tmp_path):
+    """test PuppetTarget.is_idle()"""
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_ffp.return_value.cpu_usage.return_value = [(999, 30), (998, 20), (997, 10)]
     fake_file = tmp_path / "fake"
@@ -270,7 +284,7 @@ def test_puppet_target_05(mocker, tmp_path):
         assert not target.is_idle(25)
         assert target.is_idle(50)
 
-def test_puppet_target_06(mocker, tmp_path):
+def test_puppet_target_07(mocker, tmp_path):
     """test PuppetTarget.monitor"""
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_file = tmp_path / "fake"
@@ -292,7 +306,7 @@ def test_puppet_target_06(mocker, tmp_path):
         target.monitor.clone_log("somelog")
         assert fake_ffp.return_value.clone_log.call_count == 1
 
-def test_puppet_target_07(mocker, tmp_path):
+def test_puppet_target_08(mocker, tmp_path):
     """test PuppetTarget.prefs"""
     mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_file = tmp_path / "fake"
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index f639c26c..220ed64f 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -13,9 +13,11 @@ def close(self):
     @property
     def closed(self):
         pass
-    def create_report(self):
+    def create_report(self, is_hang=False):
         pass
-    def detect_failure(self, ignored, was_timeout):
+    def detect_failure(self, ignored):
+        pass
+    def handle_hang(self, ignore_idle=True):
         pass
     def launch(self):
         pass
@@ -25,7 +27,7 @@ def monitor(self):
     @property
     def prefs(self):
         pass
-    def save_logs(self, *args, **kwargs):
+    def save_logs(self, *_args, **_kwargs):
         pass
 
 def test_target_01(tmp_path):

From 729e784d25380679bbdaca851206c875e212204b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 11 Feb 2021 18:30:46 -0800
Subject: [PATCH 205/531] Fix Status nits

---
 grizzly/common/status.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index da90365e..d861f7d0 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -36,7 +36,7 @@ class Status:
         "iteration", "log_size", "pid", "start_time", "test_name", "timestamp")
 
     def __init__(self, data_file, enable_profiling=False, start_time=None):
-        assert ".json" in data_file
+        assert data_file.endswith(".json")
         assert start_time is None or isinstance(start_time, float)
         self._lock = InterProcessLock("%s.lock" % (data_file,))
         self._enable_profiling = enable_profiling
@@ -63,11 +63,11 @@ def cleanup(self):
         """
         if self.data_file is None:
             return
-        with self._lock:
-            try:
+        try:
+            with self._lock:
                 unlink(self.data_file)
-            except OSError:  # pragma: no cover
-                LOG.warning("Failed to delete %r", self.data_file)
+        except OSError:  # pragma: no cover
+            LOG.warning("Failed to delete %r", self.data_file)
         try:
             unlink("%s.lock" % (self.data_file,))
         except OSError:  # pragma: no cover

From ce32c7b7f9f7cc818f612a2f0c0d19c4217b1afa Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 11 Feb 2021 18:33:27 -0800
Subject: [PATCH 206/531] Use Target.handle_hang() in Runner

---
 grizzly/common/harness.html   |   4 +-
 grizzly/common/runner.py      |  27 ++++----
 grizzly/common/test_runner.py | 121 +++++++++++++++++++---------------
 3 files changed, 86 insertions(+), 66 deletions(-)

diff --git a/grizzly/common/harness.html b/grizzly/common/harness.html
index 6aa8af3c..129f7a7a 100644
--- a/grizzly/common/harness.html
+++ b/grizzly/common/harness.html
@@ -74,7 +74,7 @@
     return
   }
 
-  // set the test case timeout once the test loading ends
+  // set the test case time limit
   if (time_limit > 0) {
     grzDump(`Using test case time limit of ${time_limit}`)
     sub.addEventListener('abort', setTestTimeout)
@@ -90,7 +90,7 @@
   if (args) {
     for (let kv of args.split('&')) {
       let [k, v] = kv.split('=')
-      if (k === 'timeout') {
+      if (k === 'time_limit') {
         time_limit = Number(v)
       } else if (k === 'close_after') {
         close_after = Number(v)
diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index c78551c0..17abfa34 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -143,14 +143,14 @@ def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
         self._tests_run = 0
 
     @staticmethod
-    def location(srv_path, srv_port, close_after=None, timeout=None):
+    def location(srv_path, srv_port, close_after=None, test_duration=None):
         """Build a valid URL to pass to a browser.
 
         Args:
             srv_path (str): Path segment of the URL
             srv_port (int): Server listening port
             close_after (int): Harness argument.
-            timeout (int): Harness argument.
+            test_duration (int): Harness argument.
 
         Returns:
             str: A valid URL.
@@ -161,9 +161,9 @@ def location(srv_path, srv_port, close_after=None, timeout=None):
         if close_after is not None:
             assert close_after >= 0
             args.append("close_after=%d" % (close_after,))
-        if timeout is not None:
-            assert timeout >= 0
-            args.append("timeout=%d" % (timeout * 1000,))
+        if test_duration is not None:
+            assert test_duration >= 0
+            args.append("time_limit=%d" % (test_duration * 1000,))
         if args:
             return "?".join([location, "&".join(args)])
         return location
@@ -225,6 +225,10 @@ def run(
         # add all include files that were served
         for url, resource in server_map.include.items():
             testcase.add_batch(resource.target, result.served, prefix=url)
+        if result.timeout:
+            LOG.debug("timeout detected")
+            if self._target.handle_hang(ignore_idle=True) or "timeout" in ignore:
+                result.status = RunResult.IGNORED
         if result.attempted:
             self._tests_run += 1
             if coverage and not result.timeout:
@@ -232,7 +236,7 @@ def run(
                 # to help catch any coverage related issues.
                 self._target.dump_coverage()
             # relaunch check
-            if self._tests_run >= self._relaunch:
+            if self._tests_run >= self._relaunch and not result.timeout:
                 assert self._tests_run == self._relaunch
                 server_map.dynamic.pop("grz_empty", None)
                 LOG.debug("relaunch/shutdown limit hit")
@@ -261,11 +265,12 @@ def run(
             LOG.debug("landing page %r not served!", testcase.landing_page)
             self._target.close()
         # detect failure
-        failure_detected = self._target.detect_failure(ignore, result.timeout)
-        if failure_detected == self._target.RESULT_FAILURE:
-            result.status = RunResult.FAILED
-        elif failure_detected == self._target.RESULT_IGNORED:
-            result.status = RunResult.IGNORED
+        if result.status is None:
+            failure_detected = self._target.detect_failure(ignore)
+            if failure_detected == self._target.RESULT_FAILURE:
+                result.status = RunResult.FAILED
+            elif failure_detected == self._target.RESULT_IGNORED:
+                result.status = RunResult.IGNORED
         return result
 
     def _keep_waiting(self):
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 11947dcb..0b1b3b16 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -6,7 +6,7 @@
 from itertools import count
 from os.path import join as pathjoin
 
-from pytest import raises
+from pytest import mark, raises
 
 from sapphire import Sapphire, SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT, ServerMap
 
@@ -39,6 +39,7 @@ def test_runner_01(mocker, tmp_path):
     assert not result.timeout
     assert target.close.call_count == 0
     assert target.dump_coverage.call_count == 0
+    assert target.handle_hang.call_count == 0
     assert testcase.dump.call_count == 1
     # some files served
     server.serve_path.return_value = (SERVED_REQUEST, serv_files)
@@ -51,6 +52,7 @@ def test_runner_01(mocker, tmp_path):
     assert not result.timeout
     assert target.close.call_count == 0
     assert target.dump_coverage.call_count == 1
+    assert target.handle_hang.call_count == 0
     # existing test path
     testcase.reset_mock()
     tc_path = (tmp_path / "tc")
@@ -129,79 +131,89 @@ def test_runner_02(mocker):
     assert not smap.dynamic
     assert smap.redirect.get("grz_next_test").target == "grz_empty"
 
-def test_runner_03(mocker):
+@mark.parametrize(
+    "srv_result, served",
+    [
+        # no files served
+        (SERVED_NONE, []),
+        # landing page not served
+        (SERVED_REQUEST, ["harness"]),
+    ]
+)
+def test_runner_03(mocker, srv_result, served):
     """test Runner() errors"""
     server = mocker.Mock(spec=Sapphire)
+    server.serve_path.return_value = (srv_result, served)
     target = mocker.Mock(spec=Target)
+    target.detect_failure.return_value = target.RESULT_NONE
     testcase = mocker.Mock(spec=TestCase, landing_page="x", optional=[])
     runner = Runner(server, target)
-    # no files served
-    server.serve_path.return_value = (SERVED_NONE, [])
-    target.detect_failure.return_value = target.RESULT_NONE
     result = runner.run([], ServerMap(), testcase)
     assert result.status is None
     assert not result.attempted
     assert result.initial
-    assert not result.served
+    assert set(result.served) == set(served)
     assert not result.timeout
     assert target.close.call_count == 1
-    target.reset_mock()
-    # landing page not served
-    server.serve_path.return_value = (SERVED_REQUEST, ["harness"])
-    result = runner.run([], ServerMap(), testcase)
-    assert result.status is None
-    assert not result.attempted
-    assert result.initial
-    assert result.served
-    assert target.close.call_count == 1
 
-def test_runner_04(mocker):
+@mark.parametrize(
+    "ignore, status, idle, detect_failure",
+    [
+        # detect a hang
+        (["memory"], RunResult.FAILED, False, 1),
+        # ignore a hang
+        (["timeout"], RunResult.IGNORED, False, 0),
+        # ignore idle hang
+        ([], RunResult.IGNORED, True, 0),
+    ]
+)
+def test_runner_04(mocker, ignore, status, idle, detect_failure):
     """test reporting timeout"""
     server = mocker.Mock(spec=Sapphire)
     target = mocker.Mock(spec=Target)
+    testcase = mocker.Mock(spec=TestCase, landing_page="a.bin", optional=[])
     serv_files = ["a.bin", "/another/file.bin"]
     server.serve_path.return_value = (SERVED_TIMEOUT, serv_files)
-    runner = Runner(server, target)
     target.detect_failure.return_value = target.RESULT_FAILURE
-    result = runner.run([], ServerMap(), mocker.Mock(spec=TestCase, landing_page="x", optional=[]))
-    assert result.status == RunResult.FAILED
+    target.handle_hang.return_value = idle
+    target.monitor.is_healthy.return_value = False
+    runner = Runner(server, target)
+    result = runner.run(ignore, ServerMap(), testcase)
+    assert result.status == status
     assert result.served == serv_files
     assert result.timeout
+    assert target.detect_failure.call_count == detect_failure
+    assert target.handle_hang.call_count == 1
 
-def test_runner_05(mocker):
+@mark.parametrize(
+    "served, attempted, target_result, status",
+    [
+        # FAILURE
+        (["a.bin"], True, Target.RESULT_FAILURE, RunResult.FAILED),
+        # IGNORED
+        (["a.bin"], True, Target.RESULT_IGNORED, RunResult.IGNORED),
+        # failure before serving landing page
+        (["harness"], False, Target.RESULT_FAILURE, RunResult.FAILED),
+    ]
+)
+def test_runner_05(mocker, served, attempted, target_result, status):
     """test reporting failures"""
     server = mocker.Mock(spec=Sapphire)
+    server.serve_path.return_value = (SERVED_REQUEST, served)
     target = mocker.Mock(spec=Target, launch_timeout=10)
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
+    target.RESULT_IGNORED = Target.RESULT_IGNORED
+    target.detect_failure.return_value = target_result
     target.monitor.is_healthy.return_value = False
-    serv_files = ["file.bin"]
-    server.serve_path.return_value = (SERVED_REQUEST, serv_files)
-    testcase = mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[])
+    testcase = mocker.Mock(spec=TestCase, landing_page="a.bin", optional=[])
     runner = Runner(server, target)
-    # test FAILURE
-    target.detect_failure.return_value = target.RESULT_FAILURE
-    runner.launch("http://a/")
-    result = runner.run([], ServerMap(), testcase)
-    assert result.attempted
-    assert result.status == RunResult.FAILED
-    assert result.served == serv_files
-    assert not result.timeout
-    # test IGNORED
-    target.detect_failure.return_value = target.RESULT_IGNORED
     runner.launch("http://a/")
     result = runner.run([], ServerMap(), testcase)
-    assert result.attempted
-    assert result.status == RunResult.IGNORED
-    assert result.served == serv_files
-    assert not result.timeout
-    # failure before serving landing page
-    server.serve_path.return_value = (SERVED_REQUEST, ["harness"])
-    target.detect_failure.return_value = target.RESULT_FAILURE
-    runner.launch("http://a/")
-    result = runner.run([], ServerMap(), testcase)
-    assert not result.attempted
-    assert result.status == RunResult.FAILED
-    assert result.served
+    assert result.attempted == attempted
+    assert result.status == status
     assert not result.timeout
+    assert target.handle_hang.call_count == 0
+    assert target.close.call_count == 1
 
 def test_runner_06(mocker):
     """test Runner() with idle checking"""
@@ -212,7 +224,10 @@ def test_runner_06(mocker):
     server.serve_path.return_value = (SERVED_REQUEST, serv_files)
     runner = Runner(server, target, idle_threshold=0.01, idle_delay=0.01, relaunch=10)
     assert runner._idle is not None
-    result = runner.run([], ServerMap(), mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[]))
+    result = runner.run(
+        [],
+        ServerMap(),
+        mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[]))
     assert result.status is None
     assert result.attempted
     assert target.close.call_count == 0
@@ -250,29 +265,29 @@ def test_runner_08():
     assert result == "http://127.0.0.1:34567/a.html"
     result = Runner.location("a.html", 34567, close_after=10)
     assert result == "http://127.0.0.1:34567/a.html?close_after=10"
-    result = Runner.location("a.html", 9999, timeout=60)
-    assert result == "http://127.0.0.1:9999/a.html?timeout=60000"
-    result = Runner.location("a.html", 9999, close_after=10, timeout=60)
-    assert result == "http://127.0.0.1:9999/a.html?close_after=10&timeout=60000"
+    result = Runner.location("a.html", 9999, test_duration=60)
+    assert result == "http://127.0.0.1:9999/a.html?time_limit=60000"
+    result = Runner.location("a.html", 9999, close_after=10, test_duration=60)
+    assert result == "http://127.0.0.1:9999/a.html?close_after=10&time_limit=60000"
 
 def test_runner_09(mocker):
     """test Runner.launch()"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     target = mocker.Mock(spec=Target, launch_timeout=30)
-
     runner = Runner(server, target)
+    # successful launch
     runner._tests_run = 1
     runner.launch("http://a/")
     assert runner._tests_run == 0
     assert target.launch.call_count == 1
     target.reset_mock()
-
+    # target launch error
     target.launch.side_effect = TargetLaunchError("test", mocker.Mock(spec=Report))
     with raises(TargetLaunchError, match="test"):
         runner.launch("http://a/")
     assert target.launch.call_count == 3
     target.reset_mock()
-
+    # target launch timeout
     target.launch.side_effect = TargetLaunchTimeout
     with raises(TargetLaunchTimeout):
         runner.launch("http://a/", max_retries=3)

From 04f9227417d13cc59b29ba2c7d7caf57c68dfeaa Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 11 Feb 2021 18:37:49 -0800
Subject: [PATCH 207/531] Update hang detection support in Session

* Add `--test-duration` argument
---
 grizzly/args.py         | 18 ++++++++++--
 grizzly/main.py         | 22 +++++++++++----
 grizzly/session.py      | 17 +++++++-----
 grizzly/test_main.py    | 47 ++++++++++++++++++++++++++-----
 grizzly/test_session.py | 61 +++++++++++++++++++++++++++++++----------
 5 files changed, 129 insertions(+), 36 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index cc1b85f4..7e13a853 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -81,10 +81,18 @@ def __init__(self):
             "--relaunch", type=int, default=1000,
             help="Number of iterations performed before relaunching the browser (default: %(default)s)")
         self.launcher_grp.add_argument(
-            "-t", "--timeout", type=int, default=60,
-            help="Iteration or test case timeout in seconds (default: %(default)s)."
+            "-t", "--test-duration", type=int, default=None,
+            help="This is the maximum amount of time that a test is expected to take."
+                 " After the time has elapsed the harness will attempt to close the test."
+                 " By default `Adapter.TEST_DURATION` is used."
                  " Browser build types and debuggers can affect the amount of time"
                  " required to run a test case.")
+        self.launcher_grp.add_argument(
+            "-t", "--timeout", type=int, default=None,
+            help="Iteration timeout in seconds. By default this is `test-duration`+30s."
+                 " If the timeout is reached the target is assumed to be in a bad state"
+                 " and will be closed. Typically this should be ~30s greater than"
+                 " the value used for `test-duration`.")
         self.launcher_grp.add_argument(
             "--valgrind", action="store_true",
             help="Use Valgrind (Linux only)")
@@ -161,6 +169,12 @@ def sanity_check(self, args):
         if args.prefs and not isfile(args.prefs):
             self.parser.error("-p/--prefs not found %r" % args.prefs)
 
+        if args.test_duration is not None and args.test_duration < 1:
+            self.parser.error("--test-duration must be at least 1")
+
+        if args.timeout is not None and args.timeout < 1:
+            self.parser.error("--timeout must be at least 1")
+
         if "tool" not in self._sanity_skip:
             if args.tool is not None and not args.fuzzmanager:
                 self.parser.error("--tool can only be given with --fuzzmanager")
diff --git a/grizzly/main.py b/grizzly/main.py
index 0bbd583c..be751820 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -61,14 +61,23 @@ def main(args):
         LOG.debug("initializing Adapter %r", args.adapter)
         adapter = get_adapter(args.adapter)()
 
-        if args.timeout <= adapter.TEST_DURATION:
-            LOG.info("Using minimum adapter timeout: %ds", adapter.TEST_DURATION)
-            if adapter.HARNESS_FILE:
-                LOG.info("To avoid Target relaunches due to tests failing to close"
-                         " themselves use a timeout > 'adapter.TEST_DURATION'")
-            timeout = adapter.TEST_DURATION
+        # test duration and timeout sanity checking
+        if args.test_duration:
+            test_duration = args.test_duration
         else:
+            assert adapter.TEST_DURATION >= 1
+            test_duration = adapter.TEST_DURATION
+        if args.timeout:
             timeout = args.timeout
+        else:
+            timeout = test_duration + 30
+        LOG.info("Using test duration: %ds, timeout: %ds", test_duration, timeout)
+        if timeout < test_duration:
+            LOG.error("timeout must be at least test duration if not greater")
+            return Session.EXIT_ARGS
+        if adapter.HARNESS_FILE and test_duration == timeout:
+            LOG.info("To avoid relaunches due to tests failing to close"
+                     " themselves use a timeout greater than test duration")
 
         if adapter.RELAUNCH > 0:
             LOG.info("Relaunch (%d) set in Adapter", adapter.RELAUNCH)
@@ -132,6 +141,7 @@ def main(args):
                 display_mode = Session.DISPLAY_NORMAL
             session.run(
                 args.ignore,
+                test_duration,
                 iteration_limit=args.limit,
                 display_mode=display_mode)
 
diff --git a/grizzly/session.py b/grizzly/session.py
index 00d99f95..8ea78863 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -66,7 +66,7 @@ class Session:
                  "status", "target")
 
     def __init__(self, adapter, iomanager, reporter, server, target,
-                 coverage=False, enable_profiling=True, relaunch=1):
+                 coverage=False, enable_profiling=False, relaunch=1):
         self._relaunch = relaunch
         self.adapter = adapter
         self.coverage = coverage
@@ -108,7 +108,8 @@ def generate_testcase(self):
             test.add_meta(TestFile.from_file(self.target.prefs, "prefs.js"))
         return test
 
-    def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
+    def run(self, ignore, test_duration, iteration_limit=0, display_mode=DISPLAY_NORMAL):
+        assert test_duration > 0
         assert iteration_limit >= 0
         log_limiter = LogOutputLimiter(verbose=display_mode == self.DISPLAY_VERBOSE)
         # limit relaunch to max iterations if needed
@@ -131,13 +132,11 @@ def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
                     location = runner.location("/grz_current_test", self.server.port)
                 else:
                     # harness is in use, open it and it will open the test case.
-                    # use adapter.TEST_DURATION to allow the harness to attempt to
-                    # close test cases when server timeout is greater.
                     location = runner.location(
                         "/grz_harness",
                         self.server.port,
                         close_after=relaunch,
-                        timeout=self.adapter.TEST_DURATION)
+                        test_duration=test_duration)
                 try:
                     with self.status.measure("launch"):
                         runner.launch(location, max_retries=3, retry_delay=0)
@@ -167,6 +166,7 @@ def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
             current_test.duration = result.duration
             # adapter callbacks
             if result.timeout:
+                current_test.hang = True
                 LOG.debug("calling self.adapter.on_timeout()")
                 self.adapter.on_timeout(current_test, result.served)
             else:
@@ -195,8 +195,11 @@ def run(self, ignore, iteration_limit=0, display_mode=DISPLAY_NORMAL):
             # process results
             if result.status == RunResult.FAILED:
                 LOG.debug("result detected")
-                report = self.target.create_report()
-                short_sig = report.crash_info.createShortSignature()
+                report = self.target.create_report(is_hang=result.timeout)
+                if result.timeout:
+                    short_sig = "Potential hang detected"
+                else:
+                    short_sig = report.crash_info.createShortSignature()
                 LOG.info("Result: %s (%s:%s)",
                     short_sig,
                     report.major[:8],
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index ca86ed53..7c53999b 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -3,13 +3,14 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """test Grizzly main"""
+from pytest import mark
+
 from sapphire import Sapphire
-from .common import Adapter, Report
+from .common import Adapter
 from .main import main
 from .session import Session
 from .target import Target, TargetLaunchError
 
-
 class FakeArgs:
     def __init__(self):
         self.binary = None
@@ -31,7 +32,8 @@ def __init__(self):
         self.rr = False
         self.relaunch = 1000
         self.s3_fuzzmanager = False
-        self.timeout = 60
+        self.test_duration = None
+        self.timeout = None
         self.tool = None
         self.valgrind = False
         self.verbose = False
@@ -56,10 +58,9 @@ def test_main_01(mocker):
     args.prefs = "fake"
     args.valgrind = True
     args.xvfb = True
-    # successful run (with coverage, short timeout)
+    # successful run (with coverage)
     fake_adapter.RELAUNCH = 10
     args.coverage = True
-    args.timeout = 1
     assert main(args) == Session.EXIT_SUCCESS
     assert fake_session.mock_calls[0][-1]["coverage"]
     assert fake_session.mock_calls[0][-1]["relaunch"] == 10
@@ -67,7 +68,6 @@ def test_main_01(mocker):
     # successful run (without coverage)
     fake_adapter.RELAUNCH = 1
     args.coverage = False
-    args.timeout = 60
     assert main(args) == Session.EXIT_SUCCESS
     assert not fake_session.mock_calls[0][-1]["coverage"]
     assert fake_session.mock_calls[0][-1]["relaunch"] == 1
@@ -103,7 +103,7 @@ def test_main_02(mocker):
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     fake_session.EXIT_ABORT = Session.EXIT_ABORT
-    fake_session.EXIT_ARGS = Session.EXIT_ARGS
+    fake_session.EXIT_ARGS = fake_session.EXIT_ARGS = Session.EXIT_ARGS
     fake_session.EXIT_LAUNCH_FAILURE = Session.EXIT_LAUNCH_FAILURE
     fake_session.return_value.server = mocker.Mock(spec=Sapphire)
     args = FakeArgs()
@@ -114,3 +114,36 @@ def test_main_02(mocker):
     # test TargetLaunchError
     fake_session.return_value.run.side_effect = TargetLaunchError("test", None)
     assert main(args) == Session.EXIT_LAUNCH_FAILURE
+
+@mark.parametrize(
+    "arg_duration, arg_timeout, result",
+    [
+        # use default test duration and timeout values
+        (None, None, Session.EXIT_SUCCESS),
+        # set test duration
+        (10, None, Session.EXIT_SUCCESS),
+        # set both test duration and timeout to the same value
+        (10, 10, Session.EXIT_SUCCESS),
+        # set timeout greater than test duration
+        (10, 11, Session.EXIT_SUCCESS),
+        # set test duration greater than timeout
+        (11, 10, Session.EXIT_ARGS),
+    ]
+)
+def test_main_03(mocker, arg_duration, arg_timeout, result):
+    """test main() duration and timeout"""
+    fake_adapter = mocker.Mock(spec=Adapter)
+    fake_adapter.NAME = "fake"
+    fake_adapter.RELAUNCH = 1
+    fake_adapter.TEST_DURATION = 10
+    mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
+    mocker.patch.dict("grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)})
+    fake_session = mocker.patch("grizzly.main.Session", autospec=True)
+    fake_session.return_value.server = mocker.Mock(spec=Sapphire)
+    fake_session.EXIT_ARGS = Session.EXIT_ARGS
+    fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
+    args = FakeArgs()
+    args.adapter = "fake"
+    args.test_duration = arg_duration
+    args.timeout = arg_timeout
+    assert main(args) == result
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index fcb62d57..17a3068b 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -55,7 +55,7 @@ def generate(self, testcase, server_map):
     with IOManager() as iomgr:
         fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
         with Session(adapter, iomgr, None, fake_serv, fake_target, relaunch=10) as session:
-            session.run([])
+            session.run([], 10)
             assert session.status.iteration == 5
             assert session.status.test_name == "file.bin"
 
@@ -82,7 +82,7 @@ def generate(self, testcase, server_map):
         fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
         # enable profiling for test coverage
         with Session(adapter, iomgr, None, fake_serv, fake_target, enable_profiling=True, relaunch=10) as session:
-            session.run([], iteration_limit=10)
+            session.run([], 10, iteration_limit=10)
             assert session.status.iteration == 10
             assert session.status.test_name is None
 
@@ -108,7 +108,7 @@ def generate(self, testcase, server_map):
     with IOManager() as iomgr:
         fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
         with Session(adapter, iomgr, None, fake_serv, fake_target, coverage=True, relaunch=2) as session:
-            session.run([], iteration_limit=2)
+            session.run([], 10, iteration_limit=2)
             assert session.status.iteration == 2
     assert fake_target.dump_coverage.call_count == 2
 
@@ -130,7 +130,7 @@ def generate(self, testcase, server_map):
         fake_serv.serve_path.return_value = (SERVED_NONE, [])
         with Session(adapter, iomgr, None, fake_serv, fake_target, relaunch=10) as session:
             with raises(SessionError, match="Test case is missing landing page"):
-                session.run([], iteration_limit=10)
+                session.run([], 10, iteration_limit=10)
 
 def test_session_05(tmp_path, mocker):
     """test basic Session functions"""
@@ -139,7 +139,6 @@ def test_session_05(tmp_path, mocker):
     fake_adapter.IGNORE_UNSERVED = True
     fake_adapter.TEST_DURATION = 10
     fake_testcase = mocker.Mock(spec=TestCase, landing_page="page.htm", optional=[])
-    fake_iomgr = mocker.Mock(spec=IOManager)
     fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
     fake_iomgr.create_testcase.return_value = fake_testcase
     fake_iomgr.tests = mocker.Mock(spec=deque)
@@ -147,9 +146,8 @@ def test_session_05(tmp_path, mocker):
     fake_serv.serve_path.return_value = (SERVED_TIMEOUT, [fake_testcase.landing_page])
     fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
     fake_target.monitor.launches = 1
-    fake_target.monitor.is_healthy.return_value = False
     with Session(fake_adapter, fake_iomgr, None, fake_serv, fake_target) as session:
-        session.run([], iteration_limit=1)
+        session.run([], 10, iteration_limit=1)
     assert fake_adapter.setup.call_count == 0
     assert fake_adapter.pre_launch.call_count == 1
     assert fake_adapter.generate.call_count == 1
@@ -160,8 +158,9 @@ def test_session_05(tmp_path, mocker):
     assert fake_testcase.purge_optional.call_count == 1
     assert fake_serv.serve_path.call_count == 1
     assert fake_target.launch.call_count == 1
-    assert fake_target.detect_failure.call_count == 1
-    assert fake_target.monitor.is_healthy.call_count == 1
+    assert fake_target.detect_failure.call_count == 0
+    assert fake_target.handle_hang.call_count == 1
+    assert fake_target.monitor.is_healthy.call_count == 0
 
 def test_session_06(tmp_path, mocker):
     """test Session.generate_testcase()"""
@@ -204,7 +203,7 @@ def test_session_07(tmp_path, mocker):
     run_result.initial = False
     fake_runner.return_value.run.return_value = run_result
     with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
-        session.run([], iteration_limit=1)
+        session.run([], 10, iteration_limit=1)
         assert fake_runner.return_value.run.call_count == 1
         assert fake_adapter.on_served.call_count == 1
         assert fake_adapter.on_timeout.call_count == 0
@@ -224,7 +223,7 @@ def test_session_07(tmp_path, mocker):
     fake_runner.return_value.run.return_value = run_result
     with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
         with raises(SessionError, match="Please check Adapter and Target"):
-            session.run([], iteration_limit=1)
+            session.run([], 10, iteration_limit=1)
         assert fake_runner.return_value.run.call_count == 1
         assert fake_runner.return_value.launch.call_count == 1
         assert session.status.iteration == 1
@@ -240,7 +239,7 @@ def test_session_07(tmp_path, mocker):
     fake_runner.return_value.run.return_value = run_result
     with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
         with raises(SessionError, match="Please check Adapter and Target"):
-            session.run([], iteration_limit=1)
+            session.run([], 10, iteration_limit=1)
         assert fake_runner.return_value.run.call_count == 1
         assert fake_runner.return_value.launch.call_count == 1
         assert session.status.iteration == 1
@@ -266,7 +265,7 @@ def test_session_08(tmp_path, mocker):
     fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
     fake_target.monitor.launches = 1
     with Session(fake_adapter, fake_iomgr, None, fake_serv, fake_target) as session:
-        session.run([], iteration_limit=1)
+        session.run([], 10, iteration_limit=1)
         assert fake_runner.return_value.run.call_count == 1
         assert fake_adapter.on_served.call_count == 1
         assert fake_adapter.on_timeout.call_count == 0
@@ -293,7 +292,41 @@ def test_session_09(tmp_path, mocker):
     fake_target.monitor.launches = 1
     with Session(fake_adapter, fake_iomgr, mocker.Mock(), fake_serv, fake_target) as session:
         with raises(TargetLaunchError, match="test"):
-            session.run([], iteration_limit=1)
+            session.run([], 10, iteration_limit=1)
+        assert session.status.iteration == 1
+        assert session.status.results == 1
+        assert session.status.ignored == 0
+
+def test_session_10(tmp_path, mocker):
+    """test Session.run() report hang"""
+    Status.PATH = str(tmp_path)
+    result = RunResult([], 60.0, status=RunResult.FAILED, timeout=True)
+    result.attempted = True
+    fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
+    fake_runner.return_value.run.return_value = result
+    mocker.patch("grizzly.session.TestFile", autospec=True)
+    fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
+    fake_adapter.TEST_DURATION = 10
+    fake_iomgr = mocker.Mock(
+        spec=IOManager,
+        harness=None,
+        server_map=ServerMap(),
+        tests=mocker.Mock(spec=deque))
+    fake_iomgr.create_testcase.return_value = mocker.Mock(spec=TestCase)
+    fake_report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    fake_reporter = mocker.Mock(spec=Reporter)
+    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
+    fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
+    fake_target.monitor.launches = 1
+    fake_target.create_report.return_value = fake_report
+    with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
+        session.run([], 10, iteration_limit=1)
+        assert fake_runner.return_value.run.call_count == 1
+        assert fake_adapter.on_served.call_count == 0
+        assert fake_adapter.on_timeout.call_count == 1
+        assert fake_iomgr.purge_tests.call_count == 1
+        assert fake_target.create_report.call_count == 1
+        assert fake_reporter.submit.call_count == 1
         assert session.status.iteration == 1
         assert session.status.results == 1
         assert session.status.ignored == 0

From e48d9cc06a5748423fcd3ff74f22714e38866c18 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 11 Feb 2021 18:38:43 -0800
Subject: [PATCH 208/531] [replay] Update hang detection support

---
 grizzly/replay/replay.py      |  68 ++++++++++++++++++--
 grizzly/replay/test_main.py   | 116 ++++++++++++++++++++++++++++------
 grizzly/replay/test_replay.py | 110 ++++++++++++++++++++++++--------
 3 files changed, 243 insertions(+), 51 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index b876538d..fbe20716 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -142,14 +142,26 @@ def report_to_filesystem(path, results, tests=None):
             for result in expected:
                 reporter.submit(tests or [], report=result.report)
 
-    def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0, idle_threshold=0):
+    def run(
+        self,
+        testcases,
+        test_duration,
+        repeat=1,
+        min_results=1,
+        exit_early=True,
+        expect_hang=False,
+        idle_delay=0,
+        idle_threshold=0
+    ):
         """Run testcase replay.
 
         Args:
             testcases (list): One or more TestCases to run.
+            test_duration (int): Maximum time in seconds a test should take to complete.
             repeat (int): Maximum number of times to run the TestCase.
             min_results (int): Minimum number of results needed before run can
                                be considered successful.
+            expect_hang (bool): Running testcases is expected to result in a hang.
             exit_early (bool): If True the minimum required number of iterations
                                are performed to either meet `min_results` or
                                determine that it is not possible to do so.
@@ -167,7 +179,9 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
         assert repeat > 0
         assert repeat >= min_results
         assert testcases
-        assert len(testcases) == 1 or self._harness is not None
+        assert test_duration > 0
+        assert self._harness is not None or len(testcases) == 1
+        assert not expect_hang or self._signature is not None
 
         if self.status is not None:
             LOG.debug("clearing previous status data")
@@ -210,7 +224,7 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
                             "/grz_harness",
                             self.server.port,
                             close_after=relaunch * test_count,
-                            timeout=self.server.timeout)
+                            test_duration=test_duration)
                     startup_error = False
                     # The environment from the initial testcase is used because
                     # a sequence of testcases is expected to be run without
@@ -263,24 +277,36 @@ def run(self, testcases, repeat=1, min_results=1, exit_early=True, idle_delay=0,
                     # TODO: use self.target.create_report here
                     log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
                     self.target.save_logs(log_path)
-                    report = Report(log_path, self.target.binary)
+                    report = Report(
+                        log_path,
+                        self.target.binary,
+                        is_hang=run_result.timeout
+                    )
                     # check signatures
-                    short_sig = report.crash_info.createShortSignature()
+                    if run_result.timeout:
+                        short_sig = "Potential hang detected"
+                    else:
+                        short_sig = report.crash_info.createShortSignature()
+                    # set active signature
                     if (
                         not startup_error
                         and not self._any_crash
+                        and not run_result.timeout
                         and self._signature is None
                         and short_sig != "No crash detected"
                     ):
+                        assert not expect_hang
                         LOG.debug("no signature given, using %r", short_sig)
                         self._signature = report.crash_signature
+                    # bucket result
                     if short_sig == "No crash detected":
                         # TODO: verify report.major == "NO_STACK" otherwise FM failed to parse the logs
                         # TODO: change this to support hangs/timeouts, etc
                         LOG.info("Result: No crash detected")
                     elif (
                         not startup_error
-                        and (self._any_crash or self._signature.matches(report.crash_info))
+                        and (self._any_crash
+                            or (self._signature and self._signature.matches(report.crash_info)))
                     ):
                         self.status.count_result(short_sig)
                         LOG.info("Result: %s (%s:%s)",
@@ -412,10 +438,36 @@ def main(cls, args):
             LOG.error("Error: %s", str(exc))
             return Session.EXIT_ERROR
 
+        if args.test_duration:
+            test_duration = args.test_duration
+        else:
+            duration = tuple(int(x.duration * 2) for x in testcases if x.duration)
+            if not duration:
+                LOG.error("No test duration available, set manually")
+                return Session.EXIT_ARGS
+            test_duration = max(duration)
+            # set a minimum duration
+            if test_duration < 30:
+                test_duration = 30
+        timeout = args.timeout or test_duration + 30
+        LOG.info("Using test duration: %ds, timeout: %ds", test_duration, timeout)
+        if timeout < test_duration:
+            LOG.error("timeout must be at least test duration if not greater")
+            return Session.EXIT_ARGS
+
         results = None
         target = None
         tmp_prefs = None
         try:
+            # check if hangs are expected
+            expect_hang = any(x.hang for x in testcases)
+            if expect_hang:
+                if signature is None:
+                    LOG.error("Hangs require a signature to replay")
+                    return Session.EXIT_ERROR
+                if "timeout" in args.ignore:
+                    LOG.error("Cannot ignore 'timeout' when detecting hangs")
+                    return Session.EXIT_ERROR
             if args.no_harness and len(testcases) > 1:
                 LOG.error(
                     "'--no-harness' cannot be used with multiple testcases. " \
@@ -452,7 +504,7 @@ def main(cls, args):
                         break
             LOG.debug("starting sapphire server")
             # launch HTTP server used to serve test cases
-            with Sapphire(auto_close=1, timeout=args.timeout) as server:
+            with Sapphire(auto_close=1, timeout=timeout) as server:
                 target.reverse(server.port, server.port)
                 with cls(
                     args.ignore,
@@ -465,6 +517,8 @@ def main(cls, args):
                 ) as replay:
                     results = replay.run(
                         testcases,
+                        test_duration,
+                        expect_hang=expect_hang,
                         idle_delay=args.idle_delay,
                         idle_threshold=args.idle_threshold,
                         min_results=args.min_crashes,
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 1833f9e4..92088971 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -8,7 +8,7 @@
 """
 from shutil import rmtree
 
-from pytest import raises
+from pytest import mark, raises
 
 from ..common import Report, TestCase, TestCaseLoadFailure
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
@@ -106,7 +106,8 @@ def test_main_01(mocker, tmp_path):
         rr=False,
         sig=str(tmp_path / "sig.json"),
         test_index=None,
-        timeout=10,
+        test_duration=10,
+        timeout=None,
         valgrind=False)
     assert ReplayManager.main(args) == Session.EXIT_SUCCESS
     assert target.reverse.call_count == 1
@@ -117,9 +118,9 @@ def test_main_01(mocker, tmp_path):
     assert target.close.call_count == 4
     assert target.cleanup.call_count == 1
     assert log_path.is_dir()
-    assert any(log_path.glob('**/log_asan_blah.txt'))
-    assert any(log_path.glob('**/log_stderr.txt'))
-    assert any(log_path.glob('**/log_stdout.txt'))
+    assert any(log_path.glob("reports/*/log_asan_blah.txt"))
+    assert any(log_path.glob("reports/*/log_stderr.txt"))
+    assert any(log_path.glob("reports/*/log_stdout.txt"))
 
 def test_main_02(mocker, tmp_path):
     """test ReplayManager.main() - no repro"""
@@ -150,7 +151,8 @@ def test_main_02(mocker, tmp_path):
         rr=False,
         sig=None,
         test_index=None,
-        timeout=10,
+        test_duration=10,
+        timeout=None,
         valgrind=False)
     assert ReplayManager.main(args) == Session.EXIT_FAILURE
     assert target.detect_failure.call_count == 1
@@ -159,13 +161,14 @@ def test_main_02(mocker, tmp_path):
 
 def test_main_03(mocker):
     """test ReplayManager.main() error cases"""
+    fake_sig = mocker.patch("grizzly.replay.replay.CrashSignature", autospec=True)
     mocker.patch("grizzly.replay.replay.FuzzManagerReporter", autospec=True)
     fake_load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
     mocker.patch("grizzly.replay.replay.Sapphire", autospec=True)
     fake_tc = mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
     # setup args
     args = mocker.Mock(
-        ignore=None,
+        ignore=list(),
         input="test",
         min_crashes=1,
         no_harenss=True,
@@ -173,7 +176,9 @@ def test_main_03(mocker):
         relaunch=1,
         repeat=1,
         sig=None,
-        test_index=None)
+        test_duration=10,
+        test_index=None,
+        timeout=None)
     # user abort
     fake_load_target.side_effect = KeyboardInterrupt
     # coverage
@@ -196,10 +201,23 @@ def test_main_03(mocker):
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
     # multiple test cases with --no-harness
-    fake_tc.load.return_value = [mocker.Mock(), mocker.Mock()]
+    fake_tc.load.return_value = [mocker.Mock(hang=False), mocker.Mock(hang=False)]
     assert ReplayManager.main(args) == Session.EXIT_ARGS
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
+    # signature required replaying hang
+    fake_tc.load.return_value = [mocker.Mock(hang=True)]
+    assert ReplayManager.main(args) == Session.EXIT_ERROR
+    assert fake_load_target.call_count == 0
+    fake_load_target.reset_mock()
+    # can't ignore timeout replaying hang
+    args.ignore = ["timeout"]
+    args.sig = "sig"
+    fake_tc.load.return_value = [mocker.Mock(hang=True)]
+    assert ReplayManager.main(args) == Session.EXIT_ERROR
+    assert fake_sig.fromFile.call_count == 1
+    assert fake_load_target.call_count == 0
+    fake_load_target.reset_mock()
 
 def test_main_04(mocker, tmp_path):
     """test ReplayManager.main() target exceptions"""
@@ -214,7 +232,7 @@ def test_main_04(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", autospec=True, return_value=str(fake_tmp))
     # setup args
     args = mocker.Mock(
-        ignore=None,
+        ignore=list(),
         input="test",
         min_crashes=1,
         no_harenss=True,
@@ -222,7 +240,9 @@ def test_main_04(mocker, tmp_path):
         relaunch=1,
         repeat=1,
         sig=None,
-        test_index=None)
+        test_duration=10,
+        test_index=None,
+        timeout=None)
     # target launch error
     fake_logs = (tmp_path / "fake_report")
     fake_logs.mkdir()
@@ -230,7 +250,7 @@ def test_main_04(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchError("", report))
     assert ReplayManager.main(args) == Session.EXIT_LAUNCH_FAILURE
     assert not fake_logs.is_dir()
-    assert any(fake_tmp.glob("fake_report_logs"))
+    assert "fake_report_logs" in (x.name for x in fake_tmp.iterdir())
     # target launch timeout
     mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchTimeout)
     assert ReplayManager.main(args) == Session.EXIT_LAUNCH_FAILURE
@@ -252,14 +272,15 @@ def test_main_05(mocker, tmp_path):
         fuzzmanager=False,
         idle_delay=0,
         idle_threshold=0,
-        ignore=None,
+        ignore=list(),
         min_crashes=1,
         no_harness=True,
         relaunch=1,
         repeat=1,
         sig=None,
+        test_duration=1,
         test_index=None,
-        timeout=1)
+        timeout=None)
     log_path = (tmp_path / "logs")
     args.logs = str(log_path)
     input_path = (tmp_path / "input")
@@ -292,8 +313,8 @@ def test_main_05(mocker, tmp_path):
     assert target.detect_failure.call_count == 1
     assert serve_path.call_count == 1
     assert log_path.is_dir()
-    prefs = tuple(log_path.glob('**/prefs.js'))
-    assert prefs[0].read_bytes() == b"included"
+    prefs = next(log_path.glob('**/prefs.js'))
+    assert prefs.read_bytes() == b"included"
 
     target.reset_mock()
     serve_path.reset_mock()
@@ -307,5 +328,64 @@ def test_main_05(mocker, tmp_path):
     assert target.detect_failure.call_count == 1
     assert serve_path.call_count == 1
     assert log_path.is_dir()
-    prefs = tuple(log_path.glob('**/prefs.js'))
-    assert prefs[0].read_bytes() == b"specified"
+    prefs = next(log_path.glob('**/prefs.js'))
+    assert prefs.read_bytes() == b"specified"
+
+@mark.parametrize(
+    "arg_duration, arg_timeout, test_duration, result",
+    [
+        # use default test duration and timeout values (test missing duration)
+        (None, None, None, Session.EXIT_ARGS),
+        # use default test duration and timeout values
+        (None, None, 10, Session.EXIT_FAILURE),
+        # set test duration
+        (10, None, None, Session.EXIT_FAILURE),
+        # set both test duration and timeout to the same value
+        (10, 10, None, Session.EXIT_FAILURE),
+        # set timeout greater than test duration
+        (10, 11, None, Session.EXIT_FAILURE),
+        # set test duration greater than timeout
+        (11, 10, None, Session.EXIT_ARGS),
+    ]
+)
+def test_main_06(mocker, tmp_path, arg_duration, arg_timeout, test_duration, result):
+    """test ReplayManager.main() - test duration and timeout"""
+    # mock Sapphire.serve_path only
+    mocker.patch("grizzly.common.runner.sleep", autospec=True)
+    serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
+    serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
+    # setup Target
+    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.detect_failure.return_value = Target.RESULT_NONE
+    load_target = mocker.patch("grizzly.replay.replay.load_target")
+    load_target.return_value.return_value = target
+    # create test to load
+    test = TestCase("test.html", None, None)
+    test_file = tmp_path / "test.html"
+    test_file.write_text("test")
+    test.add_from_file(str(test_file))
+    replay_path = tmp_path / "test"
+    replay_path.mkdir()
+    test.duration = test_duration
+    test.dump(str(replay_path), include_details=True)
+    # setup args
+    (tmp_path / "prefs.js").touch()
+    args = mocker.Mock(
+        fuzzmanager=False,
+        idle_delay=0,
+        idle_threshold=0,
+        ignore=["timeout"],
+        input=str(replay_path),
+        min_crashes=2,
+        no_harness=True,
+        prefs=None,
+        relaunch=1,
+        repeat=1,
+        rr=False,
+        sig=None,
+        test_index=None,
+        test_duration=arg_duration,
+        timeout=arg_timeout,
+        valgrind=False)
+    assert ReplayManager.main(args) == result
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index bdcc51db..71c4b3a0 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -9,9 +9,9 @@
 from itertools import cycle
 from os.path import join as pathjoin
 
-from pytest import raises
+from pytest import mark, raises
 
-from sapphire import Sapphire, SERVED_ALL, SERVED_NONE, SERVED_REQUEST
+from sapphire import Sapphire, SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
 from .replay import ReplayManager, ReplayResult
 from ..common import Report, Status, TestCase, TestCaseLoadFailure
 from ..target import Target
@@ -47,7 +47,7 @@ def test_replay_02(mocker, tmp_path):
     target.monitor.is_healthy.return_value = False
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True, relaunch=1) as replay:
-            assert not replay.run([testcase])
+            assert not replay.run([testcase], 10)
             assert replay.signature is None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
@@ -66,11 +66,12 @@ def test_replay_03(mocker):
     target.monitor.is_healthy.return_value = False
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True, relaunch=100) as replay:
-            assert not replay.run([testcase], repeat=10, min_results=1)
+            assert not replay.run([testcase], 10, repeat=10, min_results=1)
             assert replay.signature is None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 10
             assert replay.status.results == 0
+            assert target.handle_hang.call_count == 0
             assert target.monitor.is_healthy.call_count == 1
             assert target.close.call_count == 2
 
@@ -89,10 +90,11 @@ def test_replay_04(mocker):
     target.detect_failure.return_value = Target.RESULT_NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True, relaunch=100) as replay:
-            assert not replay.run([testcase], repeat=10, min_results=1)
+            assert not replay.run([testcase], 10, repeat=10, min_results=1)
             assert replay.status.ignored == 0
             assert replay.status.iteration == 10
             assert replay.status.results == 0
+            assert target.handle_hang.call_count == 0
             assert target.monitor.is_healthy.call_count == 0
             assert target.close.call_count == 1
 
@@ -109,11 +111,13 @@ def test_replay_05(mocker, tmp_path):
     target.save_logs = _fake_save_logs
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, relaunch=10) as replay:
-            results = replay.run([testcase])
+            assert replay.signature is None
+            results = replay.run([testcase], 10)
             assert replay.signature is not None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
             assert replay.status.results == 1
+            assert target.handle_hang.call_count == 0
             assert target.monitor.is_healthy.call_count == 1
             assert target.close.call_count == 2
         assert len(results) == 1
@@ -138,7 +142,7 @@ def test_replay_06(mocker, tmp_path):
     target.detect_failure.return_value = Target.RESULT_NONE
     server.serve_path.return_value = (SERVED_NONE, [])
     with ReplayManager([], server, target, use_harness=False) as replay:
-        assert not replay.run(testcases, repeat=1)
+        assert not replay.run(testcases, 10, repeat=1)
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 0
@@ -149,7 +153,7 @@ def test_replay_06(mocker, tmp_path):
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.save_logs = _fake_save_logs
     with ReplayManager([], server, target, use_harness=False) as replay:
-        results = replay.run(testcases, repeat=1)
+        results = replay.run(testcases, 10, repeat=1)
         assert replay.status.ignored == 1
         assert replay.status.iteration == 1
         assert replay.status.results == 0
@@ -174,7 +178,7 @@ def test_replay_07(mocker, tmp_path):
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     server.serve_path.side_effect = ((SERVED_ALL, ["index.html"]), (SERVED_REQUEST, ["x"]))
     with ReplayManager([], server, target, use_harness=True, relaunch=10) as replay:
-        assert replay.run(testcases, repeat=2)
+        assert replay.run(testcases, 10, repeat=2)
         assert replay.status.ignored == 0
         assert replay.status.iteration == 2
         assert replay.status.results == 1
@@ -192,7 +196,7 @@ def test_replay_08(mocker, tmp_path):
     target.monitor.is_healthy.return_value = False
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, use_harness=False) as replay:
-        assert not replay.run(testcases)
+        assert not replay.run(testcases, 10)
         assert target.monitor.is_healthy.call_count == 1
         assert target.close.call_count == 2
         assert replay.status.ignored == 1
@@ -216,7 +220,7 @@ def test_replay_09(mocker, tmp_path):
     target.detect_failure.side_effect = (Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_NONE)
     target.monitor.is_healthy.side_effect = (False, False, True, False)
     with ReplayManager([], server, target, use_harness=False) as replay:
-        assert not replay.run(testcases, repeat=4, min_results=3)
+        assert not replay.run(testcases, 10, repeat=4, min_results=3)
         assert target.close.call_count == 4
         assert replay.status.iteration == 3
         assert replay.status.results == 1
@@ -226,7 +230,7 @@ def test_replay_09(mocker, tmp_path):
     target.detect_failure.side_effect = (Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_FAILURE)
     target.monitor.is_healthy.side_effect = (False, False, False)
     with ReplayManager([], server, target, use_harness=False) as replay:
-        results = replay.run(testcases, repeat=4, min_results=2)
+        results = replay.run(testcases, 10, repeat=4, min_results=2)
         assert target.close.call_count == 4
         assert replay.status.iteration == 3
         assert replay.status.results == 2
@@ -240,7 +244,7 @@ def test_replay_09(mocker, tmp_path):
     target.monitor.is_healthy.side_effect = None
     target.monitor.is_healthy.return_value = True
     with ReplayManager([], server, target, use_harness=False) as replay:
-        assert not replay.run(testcases, repeat=4, min_results=4, exit_early=False)
+        assert not replay.run(testcases, 10, repeat=4, min_results=4, exit_early=False)
         assert target.close.call_count == 5
         assert replay.status.iteration == 4
         assert replay.status.results == 0
@@ -250,7 +254,7 @@ def test_replay_09(mocker, tmp_path):
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
     with ReplayManager([], server, target, use_harness=False) as replay:
-        results = replay.run(testcases, repeat=4, min_results=1, exit_early=False)
+        results = replay.run(testcases, 10, repeat=4, min_results=1, exit_early=False)
         assert target.close.call_count == 5
         assert replay.status.iteration == 4
         assert replay.status.results == 4
@@ -282,7 +286,7 @@ def test_replay_10(mocker, tmp_path):
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, signature=signature, use_harness=False) as replay:
-        results = replay.run(testcases, repeat=4, min_results=2)
+        results = replay.run(testcases, 10, repeat=4, min_results=2)
         assert target.close.call_count == 5
         assert replay.signature == signature
         assert replay.status.iteration == 4
@@ -318,7 +322,7 @@ def test_replay_11(mocker, tmp_path):
     target.monitor.is_healthy.return_value = False
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[])]
     with ReplayManager([], server, target, signature=signature, use_harness=False) as replay:
-        results = replay.run(testcases, repeat=2, min_results=2)
+        results = replay.run(testcases, 10, repeat=2, min_results=2)
         assert target.close.call_count == 3
         assert replay.signature == signature
         assert replay.status.iteration == 2
@@ -351,7 +355,7 @@ def test_replay_12(mocker, tmp_path):
     target.monitor.is_healthy.return_value = False
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
-        results = replay.run(testcases, repeat=3, min_results=2)
+        results = replay.run(testcases, 10, repeat=3, min_results=2)
         assert target.close.call_count == 4
         assert replay.signature is None
         assert replay.status.iteration == 3
@@ -386,7 +390,7 @@ def test_replay_13(mocker, tmp_path):
     target.monitor.is_healthy.return_value = False
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, any_crash=True) as replay:
-        assert not replay.run(testcases, repeat=4, min_results=3)
+        assert not replay.run(testcases, 10, repeat=4, min_results=3)
         assert target.close.call_count == 5
         assert replay.signature is None
         assert replay.status.iteration == 4
@@ -420,7 +424,7 @@ def test_replay_14(mocker, tmp_path):
     target.monitor.is_healthy.return_value = False
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, use_harness=False) as replay:
-        results = replay.run(testcases, repeat=3, min_results=2)
+        results = replay.run(testcases, 10, repeat=3, min_results=2)
         assert target.close.call_count == 4
         assert replay.signature == auto_sig
         assert replay.status.iteration == 3
@@ -449,7 +453,7 @@ def test_replay_15(mocker, tmp_path):
     testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, any_crash=True, use_harness=True, relaunch=2) as replay:
         with raises(KeyboardInterrupt):
-            replay.run(testcases, repeat=3, min_results=2)
+            replay.run(testcases, 10, repeat=3, min_results=2)
         assert replay.signature is None
         assert replay.status.iteration == 2
         assert replay.status.results == 1
@@ -472,7 +476,7 @@ def test_replay_16(mocker):
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, use_harness=True) as replay:
-        assert not replay.run(testcases)
+        assert not replay.run(testcases, 10)
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
         assert replay.status.results == 0
@@ -494,7 +498,7 @@ def test_replay_17(mocker):
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
     with ReplayManager([], server, target, use_harness=True, relaunch=2) as replay:
-        assert not replay.run(testcases, repeat=10)
+        assert not replay.run(testcases, 10, repeat=10)
         assert server.serve_path.call_count == 30
         assert target.close.call_count == 6
         assert target.launch.call_count == 5
@@ -526,7 +530,7 @@ def test_replay_18(mocker, tmp_path):
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="b.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="c.html", optional=[])]
     with ReplayManager([], server, target, use_harness=True) as replay:
-        results = replay.run(testcases)
+        results = replay.run(testcases, 30)
         assert target.close.call_count == 2
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
@@ -550,11 +554,11 @@ def test_replay_19(mocker, tmp_path):
     target.detect_failure.return_value = Target.RESULT_NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True) as replay:
-            assert not replay.run([testcase])
+            assert not replay.run([testcase], 30)
             assert replay.status.iteration == 1
-            assert not replay.run([testcase])
+            assert not replay.run([testcase], 30)
             assert replay.status.iteration == 1
-            assert not replay.run([testcase])
+            assert not replay.run([testcase], 30)
             assert replay.status.iteration == 1
     assert server.serve_path.call_count == 3
 
@@ -637,3 +641,57 @@ def test_replay_21(mocker, tmp_path):
     assert test0.cleanup.call_count == 0
     assert test1.cleanup.call_count == 1
     assert test2.cleanup.call_count == 0
+
+@mark.parametrize(
+    "expected, use_sig, match_sig, ignored, results",
+    [
+        # reproduce expected hang
+        (True, True, True, 0, 1),
+        # expected hang (signature, no match)
+        (True, True, False, 1, 0),
+        # unexpected hang (signature, match)
+        (False, True, True, 0, 1),
+        # unexpected hang (signature, no match)
+        (False, True, False, 1, 0),
+        # unexpected hang (no signature)
+        (False, False, False, 1, 0),
+    ]
+)
+def test_replay_22(mocker, tmp_path, expected, use_sig, match_sig, ignored, results):
+    """test ReplayManager.run() - detect hangs"""
+    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
+    served = ["index.html"]
+    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
+    server.serve_path.return_value = (SERVED_TIMEOUT, served)
+    if use_sig:
+        signature = mocker.Mock()
+        signature.matches.return_value = match_sig
+        signature.rawSignature = "fakesig"
+    else:
+        signature = None
+    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.handle_hang.return_value = False
+    target.save_logs = _fake_save_logs
+    with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
+        testcase.hang = expected
+        with ReplayManager([], server, target, signature=signature, relaunch=10) as replay:
+            found = replay.run([testcase], 10, expect_hang=expected)
+            assert replay.status.iteration == 1
+            assert replay.status.ignored == ignored
+            assert replay.status.results == results
+            assert target.handle_hang.call_count == 1
+            assert target.monitor.is_healthy.call_count == 0
+            assert target.close.call_count == 1
+        assert len(found) == 1
+        assert found[0].count == 1
+        assert found[0].expected == results
+        assert found[0].report
+        assert found[0].report.is_hang
+        assert len(found[0].served) == 1
+        assert found[0].served[0] == served
+        assert len(found[0].durations) == 1
+        assert testcase.hang == expected
+        found[0].report.cleanup()
+        assert not any(tmp_path.iterdir())

From 87052ae22ae18f01363cca82ade87120217b3315 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 11 Feb 2021 18:39:49 -0800
Subject: [PATCH 209/531] [reduce] Add place holders for hang detection support

---
 grizzly/reduce/core.py            |  6 ++++--
 grizzly/reduce/test_reduce.py     | 12 ++++++------
 grizzly/reduce/test_strategies.py |  8 ++++----
 3 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index c11c99d0..61535216 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -142,6 +142,7 @@ def update_timeout(self, results):
         Returns:
             None
         """
+        # TODO: properly handle test duration and timeout
         if (self._static_timeout or self._any_crash or
                 getattr(self.target, "use_valgrind", False)):
             # the amount of time it can take to replay a test case can vary
@@ -244,8 +245,8 @@ def run_reliability_analysis(self, stats):
                                     "assess reliability without harness.", len(testcases))
                     testcases = [testcases[-1]]
                 results = replay.run(
-                    testcases, repeat=self.ANALYSIS_ITERATIONS, min_results=1,
-                    exit_early=False, idle_delay=self._idle_delay,
+                    testcases, self.server.timeout, repeat=self.ANALYSIS_ITERATIONS,
+                    min_results=1, exit_early=False, idle_delay=self._idle_delay,
                     idle_threshold=self._idle_threshold,
                 )
                 try:
@@ -406,6 +407,7 @@ def run(self, repeat=1, min_results=1):
                                 # replayed
                                 results = replay.run(
                                     reduction,
+                                    self.server.timeout,
                                     repeat=repeat,
                                     min_results=min_results,
                                     idle_delay=self._idle_delay,
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 1212fb02..8510f0f5 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -246,7 +246,7 @@ def test_analysis(mocker, tmp_path, harness_last_crashes, harness_crashes,
         crashes += [False] * (11 - no_harness_crashes) + [True] * no_harness_crashes
         expected_iters += 1
 
-    def replay_run(_, **kw):
+    def replay_run(_tests, _test_duration, **kw):
         results = []
         repeat = kw["repeat"]
         assert repeat <= len(crashes)
@@ -483,7 +483,7 @@ def test_repro(mocker, tmp_path, original, strategies, detect_failure, interesti
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(testcases, **_):
+    def replay_run(testcases, _test_duration, **_):
         for test in testcases:
             contents = test.get_file("test.html").data.decode("ascii")
             # pylint: disable=logging-not-lazy
@@ -551,7 +551,7 @@ def test_report_01(mocker, tmp_path):
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(_, **_kw):
+    def replay_run(_tests, _test_duration, **_kw):
         if replayer.run.call_count in {20, 40}:
             log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
             log_path.mkdir()
@@ -613,7 +613,7 @@ def test_report_02(mocker, tmp_path):
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(_, **_kw):
+    def replay_run(_tests, _test_duration, **_kw):
         if replayer.run.call_count in {10, 20}:
             log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
             log_path.mkdir()
@@ -673,7 +673,7 @@ def test_quality_update(mocker, tmp_path):
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(testcases, **_kw):
+    def replay_run(testcases, _test_duration, **_kw):
         for test in testcases:
             contents = test.get_file("test.html").data.decode("ascii")
             if not contents.strip():
@@ -795,7 +795,7 @@ def test_timeout_update(mocker, tmp_path, durations, interesting, static_timeout
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(_testcases, **_):
+    def replay_run(_testcases, _test_duration, **_):
         LOG.debug("interesting true")
         log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
         log_path.mkdir()
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 2c3e971d..241480ce 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -118,7 +118,7 @@ def test_list(mocker, tmp_path, test_data, strategies, required_first,
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(testcases, **_):
+    def replay_run(testcases, _test_duration, **_):
         required_seen = False
         for test in testcases:
             contents = test.get_file("test.html").data.decode("ascii")
@@ -481,7 +481,7 @@ def test_beautifier(mocker, tmp_path, test_data, test_name, expected_run_calls,
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(testcases, **_):
+    def replay_run(testcases, _test_duration, **_):
         for test in testcases:
             contents = test.get_file(test_name).data.decode("ascii")
             if "nochange" in test_data:
@@ -633,7 +633,7 @@ def test_purge_unserved(mocker, tmp_path, strategies, test_data, served,
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(testcases, **_):
+    def replay_run(testcases, _test_duration, **_):
         # test.html and opt.html should always contain one line.
         # return [] (no result) if either of them exist and are empty
         has_any = False
@@ -702,7 +702,7 @@ def test_dd_only(mocker, tmp_path):
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(testcases, **_):
+    def replay_run(testcases, _test_duration, **_):
         for test in testcases:
             contents = test.get_file("test.html").data.decode("ascii")
             LOG.debug("interesting if 'required' in %r", contents)

From 40bd009d0e76a9076361a75485912729d5b2f6c3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 17 Feb 2021 15:59:18 -0800
Subject: [PATCH 210/531] [replay] Test nits

---
 grizzly/replay/test_main.py   |  4 ++--
 grizzly/replay/test_replay.py | 10 +++++-----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 92088971..0ed93ade 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -336,8 +336,8 @@ def test_main_05(mocker, tmp_path):
     [
         # use default test duration and timeout values (test missing duration)
         (None, None, None, Session.EXIT_ARGS),
-        # use default test duration and timeout values
-        (None, None, 10, Session.EXIT_FAILURE),
+        # use min test duration and default timeout values
+        (None, None, 1, Session.EXIT_FAILURE),
         # set test duration
         (10, None, None, Session.EXIT_FAILURE),
         # set both test duration and timeout to the same value
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 71c4b3a0..01321f80 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -643,7 +643,7 @@ def test_replay_21(mocker, tmp_path):
     assert test2.cleanup.call_count == 0
 
 @mark.parametrize(
-    "expected, use_sig, match_sig, ignored, results",
+    "is_hang, use_sig, match_sig, ignored, results",
     [
         # reproduce expected hang
         (True, True, True, 0, 1),
@@ -657,7 +657,7 @@ def test_replay_21(mocker, tmp_path):
         (False, False, False, 1, 0),
     ]
 )
-def test_replay_22(mocker, tmp_path, expected, use_sig, match_sig, ignored, results):
+def test_replay_22(mocker, tmp_path, is_hang, use_sig, match_sig, ignored, results):
     """test ReplayManager.run() - detect hangs"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     served = ["index.html"]
@@ -675,9 +675,9 @@ def test_replay_22(mocker, tmp_path, expected, use_sig, match_sig, ignored, resu
     target.handle_hang.return_value = False
     target.save_logs = _fake_save_logs
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
-        testcase.hang = expected
+        testcase.hang = is_hang
         with ReplayManager([], server, target, signature=signature, relaunch=10) as replay:
-            found = replay.run([testcase], 10, expect_hang=expected)
+            found = replay.run([testcase], 10, expect_hang=is_hang)
             assert replay.status.iteration == 1
             assert replay.status.ignored == ignored
             assert replay.status.results == results
@@ -692,6 +692,6 @@ def test_replay_22(mocker, tmp_path, expected, use_sig, match_sig, ignored, resu
         assert len(found[0].served) == 1
         assert found[0].served[0] == served
         assert len(found[0].durations) == 1
-        assert testcase.hang == expected
+        assert testcase.hang == is_hang
         found[0].report.cleanup()
         assert not any(tmp_path.iterdir())

From 30f114c2f7220314515f04c4b1ba8047d70b6b0c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 17 Feb 2021 16:02:28 -0800
Subject: [PATCH 211/531] Use common default settings

* Add ConfigError
* Reduce and Replay now share more common functions
---
 grizzly/args.py             |   9 +--
 grizzly/common/utils.py     |  13 +++-
 grizzly/main.py             |   3 +-
 grizzly/reduce/core.py      |  40 +++++++++----
 grizzly/reduce/test_main.py |   8 ++-
 grizzly/replay/replay.py    | 114 +++++++++++++++++++++++++++---------
 6 files changed, 140 insertions(+), 47 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 7e13a853..8394fdfd 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -8,6 +8,7 @@
 from os.path import exists, isfile, isdir
 
 from .adapters import names as adapter_names
+from .common.utils import TIMEOUT_DELAY
 from .target import available as available_targets
 
 # ref: https://stackoverflow.com/questions/12268602/sort-argparse-help-alphabetically
@@ -81,7 +82,7 @@ def __init__(self):
             "--relaunch", type=int, default=1000,
             help="Number of iterations performed before relaunching the browser (default: %(default)s)")
         self.launcher_grp.add_argument(
-            "-t", "--test-duration", type=int, default=None,
+            "-d", "--test-duration", type=int, default=None,
             help="This is the maximum amount of time that a test is expected to take."
                  " After the time has elapsed the harness will attempt to close the test."
                  " By default `Adapter.TEST_DURATION` is used."
@@ -89,10 +90,10 @@ def __init__(self):
                  " required to run a test case.")
         self.launcher_grp.add_argument(
             "-t", "--timeout", type=int, default=None,
-            help="Iteration timeout in seconds. By default this is `test-duration`+30s."
+            help="Iteration timeout in seconds. By default this is `test-duration`+%ds."
                  " If the timeout is reached the target is assumed to be in a bad state"
-                 " and will be closed. Typically this should be ~30s greater than"
-                 " the value used for `test-duration`.")
+                 " and will be closed. Typically this should be a few seconds greater"
+                 " than the value used for `test-duration`." % (TIMEOUT_DELAY,))
         self.launcher_grp.add_argument(
             "--valgrind", action="store_true",
             help="Use Valgrind (Linux only)")
diff --git a/grizzly/common/utils.py b/grizzly/common/utils.py
index a0123520..5bdfd66d 100644
--- a/grizzly/common/utils.py
+++ b/grizzly/common/utils.py
@@ -8,11 +8,22 @@
 from tempfile import gettempdir
 
 
-__all__ = ("grz_tmp",)
+__all__ = ("ConfigError", "grz_tmp", "TIMEOUT_DELAY")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
 
+# TIMEOUT_DELAY is added to the test duration to create the default timeout
+TIMEOUT_DELAY = 15
+
+
+class ConfigError(Exception):
+    """Raised to indicate invalid configuration a state"""
+    def __init__(self, message, exit_code):
+        super().__init__(message)
+        self.exit_code = exit_code
+
+
 def grz_tmp(*subdir):
     path = pathjoin(gettempdir(), "grizzly", *subdir)
     makedirs(path, exist_ok=True)
diff --git a/grizzly/main.py b/grizzly/main.py
index be751820..2dc4e212 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -11,6 +11,7 @@
 from .adapters import get as get_adapter
 from .common.iomanager import IOManager
 from .common.reporter import FilesystemReporter, FuzzManagerReporter, S3FuzzManagerReporter
+from .common.utils import TIMEOUT_DELAY
 from .session import Session
 from .target import load as load_target, TargetLaunchError, TargetLaunchTimeout
 
@@ -70,7 +71,7 @@ def main(args):
         if args.timeout:
             timeout = args.timeout
         else:
-            timeout = test_duration + 30
+            timeout = test_duration + TIMEOUT_DELAY
         LOG.info("Using test duration: %ds, timeout: %ds", test_duration, timeout)
         if timeout < test_duration:
             LOG.error("timeout must be at least test duration if not greater")
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 61535216..15d11324 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -20,7 +20,7 @@
 from ..common.fuzzmanager import CrashEntry
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter
 from ..common.storage import TestCaseLoadFailure, TestFile
-from ..common.utils import grz_tmp
+from ..common.utils import ConfigError, grz_tmp
 from ..main import configure_logging
 from ..replay import ReplayManager
 from ..session import Session
@@ -65,9 +65,9 @@ class ReduceManager:
     ITER_TIMEOUT_DURATION_MULTIPLIER = 2
 
     def __init__(self, ignore, server, target, testcases, strategies, log_path,
-                 any_crash=False, idle_delay=0, idle_threshold=0, relaunch=1,
-                 report_period=None, report_to_fuzzmanager=False, signature=None,
-                 signature_desc=None, static_timeout=False, tool=None,
+                 any_crash=False, expect_hang=False, idle_delay=0, idle_threshold=0,
+                 relaunch=1, report_period=None, report_to_fuzzmanager=False,
+                 signature=None, signature_desc=None, static_timeout=False, tool=None,
                  use_analysis=True, use_harness=True):
         """Initialize reduction manager. Many arguments are common with `ReplayManager`.
 
@@ -79,9 +79,9 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
                 Value for `self.testcases` attribute.
             strategies (list(str)): Value for `self.strategies` attribute.
             log_path (Path or str): Path to save results when reporting to filesystem.
-
             any_crash (bool): Accept any crash when reducing, not just those matching
                               the specified or first observed signature.
+            expect_hang (bool): Attempt to reduce a test that triggers a hang.
             idle_delay (int): Number of seconds to wait before polling for idle.
             idle_threshold (int): CPU usage threshold to mark the process as idle.
             relaunch (int): Maximum number of iterations performed by Runner
@@ -107,6 +107,7 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
         self.target = target
         self.testcases = testcases
         self._any_crash = any_crash
+        self._expect_hang = expect_hang
         self._idle_delay = idle_delay
         self._idle_threshold = idle_threshold
         self._log_path = Path(log_path) if isinstance(log_path, str) else log_path
@@ -118,7 +119,7 @@ def __init__(self, ignore, server, target, testcases, strategies, log_path,
         self._report_tool = tool
         self._signature = signature
         self._signature_desc = signature_desc
-        self._static_timeout = static_timeout
+        self._static_timeout = expect_hang or static_timeout
         self._stats = ReductionStats()
         self._use_analysis = use_analysis
         self._use_harness = use_harness
@@ -143,6 +144,7 @@ def update_timeout(self, results):
             None
         """
         # TODO: properly handle test duration and timeout
+        assert self._static_timeout or not self._expect_hang
         if (self._static_timeout or self._any_crash or
                 getattr(self.target, "use_valgrind", False)):
             # the amount of time it can take to replay a test case can vary
@@ -408,10 +410,11 @@ def run(self, repeat=1, min_results=1):
                                 results = replay.run(
                                     reduction,
                                     self.server.timeout,
-                                    repeat=repeat,
-                                    min_results=min_results,
+                                    expect_hang=self._expect_hang,
                                     idle_delay=self._idle_delay,
-                                    idle_threshold=self._idle_threshold)
+                                    idle_threshold=self._idle_threshold,
+                                    min_results=min_results,
+                                    repeat=repeat)
                                 strategy_stats.add_iterations(replay.status.iteration)
                                 strategy_stats.add_attempts(1)
                                 self.update_timeout(results)
@@ -627,14 +630,24 @@ def main(cls, args):
                             testcases[0].adapter_name)
                 args.tool = "grizzly-%s" % (testcases[0].adapter_name,)
 
+            expect_hang = ReplayManager.expect_hang(args.ignore, signature, testcases)
+
             if args.no_harness:
                 if len(testcases) > 1:
                     LOG.error(
-                        "Error: '--no-harness' cannot be used with multiple " \
+                        "Error: '--no-harness' cannot be used with multiple "
                         "testcases. Perhaps '--test-index' can help.")
                     return Session.EXIT_ARGS
                 LOG.debug("--no-harness specified relaunch set to 1")
                 args.relaunch = 1
+
+            # check test duration and timeout
+            # TODO: add support for test duration
+            _, timeout = ReplayManager.time_limits(
+                args.test_duration,
+                args.timeout,
+                testcases)
+
             args.repeat = max(args.min_crashes, args.repeat)
             relaunch = min(args.relaunch, args.repeat)
             LOG.debug("initializing the Target")
@@ -666,7 +679,7 @@ def main(cls, args):
 
             LOG.debug("starting sapphire server")
             # launch HTTP server used to serve test cases
-            with Sapphire(auto_close=1, timeout=args.timeout) as server:
+            with Sapphire(auto_close=1, timeout=timeout) as server:
                 target.reverse(server.port, server.port)
                 mgr = ReduceManager(
                     args.ignore,
@@ -676,6 +689,7 @@ def main(cls, args):
                     args.strategies,
                     args.logs,
                     any_crash=args.any_crash,
+                    expect_hang=expect_hang,
                     idle_delay=args.idle_delay,
                     idle_threshold=args.idle_threshold,
                     relaunch=relaunch,
@@ -690,6 +704,10 @@ def main(cls, args):
                 return_code = mgr.run(repeat=args.repeat, min_results=args.min_crashes)
             return return_code
 
+        except ConfigError as exc:
+            LOG.error(str(exc))
+            return exc.exit_code
+
         except KeyboardInterrupt as exc:
             LOG.error("Exception: %r", exc)
             return Session.EXIT_ABORT
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 5ec212d9..677b6c0e 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -83,7 +83,8 @@ def test_args_02(tmp_path):
         ),
         ("grizzly.reduce.core.ReplayManager.load_testcases", None, [], {}, 1),
         (
-            "grizzly.reduce.core.ReplayManager.load_testcases", None, [Mock(), Mock()],
+            "grizzly.reduce.core.ReplayManager.load_testcases", None,
+            [Mock(hang=False), Mock(hang=False)],
             {"no_harness": True}, 2
         ),
     ]
@@ -123,6 +124,9 @@ def test_main_launch_error(mocker, exc_type):
     reporter = mocker.patch("grizzly.reduce.core.FilesystemReporter", autospec=True)
     mocker.patch("grizzly.reduce.core.load_target", autospec=True)
     mocker.patch("grizzly.reduce.core.ReplayManager.load_testcases")
+    mocker.patch(
+        "grizzly.reduce.core.ReplayManager.time_limits", return_value=(None, 10)
+    )
     run = mocker.patch("grizzly.reduce.core.ReduceManager.run", autospec=True)
     mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
     # setup args
@@ -167,7 +171,9 @@ def test_testcase_prefs(mocker, tmp_path, result):
         prefs=None,
         repeat=1,
         sig=None,
+        test_duration=10,
         test_index=None,
+        timeout=10,
     )
     if result == "argprefs":
         (tmp_path / "args.js").write_text("argprefs")
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index fbe20716..366bb623 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -15,7 +15,7 @@
 from ..common.runner import Runner, RunResult
 from ..common.status import Status
 from ..common.storage import TestCase, TestCaseLoadFailure, TestFile
-from ..common.utils import grz_tmp
+from ..common.utils import ConfigError, grz_tmp, TIMEOUT_DELAY
 from ..main import configure_logging
 from ..session import Session
 from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
@@ -39,6 +39,7 @@ def __init__(self, report, served, durations, expected):
 
 class ReplayManager:
     HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
+    MIN_TEST_DURATION = 10
 
     __slots__ = ("ignore", "server", "status", "target", "_any_crash",
                  "_harness", "_signature", "_relaunch", "_unpacked")
@@ -70,6 +71,15 @@ def __exit__(self, *exc):
     def signature(self):
         return self._signature
 
+    @staticmethod
+    def check_match(signature, report, expect_hang):
+        if signature is None:
+            return False
+        if expect_hang and not report.is_hang:
+            # avoid catching other crashes with forgiving hang signatures
+            return False
+        return signature.matches(report.crash_info)
+
     def cleanup(self):
         """Remove temporary files from disk.
 
@@ -82,6 +92,32 @@ def cleanup(self):
         if self.status is not None:
             self.status.cleanup()
 
+    @staticmethod
+    def expect_hang(ignore, signature, tests):
+        """Check if any test is expected to trigger a hang. If a hang is expected
+        a sanity check is performed. A ConfigError is raised if a configuration
+        issue is detected.
+
+        Args:
+            ignore (list(str)): Failure types to ignore.
+            signature (CrashSignature): Signature to use for bucketing.
+            tests list(TestCase): Testcases to check.
+
+        Returns:
+            bool: True if a hang is expected otherwise False.
+        """
+        is_hang = any(x.hang for x in tests)
+        if is_hang:
+            if signature is None:
+                raise ConfigError(
+                    "Hangs require a signature to replay",
+                    Session.EXIT_ERROR)
+            if "timeout" in ignore:
+                raise ConfigError(
+                    "Cannot ignore 'timeout' when detecting hangs",
+                    Session.EXIT_ERROR)
+        return is_hang
+
     @classmethod
     def load_testcases(cls, path, load_prefs, subset=None):
         """Load TestCases.
@@ -306,7 +342,7 @@ def run(
                     elif (
                         not startup_error
                         and (self._any_crash
-                            or (self._signature and self._signature.matches(report.crash_info)))
+                            or self.check_match(self._signature, report, expect_hang))
                     ):
                         self.status.count_result(short_sig)
                         LOG.info("Result: %s (%s:%s)",
@@ -405,6 +441,40 @@ def run(
             for report in reports.values():
                 report.report.cleanup()
 
+    @classmethod
+    def time_limits(cls, duration, timeout, tests):
+        """Determine the test duration and timeout. A ConfigError is raised
+        if configuration errors are detected.
+
+        Args:
+            duration (int): Test duration.
+            timeout (int): Iteration timeout.
+            tests (iterable): Testcases that may contain duration values.
+
+        Returns:
+            tuple (int, int): Duration and timeout.
+        """
+        if duration is None:
+            # find longest test duration
+            durations = tuple(int(x.duration) for x in tests if x.duration)
+            if not durations:
+                raise ConfigError(
+                    "No test duration available, set manually",
+                    Session.EXIT_ARGS)
+            duration = max(durations)
+            # add extra time to help avoid closing tests early
+            if not any(x.hang for x in tests):
+                duration *= 1.5
+            # set a minimum duration when loading from a testcase.
+            if duration < cls.MIN_TEST_DURATION:
+                duration = cls.MIN_TEST_DURATION
+        if timeout is None:
+            timeout = duration + TIMEOUT_DELAY
+        if timeout < duration:
+            raise ConfigError(
+                "Timeout (%d) cannot be less than test duration (%d)" % (timeout, duration),
+                Session.EXIT_ARGS)
+        return duration, timeout
 
     @classmethod
     def main(cls, args):
@@ -438,41 +508,23 @@ def main(cls, args):
             LOG.error("Error: %s", str(exc))
             return Session.EXIT_ERROR
 
-        if args.test_duration:
-            test_duration = args.test_duration
-        else:
-            duration = tuple(int(x.duration * 2) for x in testcases if x.duration)
-            if not duration:
-                LOG.error("No test duration available, set manually")
-                return Session.EXIT_ARGS
-            test_duration = max(duration)
-            # set a minimum duration
-            if test_duration < 30:
-                test_duration = 30
-        timeout = args.timeout or test_duration + 30
-        LOG.info("Using test duration: %ds, timeout: %ds", test_duration, timeout)
-        if timeout < test_duration:
-            LOG.error("timeout must be at least test duration if not greater")
-            return Session.EXIT_ARGS
-
         results = None
         target = None
         tmp_prefs = None
         try:
-            # check if hangs are expected
-            expect_hang = any(x.hang for x in testcases)
-            if expect_hang:
-                if signature is None:
-                    LOG.error("Hangs require a signature to replay")
-                    return Session.EXIT_ERROR
-                if "timeout" in args.ignore:
-                    LOG.error("Cannot ignore 'timeout' when detecting hangs")
-                    return Session.EXIT_ERROR
             if args.no_harness and len(testcases) > 1:
                 LOG.error(
-                    "'--no-harness' cannot be used with multiple testcases. " \
+                    "'--no-harness' cannot be used with multiple testcases. "
                     "Perhaps '--test-index' can help.")
                 return Session.EXIT_ARGS
+            # check if hangs are expected
+            expect_hang = cls.expect_hang(args.ignore, signature, testcases)
+            # check test duration and timeout
+            test_duration, timeout = cls.time_limits(
+                args.test_duration,
+                args.timeout,
+                testcases)
+            LOG.info("Using test duration: %ds, timeout: %ds", test_duration, timeout)
             repeat = max(args.min_crashes, args.repeat)
             relaunch = min(args.relaunch, repeat)
             LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
@@ -537,6 +589,10 @@ def main(cls, args):
             # TODO: add fuzzmanager reporting
             return Session.EXIT_SUCCESS if success else Session.EXIT_FAILURE
 
+        except ConfigError as exc:
+            LOG.error(str(exc))
+            return exc.exit_code
+
         except KeyboardInterrupt:
             return Session.EXIT_ABORT
 

From d269ceb2c690acd3595cac7f4321287c3ed55b50 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 18 Feb 2021 14:04:09 -0800
Subject: [PATCH 212/531] Copy TestCase.hang in clone()

---
 grizzly/common/storage.py      | 3 ++-
 grizzly/common/test_storage.py | 4 +++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 83e6e43b..999ebc90 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -198,11 +198,12 @@ def clone(self):
             None
 
         Returns:
-            TestCase: A copy of the TestCase instance
+            TestCase: A copy of the TestCase instance.
         """
         result = type(self)(self.landing_page, self.redirect_page, self.adapter_name,
                             self.input_fname, self.timestamp)
         result.duration = self.duration
+        result.hang = self.hang
         result.env_vars.update(self.env_vars)
         for entry in self._files.meta:
             result.add_meta(entry.clone())
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 3bd2012b..35af55b1 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -403,7 +403,9 @@ def test_testcase_19():
 
 def test_testcase_20():
     """test TestCase.clone()"""
-    with TestCase("test.htm", "redirect.htm", "test-adaptor", "input.py") as src:
+    with TestCase("test.htm", "redirect.htm", "test-adapter", "input.py") as src:
+        src.duration = 1.2
+        src.hang = True
         src.add_from_data("123", "test.htm")
         src.add_from_data("456", "opt.htm", required=False)
         src.add_meta(TestFile.from_data("pref", "prefs.js"))

From 5b0d09ad0fd223a0626c38da0ea19a00c731aefc Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 18 Feb 2021 17:19:45 -0800
Subject: [PATCH 213/531] Be less ambiguous with test duration and test time
 limit

* Add TestCase.time_limit
* Rename Adapter.TEST_DURATION to TIME_LIMIT
* ReplayManager.DEFAULT_TIME_LIMIT is used if time limit is not provided
---
 grizzly/args.py                   |  8 ++---
 grizzly/common/adapter.py         | 14 +++++---
 grizzly/common/iomanager.py       |  5 +--
 grizzly/common/runner.py          | 10 +++---
 grizzly/common/storage.py         | 19 +++++++---
 grizzly/common/test_iomanager.py  |  7 ++--
 grizzly/common/test_runner.py     |  4 +--
 grizzly/common/test_storage.py    | 15 ++++----
 grizzly/common/utils.py           |  2 +-
 grizzly/main.py                   | 26 +++++++-------
 grizzly/reduce/core.py            |  6 ++--
 grizzly/reduce/test_main.py       |  2 +-
 grizzly/reduce/test_reduce.py     | 12 +++----
 grizzly/reduce/test_strategies.py |  8 ++---
 grizzly/replay/replay.py          | 58 +++++++++++++------------------
 grizzly/replay/test_main.py       | 34 +++++++++---------
 grizzly/session.py                | 12 +++----
 grizzly/test_main.py              | 26 +++++++-------
 grizzly/test_session.py           | 12 +++----
 19 files changed, 143 insertions(+), 137 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 8394fdfd..baa9d4a3 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -82,10 +82,10 @@ def __init__(self):
             "--relaunch", type=int, default=1000,
             help="Number of iterations performed before relaunching the browser (default: %(default)s)")
         self.launcher_grp.add_argument(
-            "-d", "--test-duration", type=int, default=None,
+            "--time-limit", type=int, default=None,
             help="This is the maximum amount of time that a test is expected to take."
                  " After the time has elapsed the harness will attempt to close the test."
-                 " By default `Adapter.TEST_DURATION` is used."
+                 " By default `Adapter.TIME_LIMIT` is used."
                  " Browser build types and debuggers can affect the amount of time"
                  " required to run a test case.")
         self.launcher_grp.add_argument(
@@ -170,8 +170,8 @@ def sanity_check(self, args):
         if args.prefs and not isfile(args.prefs):
             self.parser.error("-p/--prefs not found %r" % args.prefs)
 
-        if args.test_duration is not None and args.test_duration < 1:
-            self.parser.error("--test-duration must be at least 1")
+        if args.time_limit is not None and args.time_limit < 1:
+            self.parser.error("--time-limit must be at least 1")
 
         if args.timeout is not None and args.timeout < 1:
             self.parser.error("--timeout must be at least 1")
diff --git a/grizzly/common/adapter.py b/grizzly/common/adapter.py
index 0ba7c850..1c971174 100644
--- a/grizzly/common/adapter.py
+++ b/grizzly/common/adapter.py
@@ -36,10 +36,16 @@ class Adapter(metaclass=ABCMeta):
     """
 
     HARNESS_FILE = pathjoin(dirname(__file__), "harness.html")
-    IGNORE_UNSERVED = True  # Only report test cases with served content
-    NAME = None  # must be a unique string
-    RELAUNCH = 0  # maximum iterations between Target relaunches (<1 use default)
-    TEST_DURATION = 30  # maximum execution time per test (used as minimum timeout)
+    # Only report test cases with served content.
+    IGNORE_UNSERVED = True
+    # This is used as the identifier when launching Grizzly. Must be a unique string.
+    NAME = None
+    # Maximum iterations between Target relaunches (<1 use default)
+    RELAUNCH = 0
+    # Maximum execution time per test (used as minimum timeout). The iteration is
+    # expected to be complete. If the test is still open the harness will attempt to
+    # close it.
+    TIME_LIMIT = 30
 
     __slots__ = ("_harness", "fuzz", "monitor", "remaining")
 
diff --git a/grizzly/common/iomanager.py b/grizzly/common/iomanager.py
index c48b567e..3199076a 100644
--- a/grizzly/common/iomanager.py
+++ b/grizzly/common/iomanager.py
@@ -59,12 +59,13 @@ def cleanup(self):
             e_file.close()
         self.purge_tests()
 
-    def create_testcase(self, adapter_name):
+    def create_testcase(self, adapter_name, time_limit):
         # create testcase object and landing page names
         test = TestCase(
             self.page_name(),
             self.page_name(offset=1),
-            adapter_name=adapter_name)
+            adapter_name=adapter_name,
+            time_limit=time_limit)
         # add environment variable info to the test case
         for e_name, e_value in self._tracked_env.items():
             test.add_environ_var(e_name, e_value)
diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 17abfa34..778f407e 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -143,14 +143,14 @@ def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
         self._tests_run = 0
 
     @staticmethod
-    def location(srv_path, srv_port, close_after=None, test_duration=None):
+    def location(srv_path, srv_port, close_after=None, time_limit=None):
         """Build a valid URL to pass to a browser.
 
         Args:
             srv_path (str): Path segment of the URL
             srv_port (int): Server listening port
             close_after (int): Harness argument.
-            test_duration (int): Harness argument.
+            time_limit (int): Harness argument.
 
         Returns:
             str: A valid URL.
@@ -161,9 +161,9 @@ def location(srv_path, srv_port, close_after=None, test_duration=None):
         if close_after is not None:
             assert close_after >= 0
             args.append("close_after=%d" % (close_after,))
-        if test_duration is not None:
-            assert test_duration >= 0
-            args.append("time_limit=%d" % (test_duration * 1000,))
+        if time_limit is not None:
+            assert time_limit >= 0
+            args.append("time_limit=%d" % (time_limit * 1000,))
         if args:
             return "?".join([location, "&".join(args)])
         return location
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 999ebc90..f9041968 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -39,9 +39,10 @@ class TestFileExists(Exception):
 class TestCase:
     __slots__ = (
         "adapter_name", "duration", "env_vars", "hang", "input_fname", "landing_page",
-        "redirect_page", "timestamp", "_existing_paths", "_files")
+        "redirect_page", "time_limit", "timestamp", "_existing_paths", "_files")
 
-    def __init__(self, landing_page, redirect_page, adapter_name, input_fname=None, timestamp=None):
+    def __init__(self, landing_page, redirect_page, adapter_name, input_fname=None,
+                 time_limit=None, timestamp=None):
         self.adapter_name = adapter_name
         self.duration = None
         self.env_vars = dict()  # environment variables
@@ -49,6 +50,7 @@ def __init__(self, landing_page, redirect_page, adapter_name, input_fname=None,
         self.input_fname = input_fname  # file that was used to create the test case
         self.landing_page = landing_page
         self.redirect_page = redirect_page
+        self.time_limit = time_limit
         self.timestamp = time() if timestamp is None else timestamp
         self._existing_paths = list()  # file paths in use
         self._files = TestFileMap(
@@ -201,7 +203,7 @@ def clone(self):
             TestCase: A copy of the TestCase instance.
         """
         result = type(self)(self.landing_page, self.redirect_page, self.adapter_name,
-                            self.input_fname, self.timestamp)
+                            self.input_fname, self.time_limit, self.timestamp)
         result.duration = self.duration
         result.hang = self.hang
         result.env_vars.update(self.env_vars)
@@ -264,6 +266,7 @@ def dump(self, out_path, include_details=False):
                 "hang": self.hang,
                 "input": basename(self.input_fname) if self.input_fname else None,
                 "target": self.landing_page,
+                "time_limit": self.time_limit,
                 "timestamp": self.timestamp}
             with open(pathjoin(out_path, "test_info.json"), "w") as out_fp:
                 json.dump(info, out_fp, indent=2, sort_keys=True)
@@ -386,10 +389,16 @@ def load_single(cls, path, load_prefs, adjacent=False):
         else:
             raise TestCaseLoadFailure("Missing or invalid TestCase %r" % (path,))
         # create testcase and add data
-        test = cls(None, None, info.get("adapter", None), timestamp=info.get("timestamp", 0))
+        test = cls(
+            None,
+            None,
+            info.get("adapter", None),
+            input_fname=info.get("input", None),
+            time_limit=info.get("time_limit", None),
+            timestamp=info.get("timestamp", 0)
+        )
         test.duration = info.get("duration", None)
         test.hang = info.get("hang", False)
-        test.input_fname = info.get("input", None)
         if load_prefs and isfile(pathjoin(path, "prefs.js")):
             test.add_meta(TestFile.from_file(pathjoin(path, "prefs.js")))
         test.add_from_file(pathjoin(path, entry_point))
diff --git a/grizzly/common/test_iomanager.py b/grizzly/common/test_iomanager.py
index 4be91e89..b2bd560d 100644
--- a/grizzly/common/test_iomanager.py
+++ b/grizzly/common/test_iomanager.py
@@ -52,22 +52,25 @@ def test_iomanager_04():
         assert not iom.server_map.redirect
         iom._tracked_env = {"TEST": "1"}
         iom._environ_files = [TestFile.from_data(b"data", "e.txt")]
+        time_limit = 10
         # without a harness, no input files
-        tcase = iom.create_testcase("test-adapter")
+        tcase = iom.create_testcase("test-adapter", time_limit)
         assert tcase is not None
         assert iom._generated == 1
         assert len(iom.tests) == 1
         assert not any(tcase.optional)
+        assert tcase.time_limit == time_limit
         assert "grz_current_test" in iom.server_map.redirect
         assert iom.server_map.redirect["grz_current_test"].target == tcase.landing_page
         assert "grz_next_test" in iom.server_map.redirect
         assert "grz_harness" not in iom.server_map.dynamic
         # with a harness
         iom.harness = b"harness-data"
-        tcase = iom.create_testcase("test-adapter")
+        tcase = iom.create_testcase("test-adapter", time_limit)
         assert tcase is not None
         assert len(iom.tests) == 1
         assert iom._generated == 2
+        assert tcase.time_limit == time_limit
         assert "grz_current_test" in iom.server_map.redirect
         assert iom.server_map.redirect["grz_current_test"].target == tcase.landing_page
         assert "grz_next_test" in iom.server_map.redirect
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 0b1b3b16..f2e914c0 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -265,9 +265,9 @@ def test_runner_08():
     assert result == "http://127.0.0.1:34567/a.html"
     result = Runner.location("a.html", 34567, close_after=10)
     assert result == "http://127.0.0.1:34567/a.html?close_after=10"
-    result = Runner.location("a.html", 9999, test_duration=60)
+    result = Runner.location("a.html", 9999, time_limit=60)
     assert result == "http://127.0.0.1:9999/a.html?time_limit=60000"
-    result = Runner.location("a.html", 9999, close_after=10, test_duration=60)
+    result = Runner.location("a.html", 9999, close_after=10, time_limit=60)
     assert result == "http://127.0.0.1:9999/a.html?close_after=10&time_limit=60000"
 
 def test_runner_09(mocker):
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 35af55b1..fa588054 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -229,21 +229,20 @@ def test_testcase_09(tmp_path):
 def test_testcase_10(tmp_path):
     """test TestCase - dump, load and compare"""
     with TestCase("a.html", "b.html", "adpt") as org:
+        # set non default values
         org.duration = 1.23
         org.env_vars = {"en1": "1", "en2": "2"}
         org.hang = True
         org.input_fname = "infile"
+        org.time_limit = 10
         org.add_from_data("a", "a.html")
         org.dump(str(tmp_path), include_details=True)
         loaded = TestCase.load_single(str(tmp_path), False)
         try:
-            assert org.adapter_name == loaded.adapter_name
-            assert org.duration == loaded.duration
-            assert org.env_vars == loaded.env_vars
-            assert org.hang == loaded.hang
-            assert org.input_fname == loaded.input_fname
-            assert org.landing_page == loaded.landing_page
-            assert org.timestamp == loaded.timestamp
+            for prop in TestCase.__slots__:
+                if prop.startswith("_") or "redirect_page":
+                    continue
+                assert getattr(loaded, prop) == getattr(org, prop)
             assert org._existing_paths == loaded._existing_paths
         finally:
             loaded.cleanup()
@@ -403,7 +402,7 @@ def test_testcase_19():
 
 def test_testcase_20():
     """test TestCase.clone()"""
-    with TestCase("test.htm", "redirect.htm", "test-adapter", "input.py") as src:
+    with TestCase("a.htm", "b.htm", "adpt", input_fname="fn", time_limit=2) as src:
         src.duration = 1.2
         src.hang = True
         src.add_from_data("123", "test.htm")
diff --git a/grizzly/common/utils.py b/grizzly/common/utils.py
index 5bdfd66d..cad12326 100644
--- a/grizzly/common/utils.py
+++ b/grizzly/common/utils.py
@@ -13,7 +13,7 @@
 __credits__ = ["Tyson Smith"]
 
 
-# TIMEOUT_DELAY is added to the test duration to create the default timeout
+# TIMEOUT_DELAY is added to the test time limit to create the default timeout
 TIMEOUT_DELAY = 15
 
 
diff --git a/grizzly/main.py b/grizzly/main.py
index 2dc4e212..cc95bcbf 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -62,23 +62,23 @@ def main(args):
         LOG.debug("initializing Adapter %r", args.adapter)
         adapter = get_adapter(args.adapter)()
 
-        # test duration and timeout sanity checking
-        if args.test_duration:
-            test_duration = args.test_duration
+        # test time limit and timeout sanity checking
+        if args.time_limit:
+            time_limit = args.time_limit
         else:
-            assert adapter.TEST_DURATION >= 1
-            test_duration = adapter.TEST_DURATION
+            assert adapter.TIME_LIMIT >= 1
+            time_limit = adapter.TIME_LIMIT
         if args.timeout:
             timeout = args.timeout
         else:
-            timeout = test_duration + TIMEOUT_DELAY
-        LOG.info("Using test duration: %ds, timeout: %ds", test_duration, timeout)
-        if timeout < test_duration:
-            LOG.error("timeout must be at least test duration if not greater")
+            timeout = time_limit + TIMEOUT_DELAY
+        LOG.info("Using test time limit: %ds, timeout: %ds", time_limit, timeout)
+        if timeout < time_limit:
+            LOG.error("Timeout must be at least test time limit if not greater")
             return Session.EXIT_ARGS
-        if adapter.HARNESS_FILE and test_duration == timeout:
-            LOG.info("To avoid relaunches due to tests failing to close"
-                     " themselves use a timeout greater than test duration")
+        if adapter.HARNESS_FILE and time_limit == timeout:
+            LOG.warning("To avoid relaunches due to tests failing to close"
+                        " themselves use a timeout greater than time limit")
 
         if adapter.RELAUNCH > 0:
             LOG.info("Relaunch (%d) set in Adapter", adapter.RELAUNCH)
@@ -142,7 +142,7 @@ def main(args):
                 display_mode = Session.DISPLAY_NORMAL
             session.run(
                 args.ignore,
-                test_duration,
+                time_limit,
                 iteration_limit=args.limit,
                 display_mode=display_mode)
 
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 15d11324..333ace21 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -641,10 +641,10 @@ def main(cls, args):
                 LOG.debug("--no-harness specified relaunch set to 1")
                 args.relaunch = 1
 
-            # check test duration and timeout
-            # TODO: add support for test duration
+            # check test time limit and timeout
+            # TODO: add support for test time limit, use timeout in both cases for now
             _, timeout = ReplayManager.time_limits(
-                args.test_duration,
+                args.timeout,
                 args.timeout,
                 testcases)
 
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 677b6c0e..1148d222 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -171,8 +171,8 @@ def test_testcase_prefs(mocker, tmp_path, result):
         prefs=None,
         repeat=1,
         sig=None,
-        test_duration=10,
         test_index=None,
+        time_limit=10,
         timeout=10,
     )
     if result == "argprefs":
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 8510f0f5..b103ae07 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -246,7 +246,7 @@ def test_analysis(mocker, tmp_path, harness_last_crashes, harness_crashes,
         crashes += [False] * (11 - no_harness_crashes) + [True] * no_harness_crashes
         expected_iters += 1
 
-    def replay_run(_tests, _test_duration, **kw):
+    def replay_run(_tests, _time_limit, **kw):
         results = []
         repeat = kw["repeat"]
         assert repeat <= len(crashes)
@@ -483,7 +483,7 @@ def test_repro(mocker, tmp_path, original, strategies, detect_failure, interesti
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(testcases, _test_duration, **_):
+    def replay_run(testcases, _time_limit, **_):
         for test in testcases:
             contents = test.get_file("test.html").data.decode("ascii")
             # pylint: disable=logging-not-lazy
@@ -551,7 +551,7 @@ def test_report_01(mocker, tmp_path):
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(_tests, _test_duration, **_kw):
+    def replay_run(_tests, _time_limit, **_kw):
         if replayer.run.call_count in {20, 40}:
             log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
             log_path.mkdir()
@@ -613,7 +613,7 @@ def test_report_02(mocker, tmp_path):
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(_tests, _test_duration, **_kw):
+    def replay_run(_tests, _time_limit, **_kw):
         if replayer.run.call_count in {10, 20}:
             log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
             log_path.mkdir()
@@ -673,7 +673,7 @@ def test_quality_update(mocker, tmp_path):
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(testcases, _test_duration, **_kw):
+    def replay_run(testcases, _time_limit, **_kw):
         for test in testcases:
             contents = test.get_file("test.html").data.decode("ascii")
             if not contents.strip():
@@ -795,7 +795,7 @@ def test_timeout_update(mocker, tmp_path, durations, interesting, static_timeout
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(_testcases, _test_duration, **_):
+    def replay_run(_testcases, _time_limit, **_):
         LOG.debug("interesting true")
         log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
         log_path.mkdir()
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 241480ce..30371b80 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -118,7 +118,7 @@ def test_list(mocker, tmp_path, test_data, strategies, required_first,
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(testcases, _test_duration, **_):
+    def replay_run(testcases, _time_limit, **_):
         required_seen = False
         for test in testcases:
             contents = test.get_file("test.html").data.decode("ascii")
@@ -481,7 +481,7 @@ def test_beautifier(mocker, tmp_path, test_data, test_name, expected_run_calls,
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(testcases, _test_duration, **_):
+    def replay_run(testcases, _time_limit, **_):
         for test in testcases:
             contents = test.get_file(test_name).data.decode("ascii")
             if "nochange" in test_data:
@@ -633,7 +633,7 @@ def test_purge_unserved(mocker, tmp_path, strategies, test_data, served,
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(testcases, _test_duration, **_):
+    def replay_run(testcases, _time_limit, **_):
         # test.html and opt.html should always contain one line.
         # return [] (no result) if either of them exist and are empty
         has_any = False
@@ -702,7 +702,7 @@ def test_dd_only(mocker, tmp_path):
     replayer = replayer.return_value
     replayer.status.iteration = 1
 
-    def replay_run(testcases, _test_duration, **_):
+    def replay_run(testcases, _time_limit, **_):
         for test in testcases:
             contents = test.get_file("test.html").data.decode("ascii")
             LOG.debug("interesting if 'required' in %r", contents)
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 366bb623..69a13d9a 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -39,7 +39,7 @@ def __init__(self, report, served, durations, expected):
 
 class ReplayManager:
     HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
-    MIN_TEST_DURATION = 10
+    DEFAULT_TIME_LIMIT = 30
 
     __slots__ = ("ignore", "server", "status", "target", "_any_crash",
                  "_harness", "_signature", "_relaunch", "_unpacked")
@@ -181,7 +181,7 @@ def report_to_filesystem(path, results, tests=None):
     def run(
         self,
         testcases,
-        test_duration,
+        time_limit,
         repeat=1,
         min_results=1,
         exit_early=True,
@@ -193,7 +193,7 @@ def run(
 
         Args:
             testcases (list): One or more TestCases to run.
-            test_duration (int): Maximum time in seconds a test should take to complete.
+            time_limit (int): Maximum time in seconds a test should take to complete.
             repeat (int): Maximum number of times to run the TestCase.
             min_results (int): Minimum number of results needed before run can
                                be considered successful.
@@ -215,7 +215,7 @@ def run(
         assert repeat > 0
         assert repeat >= min_results
         assert testcases
-        assert test_duration > 0
+        assert time_limit > 0
         assert self._harness is not None or len(testcases) == 1
         assert not expect_hang or self._signature is not None
 
@@ -260,7 +260,7 @@ def run(
                             "/grz_harness",
                             self.server.port,
                             close_after=relaunch * test_count,
-                            test_duration=test_duration)
+                            time_limit=time_limit)
                     startup_error = False
                     # The environment from the initial testcase is used because
                     # a sequence of testcases is expected to be run without
@@ -442,39 +442,31 @@ def run(
                 report.report.cleanup()
 
     @classmethod
-    def time_limits(cls, duration, timeout, tests):
-        """Determine the test duration and timeout. A ConfigError is raised
+    def time_limits(cls, time_limit, timeout, tests):
+        """Determine the test time limit and timeout. A ConfigError is raised
         if configuration errors are detected.
 
         Args:
-            duration (int): Test duration.
+            time_limit (int): Test time limit.
             timeout (int): Iteration timeout.
-            tests (iterable): Testcases that may contain duration values.
+            tests (iterable): Testcases that may contain time limit values.
 
         Returns:
-            tuple (int, int): Duration and timeout.
+            tuple (int, int): Time limit and timeout.
         """
-        if duration is None:
-            # find longest test duration
-            durations = tuple(int(x.duration) for x in tests if x.duration)
-            if not durations:
-                raise ConfigError(
-                    "No test duration available, set manually",
-                    Session.EXIT_ARGS)
-            duration = max(durations)
-            # add extra time to help avoid closing tests early
-            if not any(x.hang for x in tests):
-                duration *= 1.5
-            # set a minimum duration when loading from a testcase.
-            if duration < cls.MIN_TEST_DURATION:
-                duration = cls.MIN_TEST_DURATION
+        if time_limit is None:
+            test_limits = tuple(int(x.time_limit) for x in tests if x.time_limit)
+            if test_limits:
+                time_limit = max(test_limits)
+            else:
+                time_limit = cls.DEFAULT_TIME_LIMIT
         if timeout is None:
-            timeout = duration + TIMEOUT_DELAY
-        if timeout < duration:
+            timeout = time_limit + TIMEOUT_DELAY
+        if timeout < time_limit:
             raise ConfigError(
-                "Timeout (%d) cannot be less than test duration (%d)" % (timeout, duration),
+                "Timeout (%d) cannot be less than time limit (%d)" % (timeout, time_limit),
                 Session.EXIT_ARGS)
-        return duration, timeout
+        return time_limit, timeout
 
     @classmethod
     def main(cls, args):
@@ -519,12 +511,12 @@ def main(cls, args):
                 return Session.EXIT_ARGS
             # check if hangs are expected
             expect_hang = cls.expect_hang(args.ignore, signature, testcases)
-            # check test duration and timeout
-            test_duration, timeout = cls.time_limits(
-                args.test_duration,
+            # check test time limit and timeout
+            time_limit, timeout = cls.time_limits(
+                args.time_limit,
                 args.timeout,
                 testcases)
-            LOG.info("Using test duration: %ds, timeout: %ds", test_duration, timeout)
+            LOG.info("Using time limit: %ds, timeout: %ds", time_limit, timeout)
             repeat = max(args.min_crashes, args.repeat)
             relaunch = min(args.relaunch, repeat)
             LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
@@ -569,7 +561,7 @@ def main(cls, args):
                 ) as replay:
                     results = replay.run(
                         testcases,
-                        test_duration,
+                        time_limit,
                         expect_hang=expect_hang,
                         idle_delay=args.idle_delay,
                         idle_threshold=args.idle_threshold,
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 0ed93ade..a1e7e044 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -106,7 +106,7 @@ def test_main_01(mocker, tmp_path):
         rr=False,
         sig=str(tmp_path / "sig.json"),
         test_index=None,
-        test_duration=10,
+        time_limit=10,
         timeout=None,
         valgrind=False)
     assert ReplayManager.main(args) == Session.EXIT_SUCCESS
@@ -151,7 +151,7 @@ def test_main_02(mocker, tmp_path):
         rr=False,
         sig=None,
         test_index=None,
-        test_duration=10,
+        time_limit=10,
         timeout=None,
         valgrind=False)
     assert ReplayManager.main(args) == Session.EXIT_FAILURE
@@ -176,8 +176,8 @@ def test_main_03(mocker):
         relaunch=1,
         repeat=1,
         sig=None,
-        test_duration=10,
         test_index=None,
+        time_limit=10,
         timeout=None)
     # user abort
     fake_load_target.side_effect = KeyboardInterrupt
@@ -240,8 +240,8 @@ def test_main_04(mocker, tmp_path):
         relaunch=1,
         repeat=1,
         sig=None,
-        test_duration=10,
         test_index=None,
+        time_limit=10,
         timeout=None)
     # target launch error
     fake_logs = (tmp_path / "fake_report")
@@ -278,8 +278,8 @@ def test_main_05(mocker, tmp_path):
         relaunch=1,
         repeat=1,
         sig=None,
-        test_duration=1,
         test_index=None,
+        time_limit=1,
         timeout=None)
     log_path = (tmp_path / "logs")
     args.logs = str(log_path)
@@ -332,24 +332,24 @@ def test_main_05(mocker, tmp_path):
     assert prefs.read_bytes() == b"specified"
 
 @mark.parametrize(
-    "arg_duration, arg_timeout, test_duration, result",
+    "arg_timelimit, arg_timeout, test_timelimit, result",
     [
-        # use default test duration and timeout values (test missing duration)
-        (None, None, None, Session.EXIT_ARGS),
-        # use min test duration and default timeout values
+        # use default test time limit and timeout values (test missing time limit)
+        (None, None, None, Session.EXIT_FAILURE),
+        # use min test time limit and default timeout values
         (None, None, 1, Session.EXIT_FAILURE),
-        # set test duration
+        # set test time limit
         (10, None, None, Session.EXIT_FAILURE),
-        # set both test duration and timeout to the same value
+        # set both test time limit and timeout to the same value
         (10, 10, None, Session.EXIT_FAILURE),
-        # set timeout greater than test duration
+        # set timeout greater than test time limit
         (10, 11, None, Session.EXIT_FAILURE),
-        # set test duration greater than timeout
+        # set test time limit greater than timeout
         (11, 10, None, Session.EXIT_ARGS),
     ]
 )
-def test_main_06(mocker, tmp_path, arg_duration, arg_timeout, test_duration, result):
-    """test ReplayManager.main() - test duration and timeout"""
+def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, result):
+    """test ReplayManager.main() - test time limit and timeout"""
     # mock Sapphire.serve_path only
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
@@ -367,7 +367,7 @@ def test_main_06(mocker, tmp_path, arg_duration, arg_timeout, test_duration, res
     test.add_from_file(str(test_file))
     replay_path = tmp_path / "test"
     replay_path.mkdir()
-    test.duration = test_duration
+    test.time_limit = test_timelimit
     test.dump(str(replay_path), include_details=True)
     # setup args
     (tmp_path / "prefs.js").touch()
@@ -385,7 +385,7 @@ def test_main_06(mocker, tmp_path, arg_duration, arg_timeout, test_duration, res
         rr=False,
         sig=None,
         test_index=None,
-        test_duration=arg_duration,
+        time_limit=arg_timelimit,
         timeout=arg_timeout,
         valgrind=False)
     assert ReplayManager.main(args) == result
diff --git a/grizzly/session.py b/grizzly/session.py
index 8ea78863..fdeb2a12 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -96,9 +96,9 @@ def display_status(self, log_limiter):
         elif log_limiter.ready(self.status.iteration, self.target.monitor.launches):
             LOG.info("I%04d-R%02d ", self.status.iteration, self.status.results)
 
-    def generate_testcase(self):
+    def generate_testcase(self, time_limit):
         LOG.debug("calling iomanager.create_testcase()")
-        test = self.iomanager.create_testcase(self.adapter.NAME)
+        test = self.iomanager.create_testcase(self.adapter.NAME, time_limit)
         LOG.debug("calling self.adapter.generate()")
         with self.status.measure("generate"):
             self.adapter.generate(test, self.iomanager.server_map)
@@ -108,8 +108,8 @@ def generate_testcase(self):
             test.add_meta(TestFile.from_file(self.target.prefs, "prefs.js"))
         return test
 
-    def run(self, ignore, test_duration, iteration_limit=0, display_mode=DISPLAY_NORMAL):
-        assert test_duration > 0
+    def run(self, ignore, time_limit, iteration_limit=0, display_mode=DISPLAY_NORMAL):
+        assert time_limit > 0
         assert iteration_limit >= 0
         log_limiter = LogOutputLimiter(verbose=display_mode == self.DISPLAY_VERBOSE)
         # limit relaunch to max iterations if needed
@@ -136,7 +136,7 @@ def run(self, ignore, test_duration, iteration_limit=0, display_mode=DISPLAY_NOR
                         "/grz_harness",
                         self.server.port,
                         close_after=relaunch,
-                        test_duration=test_duration)
+                        time_limit=time_limit)
                 try:
                     with self.status.measure("launch"):
                         runner.launch(location, max_retries=3, retry_delay=0)
@@ -152,7 +152,7 @@ def run(self, ignore, test_duration, iteration_limit=0, display_mode=DISPLAY_NOR
                     raise TargetLaunchError(str(exc), None) from None
 
             # create and populate a test case
-            current_test = self.generate_testcase()
+            current_test = self.generate_testcase(time_limit)
             # display status
             self.display_status(log_limiter=log_limiter)
 
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 7c53999b..3dddb749 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -32,7 +32,7 @@ def __init__(self):
         self.rr = False
         self.relaunch = 1000
         self.s3_fuzzmanager = False
-        self.test_duration = None
+        self.time_limit = None
         self.timeout = None
         self.tool = None
         self.valgrind = False
@@ -45,7 +45,7 @@ def test_main_01(mocker):
     """test main()"""
     fake_adapter = mocker.Mock(spec=Adapter)
     fake_adapter.NAME = "fake"
-    fake_adapter.TEST_DURATION = 10
+    fake_adapter.TIME_LIMIT = 10
     mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
     mocker.patch.dict("grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)})
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
@@ -96,7 +96,7 @@ def test_main_01(mocker):
 def test_main_02(mocker):
     """test main() exit codes"""
     fake_adapter = mocker.Mock(spec=Adapter)
-    fake_adapter.TEST_DURATION = 10
+    fake_adapter.TIME_LIMIT = 10
     fake_adapter.RELAUNCH = 0
     mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
     mocker.patch.dict("grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)})
@@ -116,26 +116,26 @@ def test_main_02(mocker):
     assert main(args) == Session.EXIT_LAUNCH_FAILURE
 
 @mark.parametrize(
-    "arg_duration, arg_timeout, result",
+    "arg_testlimit, arg_timeout, result",
     [
-        # use default test duration and timeout values
+        # use default test time limit and timeout values
         (None, None, Session.EXIT_SUCCESS),
-        # set test duration
+        # set test time limit
         (10, None, Session.EXIT_SUCCESS),
-        # set both test duration and timeout to the same value
+        # set both test time limit and timeout to the same value
         (10, 10, Session.EXIT_SUCCESS),
-        # set timeout greater than test duration
+        # set timeout greater than test time limit
         (10, 11, Session.EXIT_SUCCESS),
-        # set test duration greater than timeout
+        # set test time limit greater than timeout
         (11, 10, Session.EXIT_ARGS),
     ]
 )
-def test_main_03(mocker, arg_duration, arg_timeout, result):
-    """test main() duration and timeout"""
+def test_main_03(mocker, arg_testlimit, arg_timeout, result):
+    """test main() time-limit and timeout"""
     fake_adapter = mocker.Mock(spec=Adapter)
     fake_adapter.NAME = "fake"
     fake_adapter.RELAUNCH = 1
-    fake_adapter.TEST_DURATION = 10
+    fake_adapter.TIME_LIMIT = 10
     mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
     mocker.patch.dict("grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)})
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
@@ -144,6 +144,6 @@ def test_main_03(mocker, arg_duration, arg_timeout, result):
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     args = FakeArgs()
     args.adapter = "fake"
-    args.test_duration = arg_duration
+    args.time_limit = arg_testlimit
     args.timeout = arg_timeout
     assert main(args) == result
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 17a3068b..4fce61d0 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -137,8 +137,7 @@ def test_session_05(tmp_path, mocker):
     Status.PATH = str(tmp_path)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
     fake_adapter.IGNORE_UNSERVED = True
-    fake_adapter.TEST_DURATION = 10
-    fake_testcase = mocker.Mock(spec=TestCase, landing_page="page.htm", optional=[])
+    fake_testcase = mocker.Mock(spec_set=TestCase, landing_page="page.htm", optional=[], time_limit=10)
     fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
     fake_iomgr.create_testcase.return_value = fake_testcase
     fake_iomgr.tests = mocker.Mock(spec=deque)
@@ -169,13 +168,13 @@ def test_session_06(tmp_path, mocker):
     fake_adapter = mocker.Mock(spec=Adapter)
     fake_adapter.NAME = "fake_adapter"
     fake_iomgr = mocker.Mock(spec=IOManager, server_map=ServerMap())
-    fake_iomgr.create_testcase.return_value = mocker.Mock(spec=TestCase)
+    fake_iomgr.create_testcase.return_value = mocker.Mock(spec_set=TestCase, time_limit=10)
     fake_target = mocker.Mock(spec=Target, prefs="fake")
     with Session(fake_adapter, fake_iomgr, None, None, fake_target) as session:
         assert fake_adapter.generate.call_count == 0
-        testcase = session.generate_testcase()
+        testcase = session.generate_testcase(10)
         assert fake_iomgr.create_testcase.call_count == 1
-        fake_iomgr.create_testcase.assert_called_with("fake_adapter")
+        fake_iomgr.create_testcase.assert_called_with("fake_adapter", 10)
         assert fake_adapter.generate.call_count == 1
         fake_adapter.generate.assert_called_with(testcase, fake_iomgr.server_map)
         assert testcase.add_meta.call_count == 1
@@ -186,7 +185,6 @@ def test_session_07(tmp_path, mocker):
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
-    fake_adapter.TEST_DURATION = 10
     fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
     fake_iomgr.create_testcase.return_value = mocker.Mock(spec=TestCase)
     fake_iomgr.tests = mocker.Mock(spec=deque)
@@ -257,7 +255,6 @@ def test_session_08(tmp_path, mocker):
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
     fake_adapter.IGNORE_UNSERVED = False
-    fake_adapter.TEST_DURATION = 10
     fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
     fake_test = mocker.Mock(spec=TestCase)
     fake_iomgr.create_testcase.return_value = fake_test
@@ -306,7 +303,6 @@ def test_session_10(tmp_path, mocker):
     fake_runner.return_value.run.return_value = result
     mocker.patch("grizzly.session.TestFile", autospec=True)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
-    fake_adapter.TEST_DURATION = 10
     fake_iomgr = mocker.Mock(
         spec=IOManager,
         harness=None,

From 2d1ef9d2289d88927fa2748822d47919da1a2c07 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 19 Feb 2021 14:00:40 -0800
Subject: [PATCH 214/531] Always call close() in handle_hang()

---
 grizzly/target/puppet_target.py      | 34 +++++++++++++---------------
 grizzly/target/test_puppet_target.py | 24 +++++++++++++-------
 2 files changed, 32 insertions(+), 26 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 25403458..69807a96 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -131,28 +131,26 @@ def detect_failure(self, ignored):
 
     def handle_hang(self, ignore_idle=True):
         was_idle = False
-        if system() != "Linux":
-            # sending SIGABRT is only supported on Linux for now
-            # TODO: add/test on other OSs
-            self.close()
-        elif self._puppet.is_healthy():
-            with self._lock:
-                proc_usage = self._puppet.cpu_usage()
-            for pid, cpu in sorted(proc_usage, reverse=True, key=lambda x: x[1]):
+        if self._puppet.is_healthy():
+            proc_usage = sorted(self._puppet.cpu_usage(), key=lambda x: x[1])
+            if proc_usage:
+                pid, cpu = proc_usage.pop()
                 if ignore_idle and cpu < 15:
                     # don't send SIGABRT if process is idle
                     LOG.debug("ignoring idle hang (%0.1f%%)", cpu)
                     was_idle = True
-                    break
-                LOG.debug("sending SIGABRT to busy process: %r (%0.1f%%)", pid, cpu)
-                try:
-                    kill(pid, SIGABRT)
-                except OSError:
-                    LOG.warning("Failed to send SIGABRT to pid %d", pid)
-                self._puppet.wait(timeout=10)
-                break
-            # always close target when hung
-            self.close()
+                elif system() == "Linux":
+                    # sending SIGABRT is only supported on Linux for now
+                    # TODO: add/test on other OSs
+                    LOG.debug("sending SIGABRT to %r (%0.1f%%)", pid, cpu)
+                    try:
+                        kill(pid, SIGABRT)
+                    except OSError:
+                        LOG.warning("Failed to send SIGABRT to pid %d", pid)
+                    self._puppet.wait(timeout=10)
+        # always call close() since this function should only/always
+        # be called when there has been a timeout
+        self.close()
         return was_idle
 
     def dump_coverage(self, timeout=15):
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 432a9279..eae3272a 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -145,41 +145,49 @@ def test_puppet_target_04(mocker, tmp_path):
     """test PuppetTarget.handle_hang()"""
     fake_system = mocker.patch("grizzly.target.puppet_target.system", autospec=True)
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
+    fake_kill = mocker.patch("grizzly.target.puppet_target.kill", autospec=True)
     fake_file = tmp_path / "fake"
     fake_file.touch()
     target = PuppetTarget(str(fake_file), None, 300, 25, 5000)
     # test skipping unsupported OSs
     fake_system.return_value = "Window"
+    fake_ffp.return_value.cpu_usage.return_value = ((1234, 90),)
+    fake_ffp.return_value.is_healthy.return_value = True
     target.handle_hang()
-    assert fake_ffp.return_value.is_healthy.call_count == 0
+    assert fake_ffp.return_value.is_healthy.call_count == 1
     assert fake_ffp.return_value.close.call_count == 1
+    assert fake_ffp.return_value.cpu_usage.call_count == 1
+    assert fake_kill.call_count == 0
     fake_ffp.reset_mock()
-    # test skipping closing target if it is in a bad state
+    # test skipping idle check if target is in a bad state
     fake_system.return_value = "Linux"
     fake_ffp.return_value.is_healthy.return_value = False
     target.handle_hang()
-    assert fake_ffp.return_value.close.call_count == 0
+    assert fake_ffp.return_value.is_healthy.call_count == 1
+    assert fake_ffp.return_value.close.call_count == 1
+    assert fake_ffp.return_value.cpu_usage.call_count == 0
+    assert fake_kill.call_count == 0
     fake_ffp.reset_mock()
     # test timeout
     fake_ffp.return_value.is_healthy.return_value = True
     fake_ffp.return_value.cpu_usage.return_value = ((1234, 10), (1236, 75), (1238, 60))
     # raise OSError for code coverage
-    fake_kill = mocker.patch(
-        "grizzly.target.puppet_target.kill",
-        autospec=True,
-        side_effect=OSError)
+    fake_kill.side_effect = OSError
     target.handle_hang()
     assert fake_kill.call_count == 1
     assert fake_ffp.return_value.wait.call_count == 1
     assert fake_ffp.return_value.close.call_count == 1
+    assert fake_kill.call_count == 1
     fake_ffp.reset_mock()
     fake_kill.reset_mock()
     # test ignore idle timeout (close don't abort)
     fake_ffp.return_value.is_healthy.return_value = True
     fake_ffp.return_value.cpu_usage.return_value = ((1234, 10),)
     target.handle_hang(ignore_idle=True)
-    assert fake_kill.call_count == 0
+    assert fake_ffp.return_value.is_healthy.call_count == 1
     assert fake_ffp.return_value.close.call_count == 1
+    assert fake_ffp.return_value.cpu_usage.call_count == 1
+    assert fake_kill.call_count == 0
 
 @mark.skipif(system() == "Windows", reason="Unsupported on Windows")
 def test_puppet_target_05(mocker, tmp_path):

From fd37db675825cc8408c98f53c3d0073c1f27e24c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 19 Feb 2021 16:23:34 -0800
Subject: [PATCH 215/531] Simplify PuppetTarget.detect_failure()

---
 grizzly/target/puppet_target.py      |  6 +-
 grizzly/target/test_puppet_target.py | 88 +++++++++-------------------
 2 files changed, 30 insertions(+), 64 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 69807a96..d1cf46aa 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -101,10 +101,8 @@ def detect_failure(self, ignored):
         status = self.RESULT_NONE
         # check if there has been a crash, hangs will appear as SIGABRT
         if not self._puppet.is_healthy():
-            if self._puppet.is_running():
-                LOG.debug("browser in bad state, closing...")
-                self.close()
-            # if something has happened figure out what
+            self.close()
+            # something has happened figure out what
             if self._puppet.reason == FFPuppet.RC_CLOSED:
                 LOG.debug("target.close() was called")
             elif self._puppet.reason == FFPuppet.RC_EXITED:
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index eae3272a..1068fc39 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -71,7 +71,26 @@ def test_puppet_target_02(mocker, tmp_path):
             target.launch("launch_target_page")
         assert fake_ffp.return_value.save_logs.call_count == 1
 
-def test_puppet_target_03(mocker, tmp_path):
+@mark.parametrize(
+    "healthy, reason, ignore, result, closes",
+    [
+        # running as expected - no failures
+        (True, None, [], Target.RESULT_NONE, 0),
+        # browser process closed
+        (False, FFPuppet.RC_CLOSED, [], Target.RESULT_NONE, 1),
+        # browser process crashed
+        (False, FFPuppet.RC_ALERT, [], Target.RESULT_FAILURE, 1),
+        # browser exit with no crash logs
+        (False, FFPuppet.RC_EXITED, [], Target.RESULT_NONE, 1),
+        # ffpuppet check failed
+        (False, FFPuppet.RC_WORKER, [], Target.RESULT_FAILURE, 1),
+        # ffpuppet check ignored (memory)
+        (False, FFPuppet.RC_WORKER, ["memory"], Target.RESULT_IGNORED, 1),
+        # ffpuppet check ignored (log-limit)
+        (False, FFPuppet.RC_WORKER, ["log-limit"], Target.RESULT_IGNORED, 1),
+    ]
+)
+def test_puppet_target_03(mocker, tmp_path, healthy, reason, ignore, result, closes):
     """test PuppetTarget.detect_failure()"""
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_ffp.RC_ALERT = FFPuppet.RC_ALERT
@@ -81,65 +100,14 @@ def test_puppet_target_03(mocker, tmp_path):
     fake_file = tmp_path / "fake"
     fake_file.touch()
     target = PuppetTarget(str(fake_file), None, 300, 25, 5000)
-    # no failures
-    fake_ffp.return_value.is_healthy.return_value = True
-    fake_ffp.return_value.reason = None
-    assert target.detect_failure([]) == Target.RESULT_NONE
-    assert fake_ffp.return_value.is_running.call_count == 0
-    assert not target.closed
-    fake_ffp.reset_mock()
-    # test close
-    fake_ffp.return_value.is_healthy.return_value = False
-    fake_ffp.return_value.is_running.return_value = False
-    fake_ffp.return_value.reason = FFPuppet.RC_CLOSED
-    assert target.detect_failure([]) == Target.RESULT_NONE
-    assert fake_ffp.return_value.is_healthy.call_count == 1
-    assert fake_ffp.return_value.is_running.call_count == 1
-    assert fake_ffp.return_value.close.call_count == 0
-    fake_ffp.reset_mock()
-    # test single process crash
-    fake_ffp.return_value.is_healthy.return_value = False
-    fake_ffp.return_value.is_running.return_value = False
-    fake_ffp.return_value.reason = FFPuppet.RC_ALERT
-    assert target.detect_failure([]) == Target.RESULT_FAILURE
-    assert fake_ffp.return_value.close.call_count == 0
-    fake_ffp.reset_mock()
-    # test multiprocess crash
-    fake_ffp.return_value.is_healthy.return_value = False
-    fake_ffp.return_value.is_running.return_value = True
-    fake_ffp.return_value.reason = FFPuppet.RC_ALERT
-    assert target.detect_failure([]) == Target.RESULT_FAILURE
-    assert fake_ffp.return_value.close.call_count == 1
-    fake_ffp.reset_mock()
-    # test exit with no crash logs
-    fake_ffp.return_value.is_healthy.return_value = False
-    fake_ffp.return_value.is_running.return_value = False
-    fake_ffp.return_value.reason = FFPuppet.RC_EXITED
-    assert target.detect_failure([]) == Target.RESULT_NONE
-    assert fake_ffp.return_value.close.call_count == 0
-    fake_ffp.reset_mock()
-    # test worker
-    fake_ffp.return_value.is_healthy.return_value = False
-    fake_ffp.return_value.is_running.return_value = False
-    fake_ffp.return_value.reason = FFPuppet.RC_WORKER
-    assert target.detect_failure([]) == Target.RESULT_FAILURE
-    assert fake_ffp.return_value.close.call_count == 0
-    fake_ffp.reset_mock()
-    # test memory ignored
-    fake_ffp.return_value.is_healthy.return_value = False
-    fake_ffp.return_value.is_running.return_value = False
-    fake_ffp.return_value.reason = FFPuppet.RC_WORKER
-    fake_ffp.return_value.available_logs.return_value = " ffp_worker_memory_usage "
-    assert target.detect_failure(["memory"]) == Target.RESULT_IGNORED
-    assert fake_ffp.return_value.close.call_count == 0
-    fake_ffp.reset_mock()
-    # test log-limit ignored
-    fake_ffp.return_value.is_healthy.return_value = False
-    fake_ffp.return_value.is_running.return_value = False
-    fake_ffp.return_value.reason = FFPuppet.RC_WORKER
-    fake_ffp.return_value.available_logs.return_value = " ffp_worker_log_size "
-    assert target.detect_failure(["log-limit"]) == Target.RESULT_IGNORED
-    assert fake_ffp.return_value.close.call_count == 0
+    if "memory" in ignore:
+        fake_ffp.return_value.available_logs.return_value = "ffp_worker_memory_usage"
+    elif "log-limit" in ignore:
+        fake_ffp.return_value.available_logs.return_value = "ffp_worker_log_size"
+    fake_ffp.return_value.is_healthy.return_value = healthy
+    fake_ffp.return_value.reason = reason
+    assert target.detect_failure(ignore) == result
+    assert fake_ffp.return_value.close.call_count == closes
 
 def test_puppet_target_04(mocker, tmp_path):
     """test PuppetTarget.handle_hang()"""

From f092fa3b2fa9932a7f73e0af70027ca99fcdad93 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 19 Feb 2021 16:50:39 -0800
Subject: [PATCH 216/531] [tests] Simplify PuppetTarget.handle_hang() tests

---
 grizzly/target/test_puppet_target.py | 60 ++++++++++------------------
 1 file changed, 22 insertions(+), 38 deletions(-)

diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 1068fc39..d0a54bd4 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -109,53 +109,37 @@ def test_puppet_target_03(mocker, tmp_path, healthy, reason, ignore, result, clo
     assert target.detect_failure(ignore) == result
     assert fake_ffp.return_value.close.call_count == closes
 
-def test_puppet_target_04(mocker, tmp_path):
+@mark.parametrize(
+    "healthy, usage, os_name, killed",
+    [
+        # skip sending SIGABRT on unsupported OSs
+        (True, [(1234, 90)], "Windows", 0),
+        # skip idle check if target is in a bad state
+        (False, [], "Linux", 0),
+        # send SIGABRT to hung process
+        (True, [(234, 10), (236, 75), (238, 60)], "Linux", 1),
+        # ignore idle timeout (close don't abort)
+        (True, [(234, 10)], "Linux", 0),
+
+    ]
+)
+def test_puppet_target_04(mocker, tmp_path, healthy, usage, os_name, killed):
     """test PuppetTarget.handle_hang()"""
-    fake_system = mocker.patch("grizzly.target.puppet_target.system", autospec=True)
+    mocker.patch("grizzly.target.puppet_target.system", autospec=True, return_value=os_name)
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_kill = mocker.patch("grizzly.target.puppet_target.kill", autospec=True)
+    # raise OSError for code coverage
+    fake_kill.side_effect = OSError
     fake_file = tmp_path / "fake"
     fake_file.touch()
     target = PuppetTarget(str(fake_file), None, 300, 25, 5000)
-    # test skipping unsupported OSs
-    fake_system.return_value = "Window"
-    fake_ffp.return_value.cpu_usage.return_value = ((1234, 90),)
-    fake_ffp.return_value.is_healthy.return_value = True
-    target.handle_hang()
-    assert fake_ffp.return_value.is_healthy.call_count == 1
-    assert fake_ffp.return_value.close.call_count == 1
-    assert fake_ffp.return_value.cpu_usage.call_count == 1
-    assert fake_kill.call_count == 0
-    fake_ffp.reset_mock()
-    # test skipping idle check if target is in a bad state
-    fake_system.return_value = "Linux"
-    fake_ffp.return_value.is_healthy.return_value = False
-    target.handle_hang()
-    assert fake_ffp.return_value.is_healthy.call_count == 1
-    assert fake_ffp.return_value.close.call_count == 1
-    assert fake_ffp.return_value.cpu_usage.call_count == 0
-    assert fake_kill.call_count == 0
-    fake_ffp.reset_mock()
-    # test timeout
-    fake_ffp.return_value.is_healthy.return_value = True
-    fake_ffp.return_value.cpu_usage.return_value = ((1234, 10), (1236, 75), (1238, 60))
-    # raise OSError for code coverage
-    fake_kill.side_effect = OSError
+    fake_ffp.return_value.cpu_usage.return_value = usage
+    fake_ffp.return_value.is_healthy.return_value = healthy
     target.handle_hang()
-    assert fake_kill.call_count == 1
-    assert fake_ffp.return_value.wait.call_count == 1
-    assert fake_ffp.return_value.close.call_count == 1
-    assert fake_kill.call_count == 1
-    fake_ffp.reset_mock()
-    fake_kill.reset_mock()
-    # test ignore idle timeout (close don't abort)
-    fake_ffp.return_value.is_healthy.return_value = True
-    fake_ffp.return_value.cpu_usage.return_value = ((1234, 10),)
-    target.handle_hang(ignore_idle=True)
     assert fake_ffp.return_value.is_healthy.call_count == 1
     assert fake_ffp.return_value.close.call_count == 1
-    assert fake_ffp.return_value.cpu_usage.call_count == 1
-    assert fake_kill.call_count == 0
+    assert fake_ffp.return_value.cpu_usage.call_count == (1 if usage else 0)
+    assert fake_kill.call_count == fake_ffp.return_value.wait.call_count == killed
 
 @mark.skipif(system() == "Windows", reason="Unsupported on Windows")
 def test_puppet_target_05(mocker, tmp_path):

From 81437685c2ebd1f1150f828902662d936f1cedad Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 25 Feb 2021 13:49:08 -0500
Subject: [PATCH 217/531] Add a simple test that reducer Strategy class doesn't
 break testcase metadata when dump/loading.

---
 grizzly/reduce/test_strategies.py | 25 ++++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 30371b80..988318f1 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -15,7 +15,7 @@
 from ..common import TestCase, TestFile, Report
 from ..replay import ReplayResult
 from ..target import Target
-from .strategies import _load_strategies
+from .strategies import _load_strategies, Strategy
 from .strategies.beautify import \
     HAVE_CSSBEAUTIFIER, HAVE_JSBEAUTIFIER, CSSBeautify, JSBeautify
 from . import ReduceManager
@@ -26,6 +26,29 @@
                                      "reporter_sequential_strftime")
 
 
+@pytest.mark.parametrize("is_hang", [True, False])
+def test_strategy_tc_load(is_hang):
+    """test that strategy base class dump and load doesn't change testcase metadata"""
+    class _TestStrategy(Strategy):
+        def __iter__(self):
+            yield TestCase.load(str(self._testcase_root), False)
+
+        def update(self, success, served=None):
+            pass
+
+    # create testcase that is_hang
+    with TestCase("a.htm", None, "adpt", input_fname="fn", time_limit=2) as src:
+        src.duration = 1.2
+        src.hang = is_hang
+        src.add_from_data("123", "a.htm")
+        strat = _TestStrategy([src])
+    for attempt in strat:
+        assert len(attempt) == 1
+        assert attempt[0].hang == is_hang
+        attempt[0].cleanup()
+        strat.update(False)
+
+
 def _fake_save_logs_foo(result_logs):
     """write fake log data to disk"""
     (result_logs / "log_stderr.txt").write_text("STDERR log\n")

From 15584eaa6137b74633a651756d9e1c0ac62569ad Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 11 Mar 2021 16:01:29 -0800
Subject: [PATCH 218/531] Properly clear ServerMap after timeout

---
 grizzly/common/runner.py      |  1 +
 grizzly/common/test_runner.py | 13 ++++++++++---
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 778f407e..5e1c59f3 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -229,6 +229,7 @@ def run(
             LOG.debug("timeout detected")
             if self._target.handle_hang(ignore_idle=True) or "timeout" in ignore:
                 result.status = RunResult.IGNORED
+            server_map.dynamic.pop("grz_empty", None)
         if result.attempted:
             self._tests_run += 1
             if coverage and not result.timeout:
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index f2e914c0..301121eb 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -28,8 +28,9 @@ def test_runner_01(mocker, tmp_path):
     serv_files = ["a.bin", "/another/file.bin"]
     testcase = mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[])
     # all files served
+    serv_map = ServerMap()
     server.serve_path.return_value = (SERVED_ALL, serv_files)
-    result = runner.run([], ServerMap(), testcase)
+    result = runner.run([], serv_map, testcase)
     assert result.attempted
     assert runner._tests_run == 1
     assert result.duration == 1
@@ -37,11 +38,13 @@ def test_runner_01(mocker, tmp_path):
     assert result.status is None
     assert result.served == serv_files
     assert not result.timeout
+    assert not serv_map.dynamic
     assert target.close.call_count == 0
     assert target.dump_coverage.call_count == 0
     assert target.handle_hang.call_count == 0
     assert testcase.dump.call_count == 1
     # some files served
+    serv_map = ServerMap()
     server.serve_path.return_value = (SERVED_REQUEST, serv_files)
     result = runner.run([], ServerMap(), testcase, coverage=True)
     assert result.attempted
@@ -50,6 +53,7 @@ def test_runner_01(mocker, tmp_path):
     assert result.status is None
     assert result.served == serv_files
     assert not result.timeout
+    assert not serv_map.dynamic
     assert target.close.call_count == 0
     assert target.dump_coverage.call_count == 1
     assert target.handle_hang.call_count == 0
@@ -63,6 +67,7 @@ def test_runner_01(mocker, tmp_path):
     assert runner._tests_run == 3
     assert not result.initial
     assert result.status is None
+    assert not serv_map.dynamic
     assert target.close.call_count == 0
     assert testcase.dump.call_count == 0
     tc_path.is_dir()
@@ -177,11 +182,13 @@ def test_runner_04(mocker, ignore, status, idle, detect_failure):
     target.detect_failure.return_value = target.RESULT_FAILURE
     target.handle_hang.return_value = idle
     target.monitor.is_healthy.return_value = False
-    runner = Runner(server, target)
-    result = runner.run(ignore, ServerMap(), testcase)
+    runner = Runner(server, target, relaunch=1)
+    serv_map = ServerMap()
+    result = runner.run(ignore, serv_map, testcase)
     assert result.status == status
     assert result.served == serv_files
     assert result.timeout
+    assert "grz_empty" not in serv_map.dynamic
     assert target.detect_failure.call_count == detect_failure
     assert target.handle_hang.call_count == 1
 

From 9c3abb8e6d9a6a411f26895a4e817137f1c1e1d0 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 25 Feb 2021 13:31:31 -0800
Subject: [PATCH 219/531] [tests] Add additional code paths

---
 grizzly/common/test_runner.py |  7 ++-
 grizzly/replay/test_main.py   |  8 +--
 grizzly/test_session.py       | 96 ++++++++++++++++++++++++-----------
 3 files changed, 73 insertions(+), 38 deletions(-)

diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 301121eb..3cdc7991 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -43,9 +43,8 @@ def test_runner_01(mocker, tmp_path):
     assert target.dump_coverage.call_count == 0
     assert target.handle_hang.call_count == 0
     assert testcase.dump.call_count == 1
-    # some files served
-    serv_map = ServerMap()
-    server.serve_path.return_value = (SERVED_REQUEST, serv_files)
+    # dump coverage
+    server.serve_path.return_value = (SERVED_ALL, serv_files)
     result = runner.run([], ServerMap(), testcase, coverage=True)
     assert result.attempted
     assert runner._tests_run == 2
@@ -228,7 +227,7 @@ def test_runner_06(mocker):
     target = mocker.Mock(spec=Target)
     target.detect_failure.return_value = target.RESULT_NONE
     serv_files = ["/fake/file", "/another/file.bin"]
-    server.serve_path.return_value = (SERVED_REQUEST, serv_files)
+    server.serve_path.return_value = (SERVED_ALL, serv_files)
     runner = Runner(server, target, idle_threshold=0.01, idle_delay=0.01, relaunch=10)
     assert runner._idle is not None
     result = runner.run(
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index a1e7e044..d4a613c9 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -10,6 +10,8 @@
 
 from pytest import mark, raises
 
+from sapphire import SERVED_ALL
+
 from ..common import Report, TestCase, TestCaseLoadFailure
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from ..replay import ReplayManager
@@ -76,7 +78,7 @@ def test_main_01(mocker, tmp_path):
     # mock Sapphire.serve_path only
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
-    serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
+    serve_path.return_value = (SERVED_ALL, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_target")
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
@@ -127,7 +129,7 @@ def test_main_02(mocker, tmp_path):
     # mock Sapphire.serve_path only
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
-    serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
+    serve_path.return_value = (SERVED_ALL, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_target")
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
@@ -353,7 +355,7 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
     # mock Sapphire.serve_path only
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
-    serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
+    serve_path.return_value = (SERVED_ALL, ["test.html"])  # passed to mocked Target.detect_failure
     # setup Target
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 4fce61d0..d3133c46 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -113,26 +113,78 @@ def generate(self, testcase, server_map):
     assert fake_target.dump_coverage.call_count == 2
 
 def test_session_04(tmp_path, mocker):
-    """test Target not requesting landing page"""
+    """test Adapter creating invalid test case"""
     class FuzzAdapter(Adapter):
         NAME = "fuzz"
-        def setup(self, input_path, server_map):
-            pass
         def generate(self, testcase, server_map):
-            assert testcase.adapter_name == self.NAME
+            pass
     Status.PATH = str(tmp_path)
     adapter = FuzzAdapter()
-    adapter.setup(None, None)
     fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
     fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
     fake_target.monitor.launches = 1
     with IOManager() as iomgr:
         fake_serv.serve_path.return_value = (SERVED_NONE, [])
-        with Session(adapter, iomgr, None, fake_serv, fake_target, relaunch=10) as session:
+        with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
             with raises(SessionError, match="Test case is missing landing page"):
-                session.run([], 10, iteration_limit=10)
+                session.run([], 10)
 
 def test_session_05(tmp_path, mocker):
+    """test Target not requesting landing page"""
+    class FuzzAdapter(Adapter):
+        NAME = "fuzz"
+        def generate(self, testcase, server_map):
+            testcase.add_from_data("test", testcase.landing_page)
+    Status.PATH = str(tmp_path)
+    adapter = FuzzAdapter()
+    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    fake_target.monitor.launches = 1
+    with IOManager() as iomgr:
+        fake_serv.serve_path.return_value = (SERVED_TIMEOUT, [])
+        with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
+            with raises(SessionError, match="Please check Adapter and Target"):
+                session.run([], 10)
+
+def test_session_06(tmp_path, mocker):
+    """test Target delayed failure"""
+    class FuzzAdapter(Adapter):
+        NAME = "fuzz"
+        def setup(self, input_path, server_map):
+            self.enable_harness()
+        def generate(self, testcase, server_map):
+            testcase.add_from_data("test", testcase.landing_page)
+    Status.PATH = str(tmp_path)
+    adapter = FuzzAdapter()
+    adapter.setup(None, None)
+    reporter = mocker.Mock(spec=Reporter)
+    fake_report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    fake_report.crash_info.createShortSignature.return_value = "[@ sig]"
+    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
+    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    fake_target.RESULT_FAILURE = Target.RESULT_FAILURE
+    fake_target.RESULT_NONE = Target.RESULT_NONE
+    fake_target.monitor.launches = 1
+    type(fake_target).closed = mocker.PropertyMock(side_effect=(True, False))
+    fake_target.detect_failure.side_effect = (
+        Target.RESULT_NONE,
+        Target.RESULT_FAILURE
+    )
+    fake_target.log_size.return_value = 1
+    fake_target.create_report.return_value = fake_report
+    with IOManager() as iomgr:
+        iomgr.harness = adapter.get_harness()
+        fake_serv.serve_path.side_effect = (
+            (SERVED_ALL, [iomgr.page_name()]),
+            (SERVED_NONE, [])
+        )
+        with Session(adapter, iomgr, reporter, fake_serv, fake_target, relaunch=2) as session:
+            session.run([], 10, iteration_limit=2)
+    assert reporter.submit.call_count == 1
+    assert len(reporter.submit.call_args[0][0]) == 1
+    assert reporter.submit.call_args[0][1].major == "major123"
+
+def test_session_07(tmp_path, mocker):
     """test basic Session functions"""
     Status.PATH = str(tmp_path)
     fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
@@ -161,7 +213,7 @@ def test_session_05(tmp_path, mocker):
     assert fake_target.handle_hang.call_count == 1
     assert fake_target.monitor.is_healthy.call_count == 0
 
-def test_session_06(tmp_path, mocker):
+def test_session_08(tmp_path, mocker):
     """test Session.generate_testcase()"""
     Status.PATH = str(tmp_path)
     mocker.patch("grizzly.session.TestFile", autospec=True)
@@ -179,8 +231,9 @@ def test_session_06(tmp_path, mocker):
         fake_adapter.generate.assert_called_with(testcase, fake_iomgr.server_map)
         assert testcase.add_meta.call_count == 1
 
-def test_session_07(tmp_path, mocker):
+def test_session_09(tmp_path, mocker):
     """test Session.run() - test case was not served"""
+    # TODO: use parametrize?
     Status.PATH = str(tmp_path)
     fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
     mocker.patch("grizzly.session.TestFile", autospec=True)
@@ -195,25 +248,6 @@ def test_session_07(tmp_path, mocker):
     fake_target.monitor.launches = 1
     fake_target.create_report.return_value = fake_report
     fake_reporter = mocker.Mock(spec=Reporter)
-    # between iterations
-    run_result = RunResult([], 1, status=RunResult.FAILED)
-    run_result.attempted = False
-    run_result.initial = False
-    fake_runner.return_value.run.return_value = run_result
-    with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
-        session.run([], 10, iteration_limit=1)
-        assert fake_runner.return_value.run.call_count == 1
-        assert fake_adapter.on_served.call_count == 1
-        assert fake_adapter.on_timeout.call_count == 0
-        assert fake_iomgr.purge_tests.call_count == 1
-        assert fake_runner.return_value.launch.call_count == 1
-        assert session.status.iteration == 1
-        assert session.status.results == 1
-        assert session.status.ignored == 0
-        assert fake_reporter.submit.call_count == 1
-        assert fake_iomgr.tests.pop.call_count == 1
-    fake_reporter.reset_mock()
-    fake_runner.reset_mock()
     # delayed startup crash
     run_result = RunResult([], 1, status=RunResult.FAILED)
     run_result.attempted = False
@@ -245,7 +279,7 @@ def test_session_07(tmp_path, mocker):
         assert session.status.ignored == 0
         assert fake_reporter.submit.call_count == 0
 
-def test_session_08(tmp_path, mocker):
+def test_session_10(tmp_path, mocker):
     """test Session.run() ignoring failures"""
     Status.PATH = str(tmp_path)
     result = RunResult([], 0.1, status=RunResult.IGNORED)
@@ -274,7 +308,7 @@ def test_session_08(tmp_path, mocker):
         assert session.status.results == 0
         assert session.status.ignored == 1
 
-def test_session_09(tmp_path, mocker):
+def test_session_11(tmp_path, mocker):
     """test Session.run() handle TargetLaunchError"""
     Status.PATH = str(tmp_path)
     fake_report = mocker.Mock(spec=Report, major="major123", minor="minor456")
@@ -294,7 +328,7 @@ def test_session_09(tmp_path, mocker):
         assert session.status.results == 1
         assert session.status.ignored == 0
 
-def test_session_10(tmp_path, mocker):
+def test_session_12(tmp_path, mocker):
     """test Session.run() report hang"""
     Status.PATH = str(tmp_path)
     result = RunResult([], 60.0, status=RunResult.FAILED, timeout=True)

From c0817ed2f60c16eac31dcf05d5e845b45df47bd7 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 26 Feb 2021 15:10:32 -0800
Subject: [PATCH 220/531] Move IOManager into Session

* Update Session tests
---
 grizzly/main.py         |  19 +-
 grizzly/session.py      |  61 ++++-
 grizzly/test_session.py | 591 ++++++++++++++++++++--------------------
 3 files changed, 350 insertions(+), 321 deletions(-)

diff --git a/grizzly/main.py b/grizzly/main.py
index cc95bcbf..02107ed0 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -9,7 +9,6 @@
 from sapphire import Sapphire
 
 from .adapters import get as get_adapter
-from .common.iomanager import IOManager
 from .common.reporter import FilesystemReporter, FuzzManagerReporter, S3FuzzManagerReporter
 from .common.utils import TIMEOUT_DELAY
 from .session import Session
@@ -51,14 +50,9 @@ def main(args):
         LOG.info("Running with Valgrind. This will be SLOW!")
 
     adapter = None
-    iomanager = None
     session = None
     target = None
     try:
-        LOG.debug("initializing the IOManager")
-        # TODO: move this into Session
-        iomanager = IOManager(report_size=(max(args.cache, 0) + 1))
-
         LOG.debug("initializing Adapter %r", args.adapter)
         adapter = get_adapter(args.adapter)()
 
@@ -101,11 +95,6 @@ def main(args):
             LOG.info("Using prefs %r", args.prefs)
         adapter.monitor = target.monitor
 
-        LOG.debug("calling adapter setup()")
-        adapter.setup(args.input, iomanager.server_map)
-        LOG.debug("configuring harness")
-        iomanager.harness = adapter.get_harness()
-
         LOG.debug("initializing the Reporter")
         if args.fuzzmanager:
             LOG.info("Results will be reported via FuzzManager")
@@ -129,13 +118,13 @@ def main(args):
             LOG.debug("initializing the Session")
             session = Session(
                 adapter,
-                iomanager,
                 reporter,
                 server,
                 target,
                 coverage=args.coverage,
                 enable_profiling=args.enable_profiling,
-                relaunch=relaunch)
+                relaunch=relaunch,
+                report_size=max(args.cache, 0) + 1)
             if args.log_level == DEBUG or args.verbose:
                 display_mode = Session.DISPLAY_VERBOSE
             else:
@@ -143,6 +132,7 @@ def main(args):
             session.run(
                 args.ignore,
                 time_limit,
+                input_path=args.input,
                 iteration_limit=args.limit,
                 display_mode=display_mode)
 
@@ -165,9 +155,6 @@ def main(args):
         if adapter is not None:
             LOG.debug("calling adapter.cleanup()")
             adapter.cleanup()
-        if iomanager is not None:
-            LOG.debug("calling iomanager.cleanup()")
-            iomanager.cleanup()
         LOG.info("Done.")
 
     return Session.EXIT_SUCCESS
diff --git a/grizzly/session.py b/grizzly/session.py
index fdeb2a12..e8d410c2 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -5,7 +5,7 @@
 from logging import getLogger
 from time import time
 
-from .common import Runner, RunResult, Status, TestFile
+from .common import IOManager, Runner, RunResult, Status, TestFile
 from .target import TargetLaunchError
 
 
@@ -62,19 +62,41 @@ class Session:
 
     TARGET_LOG_SIZE_WARN = 0x1900000  # display warning when target log files exceed limit (25MB)
 
-    __slots__ = ("_relaunch", "adapter", "coverage", "iomanager", "reporter", "server",
-                 "status", "target")
+    __slots__ = (
+        "_coverage",
+        "_relaunch",
+        "_report_size",
+        "adapter",
+        "iomanager",
+        "reporter",
+        "server",
+        "status",
+        "target"
+    )
 
-    def __init__(self, adapter, iomanager, reporter, server, target,
-                 coverage=False, enable_profiling=False, relaunch=1):
+    def __init__(
+        self,
+        adapter,
+        reporter,
+        server,
+        target,
+        coverage=False,
+        enable_profiling=False,
+        relaunch=1,
+        report_size=1
+    ):
+        assert relaunch > 0
+        assert report_size > 0
+        self._coverage = coverage
         self._relaunch = relaunch
         self.adapter = adapter
-        self.coverage = coverage
-        self.iomanager = iomanager
+        self.iomanager = None
         self.reporter = reporter
         self.server = server
-        self.status = Status.start(enable_profiling=enable_profiling)
         self.target = target
+        self.status = None
+        self.iomanager = IOManager(report_size=report_size)
+        self.status = Status.start(enable_profiling=enable_profiling)
 
     def __enter__(self):
         return self
@@ -83,7 +105,10 @@ def __exit__(self, *exc):
         self.close()
 
     def close(self):
-        self.status.cleanup()
+        if self.iomanager is not None:
+            self.iomanager.cleanup()
+        if self.status is not None:
+            self.status.cleanup()
 
     def display_status(self, log_limiter):
         if self.adapter.remaining is not None:
@@ -108,9 +133,22 @@ def generate_testcase(self, time_limit):
             test.add_meta(TestFile.from_file(self.target.prefs, "prefs.js"))
         return test
 
-    def run(self, ignore, time_limit, iteration_limit=0, display_mode=DISPLAY_NORMAL):
+    def run(
+        self,
+        ignore,
+        time_limit,
+        input_path=None,
+        iteration_limit=0,
+        display_mode=DISPLAY_NORMAL
+    ):
         assert time_limit > 0
         assert iteration_limit >= 0
+
+        LOG.debug("calling adapter.setup()")
+        self.adapter.setup(input_path, self.iomanager.server_map)
+        LOG.debug("configuring harness")
+        self.iomanager.harness = self.adapter.get_harness()
+
         log_limiter = LogOutputLimiter(verbose=display_mode == self.DISPLAY_VERBOSE)
         # limit relaunch to max iterations if needed
         relaunch = min(self._relaunch, iteration_limit) or self._relaunch
@@ -120,6 +158,7 @@ def run(self, ignore, time_limit, iteration_limit=0, display_mode=DISPLAY_NORMAL
         runner = Runner(self.server, self.target, relaunch=relaunch)
         startup_error = False
         while True:
+            LOG.debug("- iteration %d -", self.status.iteration + 1)
             self.status.report()
             self.status.iteration += 1
 
@@ -162,7 +201,7 @@ def run(self, ignore, time_limit, iteration_limit=0, display_mode=DISPLAY_NORMAL
                     ignore,
                     self.iomanager.server_map,
                     current_test,
-                    coverage=self.coverage)
+                    coverage=self._coverage)
             current_test.duration = result.duration
             # adapter callbacks
             if result.timeout:
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index d3133c46..b4d38128 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -6,357 +6,360 @@
 """
 unit tests for grizzly.Session
 """
-from collections import deque
+from pytest import mark, raises
 
-from pytest import raises
-
-from sapphire import Sapphire, ServerMap, SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT
-from .common import Adapter, IOManager, Report, Reporter, RunResult, Status, TestCase
+from sapphire import Sapphire, SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT
+from .common import Adapter, Report, Reporter, RunResult, Status
 from .session import LogOutputLimiter, Session, SessionError
 from .target import Target, TargetLaunchError
 
 
-class NullReporter(Reporter):
-    def __init__(self):
-        self.submit_calls = 0
-
-    def _post_submit(self):
-        pass
-
-    def _pre_submit(self, report):
-        pass
+class SimpleAdapter(Adapter):
+    NAME = "simple"
+    def __init__(self, use_harness, remaining=None):
+        super().__init__()
+        self.remaining = remaining
+        self._use_harness = use_harness
+    def setup(self, input_path, server_map):
+        if self._use_harness:
+            self.enable_harness()
+        self.fuzz["input"] = input_path
+    def generate(self, testcase, server_map):
+        assert testcase.adapter_name == self.NAME
+        testcase.input_fname = self.fuzz["input"]
+        testcase.add_from_data("test", testcase.landing_page)
+        if self.remaining is not None:
+            assert self.remaining > 0
+            self.remaining -= 1
 
-    def _submit_report(self, report, test_cases):
-        assert isinstance(report, Report)
-        for test in test_cases:
-            assert isinstance(test, TestCase)
-        self.submit_calls += 1
 
-def test_session_01(tmp_path, mocker):
-    """test Session with playback Adapter"""
-    class PlaybackAdapter(Adapter):
-        NAME = "playback"
-        def setup(self, input_path, server_map):
-            self.remaining = 5
-        def generate(self, testcase, server_map):
-            assert testcase.adapter_name == self.NAME
-            testcase.input_fname = "file.bin"
-            testcase.add_from_data("test", testcase.landing_page)
-            self.remaining -= 1
+@mark.parametrize(
+    "harness, profiling, coverage, relaunch, iters",
+    [
+        # with harness, single iteration
+        (True, False, False, 1, 1),
+        # with harness, 10 iterations relaunch every iteration
+        (True, False, False, 1, 10),
+        # with harness, 10 iterations relaunch every other iteration
+        (True, False, False, 2, 10),
+        # with harness, 10 iterations no relaunches
+        (True, False, False, 10, 10),
+        # no harness, single iteration
+        (False, False, False, 1, 1),
+        # no harness, 10 iterations
+        (False, False, False, 1, 10),
+        # test enable profiling
+        (True, True, False, 10, 10),
+        # test Session.dump_coverage()
+        (True, True, True, 2, 2),
+    ]
+)
+def test_session_01(mocker, tmp_path, harness, profiling, coverage, relaunch, iters):
+    """test Session with typical fuzzer Adapter"""
     Status.PATH = str(tmp_path)
-    adapter = PlaybackAdapter()
-    adapter.setup(None, None)
-    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
     prefs = tmp_path / "prefs.js"
     prefs.touch()
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=str(prefs))
-    # set target.log_size to test warning code path
-    fake_target.log_size.return_value = Session.TARGET_LOG_SIZE_WARN + 1
-    with IOManager() as iomgr:
-        fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
-        with Session(adapter, iomgr, None, fake_serv, fake_target, relaunch=10) as session:
-            session.run([], 10)
-            assert session.status.iteration == 5
-            assert session.status.test_name == "file.bin"
+    target = mocker.Mock(spec=Target, launch_timeout=30, prefs=str(prefs))
+    target.log_size.return_value = 1000
+    target.monitor.launches = 1
+    # avoid shutdown delay
+    target.monitor.is_healthy.return_value = False
+    # calculate if the target is 'closed' based on relaunch
+    type(target).closed = mocker.PropertyMock(
+        side_effect=((x % relaunch == 0) for x in range(iters))
+    )
+    with Session(
+        SimpleAdapter(harness),
+        None,
+        server,
+        target,
+        coverage=coverage,
+        enable_profiling=profiling,
+        relaunch=relaunch,
+    ) as session:
+        server.serve_path = lambda *a, **kv: (
+            SERVED_ALL,
+            [session.iomanager.page_name(offset=-1)]
+        )
+        session.run([], 10, input_path="file.bin", iteration_limit=iters)
+        assert session.status.iteration == iters
+        assert session.status.test_name == "file.bin"
+        assert target.close.call_count == iters / relaunch
+        assert target.detect_failure.call_count == iters
+        assert target.handle_hang.call_count == 0
+        if profiling:
+            assert any(session.status.profile_entries())
+        else:
+            assert not any(session.status.profile_entries())
+        if coverage:
+            assert target.dump_coverage.call_count == iters
+        else:
+            assert target.dump_coverage.call_count == 0
 
-def test_session_02(tmp_path, mocker):
-    """test Session with basic fuzzer Adapter (w/harness)"""
-    class FuzzAdapter(Adapter):
-        NAME = "fuzz"
-        def setup(self, input_path, server_map):
-            self.enable_harness()
-        def generate(self, testcase, server_map):
-            assert testcase.adapter_name == self.NAME
-            testcase.add_from_data("test", testcase.landing_page)
+@mark.parametrize(
+    "harness, relaunch, remaining",
+    [
+        # no harness, 1 iteration
+        (False, 1, 1),
+        # no harness, 5 iterations, relaunch every iteration
+        (False, 1, 5),
+        # harness, 1 iteration
+        (True, 1, 1),
+        # harness, 10 iterations, relaunch every other iteration
+        (True, 2, 10),
+        # harness, 10 iterations
+        (True, 10, 10),
+    ]
+)
+def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
+    """test Session with playback Adapter"""
     Status.PATH = str(tmp_path)
-    adapter = FuzzAdapter()
-    adapter.setup(None, None)
-    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    prefs = tmp_path / "prefs.js"
-    prefs.touch()
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=str(prefs))
-    fake_target.log_size.return_value = 1000
-    fake_target.monitor.launches = 1
-    with IOManager() as iomgr:
-        iomgr.harness = adapter.get_harness()
-        fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
-        # enable profiling for test coverage
-        with Session(adapter, iomgr, None, fake_serv, fake_target, enable_profiling=True, relaunch=10) as session:
-            session.run([], 10, iteration_limit=10)
-            assert session.status.iteration == 10
-            assert session.status.test_name is None
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    # calculate if the target is 'closed' based on relaunch
+    type(target).closed = mocker.PropertyMock(
+        side_effect=((x % relaunch == 0) for x in range(remaining))
+    )
+    # avoid shutdown delay
+    target.monitor.is_healthy.return_value = False
+    # set target.log_size to test warning code path
+    target.log_size.return_value = Session.TARGET_LOG_SIZE_WARN + 1
+    with Session(
+        SimpleAdapter(harness, remaining=remaining),
+        None,
+        server,
+        target,
+        relaunch=relaunch
+    ) as session:
+        server.serve_path = lambda *a, **kv: (
+            SERVED_ALL,
+            [session.iomanager.page_name(offset=-1)]
+        )
+        session.run([], 10)
+        assert session.status.iteration == remaining
+        assert session.status.test_name is None
+        assert target.detect_failure.call_count == remaining
+        assert target.handle_hang.call_count == 0
 
-def test_session_03(tmp_path, mocker):
-    """test Session.dump_coverage()"""
-    class FuzzAdapter(Adapter):
-        NAME = "fuzz"
-        def setup(self, input_path, server_map):
-            self.enable_harness()
-        def generate(self, testcase, server_map):
-            assert testcase.adapter_name == self.NAME
-            testcase.add_from_data("test", testcase.landing_page)
+@mark.parametrize(
+    "harness, report_size, relaunch, iters",
+    [
+        # with harness, collect 1 test case
+        (True, 1, 1, 1),
+        # with harness, collect 2 test cases
+        (True, 2, 2, 2),
+        # with harness, collect 2 test cases,
+        (True, 2, 3, 3),
+        # with harness, collect 3 test cases, relaunch 1
+        (True, 3, 1, 3),
+        # without harness, collect 1 test case
+        (False, 1, 1, 1),
+        # without harness, collect 1 test case, 3 iterations
+        (False, 1, 1, 3),
+    ],
+)
+def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
+    """test Session - detecting failure"""
     Status.PATH = str(tmp_path)
-    mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    adapter = FuzzAdapter()
-    adapter.setup(None, None)
-    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target, prefs=None)
-    fake_target.log_size.return_value = 1000
-    fake_target.monitor.launches = 1
-    # target.launch() call will be skipped
-    fake_target.closed = False
-    with IOManager() as iomgr:
-        fake_serv.serve_path = lambda *a, **kv: (SERVED_ALL, [iomgr.page_name(offset=-1)])
-        with Session(adapter, iomgr, None, fake_serv, fake_target, coverage=True, relaunch=2) as session:
-            session.run([], 10, iteration_limit=2)
-            assert session.status.iteration == 2
-    assert fake_target.dump_coverage.call_count == 2
+    adapter = SimpleAdapter(harness)
+    reporter = mocker.Mock(spec=Reporter)
+    report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    report.crash_info.createShortSignature.return_value = "[@ sig]"
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.monitor.launches = 1
+    # avoid shutdown delay
+    target.monitor.is_healthy.return_value = False
+    # calculate if the target is 'closed' based on relaunch
+    type(target).closed = mocker.PropertyMock(
+        side_effect=((x % relaunch == 0) for x in range(iters))
+    )
+    # failure is on final iteration
+    target.detect_failure.side_effect = [
+        Target.RESULT_NONE for x in range(iters - 1)
+    ] + [Target.RESULT_FAILURE]
+    target.log_size.return_value = 1
+    target.create_report.return_value = report
+    with Session(
+        adapter, reporter, server, target, relaunch=relaunch, report_size=report_size
+    ) as session:
+        server.serve_path = lambda *a, **kv: (
+            SERVED_ALL,
+            [session.iomanager.page_name(offset=-1)]
+        )
+        session.run([], 10, input_path="file.bin", iteration_limit=iters)
+        assert reporter.submit.call_count == 1
+        assert len(reporter.submit.call_args[0][0]) == min(report_size, relaunch)
+        assert reporter.submit.call_args[0][1].major == "major123"
 
-def test_session_04(tmp_path, mocker):
+def test_session_04(mocker, tmp_path):
     """test Adapter creating invalid test case"""
     class FuzzAdapter(Adapter):
         NAME = "fuzz"
         def generate(self, testcase, server_map):
             pass
     Status.PATH = str(tmp_path)
-    adapter = FuzzAdapter()
-    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
-    fake_target.monitor.launches = 1
-    with IOManager() as iomgr:
-        fake_serv.serve_path.return_value = (SERVED_NONE, [])
-        with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
-            with raises(SessionError, match="Test case is missing landing page"):
-                session.run([], 10)
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server.serve_path.return_value = (SERVED_NONE, [])
+    target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    target.monitor.launches = 1
+    with Session(FuzzAdapter(), None, server, target) as session:
+        with raises(SessionError, match="Test case is missing landing page"):
+            session.run([], 10)
 
-def test_session_05(tmp_path, mocker):
+def test_session_05(mocker, tmp_path):
     """test Target not requesting landing page"""
-    class FuzzAdapter(Adapter):
-        NAME = "fuzz"
-        def generate(self, testcase, server_map):
-            testcase.add_from_data("test", testcase.landing_page)
     Status.PATH = str(tmp_path)
-    adapter = FuzzAdapter()
-    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
-    fake_target.monitor.launches = 1
-    with IOManager() as iomgr:
-        fake_serv.serve_path.return_value = (SERVED_TIMEOUT, [])
-        with Session(adapter, iomgr, None, fake_serv, fake_target) as session:
-            with raises(SessionError, match="Please check Adapter and Target"):
-                session.run([], 10)
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server.serve_path.return_value = (SERVED_TIMEOUT, [])
+    target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    target.monitor.launches = 1
+    with Session(SimpleAdapter(False), None, server, target) as session:
+        with raises(SessionError, match="Please check Adapter and Target"):
+            session.run([], 10)
 
-def test_session_06(tmp_path, mocker):
-    """test Target delayed failure"""
-    class FuzzAdapter(Adapter):
-        NAME = "fuzz"
-        def setup(self, input_path, server_map):
-            self.enable_harness()
-        def generate(self, testcase, server_map):
-            testcase.add_from_data("test", testcase.landing_page)
+@mark.parametrize(
+    "harness, report_size",
+    [
+        # with harness, collect 1 test case
+        (True, 1),
+        # with harness, collect 2 test cases
+        (True, 2),
+        # without harness, collect 1 test case
+        (False, 1),
+    ],
+)
+def test_session_06(mocker, tmp_path, harness, report_size):
+    """test Session - handle Target delayed failures"""
     Status.PATH = str(tmp_path)
-    adapter = FuzzAdapter()
-    adapter.setup(None, None)
     reporter = mocker.Mock(spec=Reporter)
-    fake_report = mocker.Mock(spec=Report, major="major123", minor="minor456")
-    fake_report.crash_info.createShortSignature.return_value = "[@ sig]"
-    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
-    fake_target.RESULT_FAILURE = Target.RESULT_FAILURE
-    fake_target.RESULT_NONE = Target.RESULT_NONE
-    fake_target.monitor.launches = 1
-    type(fake_target).closed = mocker.PropertyMock(side_effect=(True, False))
-    fake_target.detect_failure.side_effect = (
-        Target.RESULT_NONE,
-        Target.RESULT_FAILURE
-    )
-    fake_target.log_size.return_value = 1
-    fake_target.create_report.return_value = fake_report
-    with IOManager() as iomgr:
-        iomgr.harness = adapter.get_harness()
-        fake_serv.serve_path.side_effect = (
-            (SERVED_ALL, [iomgr.page_name()]),
-            (SERVED_NONE, [])
+    report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    report.crash_info.createShortSignature.return_value = "[@ sig]"
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.monitor.launches = 1
+    type(target).closed = mocker.PropertyMock(side_effect=(True, False))
+    target.detect_failure.side_effect = (Target.RESULT_NONE, Target.RESULT_FAILURE)
+    target.log_size.return_value = 1
+    target.create_report.return_value = report
+    with Session(
+        SimpleAdapter(harness),
+        reporter,
+        server,
+        target,
+        relaunch=2,
+        report_size=report_size
+    ) as session:
+        server.serve_path.side_effect = (
+            (SERVED_ALL, [session.iomanager.page_name()]),
+            (SERVED_NONE, []),
         )
-        with Session(adapter, iomgr, reporter, fake_serv, fake_target, relaunch=2) as session:
-            session.run([], 10, iteration_limit=2)
-    assert reporter.submit.call_count == 1
-    assert len(reporter.submit.call_args[0][0]) == 1
-    assert reporter.submit.call_args[0][1].major == "major123"
-
-def test_session_07(tmp_path, mocker):
-    """test basic Session functions"""
-    Status.PATH = str(tmp_path)
-    fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
-    fake_adapter.IGNORE_UNSERVED = True
-    fake_testcase = mocker.Mock(spec_set=TestCase, landing_page="page.htm", optional=[], time_limit=10)
-    fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
-    fake_iomgr.create_testcase.return_value = fake_testcase
-    fake_iomgr.tests = mocker.Mock(spec=deque)
-    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_serv.serve_path.return_value = (SERVED_TIMEOUT, [fake_testcase.landing_page])
-    fake_target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
-    fake_target.monitor.launches = 1
-    with Session(fake_adapter, fake_iomgr, None, fake_serv, fake_target) as session:
-        session.run([], 10, iteration_limit=1)
-    assert fake_adapter.setup.call_count == 0
-    assert fake_adapter.pre_launch.call_count == 1
-    assert fake_adapter.generate.call_count == 1
-    assert fake_adapter.on_served.call_count == 0
-    assert fake_adapter.on_timeout.call_count == 1
-    assert fake_iomgr.create_testcase.call_count == 1
-    assert fake_iomgr.tests.pop.call_count == 0
-    assert fake_testcase.purge_optional.call_count == 1
-    assert fake_serv.serve_path.call_count == 1
-    assert fake_target.launch.call_count == 1
-    assert fake_target.detect_failure.call_count == 0
-    assert fake_target.handle_hang.call_count == 1
-    assert fake_target.monitor.is_healthy.call_count == 0
-
-def test_session_08(tmp_path, mocker):
-    """test Session.generate_testcase()"""
-    Status.PATH = str(tmp_path)
-    mocker.patch("grizzly.session.TestFile", autospec=True)
-    fake_adapter = mocker.Mock(spec=Adapter)
-    fake_adapter.NAME = "fake_adapter"
-    fake_iomgr = mocker.Mock(spec=IOManager, server_map=ServerMap())
-    fake_iomgr.create_testcase.return_value = mocker.Mock(spec_set=TestCase, time_limit=10)
-    fake_target = mocker.Mock(spec=Target, prefs="fake")
-    with Session(fake_adapter, fake_iomgr, None, None, fake_target) as session:
-        assert fake_adapter.generate.call_count == 0
-        testcase = session.generate_testcase(10)
-        assert fake_iomgr.create_testcase.call_count == 1
-        fake_iomgr.create_testcase.assert_called_with("fake_adapter", 10)
-        assert fake_adapter.generate.call_count == 1
-        fake_adapter.generate.assert_called_with(testcase, fake_iomgr.server_map)
-        assert testcase.add_meta.call_count == 1
+        session.run([], 10, iteration_limit=2)
+        assert reporter.submit.call_count == 1
+        assert len(reporter.submit.call_args[0][0]) == 1
+        assert reporter.submit.call_args[0][1].major == "major123"
 
-def test_session_09(tmp_path, mocker):
-    """test Session.run() - test case was not served"""
-    # TODO: use parametrize?
+@mark.parametrize(
+    "srv_results, target_result, ignored, results",
+    [
+        # delayed startup crash
+        (SERVED_NONE, Target.RESULT_FAILURE, 0, 1),
+        # startup hang/unresponsive
+        (SERVED_TIMEOUT, Target.RESULT_NONE, 1, 0),
+    ],
+)
+def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, results):
+    """test Session.run() - initial test case was not served"""
     Status.PATH = str(tmp_path)
-    fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
-    mocker.patch("grizzly.session.TestFile", autospec=True)
-    fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
-    fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
-    fake_iomgr.create_testcase.return_value = mocker.Mock(spec=TestCase)
-    fake_iomgr.tests = mocker.Mock(spec=deque)
-    fake_report = mocker.Mock(spec=Report, major="major123", minor="minor456")
-    fake_report.crash_info.createShortSignature.return_value = "[@ sig]"
-    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
-    fake_target.monitor.launches = 1
-    fake_target.create_report.return_value = fake_report
-    fake_reporter = mocker.Mock(spec=Reporter)
-    # delayed startup crash
-    run_result = RunResult([], 1, status=RunResult.FAILED)
-    run_result.attempted = False
-    run_result.initial = True
-    fake_runner.return_value.run.return_value = run_result
-    with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
-        with raises(SessionError, match="Please check Adapter and Target"):
-            session.run([], 10, iteration_limit=1)
-        assert fake_runner.return_value.run.call_count == 1
-        assert fake_runner.return_value.launch.call_count == 1
-        assert session.status.iteration == 1
-        assert session.status.results == 1
-        assert session.status.ignored == 0
-        assert fake_reporter.submit.call_count == 1
-    fake_reporter.reset_mock()
-    fake_runner.reset_mock()
-    # startup hang/unresponsive
-    run_result = RunResult([], 1)
-    run_result.attempted = False
-    run_result.initial = True
-    fake_runner.return_value.run.return_value = run_result
-    with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
+    report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    report.crash_info.createShortSignature.return_value = "[@ sig]"
+    reporter = mocker.Mock(spec=Reporter)
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, prefs=None)
+    target.RESULT_FAILURE = Target.RESULT_FAILURE
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.monitor.launches = 1
+    target.detect_failure.side_effect = (target_result,)
+    target.create_report.return_value = report
+    with Session(SimpleAdapter(False), reporter, server, target) as session:
+        server.serve_path.return_value = (srv_results, [])
         with raises(SessionError, match="Please check Adapter and Target"):
-            session.run([], 10, iteration_limit=1)
-        assert fake_runner.return_value.run.call_count == 1
-        assert fake_runner.return_value.launch.call_count == 1
+            session.run([], 10, iteration_limit=2)
         assert session.status.iteration == 1
-        assert session.status.results == 0
-        assert session.status.ignored == 0
-        assert fake_reporter.submit.call_count == 0
+        assert session.status.results == results
+        assert session.status.ignored == ignored
+        assert reporter.submit.call_count == results
+        assert target.detect_failure.call_count == results
+        assert target.handle_hang.call_count == ignored
 
-def test_session_10(tmp_path, mocker):
+def test_session_08(tmp_path, mocker):
     """test Session.run() ignoring failures"""
     Status.PATH = str(tmp_path)
     result = RunResult([], 0.1, status=RunResult.IGNORED)
     result.attempted = True
-    fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
-    fake_runner.return_value.run.return_value = result
+    runner = mocker.patch("grizzly.session.Runner", autospec=True)
+    runner.return_value.run.return_value = result
     mocker.patch("grizzly.session.TestFile", autospec=True)
-    fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
-    fake_adapter.IGNORE_UNSERVED = False
-    fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
-    fake_test = mocker.Mock(spec=TestCase)
-    fake_iomgr.create_testcase.return_value = fake_test
-    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
-    fake_target.monitor.launches = 1
-    with Session(fake_adapter, fake_iomgr, None, fake_serv, fake_target) as session:
+    adapter = mocker.Mock(spec=Adapter, remaining=None)
+    adapter.IGNORE_UNSERVED = False
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    target = mocker.Mock(spec=Target, prefs=None)
+    target.monitor.launches = 1
+    with Session(adapter, None, server, target) as session:
         session.run([], 10, iteration_limit=1)
-        assert fake_runner.return_value.run.call_count == 1
-        assert fake_adapter.on_served.call_count == 1
-        assert fake_adapter.on_timeout.call_count == 0
-        assert fake_iomgr.purge_tests.call_count == 1
-        assert fake_test.purge_optional.call_count == 0
-        assert fake_runner.return_value.launch.call_count == fake_iomgr.purge_tests.call_count
-        assert fake_target.create_report.call_count == 0
+        assert runner.return_value.run.call_count == 1
+        assert adapter.on_served.call_count == 1
+        assert adapter.on_timeout.call_count == 0
+        assert target.create_report.call_count == 0
         assert session.status.iteration == 1
         assert session.status.results == 0
         assert session.status.ignored == 1
 
-def test_session_11(tmp_path, mocker):
+def test_session_09(tmp_path, mocker):
     """test Session.run() handle TargetLaunchError"""
     Status.PATH = str(tmp_path)
-    fake_report = mocker.Mock(spec=Report, major="major123", minor="minor456")
-    fake_report.crash_info.createShortSignature.return_value = "[@ sig]"
-    fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
-    fake_runner.return_value.launch.side_effect = TargetLaunchError("test", fake_report)
+    report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    runner = mocker.patch("grizzly.session.Runner", autospec=True)
+    runner.return_value.launch.side_effect = TargetLaunchError("test", report)
     mocker.patch("grizzly.session.TestFile", autospec=True)
-    fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
-    fake_iomgr = mocker.Mock(spec=IOManager, harness=None, server_map=ServerMap())
-    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target)
-    fake_target.monitor.launches = 1
-    with Session(fake_adapter, fake_iomgr, mocker.Mock(), fake_serv, fake_target) as session:
+    adapter = mocker.Mock(spec=Adapter, remaining=None)
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    target = mocker.Mock(spec=Target)
+    target.monitor.launches = 1
+    with Session(adapter, mocker.Mock(spec=Reporter), server, target) as session:
         with raises(TargetLaunchError, match="test"):
-            session.run([], 10, iteration_limit=1)
+            session.run([], 10, iteration_limit=2)
         assert session.status.iteration == 1
         assert session.status.results == 1
         assert session.status.ignored == 0
 
-def test_session_12(tmp_path, mocker):
+def test_session_10(tmp_path, mocker):
     """test Session.run() report hang"""
     Status.PATH = str(tmp_path)
     result = RunResult([], 60.0, status=RunResult.FAILED, timeout=True)
     result.attempted = True
-    fake_runner = mocker.patch("grizzly.session.Runner", autospec=True)
-    fake_runner.return_value.run.return_value = result
+    runner = mocker.patch("grizzly.session.Runner", autospec=True)
+    runner.return_value.run.return_value = result
     mocker.patch("grizzly.session.TestFile", autospec=True)
-    fake_adapter = mocker.Mock(spec=Adapter, remaining=None)
-    fake_iomgr = mocker.Mock(
-        spec=IOManager,
-        harness=None,
-        server_map=ServerMap(),
-        tests=mocker.Mock(spec=deque))
-    fake_iomgr.create_testcase.return_value = mocker.Mock(spec=TestCase)
-    fake_report = mocker.Mock(spec=Report, major="major123", minor="minor456")
-    fake_reporter = mocker.Mock(spec=Reporter)
-    fake_serv = mocker.Mock(spec=Sapphire, port=0x1337)
-    fake_target = mocker.Mock(spec=Target, prefs="prefs.js")
-    fake_target.monitor.launches = 1
-    fake_target.create_report.return_value = fake_report
-    with Session(fake_adapter, fake_iomgr, fake_reporter, fake_serv, fake_target) as session:
+    adapter = mocker.Mock(spec=Adapter, remaining=None)
+    report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    reporter = mocker.Mock(spec=Reporter)
+    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    target = mocker.Mock(spec=Target, prefs=None)
+    target.monitor.launches = 1
+    target.create_report.return_value = report
+    with Session(adapter, reporter, server, target) as session:
         session.run([], 10, iteration_limit=1)
-        assert fake_runner.return_value.run.call_count == 1
-        assert fake_adapter.on_served.call_count == 0
-        assert fake_adapter.on_timeout.call_count == 1
-        assert fake_iomgr.purge_tests.call_count == 1
-        assert fake_target.create_report.call_count == 1
-        assert fake_reporter.submit.call_count == 1
+        assert runner.return_value.run.call_count == 1
+        assert adapter.on_served.call_count == 0
+        assert adapter.on_timeout.call_count == 1
+        assert target.create_report.call_count == 1
+        assert reporter.submit.call_count == 1
         assert session.status.iteration == 1
         assert session.status.results == 1
         assert session.status.ignored == 0

From c20eb6f01ee4b6b4d60d5b96d9410b0b4c316504 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 26 Feb 2021 15:17:47 -0800
Subject: [PATCH 221/531] Rename argument --cache to --collect

---
 grizzly/args.py      | 7 +++++--
 grizzly/main.py      | 2 +-
 grizzly/test_main.py | 2 +-
 3 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index baa9d4a3..9a749bd8 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -214,8 +214,8 @@ def __init__(self):
             help="Use RR (Linux only)")
 
         self.reporter_grp.add_argument(
-            "-c", "--cache", type=int, default=0,
-            help="Maximum number of additional test cases to include in report (default: %(default)s)")
+            "-c", "--collect", type=int, default=1,
+            help="Maximum number of test cases to include in the report (default: %(default)s)")
         self.reporter_grp.add_argument(
             "--s3-fuzzmanager", action="store_true",
             help="Report large attachments (if any) to S3 and then the crash & S3 link to FuzzManager")
@@ -231,6 +231,9 @@ def sanity_check(self, args):
                 msg.append("No adapters available.")
             self.parser.error(" ".join(msg))
 
+        if args.collect < 1:
+            self.parser.error("--collect must be greater than 0")
+
         if args.fuzzmanager and args.s3_fuzzmanager:
             self.parser.error("--fuzzmanager and --s3-fuzzmanager are mutually exclusive")
 
diff --git a/grizzly/main.py b/grizzly/main.py
index 02107ed0..8cb7a358 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -124,7 +124,7 @@ def main(args):
                 coverage=args.coverage,
                 enable_profiling=args.enable_profiling,
                 relaunch=relaunch,
-                report_size=max(args.cache, 0) + 1)
+                report_size=args.collect)
             if args.log_level == DEBUG or args.verbose:
                 display_mode = Session.DISPLAY_VERBOSE
             else:
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 3dddb749..2bfde90d 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -16,7 +16,7 @@ def __init__(self):
         self.binary = None
         self.input = None
         self.adapter = None
-        self.cache = 0
+        self.collect = 1
         self.coverage = False
         self.enable_profiling = False
         self.extension = None

From 0a4b6125b6ce6561bf9467887ca7b5945ab1506b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 26 Feb 2021 16:56:09 -0800
Subject: [PATCH 222/531] Update IOManager test case management

---
 grizzly/common/iomanager.py      | 61 ++++++++++++++++++++++----------
 grizzly/common/storage.py        |  6 ++--
 grizzly/common/test_iomanager.py | 50 +++++++++++++++++++++-----
 grizzly/session.py               | 13 ++++---
 4 files changed, 92 insertions(+), 38 deletions(-)

diff --git a/grizzly/common/iomanager.py b/grizzly/common/iomanager.py
index 3199076a..1a469947 100644
--- a/grizzly/common/iomanager.py
+++ b/grizzly/common/iomanager.py
@@ -2,7 +2,6 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
 from collections import deque
 from os import environ
 from os.path import isfile
@@ -18,21 +17,35 @@
 
 
 class IOManager:
+    # TODO: some of these are target specific
     TRACKED_ENVVARS = (
         "ASAN_OPTIONS",
         "LSAN_OPTIONS",
         "GNOME_ACCESSIBILITY",
         "MOZ_CHAOSMODE",
-        "XPCOM_DEBUG_BREAK")
+        "XPCOM_DEBUG_BREAK",
+    )
+
+    __slots__ = (
+        "_environ_files",
+        "_generated",
+        "_report_size",
+        "_test",
+        "_tracked_env",
+        "harness",
+        "server_map",
+        "tests",
+    )
 
     def __init__(self, report_size=1):
         assert report_size > 0
         self.harness = None
-        self.server_map = ServerMap()  # manage redirects, include directories and dynamic responses
+        self.server_map = ServerMap()
         self.tests = deque()
-        self._environ_files = list()  # collection of files that should be added to the testcase
+        self._environ_files = list()
         self._generated = 0  # number of test cases generated
         self._report_size = report_size
+        self._test = None
         # used to record environment variable that directly impact the browser
         self._tracked_env = self.tracked_environ()
         self._add_suppressions()
@@ -57,41 +70,51 @@ def _add_suppressions(self):
     def cleanup(self):
         for e_file in self._environ_files:
             e_file.close()
-        self.purge_tests()
+        self.purge()
+
+    def commit(self):
+        assert self._test is not None
+        self.tests.appendleft(self._test)
+        self._test = None
+        # manage testcase cache size
+        if len(self.tests) > self._report_size:
+            self.tests.pop().cleanup()
 
     def create_testcase(self, adapter_name, time_limit):
+        assert self._test is None
         # create testcase object and landing page names
-        test = TestCase(
+        self._test = TestCase(
             self.page_name(),
             self.page_name(offset=1),
             adapter_name=adapter_name,
-            time_limit=time_limit)
+            time_limit=time_limit,
+        )
         # add environment variable info to the test case
         for e_name, e_value in self._tracked_env.items():
-            test.add_environ_var(e_name, e_value)
+            self._test.add_environ_var(e_name, e_value)
         # add environment files to the test case
         for e_file in self._environ_files:
-            test.add_meta(e_file.clone())
+            self._test.add_meta(e_file.clone())
         # reset redirect map
         self.server_map.redirect.clear()
-        self.server_map.set_redirect("grz_current_test", self.page_name(), required=False)
+        self.server_map.set_redirect(
+            "grz_current_test", self.page_name(), required=False
+        )
         self.server_map.set_redirect("grz_next_test", self.page_name(offset=1))
         if self.harness is not None:
             self.server_map.set_dynamic_response(
-                "grz_harness",
-                lambda: self.harness,
-                mime_type="text/html")
+                "grz_harness", lambda: self.harness, mime_type="text/html"
+            )
         self._generated += 1
-        self.tests.append(test)
-        # manage testcase cache size
-        if len(self.tests) > self._report_size:
-            self.tests.popleft().cleanup()
-        return test
+        return self._test
 
     def page_name(self, offset=0):
         return "test_%04d.html" % (self._generated + offset,)
 
-    def purge_tests(self):
+    def purge(self):
+        if self._test is not None:
+            self._test.cleanup()
+            self._test = None
         for testcase in self.tests:
             testcase.cleanup()
         self.tests.clear()
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index f9041968..05d1db0d 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -300,9 +300,9 @@ def load(cls, path, load_prefs, adjacent=False):
                            subdirectories containing testcase data.
                         4) A single file to be used as a test case.
             load_prefs (bool): Load prefs.js file if available.
-            adjacent (str): Load adjacent files as part of the test case.
-                            This is always the case when loading a directory.
-                            WARNING: This should be used with caution!
+            adjacent (bool): Load adjacent files as part of the test case.
+                             This is always the case when loading a directory.
+                             WARNING: This should be used with caution!
 
         Returns:
             list: TestCases successfully loaded from path.
diff --git a/grizzly/common/test_iomanager.py b/grizzly/common/test_iomanager.py
index b2bd560d..cd0ff713 100644
--- a/grizzly/common/test_iomanager.py
+++ b/grizzly/common/test_iomanager.py
@@ -3,6 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
+from pytest import mark
 
 from .iomanager import IOManager
 from .storage import TestFile
@@ -11,12 +12,44 @@
 def test_iomanager_01():
     """test a simple IOManager"""
     with IOManager() as iom:
+        assert iom.harness is None
         assert iom.server_map is not None
+        assert not iom.tests
         assert not iom._environ_files
         assert iom._generated == 0
         assert iom._report_size == 1
+        assert iom._test is None
+
+@mark.parametrize(
+    "report_size, iters",
+    [
+        (1, 1),
+        (1, 2),
+        (2, 2),
+        (2, 3),
+    ]
+)
+def test_iomanager_02(report_size, iters):
+    """test IOManager create_testcase(), commit() and purge()"""
+    with IOManager(report_size=report_size) as iom:
+        assert not iom.tests
+        for current in range(1, iters + 1):
+            tcase = iom.create_testcase("test-adapter", 10)
+            assert iom._generated == current
+            assert iom._test
+            precommit_size = len(iom.tests)
+            iom.commit()
+            assert iom._test is None
+            assert tcase == iom.tests[0]
+            size = len(iom.tests)
+            assert precommit_size <= size
+            assert size <= report_size
+        assert size == report_size
+        iom.purge()
+        assert iom._test is None
+        assert not iom.tests
 
-def test_iomanager_02():
+def test_iomanager_03():
     """test IOManager.page_name()"""
     with IOManager() as iom:
         assert iom.page_name() != iom.page_name(offset=1)
@@ -24,7 +57,7 @@ def test_iomanager_02():
         iom._generated += 1
         assert iom.page_name() == next_page
 
-def test_iomanager_03(mocker, tmp_path):
+def test_iomanager_04(mocker, tmp_path):
     """test IOManager._add_suppressions()"""
     mocker.patch.dict("grizzly.common.iomanager.environ", values={})
     with IOManager() as iom:
@@ -41,8 +74,9 @@ def test_iomanager_03(mocker, tmp_path):
         iom._add_suppressions()
         assert "asan.supp" in (x.file_name for x in iom._environ_files)
 
-def test_iomanager_04():
+def test_iomanager_05():
     """test IOManager.create_testcase()"""
+    time_limit = 10
     with IOManager() as iom:
         assert iom._generated == 0
         assert iom._report_size == 1
@@ -52,31 +86,29 @@ def test_iomanager_04():
         assert not iom.server_map.redirect
         iom._tracked_env = {"TEST": "1"}
         iom._environ_files = [TestFile.from_data(b"data", "e.txt")]
-        time_limit = 10
         # without a harness, no input files
         tcase = iom.create_testcase("test-adapter", time_limit)
         assert tcase is not None
-        assert iom._generated == 1
-        assert len(iom.tests) == 1
         assert not any(tcase.optional)
         assert tcase.time_limit == time_limit
         assert "grz_current_test" in iom.server_map.redirect
         assert iom.server_map.redirect["grz_current_test"].target == tcase.landing_page
         assert "grz_next_test" in iom.server_map.redirect
         assert "grz_harness" not in iom.server_map.dynamic
+        assert iom._test is not None
+        iom.purge()
+        assert iom._test is None
         # with a harness
         iom.harness = b"harness-data"
         tcase = iom.create_testcase("test-adapter", time_limit)
         assert tcase is not None
-        assert len(iom.tests) == 1
-        assert iom._generated == 2
         assert tcase.time_limit == time_limit
         assert "grz_current_test" in iom.server_map.redirect
         assert iom.server_map.redirect["grz_current_test"].target == tcase.landing_page
         assert "grz_next_test" in iom.server_map.redirect
         assert "grz_harness" in iom.server_map.dynamic
 
-def test_iomanager_05(mocker):
+def test_iomanager_06(mocker):
     """test IOManager.tracked_environ()"""
     mocker.patch.dict("grizzly.common.iomanager.environ", values={})
     assert not IOManager.tracked_environ()
diff --git a/grizzly/session.py b/grizzly/session.py
index e8d410c2..92bf3255 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -164,7 +164,7 @@ def run(
 
             if self.target.closed:
                 # (re-)launch target
-                self.iomanager.purge_tests()
+                self.iomanager.purge()
                 self.adapter.pre_launch()
                 if self.iomanager.harness is None:
                     # harness is not in use, open the test case
@@ -214,7 +214,6 @@ def run(
             if not result.attempted:
                 LOG.warning("Test case was not served")
                 LOG.debug("ignoring test case since nothing was served")
-                self.iomanager.tests.pop().cleanup()
                 if not current_test.contains(current_test.landing_page):
                     raise SessionError("Test case is missing landing page")
                 if result.initial:
@@ -228,9 +227,11 @@ def run(
                     # to avoid aborting a fuzzing session unnecessarily
                     if self.status.iteration < 100:
                         startup_error = True
-            elif self.adapter.IGNORE_UNSERVED:
-                LOG.debug("removing unserved files from the test case")
-                current_test.purge_optional(result.served)
+            else:
+                if self.adapter.IGNORE_UNSERVED:
+                    LOG.debug("removing unserved files from the test case")
+                    current_test.purge_optional(result.served)
+                self.iomanager.commit()
             # process results
             if result.status == RunResult.FAILED:
                 LOG.debug("result detected")
@@ -243,8 +244,6 @@ def run(
                     short_sig,
                     report.major[:8],
                     report.minor[:8])
-                # order test cases newest to oldest
-                self.iomanager.tests.reverse()
                 self.reporter.submit(self.iomanager.tests, report)
                 report.cleanup()
                 self.status.count_result(short_sig)

From 36b07f3bf6cd3ce9a6dd2cf374f0aff48160d83e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 8 Mar 2021 16:53:44 -0800
Subject: [PATCH 223/531] Add missing dependency lithium-reducer

---
 setup.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/setup.py b/setup.py
index 5ce5da7b..f724ae04 100755
--- a/setup.py
+++ b/setup.py
@@ -57,6 +57,7 @@
             'fasteners',
             'ffpuppet',
             'FuzzManager',
+            'lithium-reducer',
             'prefpicker',
             'psutil'
         ],

From 2eb41df7a7988af736cd89e6ad56776e07e414c3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 17 Mar 2021 16:25:06 -0700
Subject: [PATCH 224/531] [tests] Fix sapphire test_connection_manager_04
 warning

---
 sapphire/test_connection_manager.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sapphire/test_connection_manager.py b/sapphire/test_connection_manager.py
index c9c3c3a8..aca1b6bf 100644
--- a/sapphire/test_connection_manager.py
+++ b/sapphire/test_connection_manager.py
@@ -4,6 +4,7 @@
 """
 # pylint: disable=protected-access
 
+from itertools import count
 from socket import socket
 from threading import ThreadError
 
@@ -83,7 +84,7 @@ def test_connection_manager_04(mocker, tmp_path):
     # timeout
     job = Job(str(tmp_path))
     fake_time = mocker.patch("sapphire.connection_manager.time", autospec=True)
-    fake_time.side_effect = (1, 2, 3)
+    fake_time.side_effect = count()
     with ConnectionManager(job, serv_sock, max_workers=10) as loadmgr:
         assert not loadmgr.wait(1, continue_cb=lambda: False, poll=0.01)
 

From 8123ffffb4b28cee5e2dd0a81d96a96a7903a78d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 17 Mar 2021 16:37:50 -0700
Subject: [PATCH 225/531] [tests] Fix test_runner_01

---
 grizzly/common/test_runner.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 3cdc7991..bea3a37a 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -44,8 +44,9 @@ def test_runner_01(mocker, tmp_path):
     assert target.handle_hang.call_count == 0
     assert testcase.dump.call_count == 1
     # dump coverage
+    serv_map = ServerMap()
     server.serve_path.return_value = (SERVED_ALL, serv_files)
-    result = runner.run([], ServerMap(), testcase, coverage=True)
+    result = runner.run([], serv_map, testcase, coverage=True)
     assert result.attempted
     assert runner._tests_run == 2
     assert not result.initial
@@ -60,8 +61,9 @@ def test_runner_01(mocker, tmp_path):
     testcase.reset_mock()
     tc_path = (tmp_path / "tc")
     tc_path.mkdir()
+    serv_map = ServerMap()
     server.serve_path.return_value = (SERVED_ALL, serv_files)
-    result = runner.run([], ServerMap(), testcase, test_path=str(tc_path))
+    result = runner.run([], serv_map, testcase, test_path=str(tc_path))
     assert result.attempted
     assert runner._tests_run == 3
     assert not result.initial

From d9ff4cf139f6f7b9604d290ef0a77861760742b8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 18 Mar 2021 12:19:01 -0700
Subject: [PATCH 226/531] Use tox for tests

---
 .pylintrc      |  18 ---------
 MANIFEST.in    |   1 +
 pyproject.toml |  56 +++++++++++++++++++++++++++
 setup.cfg      |  68 ++++++++++++++++++++++++++++++--
 setup.py       |  84 ++++------------------------------------
 tox.ini        | 103 +++++++++++++++++++++++++++++--------------------
 6 files changed, 191 insertions(+), 139 deletions(-)
 delete mode 100644 .pylintrc
 create mode 100644 MANIFEST.in
 create mode 100644 pyproject.toml

diff --git a/.pylintrc b/.pylintrc
deleted file mode 100644
index dc676a7f..00000000
--- a/.pylintrc
+++ /dev/null
@@ -1,18 +0,0 @@
-[MESSAGES CONTROL]
-disable=
-    duplicate-code,
-    fixme,
-    missing-docstring,
-    too-few-public-methods,
-    too-many-arguments,
-    too-many-branches,
-    too-many-instance-attributes,
-    too-many-locals,
-    too-many-nested-blocks,
-    too-many-return-statements,
-    too-many-statements,
-    useless-object-inheritance,
-
-[FORMAT]
-max-line-length=110
-const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__)|pytestmark)$
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 00000000..b84b7233
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1 @@
+include grizzly/common/harness.html
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 00000000..81ec1bf7
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools >= 43", "wheel", "setuptools_scm[toml] >= 3.4"]
+build-backend = "setuptools.build_meta"
+
+[tool.coverage.run]
+omit = [
+    "*/setup.py",
+    "*/__main__.py",
+    "*/test_*",
+    "*/build/*",
+    "*/dist/*",
+    "*/resources/*",
+    "*/.tox/*",
+    "*/.egg/*",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+]
+
+#[tool.isort]
+#known_first_party = "grizzly"
+#profile = "black"
+
+[tool.pylint.format]
+max-line-length = 88
+
+[tool.pylint.messages_control]
+disable = [
+    "C0330",
+    "C0326",
+    "bad-continuation",
+    "fixme",
+    "import-error",
+    "subprocess-run-check",
+    "too-few-public-methods",
+    "too-many-arguments",
+    "too-many-branches",
+    "too-many-instance-attributes",
+    "too-many-lines",
+    "too-many-locals",
+    "too-many-nested-blocks",
+    "too-many-statements",
+]
+
+[tool.pylint.typecheck]
+ignored-modules = ["pytest"]
+
+[tool.pytest.ini_options]
+filterwarnings = [
+    "ignore::pytest.PytestCollectionWarning",
+]
+log_level = "DEBUG"
+
+[tool.setuptools_scm]
diff --git a/setup.cfg b/setup.cfg
index 6fedc193..a0eb7d35 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,5 +1,67 @@
 [metadata]
-description-file = README.md
+author = Tyson Smith
+author_email = twsmith@mozilla.com
+classifiers =
+    Intended Audience :: Developers
+    License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+    Programming Language :: Python :: 3
+    Topic :: Security
+    Topic :: Software Development :: Testing
+description = A framework for developing and running browser fuzzers
+keywords = firefox framework fuzz fuzzing test testing
+license = MPL 2.0
+long_description = file: README.md
+long_description_content_type = text/markdown
+maintainer = Mozilla Fuzzing Team
+maintainer_email = fuzzing@mozilla.com
+name = grizzly-framework
+url = https://github.com/MozillaSecurity/grizzly
 
-[bdist_wheel]
-universal=1
+[options]
+include_package_data = True
+install_requires =
+    fasteners
+    ffpuppet
+    FuzzManager
+    lithium-reducer >= 0.5
+    prefpicker
+    psutil >= 4.4.0
+packages =
+    grizzly
+    grizzly.adapters
+    grizzly.adapters.NoOpAdapter
+    grizzly.common
+    grizzly.reduce
+    grizzly.reduce.strategies
+    grizzly.replay
+    grizzly.target
+    loki
+    sapphire
+python_requires = >=3.6
+zip_safe = False
+
+[options.entry_points]
+console_scripts =
+    grizzly.status = grizzly.common.status_reporter:main
+grizzly_targets =
+    ffpuppet = grizzly.target.puppet_target:PuppetTarget
+grizzly_reduce_strategies =
+    attrs = grizzly.reduce.strategies.lithium:MinimizeAttrs
+    chars = grizzly.reduce.strategies.lithium:MinimizeChars
+    check = grizzly.reduce.strategies.lithium:Check
+    collapsebraces = grizzly.reduce.strategies.lithium:CollapseEmptyBraces
+    cssbeautify = grizzly.reduce.strategies.beautify:CSSBeautify
+    jsbeautify = grizzly.reduce.strategies.beautify:JSBeautify
+    jschars = grizzly.reduce.strategies.lithium:MinimizeJSChars
+    lines = grizzly.reduce.strategies.lithium:MinimizeLines
+    list = grizzly.reduce.strategies.testcases:MinimizeTestcaseList
+
+[options.extras_require]
+dev =
+    pre-commit
+    tox
+reduce =
+    cssbeautifier
+    jsbeautifier
+s3 =
+    boto3
diff --git a/setup.py b/setup.py
index f724ae04..2e4a54cc 100755
--- a/setup.py
+++ b/setup.py
@@ -1,85 +1,17 @@
 #!/usr/bin/env python
 # coding=utf-8
+#
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
-"""Grizzly setup"""
-from os.path import dirname, join as pathjoin
-from itertools import chain
-from setuptools import setup
+"""setuptools install script"""
+
+import site
 
+from setuptools import setup
 
-EXTRAS = {
-    'reduce': ['cssbeautifier', 'lithium-reducer>=0.5', 'jsbeautifier'],
-    's3': ['boto3'],
-}
-EXTRAS['all'] = list(set(chain.from_iterable(EXTRAS.values())))
-EXTRAS['test'] = ['pytest>=3.9', 'pytest-cov', 'pytest-mock']
+site.ENABLE_USER_SITE = True
 
 
-if __name__ == '__main__':
-    with open(pathjoin(dirname(__file__), 'README.md'), 'r') as infp:
-        README = infp.read()
-    setup(
-        classifiers=[
-            'Intended Audience :: Developers',
-            'Topic :: Software Development :: Testing',
-            'Topic :: Security',
-            'License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)',
-            'Programming Language :: Python :: 3',
-            'Programming Language :: Python :: 3.6',
-            'Programming Language :: Python :: 3.7',
-            'Programming Language :: Python :: 3.8',
-            'Programming Language :: Python :: 3.9',
-        ],
-        description='A framework for developing and running browser fuzzers',
-        entry_points={
-            'console_scripts': [
-                'grizzly.status = grizzly.common.status_reporter:main',
-            ],
-            'grizzly_targets': [
-                'ffpuppet = grizzly.target.puppet_target:PuppetTarget',
-            ],
-            'grizzly_reduce_strategies': [
-                'chars = grizzly.reduce.strategies.lithium:MinimizeChars',
-                'check = grizzly.reduce.strategies.lithium:Check',
-                'collapsebraces = grizzly.reduce.strategies.lithium:CollapseEmptyBraces',
-                'cssbeautify = grizzly.reduce.strategies.beautify:CSSBeautify',
-                'jsbeautify = grizzly.reduce.strategies.beautify:JSBeautify',
-                'jschars = grizzly.reduce.strategies.lithium:MinimizeJSChars',
-                'lines = grizzly.reduce.strategies.lithium:MinimizeLines',
-                'list = grizzly.reduce.strategies.testcases:MinimizeTestcaseList',
-                'attrs = grizzly.reduce.strategies.lithium:MinimizeAttrs',
-            ],
-        },
-        extras_require=EXTRAS,
-        install_requires=[
-            'fasteners',
-            'ffpuppet',
-            'FuzzManager',
-            'lithium-reducer',
-            'prefpicker',
-            'psutil'
-        ],
-        keywords='firefox framework fuzz fuzzing test testing',
-        license='MPL 2.0',
-        long_description=README,
-        long_description_content_type='text/markdown',
-        maintainer='Mozilla Fuzzing Team',
-        maintainer_email='fuzzing@mozilla.com',
-        name='grizzly-framework',
-        packages=[
-            'grizzly',
-            'grizzly.adapters',
-            'grizzly.adapters.NoOpAdapter',
-            'grizzly.common',
-            'grizzly.reduce',
-            'grizzly.reduce.strategies',
-            'grizzly.replay',
-            'grizzly.target',
-            'loki',
-            'sapphire',
-        ],
-        package_data={"grizzly.common": ["harness.html"]},
-        url='https://github.com/MozillaSecurity/grizzly',
-        version='0.11.1')
+if __name__ == "__main__":
+    setup()
diff --git a/tox.ini b/tox.ini
index ead47f73..183db6ab 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,47 +1,66 @@
-[coverage:report]
-exclude_lines =
-    if __name__ == .__main__.:
-    @(abc.)?abstract*
-    pragma: no cover
+[tox]
+envlist = py{36,37,38,39} #,lint
+skip_missing_interpreters = true
+tox_pip_extensions_ext_venv_update = true
 
-[coverage:run]
-omit =
-    */__main__.py
-    */test_*.py
-    */conftest.py
-    grizzly/adapters/*/__init__.py
-    setup.py
-    dist/*
-    .tox/*
-    .egg/*
+[testenv]
+commands = pytest -v --cache-clear --cov="{toxinidir}" --cov-config="{toxinidir}/pyproject.toml" --cov-report term-missing --basetemp="{envtmpdir}" {posargs}
+deps =
+    pytest
+    pytest-cov
+    pytest-mock
+passenv =
+    BUILD_CACHE
+    CI
+    CODECOV_*
+    TOXENV
+    TRAVIS
+    TRAVIS_*
+    TWINE_*
+usedevelop = true
 
-[flake8]
-max-line-length = 110
-exclude =
-    .git
-    dist
-    .tox
+[testenv:codecov]
+commands =
+    codecov
+deps =
+    codecov
+    coverage[toml]
+skip_install = true
 
-[pytest]
-addopts =
-    -v
-    --cache-clear
-    --cov .
-    --cov-report term-missing
-filterwarnings =
-    ignore:cannot collect test class 'Test.*' because it has a __init__ constructor:pytest.PytestCollectionWarning
-    ignore:Using or importing the ABCs:DeprecationWarning:botocore
-log_level = DEBUG
+#[testenv:lint]
+#allowlist_externals =
+#    bash
+#commands =
+#    isort {toxinidir}
+#    black {toxinidir}
+#    codespell {toxinidir} --skip=".git,.tox,htmlcov,results"
+#    pylint {toxinidir}/grizzly
+#    pylint {toxinidir}/loki
+#    pylint {toxinidir}/sapphire
+#    flake8 {toxinidir}
+#deps =
+#    black
+#    codespell
+#    flake8
+#    isort
+#    pylint
+#usedevelop = true
 
-[testenv]
-commands = pytest -o addopts= -v --cache-clear --cov="{toxinidir}" --cov-report term-missing --basetemp="{envtmpdir}" {posargs}
-extras =
-    all
-    test
-usedevelop = true
+[testenv:pypi]
+commands =
+    python setup.py sdist bdist_wheel
+    twine upload --skip-existing dist/*
+deps =
+    setuptools>=43
+    setuptools_scm[toml]>=3.4
+    twine
+    wheel
+skip_install = true
 
-[tox]
-envlist = py36,py37,py38,py39
-minversion = 3.6
-skip_missing_interpreters = true
-tox_pip_extensions_ext_venv_update = true
+[flake8]
+extend-ignore = E203
+per-file-ignores =
+    */__init__.py: F401
+max-line-length = 88
+show-source = true
+statistics = true

From e7ce16d52bf97188c4a060ef711a7213d47b513f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 18 Mar 2021 12:32:56 -0700
Subject: [PATCH 227/531] Enable isort

---
 grizzly/__main__.py                    |  2 +-
 grizzly/adapters/__init__.py           |  6 ++++--
 grizzly/args.py                        |  3 ++-
 grizzly/common/__init__.py             | 11 ++++++++---
 grizzly/common/adapter.py              |  4 ++--
 grizzly/common/fuzzmanager.py          |  1 -
 grizzly/common/iomanager.py            |  4 ++--
 grizzly/common/reporter.py             | 18 ++++++++++--------
 grizzly/common/runner.py               |  1 +
 grizzly/common/stack_hasher.py         |  5 +++--
 grizzly/common/status.py               |  3 ++-
 grizzly/common/status_reporter.py      |  6 +++---
 grizzly/common/storage.py              | 12 ++++++------
 grizzly/common/test_reporter.py        | 12 +++++++++---
 grizzly/common/test_runner.py          | 14 +++++++++++---
 grizzly/common/test_status_reporter.py |  5 +++--
 grizzly/common/test_storage.py         |  6 +++---
 grizzly/common/test_utils.py           |  1 +
 grizzly/common/utils.py                |  1 -
 grizzly/main.py                        | 14 +++++++++-----
 grizzly/reduce/__init__.py             |  2 +-
 grizzly/reduce/__main__.py             |  3 +--
 grizzly/reduce/args.py                 |  1 -
 grizzly/reduce/bucket.py               |  5 ++---
 grizzly/reduce/core.py                 |  9 +++++----
 grizzly/reduce/crash.py                |  5 ++---
 grizzly/reduce/stats.py                |  5 ++---
 grizzly/reduce/strategies/__init__.py  |  1 -
 grizzly/reduce/strategies/beautify.py  |  3 +--
 grizzly/reduce/strategies/lithium.py   | 11 ++++++-----
 grizzly/reduce/strategies/testcases.py |  1 -
 grizzly/reduce/test_main.py            |  3 +--
 grizzly/reduce/test_main_fm.py         |  3 +--
 grizzly/reduce/test_reduce.py          |  4 ++--
 grizzly/reduce/test_strategies.py      | 14 +++++++++-----
 grizzly/replay/__init__.py             |  2 +-
 grizzly/replay/__main__.py             |  1 -
 grizzly/replay/replay.py               | 11 +++++++----
 grizzly/replay/test_main.py            |  3 +--
 grizzly/replay/test_replay.py          |  5 +++--
 grizzly/session.py                     |  1 -
 grizzly/target/__init__.py             |  9 ++++++++-
 grizzly/target/puppet_target.py        | 11 +++++------
 grizzly/target/target.py               |  1 -
 grizzly/target/target_monitor.py       |  1 -
 grizzly/target/test_puppet_target.py   |  4 ++--
 grizzly/target/test_target.py          |  3 ++-
 grizzly/target/test_target_loader.py   |  2 +-
 grizzly/target/test_target_monitor.py  |  1 +
 grizzly/test_args.py                   |  1 +
 grizzly/test_main.py                   |  2 ++
 grizzly/test_session.py                |  3 ++-
 loki/__main__.py                       |  1 -
 loki/args.py                           |  2 +-
 loki/loki.py                           | 11 ++++++-----
 pyproject.toml                         |  6 +++---
 sapphire/__main__.py                   |  2 +-
 sapphire/conftest.py                   |  3 +--
 sapphire/connection_manager.py         |  2 +-
 sapphire/core.py                       |  6 ++----
 sapphire/job.py                        |  6 ++++--
 sapphire/test_job.py                   |  2 +-
 sapphire/test_sapphire.py              |  2 +-
 sapphire/test_worker.py                |  1 +
 sapphire/worker.py                     |  5 +++--
 tox.ini                                | 26 +++++++++++++-------------
 66 files changed, 187 insertions(+), 148 deletions(-)

diff --git a/grizzly/__main__.py b/grizzly/__main__.py
index 191dd7a6..2bd06ec2 100644
--- a/grizzly/__main__.py
+++ b/grizzly/__main__.py
@@ -2,7 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from logging import basicConfig, DEBUG
+from logging import DEBUG, basicConfig
 from os import getenv
 
 from .adapters import load
diff --git a/grizzly/adapters/__init__.py b/grizzly/adapters/__init__.py
index a07d6cf4..d8cbd1e1 100644
--- a/grizzly/adapters/__init__.py
+++ b/grizzly/adapters/__init__.py
@@ -1,8 +1,10 @@
 from importlib import import_module
 from logging import getLogger
 from os import listdir
-from os.path import abspath, dirname, isfile, join as pathjoin
-from sys import exc_info, path as syspath
+from os.path import abspath, dirname, isfile
+from os.path import join as pathjoin
+from sys import exc_info
+from sys import path as syspath
 from traceback import extract_tb
 
 from grizzly.common import Adapter
diff --git a/grizzly/args.py b/grizzly/args.py
index 9a749bd8..ae5cbef7 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -5,12 +5,13 @@
 from argparse import ArgumentParser, HelpFormatter
 from logging import CRITICAL, DEBUG, ERROR, INFO, WARNING
 from os import listdir
-from os.path import exists, isfile, isdir
+from os.path import exists, isdir, isfile
 
 from .adapters import names as adapter_names
 from .common.utils import TIMEOUT_DELAY
 from .target import available as available_targets
 
+
 # ref: https://stackoverflow.com/questions/12268602/sort-argparse-help-alphabetically
 class SortingHelpFormatter(HelpFormatter):
     @staticmethod
diff --git a/grizzly/common/__init__.py b/grizzly/common/__init__.py
index 74bf84ce..eb5de6a7 100644
--- a/grizzly/common/__init__.py
+++ b/grizzly/common/__init__.py
@@ -5,13 +5,18 @@
 
 from .adapter import Adapter, AdapterError
 from .iomanager import IOManager, ServerMap
-from .reporter import FilesystemReporter, FuzzManagerReporter, Report, Reporter, S3FuzzManagerReporter
+from .reporter import (
+    FilesystemReporter,
+    FuzzManagerReporter,
+    Report,
+    Reporter,
+    S3FuzzManagerReporter,
+)
 from .runner import Runner, RunResult
 from .status import Status
-from .storage import TestCaseLoadFailure, TestCase, TestFile, TestFileExists
+from .storage import TestCase, TestCaseLoadFailure, TestFile, TestFileExists
 from .utils import grz_tmp
 
-
 __all__ = (
     "Adapter", "AdapterError", "FilesystemReporter", "FuzzManagerReporter", "grz_tmp", "IOManager",
     "Report", "Reporter", "Runner", "RunResult", "S3FuzzManagerReporter",
diff --git a/grizzly/common/adapter.py b/grizzly/common/adapter.py
index 1c971174..663403dc 100644
--- a/grizzly/common/adapter.py
+++ b/grizzly/common/adapter.py
@@ -4,8 +4,8 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from abc import ABCMeta, abstractmethod
 from os import walk
-from os.path import abspath, dirname, isdir, isfile, join as pathjoin
-
+from os.path import abspath, dirname, isdir, isfile
+from os.path import join as pathjoin
 
 __all__ = ("Adapter", "AdapterError")
 __author__ = "Tyson Smith"
diff --git a/grizzly/common/fuzzmanager.py b/grizzly/common/fuzzmanager.py
index acf4f009..814b2ff2 100644
--- a/grizzly/common/fuzzmanager.py
+++ b/grizzly/common/fuzzmanager.py
@@ -14,7 +14,6 @@
 
 from .utils import grz_tmp
 
-
 LOG = getLogger(__name__)
 
 
diff --git a/grizzly/common/iomanager.py b/grizzly/common/iomanager.py
index 1a469947..7abb14a7 100644
--- a/grizzly/common/iomanager.py
+++ b/grizzly/common/iomanager.py
@@ -7,9 +7,9 @@
 from os.path import isfile
 
 from sapphire.server_map import ServerMap
-from .storage import TestCase, TestFile
-from ..target import sanitizer_opts
 
+from ..target import sanitizer_opts
+from .storage import TestCase, TestFile
 
 __all__ = ("IOManager",)
 __author__ = "Tyson Smith"
diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index fedad40d..340409d1 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -7,24 +7,26 @@
 from collections import namedtuple
 from hashlib import sha1
 from json import dump, dumps, loads
-from logging import getLogger, WARNING
+from logging import WARNING, getLogger
+from os import SEEK_END, getcwd, getenv, makedirs, mkdir, scandir, stat, unlink, walk
+from os.path import basename, expanduser, isdir, isfile
+from os.path import join as pathjoin
+from os.path import realpath, relpath
 from platform import machine, system
-from os import getcwd, getenv, makedirs, mkdir, scandir, SEEK_END, stat, unlink, walk
-from os.path import basename, expanduser, isdir, isfile, join as pathjoin, realpath, relpath
-from re import compile as re_compile, DOTALL, VERBOSE
+from re import DOTALL, VERBOSE
+from re import compile as re_compile
 from shutil import copyfile, copyfileobj, move, rmtree
 from tarfile import open as tar_open
 from tempfile import mkstemp
 from time import strftime
-from zipfile import ZipFile, ZIP_DEFLATED
-
-from fasteners.process_lock import InterProcessLock
-from psutil import disk_usage
+from zipfile import ZIP_DEFLATED, ZipFile
 
 # import FuzzManager utilities
 from Collector.Collector import Collector
+from fasteners.process_lock import InterProcessLock
 from FTB.ProgramConfiguration import ProgramConfiguration
 from FTB.Signatures.CrashInfo import CrashInfo
+from psutil import disk_usage
 
 # check if boto is available for S3FuzzManager reporter
 try:
diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 5e1c59f3..4a4d9048 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -8,6 +8,7 @@
 from time import sleep, time
 
 from sapphire import SERVED_TIMEOUT
+
 from ..target import TargetLaunchError, TargetLaunchTimeout
 from .utils import grz_tmp
 
diff --git a/grizzly/common/stack_hasher.py b/grizzly/common/stack_hasher.py
index 9f41f549..d932c1ca 100644
--- a/grizzly/common/stack_hasher.py
+++ b/grizzly/common/stack_hasher.py
@@ -13,9 +13,10 @@
 well in most cases.
 """
 from hashlib import sha1
-from logging import basicConfig, getLogger, INFO, DEBUG
+from logging import DEBUG, INFO, basicConfig, getLogger
 from os.path import basename
-from re import compile as re_compile, match as re_match
+from re import compile as re_compile
+from re import match as re_match
 
 __all__ = ("Stack", "StackFrame")
 __author__ = "Tyson Smith"
diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index d861f7d0..039d8ba0 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -8,7 +8,8 @@
 from json import dump, load
 from logging import getLogger
 from os import close, getpid, listdir, unlink
-from os.path import isdir, isfile, join as pathjoin
+from os.path import isdir, isfile
+from os.path import join as pathjoin
 from tempfile import mkstemp
 from time import time
 
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index ba3f0103..75014897 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -5,12 +5,12 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Manage Grizzly status reports."""
 import argparse
-from collections import defaultdict
-from datetime import timedelta
-from functools import partial
 import logging
 import os
 import re
+from collections import defaultdict
+from datetime import timedelta
+from functools import partial
 from time import gmtime, localtime, strftime, time
 
 import psutil
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 05d1db0d..59029a7a 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -3,14 +3,15 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
+import json
 from collections import namedtuple
 from itertools import chain
-import json
-from os import listdir, makedirs, SEEK_END, walk
-from os.path import abspath, basename, dirname, isfile, isdir, join as pathjoin, \
-    normpath, relpath
+from os import SEEK_END, listdir, makedirs, walk
+from os.path import abspath, basename, dirname, isdir, isfile
+from os.path import join as pathjoin
+from os.path import normpath, relpath
 from shutil import copyfileobj, rmtree
-from tempfile import mkdtemp, SpooledTemporaryFile
+from tempfile import SpooledTemporaryFile, mkdtemp
 from time import time
 from zipfile import BadZipfile, ZipFile
 from zlib import error as zlib_error
@@ -18,7 +19,6 @@
 from ..target import sanitizer_opts
 from .utils import grz_tmp
 
-
 __all__ = ("TestCase", "TestFile", "TestCaseLoadFailure", "TestFileExists")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 630eff98..18c777cf 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -6,18 +6,24 @@
 # pylint: disable=protected-access
 
 import os
-from pathlib import Path
 import sys
 import tarfile
+from pathlib import Path
 
 import pytest
-
 from FTB.ProgramConfiguration import ProgramConfiguration
 from FTB.Signatures.CrashInfo import CrashInfo
 
-from .reporter import FilesystemReporter, FuzzManagerReporter, Report, Reporter, S3FuzzManagerReporter
+from .reporter import (
+    FilesystemReporter,
+    FuzzManagerReporter,
+    Report,
+    Reporter,
+    S3FuzzManagerReporter,
+)
 from .storage import TestCase
 
+
 def _create_crash_log(log_path):
     with log_path.open("w") as log_fp:
         log_fp.write("==1==ERROR: AddressSanitizer: SEGV on unknown address 0x0")
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index bea3a37a..ed27ae04 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -8,12 +8,20 @@
 
 from pytest import mark, raises
 
-from sapphire import Sapphire, SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT, ServerMap
+from sapphire import (
+    SERVED_ALL,
+    SERVED_NONE,
+    SERVED_REQUEST,
+    SERVED_TIMEOUT,
+    Sapphire,
+    ServerMap,
+)
 
+from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from .reporter import Report
-from .runner import _IdleChecker, Runner, RunResult
+from .runner import Runner, RunResult, _IdleChecker
 from .storage import TestCase
-from ..target import Target, TargetLaunchError, TargetLaunchTimeout
+
 
 def test_runner_01(mocker, tmp_path):
     """test Runner()"""
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 956884b1..4c4661c4 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -5,12 +5,13 @@
 """test Grizzly status reporter"""
 # pylint: disable=protected-access
 
-from itertools import count
 import re
+from itertools import count
 
 import pytest
 
-from .status_reporter import main, Status, StatusReporter, TracebackReport
+from .status_reporter import Status, StatusReporter, TracebackReport, main
+
 
 def _fake_sys_info():
     return "CPU & Load : 64 @ 93.1% (85.25, 76.21, 51.06)\n" \
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index fa588054..a37e0c47 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -4,15 +4,15 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
 
-from itertools import chain
 import json
-import re
 import os
+import re
 import zipfile
+from itertools import chain
 
 import pytest
 
-from .storage import TestCase, TestFile, TestCaseLoadFailure, TestFileExists
+from .storage import TestCase, TestCaseLoadFailure, TestFile, TestFileExists
 
 
 def test_testcase_01(tmp_path):
diff --git a/grizzly/common/test_utils.py b/grizzly/common/test_utils.py
index 8373d7c8..5f935d33 100644
--- a/grizzly/common/test_utils.py
+++ b/grizzly/common/test_utils.py
@@ -5,6 +5,7 @@
 
 from .utils import grz_tmp
 
+
 def test_testcase_01(mocker, tmp_path):
     """test grz_tmp()"""
     mocker.patch("grizzly.common.utils.gettempdir", autospec=True, return_value=str(tmp_path))
diff --git a/grizzly/common/utils.py b/grizzly/common/utils.py
index cad12326..223a7c81 100644
--- a/grizzly/common/utils.py
+++ b/grizzly/common/utils.py
@@ -7,7 +7,6 @@
 from os.path import join as pathjoin
 from tempfile import gettempdir
 
-
 __all__ = ("ConfigError", "grz_tmp", "TIMEOUT_DELAY")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
diff --git a/grizzly/main.py b/grizzly/main.py
index 8cb7a358..a9248e08 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -2,18 +2,22 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from logging import basicConfig, DEBUG, getLogger
-from os.path import join as pathjoin
+from logging import DEBUG, basicConfig, getLogger
 from os import getcwd, getenv, getpid
+from os.path import join as pathjoin
 
 from sapphire import Sapphire
 
 from .adapters import get as get_adapter
-from .common.reporter import FilesystemReporter, FuzzManagerReporter, S3FuzzManagerReporter
+from .common.reporter import (
+    FilesystemReporter,
+    FuzzManagerReporter,
+    S3FuzzManagerReporter,
+)
 from .common.utils import TIMEOUT_DELAY
 from .session import Session
-from .target import load as load_target, TargetLaunchError, TargetLaunchTimeout
-
+from .target import TargetLaunchError, TargetLaunchTimeout
+from .target import load as load_target
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
diff --git a/grizzly/reduce/__init__.py b/grizzly/reduce/__init__.py
index 87f67339..2d45e7cc 100644
--- a/grizzly/reduce/__init__.py
+++ b/grizzly/reduce/__init__.py
@@ -7,5 +7,5 @@
 
 __all__ = ("ReduceManager", "ReduceArgs")
 
-from .core import ReduceManager
 from .args import ReduceArgs
+from .core import ReduceManager
diff --git a/grizzly/reduce/__main__.py b/grizzly/reduce/__main__.py
index 0becd66e..b02fc9d9 100644
--- a/grizzly/reduce/__main__.py
+++ b/grizzly/reduce/__main__.py
@@ -4,8 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Grizzly reducer CLI.
 """
-from .args import ReduceArgs
 from . import ReduceManager
-
+from .args import ReduceArgs
 
 raise SystemExit(ReduceManager.main(ReduceArgs().parse_args()))
diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 62d74ce1..27289833 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -10,7 +10,6 @@
 from ..replay.args import ReplayArgs
 from .strategies import DEFAULT_STRATEGIES, STRATEGIES
 
-
 LOG = getLogger(__name__)
 
 
diff --git a/grizzly/reduce/bucket.py b/grizzly/reduce/bucket.py
index e33ecfad..ec342153 100644
--- a/grizzly/reduce/bucket.py
+++ b/grizzly/reduce/bucket.py
@@ -4,12 +4,11 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
 
-from .args import ReduceFuzzManagerIDQualityArgs
-from .crash import main as crash_main
 from ..common.fuzzmanager import Bucket
 from ..main import configure_logging
 from ..session import Session
-
+from .args import ReduceFuzzManagerIDQualityArgs
+from .crash import main as crash_main
 
 LOG = getLogger(__name__)
 
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 333ace21..d9aa6090 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -3,18 +3,19 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """`ReduceManager` finds the smallest testcase(s) to reproduce an issue."""
-from itertools import chain
 import json
+import os
+from itertools import chain
 from locale import LC_ALL, setlocale
 from logging import getLogger
 from math import ceil, log
-import os
 from pathlib import Path
 from shutil import rmtree
 from tempfile import mkdtemp
 from time import time
 
 from FTB.Signatures.CrashInfo import CrashSignature
+
 from sapphire import Sapphire
 
 from ..common.fuzzmanager import CrashEntry
@@ -24,12 +25,12 @@
 from ..main import configure_logging
 from ..replay import ReplayManager
 from ..session import Session
-from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
+from ..target import TargetLaunchError, TargetLaunchTimeout
+from ..target import load as load_target
 from .exceptions import GrizzlyReduceBaseException, NotReproducible
 from .stats import ReductionStats
 from .strategies import STRATEGIES
 
-
 __author__ = "Jesse Schwartzentruber"
 __credits__ = ["Jesse Schwartzentruber", "Tyson Smith"]
 
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index dc2b08f2..aa3ae201 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -4,13 +4,12 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
 
-from .args import ReduceFuzzManagerIDArgs
-from .core import ReduceManager
 from ..common.fuzzmanager import Bucket, CrashEntry
 from ..common.reporter import FuzzManagerReporter
 from ..main import configure_logging
 from ..session import Session
-
+from .args import ReduceFuzzManagerIDArgs
+from .core import ReduceManager
 
 LOG = getLogger(__name__)
 
diff --git a/grizzly/reduce/stats.py b/grizzly/reduce/stats.py
index 962b9fa3..1f3473a1 100644
--- a/grizzly/reduce/stats.py
+++ b/grizzly/reduce/stats.py
@@ -3,15 +3,14 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Keep statistics about reduction."""
+import json
+import re
 from collections import namedtuple
 from copy import deepcopy
 from functools import partial
 from itertools import zip_longest
-import json
-import re
 from time import time
 
-
 ReductionStat = namedtuple(
     "ReductionStat", "name, duration, successes, attempts, size, iterations")
 
diff --git a/grizzly/reduce/strategies/__init__.py b/grizzly/reduce/strategies/__init__.py
index 49f58200..ee6e9f69 100644
--- a/grizzly/reduce/strategies/__init__.py
+++ b/grizzly/reduce/strategies/__init__.py
@@ -26,7 +26,6 @@
 
 from ...common.utils import grz_tmp
 
-
 LOG = getLogger(__name__)
 
 
diff --git a/grizzly/reduce/strategies/beautify.py b/grizzly/reduce/strategies/beautify.py
index 7f03e0c0..f286fd4a 100644
--- a/grizzly/reduce/strategies/beautify.py
+++ b/grizzly/reduce/strategies/beautify.py
@@ -8,9 +8,9 @@
     HAVE_CSSBEAUTIFIER (bool): True if `cssbeautifier` module is available.
     HAVE_JSBEAUTIFIER (bool): True if `jsbeautifier` module is available.
 """
+import re
 from abc import ABC, abstractmethod
 from logging import getLogger
-import re
 
 from lithium.testcases import TestcaseLine
 
@@ -28,7 +28,6 @@
 from ...common.storage import TestCase
 from . import Strategy, _contains_dd
 
-
 LOG = getLogger(__name__)
 
 
diff --git a/grizzly/reduce/strategies/lithium.py b/grizzly/reduce/strategies/lithium.py
index c95e6e12..77f7c398 100644
--- a/grizzly/reduce/strategies/lithium.py
+++ b/grizzly/reduce/strategies/lithium.py
@@ -7,15 +7,16 @@
 from abc import ABC
 from logging import getLogger
 
-from lithium.strategies import CheckOnly, \
-    CollapseEmptyBraces as LithCollapseEmptyBraces, Minimize, Strategy as LithStrategy
-from lithium.testcases import TestcaseChar, TestcaseJsStr, TestcaseLine, \
-    Testcase as LithTestcase, TestcaseAttrs
+from lithium.strategies import CheckOnly
+from lithium.strategies import CollapseEmptyBraces as LithCollapseEmptyBraces
+from lithium.strategies import Minimize
+from lithium.strategies import Strategy as LithStrategy
+from lithium.testcases import Testcase as LithTestcase
+from lithium.testcases import TestcaseAttrs, TestcaseChar, TestcaseJsStr, TestcaseLine
 
 from ...common.storage import TestCase
 from . import Strategy, _contains_dd
 
-
 LOG = getLogger(__name__)
 
 
diff --git a/grizzly/reduce/strategies/testcases.py b/grizzly/reduce/strategies/testcases.py
index 3f80ff79..086efee0 100644
--- a/grizzly/reduce/strategies/testcases.py
+++ b/grizzly/reduce/strategies/testcases.py
@@ -9,7 +9,6 @@
 from ...common.storage import TestCase
 from . import Strategy
 
-
 LOG = getLogger(__name__)
 
 
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 1148d222..a2eb9c12 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -13,11 +13,10 @@
 
 from ..common import TestCaseLoadFailure
 from ..target import TargetLaunchError, TargetLaunchTimeout
-from .args import ReduceArgs
 from . import ReduceManager
+from .args import ReduceArgs
 from .exceptions import GrizzlyReduceBaseException
 
-
 LOG = getLogger(__name__)
 pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")
 
diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
index b3de0241..bd7488a1 100644
--- a/grizzly/reduce/test_main_fm.py
+++ b/grizzly/reduce/test_main_fm.py
@@ -8,9 +8,8 @@
 
 import pytest
 
-from .crash import main as crash_main
 from .bucket import main as bucket_main
-
+from .crash import main as crash_main
 
 LOG = getLogger(__name__)
 pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index b103ae07..92fff9ad 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -14,14 +14,14 @@
 from pytest import raises
 
 from sapphire import Sapphire
-from ..common import TestCase, Report
+
+from ..common import Report, TestCase
 from ..replay import ReplayResult
 from ..target import Target
 from . import ReduceManager
 from .exceptions import NotReproducible
 from .strategies import Strategy
 
-
 LOG = getLogger(__name__)
 pytestmark = pytest.mark.usefixtures("tmp_path_fm_config", "reporter_sequential_strftime")
 
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 988318f1..516d562a 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -12,14 +12,18 @@
 from pytest import raises
 
 from sapphire import Sapphire
-from ..common import TestCase, TestFile, Report
+
+from ..common import Report, TestCase, TestFile
 from ..replay import ReplayResult
 from ..target import Target
-from .strategies import _load_strategies, Strategy
-from .strategies.beautify import \
-    HAVE_CSSBEAUTIFIER, HAVE_JSBEAUTIFIER, CSSBeautify, JSBeautify
 from . import ReduceManager
-
+from .strategies import Strategy, _load_strategies
+from .strategies.beautify import (
+    HAVE_CSSBEAUTIFIER,
+    HAVE_JSBEAUTIFIER,
+    CSSBeautify,
+    JSBeautify,
+)
 
 LOG = getLogger(__name__)
 pytestmark = pytest.mark.usefixtures("tmp_path_fm_config",
diff --git a/grizzly/replay/__init__.py b/grizzly/replay/__init__.py
index 5e1048db..81c241fe 100644
--- a/grizzly/replay/__init__.py
+++ b/grizzly/replay/__init__.py
@@ -5,5 +5,5 @@
 
 __all__ = ("ReplayManager", "ReplayArgs", "ReplayResult")
 
-from .replay import ReplayManager, ReplayResult
 from .args import ReplayArgs
+from .replay import ReplayManager, ReplayResult
diff --git a/grizzly/replay/__main__.py b/grizzly/replay/__main__.py
index 9d7a2bdd..75b94a96 100644
--- a/grizzly/replay/__main__.py
+++ b/grizzly/replay/__main__.py
@@ -5,5 +5,4 @@
 from .args import ReplayArgs
 from .replay import ReplayManager
 
-
 raise SystemExit(ReplayManager.main(ReplayArgs().parse_args()))
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 69a13d9a..0b237289 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -4,21 +4,24 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from logging import getLogger
-from os.path import dirname, join as pathjoin
-from tempfile import mkdtemp
+from os.path import dirname
+from os.path import join as pathjoin
 from shutil import rmtree
+from tempfile import mkdtemp
 
 from FTB.Signatures.CrashInfo import CrashSignature
+
 from sapphire import Sapphire, ServerMap
 
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter, Report
 from ..common.runner import Runner, RunResult
 from ..common.status import Status
 from ..common.storage import TestCase, TestCaseLoadFailure, TestFile
-from ..common.utils import ConfigError, grz_tmp, TIMEOUT_DELAY
+from ..common.utils import TIMEOUT_DELAY, ConfigError, grz_tmp
 from ..main import configure_logging
 from ..session import Session
-from ..target import load as load_target, TargetLaunchError, TargetLaunchTimeout
+from ..target import TargetLaunchError, TargetLaunchTimeout
+from ..target import load as load_target
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index d4a613c9..1e9c36c6 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -13,11 +13,10 @@
 from sapphire import SERVED_ALL
 
 from ..common import Report, TestCase, TestCaseLoadFailure
-from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from ..replay import ReplayManager
 from ..replay.args import ReplayArgs
 from ..session import Session
-
+from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from .test_replay import _fake_save_logs
 
 
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 01321f80..1b1ded74 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -11,10 +11,11 @@
 
 from pytest import mark, raises
 
-from sapphire import Sapphire, SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
-from .replay import ReplayManager, ReplayResult
+from sapphire import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT, Sapphire
+
 from ..common import Report, Status, TestCase, TestCaseLoadFailure
 from ..target import Target
+from .replay import ReplayManager, ReplayResult
 
 
 def _fake_save_logs(result_logs, meta=False):  # pylint: disable=unused-argument
diff --git a/grizzly/session.py b/grizzly/session.py
index 92bf3255..ed9f6be3 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -8,7 +8,6 @@
 from .common import IOManager, Runner, RunResult, Status, TestFile
 from .target import TargetLaunchError
 
-
 __all__ = ("SessionError", "LogOutputLimiter", "Session")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
diff --git a/grizzly/target/__init__.py b/grizzly/target/__init__.py
index 63897969..adf315bd 100644
--- a/grizzly/target/__init__.py
+++ b/grizzly/target/__init__.py
@@ -5,9 +5,16 @@
 from logging import getLogger
 from sys import exc_info
 from traceback import extract_tb
+
 from pkg_resources import iter_entry_points
 
-from .target import sanitizer_opts, Target, TargetError, TargetLaunchError, TargetLaunchTimeout
+from .target import (
+    Target,
+    TargetError,
+    TargetLaunchError,
+    TargetLaunchTimeout,
+    sanitizer_opts,
+)
 
 __all__ = ("Target", "TargetError", "TargetLaunchError", "TargetLaunchTimeout",
            "available", "load", "sanitizer_opts")
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index d1cf46aa..894a8cb8 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -7,23 +7,22 @@
 from os.path import abspath, isfile
 from platform import system
 from signal import SIGABRT
+
 try:
     from signal import SIGUSR1
 except ImportError:
     SIGUSR1 = None
-from time import sleep, time
 from tempfile import mkdtemp, mkstemp
-
-from psutil import AccessDenied, NoSuchProcess, Process, process_iter
+from time import sleep, time
 
 from ffpuppet import BrowserTimeoutError, FFPuppet, LaunchError
 from prefpicker import PrefPicker
+from psutil import AccessDenied, NoSuchProcess, Process, process_iter
 
-from .target_monitor import TargetMonitor
-from .target import Target, TargetLaunchError, TargetLaunchTimeout, TargetError
 from ..common.reporter import Report
 from ..common.utils import grz_tmp
-
+from .target import Target, TargetError, TargetLaunchError, TargetLaunchTimeout
+from .target_monitor import TargetMonitor
 
 __all__ = ("PuppetTarget",)
 __author__ = "Tyson Smith"
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 348fde20..4ff5a044 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -8,7 +8,6 @@
 from re import split as resplit
 from threading import Lock
 
-
 __all__ = ("Target", "sanitizer_opts")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
diff --git a/grizzly/target/target_monitor.py b/grizzly/target/target_monitor.py
index 96c13967..bc346ec7 100644
--- a/grizzly/target/target_monitor.py
+++ b/grizzly/target/target_monitor.py
@@ -5,7 +5,6 @@
 from abc import ABCMeta, abstractmethod, abstractproperty
 from os import remove
 
-
 __all__ = ("TargetMonitor",)
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index d0a54bd4..5101dc22 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -6,13 +6,13 @@
 from os.path import isfile
 from platform import system
 
-from pytest import mark, raises
-
 from ffpuppet import BrowserTerminatedError, BrowserTimeoutError, FFPuppet
+from pytest import mark, raises
 
 from .puppet_target import PuppetTarget
 from .target import Target, TargetError, TargetLaunchError, TargetLaunchTimeout
 
+
 def test_puppet_target_01(mocker, tmp_path):
     """test creating a PuppetTarget"""
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index 220ed64f..6e11b557 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -3,7 +3,8 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
 
-from .target import sanitizer_opts, Target
+from .target import Target, sanitizer_opts
+
 
 class SimpleTarget(Target):
     def cleanup(self):
diff --git a/grizzly/target/test_target_loader.py b/grizzly/target/test_target_loader.py
index 49ca2a0d..833e5c08 100644
--- a/grizzly/target/test_target_loader.py
+++ b/grizzly/target/test_target_loader.py
@@ -8,7 +8,7 @@
 
 import pytest
 
-from grizzly.target import available, load, Target
+from grizzly.target import Target, available, load
 
 
 class _FakeTarget1(Target):  # pylint: disable=abstract-method
diff --git a/grizzly/target/test_target_monitor.py b/grizzly/target/test_target_monitor.py
index 73ddd066..53a8fd30 100644
--- a/grizzly/target/test_target_monitor.py
+++ b/grizzly/target/test_target_monitor.py
@@ -5,6 +5,7 @@
 
 from .target_monitor import TargetMonitor
 
+
 def test_target_monitor_01(tmp_path):
     """test a basic TargetMonitor"""
     class _BasicMonitor(TargetMonitor):
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index d44b7aa0..9caa1b61 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -7,6 +7,7 @@
 
 from .args import GrizzlyArgs
 
+
 def test_grizzly_args_01(capsys, tmp_path):
     """test GrizzlyArgs.parse_args()"""
     # test help
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 2bfde90d..6a950327 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -6,11 +6,13 @@
 from pytest import mark
 
 from sapphire import Sapphire
+
 from .common import Adapter
 from .main import main
 from .session import Session
 from .target import Target, TargetLaunchError
 
+
 class FakeArgs:
     def __init__(self):
         self.binary = None
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index b4d38128..9cbc81f7 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -8,7 +8,8 @@
 """
 from pytest import mark, raises
 
-from sapphire import Sapphire, SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT
+from sapphire import SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT, Sapphire
+
 from .common import Adapter, Report, Reporter, RunResult, Status
 from .session import LogOutputLimiter, Session, SessionError
 from .target import Target, TargetLaunchError
diff --git a/loki/__main__.py b/loki/__main__.py
index 854fc8b1..7722a49d 100644
--- a/loki/__main__.py
+++ b/loki/__main__.py
@@ -8,5 +8,4 @@
 from .args import parse_args
 from .loki import Loki
 
-
 raise SystemExit(Loki.main(parse_args()))
diff --git a/loki/args.py b/loki/args.py
index ecba9014..4252936e 100644
--- a/loki/args.py
+++ b/loki/args.py
@@ -3,8 +3,8 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from argparse import ArgumentParser
-from loki import Loki
 
+from loki import Loki
 
 __author__ = "Tyson Smith"
 
diff --git a/loki/loki.py b/loki/loki.py
index bf3f8b1c..d4764457 100644
--- a/loki/loki.py
+++ b/loki/loki.py
@@ -5,16 +5,17 @@
 """
 Loki fuzzing library
 """
-from logging import basicConfig, getLogger, ERROR, INFO
-from os import makedirs, SEEK_END
-from os.path import abspath, getsize, splitext, join as pathjoin
+from logging import ERROR, INFO, basicConfig, getLogger
+from os import SEEK_END, makedirs
+from os.path import abspath, getsize
+from os.path import join as pathjoin
+from os.path import splitext
 from random import choice, getrandbits, randint, sample
 from shutil import copy
 from struct import pack, unpack
-from tempfile import mkdtemp, SpooledTemporaryFile
+from tempfile import SpooledTemporaryFile, mkdtemp
 from time import strftime, time
 
-
 __author__ = "Tyson Smith"
 
 LOG = getLogger(__name__)
diff --git a/pyproject.toml b/pyproject.toml
index 81ec1bf7..6a2166d2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -19,9 +19,9 @@ exclude_lines = [
     "pragma: no cover",
 ]
 
-#[tool.isort]
-#known_first_party = "grizzly"
-#profile = "black"
+[tool.isort]
+known_first_party = "grizzly"
+profile = "black"
 
 [tool.pylint.format]
 max-line-length = 88
diff --git a/sapphire/__main__.py b/sapphire/__main__.py
index a5e81d15..a1c6b2ca 100644
--- a/sapphire/__main__.py
+++ b/sapphire/__main__.py
@@ -3,7 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from argparse import ArgumentParser
-from logging import basicConfig, DEBUG, INFO
+from logging import DEBUG, INFO, basicConfig
 from os.path import isdir
 
 from .core import Sapphire
diff --git a/sapphire/conftest.py b/sapphire/conftest.py
index eab968d9..d42ef5fa 100644
--- a/sapphire/conftest.py
+++ b/sapphire/conftest.py
@@ -3,7 +3,6 @@
 Sapphire unit test fixtures
 """
 import hashlib
-from http.client import BadStatusLine
 import logging
 import random
 import re
@@ -11,13 +10,13 @@
 import sys
 import threading
 import time
+from http.client import BadStatusLine
 from urllib.error import HTTPError, URLError
 from urllib.parse import quote
 from urllib.request import urlopen
 
 import pytest
 
-
 LOG = logging.getLogger(__name__)
 
 
diff --git a/sapphire/connection_manager.py b/sapphire/connection_manager.py
index d6cd7e79..edc7316a 100644
--- a/sapphire/connection_manager.py
+++ b/sapphire/connection_manager.py
@@ -4,7 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
 from sys import exc_info
-from threading import active_count, Thread, ThreadError
+from threading import Thread, ThreadError, active_count
 from time import sleep, time
 from traceback import format_exception
 
diff --git a/sapphire/core.py b/sapphire/core.py
index 1eaa8734..337e9a04 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -9,13 +9,11 @@
 from logging import getLogger
 from os.path import abspath
 from random import randint
-from socket import AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
-from socket import gethostname, socket
+from socket import AF_INET, SO_REUSEADDR, SOCK_STREAM, SOL_SOCKET, gethostname, socket
 from time import sleep, time
 
-from .job import Job, SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT
 from .connection_manager import ConnectionManager
-
+from .job import SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT, Job
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
diff --git a/sapphire/job.py b/sapphire/job.py
index 759f9dec..9328cab4 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -5,11 +5,13 @@
 """
 Sapphire HTTP server job
 """
-from mimetypes import guess_type
 from collections import defaultdict, namedtuple
 from logging import getLogger
+from mimetypes import guess_type
 from os import walk
-from os.path import abspath, isdir, isfile, join as pathjoin, normpath, relpath, splitext
+from os.path import abspath, isdir, isfile
+from os.path import join as pathjoin
+from os.path import normpath, relpath, splitext
 from queue import Queue
 from threading import Event, Lock
 
diff --git a/sapphire/test_job.py b/sapphire/test_job.py
index 0894adec..d60ec9ea 100644
--- a/sapphire/test_job.py
+++ b/sapphire/test_job.py
@@ -8,7 +8,7 @@
 
 import pytest
 
-from .job import Job, SERVED_ALL, SERVED_NONE, SERVED_REQUEST
+from .job import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, Job
 from .server_map import Resource, ServerMap
 
 
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 233abffd..b6931bf9 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -14,8 +14,8 @@
 
 from .core import Sapphire
 from .job import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
-from .worker import Worker
 from .server_map import ServerMap
+from .worker import Worker
 
 
 class _TestFile:
diff --git a/sapphire/test_worker.py b/sapphire/test_worker.py
index db9bf980..a910bd6c 100644
--- a/sapphire/test_worker.py
+++ b/sapphire/test_worker.py
@@ -12,6 +12,7 @@
 from .job import Job
 from .worker import Worker, WorkerError
 
+
 def test_worker_01(mocker):
     """test simple Worker in running state"""
     wthread = mocker.Mock(spec=threading.Thread)
diff --git a/sapphire/worker.py b/sapphire/worker.py
index 9991da3d..268b481d 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -9,9 +9,10 @@
 from os import stat
 from os.path import isfile
 from re import compile as re_compile
-from socket import error as sock_error, timeout as sock_timeout
+from socket import error as sock_error
+from socket import timeout as sock_timeout
 from sys import exc_info
-from threading import active_count, Thread, ThreadError
+from threading import Thread, ThreadError, active_count
 from time import sleep
 from urllib.parse import unquote_plus
 
diff --git a/tox.ini b/tox.ini
index 183db6ab..2ccdce75 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,5 +1,5 @@
 [tox]
-envlist = py{36,37,38,39} #,lint
+envlist = py{36,37,38,39},lint
 skip_missing_interpreters = true
 tox_pip_extensions_ext_venv_update = true
 
@@ -27,24 +27,24 @@ deps =
     coverage[toml]
 skip_install = true
 
-#[testenv:lint]
-#allowlist_externals =
-#    bash
-#commands =
-#    isort {toxinidir}
+[testenv:lint]
+allowlist_externals =
+    bash
+commands =
+    isort {toxinidir}
 #    black {toxinidir}
 #    codespell {toxinidir} --skip=".git,.tox,htmlcov,results"
 #    pylint {toxinidir}/grizzly
 #    pylint {toxinidir}/loki
 #    pylint {toxinidir}/sapphire
 #    flake8 {toxinidir}
-#deps =
-#    black
-#    codespell
-#    flake8
-#    isort
-#    pylint
-#usedevelop = true
+deps =
+    black
+    codespell
+    flake8
+    isort
+    pylint
+usedevelop = true
 
 [testenv:pypi]
 commands =

From 9e7a6b1c038ad1cd020c6b663f3a5cfc9f0467a6 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 18 Mar 2021 12:59:24 -0700
Subject: [PATCH 228/531] Enable codespell

---
 grizzly/common/runner.py          | 2 +-
 grizzly/reduce/test_strategies.py | 6 +++---
 sapphire/server_map.py            | 2 +-
 sapphire/test_server_map.py       | 2 +-
 tox.ini                           | 5 ++++-
 5 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 4a4d9048..971c73e7 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -107,7 +107,7 @@ def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
         Args:
             location (str): URL to open via Target.
             env_mod (dict): Environment modifications.
-            max_retries (int): Number of retries to preform before re-raising
+            max_retries (int): Number of retries to perform before re-raising
                                TargetLaunchTimeout.
             retry_delay (int): Time in seconds to wait between retries.
 
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 516d562a..995fca48 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -45,12 +45,12 @@ def update(self, success, served=None):
         src.duration = 1.2
         src.hang = is_hang
         src.add_from_data("123", "a.htm")
-        strat = _TestStrategy([src])
-    for attempt in strat:
+        strategy = _TestStrategy([src])
+    for attempt in strategy:
         assert len(attempt) == 1
         assert attempt[0].hang == is_hang
         attempt[0].cleanup()
-        strat.update(False)
+        strategy.update(False)
 
 
 def _fake_save_logs_foo(result_logs):
diff --git a/sapphire/server_map.py b/sapphire/server_map.py
index c96c196f..8e50886f 100644
--- a/sapphire/server_map.py
+++ b/sapphire/server_map.py
@@ -50,7 +50,7 @@ def _check_url(url):
         # check and sanitize URL
         url = url.strip("/")
         if re_search(r"\W", url) is not None:
-            raise InvalidURLError("Only alpha-numeric characters accepted in URL.")
+            raise InvalidURLError("Only alphanumeric characters accepted in URL.")
         return url
 
     def set_dynamic_response(self, url, callback, mime_type="application/octet-stream", required=False):
diff --git a/sapphire/test_server_map.py b/sapphire/test_server_map.py
index 45a6fe7e..a25c16c0 100644
--- a/sapphire/test_server_map.py
+++ b/sapphire/test_server_map.py
@@ -92,7 +92,7 @@ def test_servermap_05():
     """test ServerMap._check_url()"""
     assert ServerMap._check_url("test") == "test"
     assert ServerMap._check_url("") == ""
-    # only alpha-numeric is allowed
+    # only alphanumeric is allowed
     with pytest.raises(InvalidURLError):
         ServerMap._check_url("asd!@#")
     # '..' should not be accepted
diff --git a/tox.ini b/tox.ini
index 2ccdce75..8c342b20 100644
--- a/tox.ini
+++ b/tox.ini
@@ -33,7 +33,10 @@ allowlist_externals =
 commands =
     isort {toxinidir}
 #    black {toxinidir}
-#    codespell {toxinidir} --skip=".git,.tox,htmlcov,results"
+    # codespell trips over the regex in 'sapphire/worker.py' saying 'sHTTP ==> https'
+    # https://github.com/codespell-project/codespell/issues/1774
+    # ignoring it is broken so we need to ignore the file
+    codespell --skip=".git,.tox,htmlcov,results,./sapphire/worker.py" {toxinidir}
 #    pylint {toxinidir}/grizzly
 #    pylint {toxinidir}/loki
 #    pylint {toxinidir}/sapphire

From d82fc188dc4068eda40745553e5653e6573501ab Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 18 Mar 2021 14:33:22 -0700
Subject: [PATCH 229/531] Enable Black

---
 grizzly/__main__.py                    |   4 +-
 grizzly/adapters/__init__.py           |  25 +-
 grizzly/args.py                        | 189 ++++++++-----
 grizzly/common/__init__.py             |  21 +-
 grizzly/common/fuzzmanager.py          |  44 ++-
 grizzly/common/reporter.py             | 122 ++++++---
 grizzly/common/stack_hasher.py         |  52 +++-
 grizzly/common/status.py               |  20 +-
 grizzly/common/status_reporter.py      |  68 +++--
 grizzly/common/storage.py              |  85 ++++--
 grizzly/common/test_adapter.py         |  11 +-
 grizzly/common/test_fuzzmanager.py     |  12 +-
 grizzly/common/test_iomanager.py       |  20 +-
 grizzly/common/test_reporter.py        | 151 ++++++++---
 grizzly/common/test_runner.py          |  32 ++-
 grizzly/common/test_stack_hasher.py    | 292 ++++++++++++++------
 grizzly/common/test_status.py          |  20 +-
 grizzly/common/test_status_reporter.py |  78 ++++--
 grizzly/common/test_storage.py         |  85 ++++--
 grizzly/common/test_utils.py           |   4 +-
 grizzly/common/utils.py                |   1 +
 grizzly/main.py                        |  21 +-
 grizzly/reduce/args.py                 |  41 +--
 grizzly/reduce/conftest.py             |   1 +
 grizzly/reduce/core.py                 | 362 ++++++++++++++++---------
 grizzly/reduce/crash.py                |   4 +-
 grizzly/reduce/exceptions.py           |   2 +
 grizzly/reduce/stats.py                |  46 +++-
 grizzly/reduce/strategies/__init__.py  |  14 +-
 grizzly/reduce/strategies/beautify.py  |  53 ++--
 grizzly/reduce/strategies/lithium.py   |  26 +-
 grizzly/reduce/strategies/testcases.py |  22 +-
 grizzly/reduce/test_main.py            |  45 ++-
 grizzly/reduce/test_main_fm.py         |  15 +-
 grizzly/reduce/test_reduce.py          | 211 ++++++++++----
 grizzly/reduce/test_strategies.py      | 322 ++++++++++++++--------
 grizzly/replay/args.py                 |  94 ++++---
 grizzly/replay/replay.py               | 204 +++++++++-----
 grizzly/replay/test_main.py            | 115 +++++---
 grizzly/replay/test_replay.py          | 227 ++++++++++++----
 grizzly/session.py                     |  44 ++-
 grizzly/target/__init__.py             |  34 ++-
 grizzly/target/puppet_target.py        |  28 +-
 grizzly/target/target.py               |  12 +-
 grizzly/target/test_puppet_target.py   |  65 ++++-
 grizzly/target/test_target.py          |  13 +-
 grizzly/target/test_target_loader.py   |  72 +++--
 grizzly/target/test_target_monitor.py  |   6 +
 grizzly/test_args.py                   |   7 +-
 grizzly/test_main.py                   |  18 +-
 grizzly/test_session.py                |  33 ++-
 loki/args.py                           |  44 ++-
 loki/loki.py                           |   9 +-
 loki/test_loki.py                      |  19 +-
 sapphire/__init__.py                   |   9 +-
 sapphire/__main__.py                   |  30 +-
 sapphire/conftest.py                   |  64 ++++-
 sapphire/connection_manager.py         |  10 +-
 sapphire/core.py                       |  23 +-
 sapphire/job.py                        |  55 +++-
 sapphire/server_map.py                 |  27 +-
 sapphire/test_connection_manager.py    |   8 +-
 sapphire/test_job.py                   |  38 ++-
 sapphire/test_sapphire.py              | 140 ++++++++--
 sapphire/test_server_map.py            |  12 +-
 sapphire/test_worker.py                |  12 +-
 sapphire/worker.py                     |  65 +++--
 tox.ini                                |   2 +-
 68 files changed, 2837 insertions(+), 1223 deletions(-)

diff --git a/grizzly/__main__.py b/grizzly/__main__.py
index 2bd06ec2..2b437d58 100644
--- a/grizzly/__main__.py
+++ b/grizzly/__main__.py
@@ -19,8 +19,8 @@
 # is where basicConfig should be called).
 if getenv("DEBUG"):
     basicConfig(
-        format="%(asctime)s %(levelname).1s %(name)s | %(message)s",
-        level=DEBUG)
+        format="%(asctime)s %(levelname).1s %(name)s | %(message)s", level=DEBUG
+    )
 # load Adapters
 load()
 raise SystemExit(main(GrizzlyArgs().parse_args()))
diff --git a/grizzly/adapters/__init__.py b/grizzly/adapters/__init__.py
index d8cbd1e1..b71ae222 100644
--- a/grizzly/adapters/__init__.py
+++ b/grizzly/adapters/__init__.py
@@ -14,9 +14,11 @@
 __all__ = ("get", "load", "names")
 __adapters__ = dict()
 
+
 def get(name):
     return __adapters__.get(name.lower(), None)
 
+
 def load(path=None, skip_failures=True):
     assert not __adapters__, "adapters have already been loaded"
     if path is None:
@@ -35,7 +37,13 @@ def load(path=None, skip_failures=True):
                 raise
             exc_type, exc_obj, exc_tb = exc_info()
             tbinfo = extract_tb(exc_tb)[-1]
-            LOG.debug("raised %s: %s (%s:%d)", exc_type.__name__, exc_obj, tbinfo[0], tbinfo[1])
+            LOG.debug(
+                "raised %s: %s (%s:%d)",
+                exc_type.__name__,
+                exc_obj,
+                tbinfo[0],
+                tbinfo[1],
+            )
             continue
         for clsname in dir(lib):
             cls = getattr(lib, clsname)
@@ -45,20 +53,23 @@ def load(path=None, skip_failures=True):
                 LOG.debug("sanity checking %r", clsname)
                 if not isinstance(cls.NAME, str):
                     raise RuntimeError(
-                        "%s.NAME must be 'str' not %r" % (cls.__name__, type(cls.NAME).__name__))
+                        "%s.NAME must be 'str' not %r"
+                        % (cls.__name__, type(cls.NAME).__name__)
+                    )
                 if cls.NAME.lower() != cls.NAME:
                     raise RuntimeError(
-                        "%s.NAME %r must be lowercase" % (cls.__name__, cls.NAME))
+                        "%s.NAME %r must be lowercase" % (cls.__name__, cls.NAME)
+                    )
                 if cls.NAME in __adapters__:
                     raise RuntimeError(
-                        "Name collision! %r is used by %r and %r" % (
-                            cls.NAME,
-                            __adapters__[cls.NAME].__name__,
-                            cls.__name__))
+                        "Name collision! %r is used by %r and %r"
+                        % (cls.NAME, __adapters__[cls.NAME].__name__, cls.__name__)
+                    )
                 __adapters__[cls.NAME] = cls
         else:
             LOG.debug("ignored %r", sub)
     LOG.debug("%d adapters loaded", len(__adapters__))
 
+
 def names():
     return __adapters__.keys()
diff --git a/grizzly/args.py b/grizzly/args.py
index ae5cbef7..cd7a635f 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -42,80 +42,115 @@ def __init__(self):
             "ERROR": ERROR,
             "WARN": WARNING,
             "INFO": INFO,
-            "DEBUG": DEBUG}
+            "DEBUG": DEBUG,
+        }
         self._sanity_skip = set()
 
         if not hasattr(self, "parser"):
             self.parser = ArgumentParser(
-                formatter_class=SortingHelpFormatter,
-                conflict_handler='resolve')
+                formatter_class=SortingHelpFormatter, conflict_handler="resolve"
+            )
 
+        self.parser.add_argument("binary", help="Firefox binary to run")
         self.parser.add_argument(
-            "binary",
-            help="Firefox binary to run")
-        self.parser.add_argument(
-            "--log-level", default="INFO",
-            help="Configure console logging. Options: %s (default: %%(default)s)" %
-            ", ".join(k for k, v in sorted(self._level_map.items(), key=lambda x: x[1])))
+            "--log-level",
+            default="INFO",
+            help="Configure console logging. Options: %s (default: %%(default)s)"
+            % ", ".join(
+                k for k, v in sorted(self._level_map.items(), key=lambda x: x[1])
+            ),
+        )
 
         self.launcher_grp = self.parser.add_argument_group("Launcher Arguments")
         self.launcher_grp.add_argument(
-            "-e", "--extension", action="append",
+            "-e",
+            "--extension",
+            action="append",
             help="Install an extension. Specify the path to the xpi or the directory"
-                 " containing the unpacked extension. To install multiple extensions"
-                 " specify multiple times")
-        self.launcher_grp.add_argument(
-            "--launch-timeout", type=int, default=300,
-            help="Number of seconds to wait before LaunchError is raised (default: %(default)s)")
+            " containing the unpacked extension. To install multiple extensions"
+            " specify multiple times",
+        )
         self.launcher_grp.add_argument(
-            "--log-limit", type=int, default=0,
-            help="Browser log file size limit in MBs (default: 'no limit')")
+            "--launch-timeout",
+            type=int,
+            default=300,
+            help="Number of seconds to wait before LaunchError is raised"
+            " (default: %(default)s)",
+        )
         self.launcher_grp.add_argument(
-            "-m", "--memory", type=int, default=0,
-            help="Browser process memory limit in MBs (default: 'no limit')")
+            "--log-limit",
+            type=int,
+            default=0,
+            help="Browser log file size limit in MBs (default: 'no limit')",
+        )
         self.launcher_grp.add_argument(
-            "--platform", default="ffpuppet",
-            help="Platforms available: %s (default: %%(default)s)" % ", ".join(available_targets()))
+            "-m",
+            "--memory",
+            type=int,
+            default=0,
+            help="Browser process memory limit in MBs (default: 'no limit')",
+        )
         self.launcher_grp.add_argument(
-            "-p", "--prefs",
-            help="prefs.js file to use")
+            "--platform",
+            default="ffpuppet",
+            help="Platforms available: %s (default: %%(default)s)"
+            % ", ".join(available_targets()),
+        )
+        self.launcher_grp.add_argument("-p", "--prefs", help="prefs.js file to use")
         self.launcher_grp.add_argument(
-            "--relaunch", type=int, default=1000,
-            help="Number of iterations performed before relaunching the browser (default: %(default)s)")
+            "--relaunch",
+            type=int,
+            default=1000,
+            help="Number of iterations performed before relaunching the browser"
+            " (default: %(default)s)",
+        )
         self.launcher_grp.add_argument(
-            "--time-limit", type=int, default=None,
+            "--time-limit",
+            type=int,
+            default=None,
             help="This is the maximum amount of time that a test is expected to take."
-                 " After the time has elapsed the harness will attempt to close the test."
-                 " By default `Adapter.TIME_LIMIT` is used."
-                 " Browser build types and debuggers can affect the amount of time"
-                 " required to run a test case.")
+            " After the time has elapsed the harness will attempt to close the test."
+            " By default `Adapter.TIME_LIMIT` is used."
+            " Browser build types and debuggers can affect the amount of time"
+            " required to run a test case.",
+        )
         self.launcher_grp.add_argument(
-            "-t", "--timeout", type=int, default=None,
+            "-t",
+            "--timeout",
+            type=int,
+            default=None,
             help="Iteration timeout in seconds. By default this is `test-duration`+%ds."
-                 " If the timeout is reached the target is assumed to be in a bad state"
-                 " and will be closed. Typically this should be a few seconds greater"
-                 " than the value used for `test-duration`." % (TIMEOUT_DELAY,))
+            " If the timeout is reached the target is assumed to be in a bad state"
+            " and will be closed. Typically this should be a few seconds greater"
+            " than the value used for `test-duration`." % (TIMEOUT_DELAY,),
+        )
         self.launcher_grp.add_argument(
-            "--valgrind", action="store_true",
-            help="Use Valgrind (Linux only)")
+            "--valgrind", action="store_true", help="Use Valgrind (Linux only)"
+        )
         self.launcher_grp.add_argument(
-            "--xvfb", action="store_true",
-            help="Use Xvfb (Linux only)")
+            "--xvfb", action="store_true", help="Use Xvfb (Linux only)"
+        )
 
         self.reporter_grp = self.parser.add_argument_group("Reporter Arguments")
         self.reporter_grp.add_argument(
-            "--fuzzmanager", action="store_true",
-            help="Report results to FuzzManager")
+            "--fuzzmanager", action="store_true", help="Report results to FuzzManager"
+        )
         self.reporter_grp.add_argument(
-            "--ignore", nargs="*", default=list(self.IGNORE),
+            "--ignore",
+            nargs="*",
+            default=list(self.IGNORE),
             help="Space separated list of issue types to ignore. Valid options: %s"
-                 " (default: %s)" % (" ".join(self.IGNORABLE), " ".join(self.IGNORE)))
+            " (default: %s)" % (" ".join(self.IGNORABLE), " ".join(self.IGNORE)),
+        )
         self.reporter_grp.add_argument(
             "--tool",
-            help="Override tool name used when reporting issues to FuzzManager")
+            help="Override tool name used when reporting issues to FuzzManager",
+        )
 
-        self.parser.epilog = "For addition help check out the wiki:" \
+        self.parser.epilog = (
+            "For addition help check out the wiki:"
             " https://github.com/MozillaSecurity/grizzly/wiki"
+        )
 
     def parse_args(self, argv=None):
         args = self.parser.parse_args(argv)
@@ -123,7 +158,7 @@ def parse_args(self, argv=None):
         return args
 
     def sanity_check(self, args):
-        if hasattr(super(), 'sanity_check'):
+        if hasattr(super(), "sanity_check"):
             super().sanity_check(args)
 
         if "binary" not in self._sanity_skip and not isfile(args.binary):
@@ -188,38 +223,54 @@ def __init__(self):
         self._adapters = sorted(adapter_names())
         self._sanity_skip.add("tool")
         self.parser.add_argument(
-            "adapter",
-            help="Available adapters: %s" % ", ".join(self._adapters))
+            "adapter", help="Available adapters: %s" % ", ".join(self._adapters)
+        )
         self.parser.add_argument(
-            "--enable-profiling", action="store_true",
+            "--enable-profiling",
+            action="store_true",
             help="Record profiling data. The data can be viewed by running the"
-                 " status reporter while running Grizzly.")
+            " status reporter while running Grizzly.",
+        )
         self.parser.add_argument(
-            "-i", "--input",
-            help="Test case or directory containing test cases")
+            "-i", "--input", help="Test case or directory containing test cases"
+        )
         self.parser.add_argument(
-            "--limit", type=int, default=0,
-            help="Maximum number of iterations to be performed. (default: no limit)")
+            "--limit",
+            type=int,
+            default=0,
+            help="Maximum number of iterations to be performed. (default: no limit)",
+        )
         self.parser.add_argument(
-            "-v", "--verbose", action="store_true",
+            "-v",
+            "--verbose",
+            action="store_true",
             help="Output console updates every iteration. By default the number"
-                 " of iterations between console updates doubles each update."
-                 " Updates are always printed when a result is detected or the"
-                 " target is relaunched.")
+            " of iterations between console updates doubles each update."
+            " Updates are always printed when a result is detected or the"
+            " target is relaunched.",
+        )
 
         self.launcher_grp.add_argument(
-            "--coverage", action="store_true",
-            help="Enable coverage collection")
+            "--coverage", action="store_true", help="Enable coverage collection"
+        )
         self.launcher_grp.add_argument(
-            "--rr", action="store_true",
-            help="Use RR (Linux only)")
+            "--rr", action="store_true", help="Use RR (Linux only)"
+        )
 
         self.reporter_grp.add_argument(
-            "-c", "--collect", type=int, default=1,
-            help="Maximum number of test cases to include in the report (default: %(default)s)")
+            "-c",
+            "--collect",
+            type=int,
+            default=1,
+            help="Maximum number of test cases to include in the report"
+            "(default: %(default)s)",
+        )
         self.reporter_grp.add_argument(
-            "--s3-fuzzmanager", action="store_true",
-            help="Report large attachments (if any) to S3 and then the crash & S3 link to FuzzManager")
+            "--s3-fuzzmanager",
+            action="store_true",
+            help="Report large attachments (if any) to S3 and then the crash &"
+            " S3 link to FuzzManager",
+        )
 
     def sanity_check(self, args):
         super().sanity_check(args)
@@ -236,13 +287,17 @@ def sanity_check(self, args):
             self.parser.error("--collect must be greater than 0")
 
         if args.fuzzmanager and args.s3_fuzzmanager:
-            self.parser.error("--fuzzmanager and --s3-fuzzmanager are mutually exclusive")
+            self.parser.error(
+                "--fuzzmanager and --s3-fuzzmanager are mutually exclusive"
+            )
 
         if args.limit < 0:
             self.parser.error("--limit must be >= 0 (0 = no limit)")
 
         if args.tool is not None and not (args.fuzzmanager or args.s3_fuzzmanager):
-            self.parser.error("--tool can only be given with --fuzzmanager/--s3-fuzzmanager")
+            self.parser.error(
+                "--tool can only be given with --fuzzmanager/--s3-fuzzmanager"
+            )
 
         if args.rr and args.valgrind:
             self.parser.error("'--rr' and '--valgrind' cannot be used together")
diff --git a/grizzly/common/__init__.py b/grizzly/common/__init__.py
index eb5de6a7..f88daeb6 100644
--- a/grizzly/common/__init__.py
+++ b/grizzly/common/__init__.py
@@ -18,8 +18,23 @@
 from .utils import grz_tmp
 
 __all__ = (
-    "Adapter", "AdapterError", "FilesystemReporter", "FuzzManagerReporter", "grz_tmp", "IOManager",
-    "Report", "Reporter", "Runner", "RunResult", "S3FuzzManagerReporter",
-    "ServerMap", "Status", "TestCase", "TestCaseLoadFailure", "TestFile", "TestFileExists")
+    "Adapter",
+    "AdapterError",
+    "FilesystemReporter",
+    "FuzzManagerReporter",
+    "grz_tmp",
+    "IOManager",
+    "Report",
+    "Reporter",
+    "Runner",
+    "RunResult",
+    "S3FuzzManagerReporter",
+    "ServerMap",
+    "Status",
+    "TestCase",
+    "TestCaseLoadFailure",
+    "TestFile",
+    "TestFileExists",
+)
 __author__ = "Jesse Schwartzentruber"
 __credits__ = ["Jesse Schwartzentruber", "Tyson Smith"]
diff --git a/grizzly/common/fuzzmanager.py b/grizzly/common/fuzzmanager.py
index 814b2ff2..410b9f3c 100644
--- a/grizzly/common/fuzzmanager.py
+++ b/grizzly/common/fuzzmanager.py
@@ -93,14 +93,22 @@ def _get_results(endpoint, params=None):
             """
             LOG.debug("first request to /%s/", endpoint)
 
-            url = "%s://%s:%d/crashmanager/rest/%s/" \
-                % (self._coll.serverProtocol, self._coll.serverHost,
-                   self._coll.serverPort, endpoint)
+            url = "%s://%s:%d/crashmanager/rest/%s/" % (
+                self._coll.serverProtocol,
+                self._coll.serverHost,
+                self._coll.serverPort,
+                endpoint,
+            )
 
             response = self._coll.get(url, params=params).json()
 
             while True:
-                LOG.debug("got %d/%d %s", len(response["results"]), response["count"], endpoint)
+                LOG.debug(
+                    "got %d/%d %s",
+                    len(response["results"]),
+                    response["count"],
+                    endpoint,
+                )
                 while response["results"]:
                     yield response["results"].pop()
 
@@ -120,7 +128,9 @@ def _get_results(endpoint, params=None):
         query = json.dumps(dict(query_args))
 
         n_yielded = 0
-        for crash in _get_results("crashes", params={"query": query, "include_raw": "0"}):
+        for crash in _get_results(
+            "crashes", params={"query": query, "include_raw": "0"}
+        ):
 
             if not crash["testcase"]:
                 LOG.warning("crash %d has no testcase, skipping", crash["id"])
@@ -144,8 +154,11 @@ def signature_path(self):
         if self._sig_filename is not None:
             return self._sig_filename
 
-        tmpd = Path(mkdtemp(prefix="bucket-%d-" % (self._bucket_id,),
-                            dir=grz_tmp("fuzzmanager")))
+        tmpd = Path(
+            mkdtemp(
+                prefix="bucket-%d-" % (self._bucket_id,), dir=grz_tmp("fuzzmanager")
+            )
+        )
         try:
             sig_basename = "%d.signature" % (self._bucket_id,)
             sig_filename = tmpd / sig_basename
@@ -176,6 +189,7 @@ class CrashEntry:
         crash_id (int): the server ID for the crash
         see crashmanager.serializers.CrashEntrySerializer
     """
+
     RAW_FIELDS = frozenset({"rawCrashData", "rawStderr", "rawStdout"})
 
     def __init__(self, crash_id):
@@ -202,7 +216,9 @@ def crash_id(self):
     def __getattr__(self, name):
         if self._data is None or (name in self.RAW_FIELDS and name not in self._data):
             need_raw = "1" if name in self.RAW_FIELDS else "0"
-            self._data = self._coll.get(self._url, params={"include_raw": need_raw}).json()
+            self._data = self._coll.get(
+                self._url, params={"include_raw": need_raw}
+            ).json()
         if name not in self._data:
             raise AttributeError(
                 "'%s' object has no attribute '%s' (has: %s)"
@@ -248,10 +264,14 @@ def testcase_path(self):
         response = self._coll.get(dlurl)
 
         if "content-disposition" not in response.headers:
-            raise RuntimeError("Server sent malformed response: %r" % (response,))  # pragma: no cover
-
-        handle, filename = mkstemp(dir=grz_tmp("fuzzmanager"),
-            prefix="crash-%d-" % (self.crash_id,), suffix=Path(self.testcase).suffix
+            raise RuntimeError(
+                "Server sent malformed response: %r" % (response,)
+            )  # pragma: no cover
+
+        handle, filename = mkstemp(
+            dir=grz_tmp("fuzzmanager"),
+            prefix="crash-%d-" % (self.crash_id,),
+            suffix=Path(self.testcase).suffix,
         )
         try:
             with open(handle, "wb") as output:
diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 340409d1..9159c931 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -32,6 +32,7 @@
 try:
     from boto3 import resource
     from botocore.exceptions import ClientError
+
     _boto_import_error = None  # pylint: disable=invalid-name
     getLogger("botocore").setLevel(WARNING)
     getLogger("boto3").setLevel(WARNING)
@@ -42,7 +43,12 @@
 from .stack_hasher import Stack
 from .utils import grz_tmp
 
-__all__ = ("FilesystemReporter", "FuzzManagerReporter", "Report", "S3FuzzManagerReporter")
+__all__ = (
+    "FilesystemReporter",
+    "FuzzManagerReporter",
+    "Report",
+    "S3FuzzManagerReporter",
+)
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
@@ -58,8 +64,16 @@ class Report:
     HANG_STACK_HEIGHT = 10
     MAX_LOG_SIZE = 1048576  # 1MB
 
-    __slots__ = ("_crash_info", "_logs", "_signature",  "_target_binary",
-                 "is_hang", "path", "prefix", "stack")
+    __slots__ = (
+        "_crash_info",
+        "_logs",
+        "_signature",
+        "_target_binary",
+        "is_hang",
+        "path",
+        "prefix",
+        "stack",
+    )
 
     def __init__(self, log_path, target_binary, is_hang=False, size_limit=MAX_LOG_SIZE):
         assert isinstance(log_path, str)
@@ -146,7 +160,9 @@ def crash_info(self):
             # read in the log files and create a CrashInfo object
             if self._logs.aux is not None:
                 with open(self._logs.aux, "rb") as log_fp:
-                    aux_data = log_fp.read().decode("utf-8", errors="ignore").splitlines()
+                    aux_data = (
+                        log_fp.read().decode("utf-8", errors="ignore").splitlines()
+                    )
             else:
                 aux_data = None
             # create ProgramConfiguration that can be reported to a FM server
@@ -162,13 +178,17 @@ def crash_info(self):
                 fm_cfg = ProgramConfiguration(
                     basename(self._target_binary),
                     "x86_64" if cpu == "amd64" else cpu,
-                    system())
-            with open(self._logs.stderr, "rb") as err_fp, open(self._logs.stdout, "rb") as out_fp:
+                    system(),
+                )
+            with open(self._logs.stderr, "rb") as err_fp, open(
+                self._logs.stdout, "rb"
+            ) as out_fp:
                 self._crash_info = CrashInfo.fromRawCrashData(
                     out_fp.read().decode("utf-8", errors="ignore").splitlines(),
                     err_fp.read().decode("utf-8", errors="ignore").splitlines(),
                     fm_cfg,
-                    auxCrashData=aux_data)
+                    auxCrashData=aux_data,
+                )
         return self._crash_info
 
     @property
@@ -183,14 +203,15 @@ def crash_signature(self):
         """
         if self._signature is None:
             self._signature = self.crash_info.createCrashSignature(
-                maxFrames=self.crash_signature_max_frames(self.crash_info))
+                maxFrames=self.crash_signature_max_frames(self.crash_info)
+            )
         return self._signature
 
     @staticmethod
     def crash_signature_max_frames(crash_info, suggested_frames=8):
         if set(crash_info.backtrace) & {
-                "std::panicking::rust_panic",
-                "std::panicking::rust_panic_with_hook",
+            "std::panicking::rust_panic",
+            "std::panicking::rust_panic_with_hook",
         }:
             # rust panic adds 5-6 frames of noise at the top of the stack
             suggested_frames += 6
@@ -224,7 +245,9 @@ def _find_minidump(logs):
         Returns:
             str: The full file path if a match is found otherwise None.
         """
-        re_dump_req = re_compile(r"\d+\|0\|.+?\|google_breakpad::ExceptionHandler::WriteMinidump")
+        re_dump_req = re_compile(
+            r"\d+\|0\|.+?\|google_breakpad::ExceptionHandler::WriteMinidump"
+        )
         for fname in (x for x in logs if "minidump" in x):
             with open(fname, "r") as log_fp:
                 data = log_fp.read(65536)
@@ -248,10 +271,13 @@ def _find_sanitizer(logs):
         """
         # pattern to identify the ASan crash triggered when the parent process goes away
         # TODO: this may no longer be required
-        re_e10s_forced = re_compile(r"""
+        re_e10s_forced = re_compile(
+            r"""
             ==\d+==ERROR:.+?SEGV\son.+?0x[0]+\s\(.+?T2\).+?
             #0\s+0x[0-9a-f]+\sin\s+mozilla::ipc::MessageChannel::OnChannelErrorFromLink
-            """, DOTALL | VERBOSE)
+            """,
+            DOTALL | VERBOSE,
+        )
         # this is a list of Sanitizer error reports to prioritize
         # Sanitizer reports not included below are deprioritized
         prioritize_tokens = (
@@ -261,7 +287,8 @@ def _find_sanitizer(logs):
             "access-violation on ",
             "attempting free on ",
             "negative-size-param",
-            "-param-overlap")
+            "-param-overlap",
+        )
         found = None
         for fname in (x for x in logs if "asan" in x):
             with open(fname, "r") as log_fp:
@@ -481,7 +508,9 @@ def _submit_report(self, report, test_cases):
         # avoid filling the disk
         free_space = disk_usage(log_path).free
         if free_space < self.DISK_SPACE_ABORT:
-            raise RuntimeError("Running low on disk space (%0.1fMB)" % (free_space / 1048576.0,))
+            raise RuntimeError(
+                "Running low on disk space (%0.1fMB)" % (free_space / 1048576.0,)
+            )
         return dest_path
 
 
@@ -496,7 +525,7 @@ class FuzzManagerReporter(Reporter):
     QUAL_REDUCING = 4  # the testcase is currently being reduced
     QUAL_UNREDUCED = 5  # haven't attempted reduction yet (1st attempt, generic reducer)
     QUAL_REQUEST_SPECIFIC = 6  # platform specific reduction requested (2nd attempt)
-    QUAL_NO_TESTCASE = 7  # no testcase was detected (could be the "testcase" is not a testcase)
+    QUAL_NO_TESTCASE = 7  # testcase not detected ("testcase" not a testcase?)
     QUAL_REDUCER_BROKE = 8  # the testcase was reproducible, but broke during reduction
     QUAL_REDUCER_ERROR = 9  # reducer error
     QUAL_NOT_REPRODUCIBLE = 10  # could not reproduce the testcase
@@ -531,15 +560,15 @@ def add_extra_metadata(self, key, value):
 
         Arguments:
             key (str): key for this data in the metadata dict
-            value (object): JSON serializable object to be included in the FM crash metadata.
-                            The object will be deep-copied.
+            value (object): JSON serializable object to be included in the FM crash
+                            metadata. The object will be deep-copied.
 
         Returns:
             None
         """
         assert isinstance(key, str)
         assert key not in self._extra_metadata
-        # this not only does a deep copy, but also ensures that value is JSON serializable
+        # deep copy and ensure that value is JSON serializable
         self._extra_metadata[key] = loads(dumps(value))
 
     @classmethod
@@ -557,7 +586,7 @@ def _process_rr_trace(self, report):
         trace_path = pathjoin(report.path, "rr-traces")
         if isdir(trace_path):
             LOG.info("Ignored rr trace")
-            self.add_extra_metadata("rr-trace",  "ignored")
+            self.add_extra_metadata("rr-trace", "ignored")
             # remove traces so they are not uploaded to FM (because they are huge)
             # use S3FuzzManagerReporter instead
             rmtree(trace_path)
@@ -568,9 +597,7 @@ def _ignored(report):
         # that were caused by system OOM or bogus other crashes
         with open(report.preferred, "rb") as log_fp:
             log_data = log_fp.read().decode("utf-8", errors="ignore")
-        mem_errs = (
-            "ERROR: Failed to mmap",
-            ": AddressSanitizer failed to allocate")
+        mem_errs = ("ERROR: Failed to mmap", ": AddressSanitizer failed to allocate")
         # ignore sanitizer OOMs missing stack
         for msg in mem_errs:
             if msg in log_data and "#0 " not in log_data:
@@ -588,14 +615,18 @@ def _submit_report(self, report, test_cases):
             cache_sig_file, cache_metadata = collector.search(report.crash_info)
             if cache_metadata is not None:
                 if cache_metadata["frequent"]:
-                    LOG.info("Frequent crash matched existing signature: %s",
-                             cache_metadata["shortDescription"])
+                    LOG.info(
+                        "Frequent crash matched existing signature: %s",
+                        cache_metadata["shortDescription"],
+                    )
                     if not self.force_report:
                         return None
                 elif "bug__id" in cache_metadata:
-                    LOG.info("Crash matched existing signature (bug %s): %s",
-                             cache_metadata["bug__id"],
-                             cache_metadata["shortDescription"])
+                    LOG.info(
+                        "Crash matched existing signature (bug %s): %s",
+                        cache_metadata["bug__id"],
+                        cache_metadata["shortDescription"],
+                    )
                     # we will still report this one, but no more
                     cache_metadata["frequent"] = True
                 # there is already a signature, initialize count
@@ -604,11 +635,14 @@ def _submit_report(self, report, test_cases):
                 # there is no signature, create one locally so we can count
                 # the number of times we've seen it
                 max_frames = report.crash_signature_max_frames(report.crash_info)
-                cache_sig_file = collector.generate(report.crash_info, numFrames=max_frames)
+                cache_sig_file = collector.generate(
+                    report.crash_info, numFrames=max_frames
+                )
                 cache_metadata = {
                     "_grizzly_seen_count": 0,
                     "frequent": False,
-                    "shortDescription": report.crash_info.createShortSignature()}
+                    "shortDescription": report.crash_info.createShortSignature(),
+                }
             if cache_sig_file is None:
                 if self._ignored(report):
                     LOG.info("Report is unsupported and is in ignore list")
@@ -636,10 +670,16 @@ def _submit_report(self, report, test_cases):
             if not isdir(dump_path):
                 mkdir(dump_path)
             test_case.dump(dump_path, include_details=True)
-        report.crash_info.configuration.addMetadata({"grizzly_input": repr(test_case_meta)})
+        report.crash_info.configuration.addMetadata(
+            {"grizzly_input": repr(test_case_meta)}
+        )
         if test_cases:
-            environ_string = " ".join("=".join(kv) for kv in test_cases[0].env_vars.items())
-            report.crash_info.configuration.addMetadata({"recorded_envvars": environ_string})
+            environ_string = " ".join(
+                "=".join(kv) for kv in test_cases[0].env_vars.items()
+            )
+            report.crash_info.configuration.addMetadata(
+                {"recorded_envvars": environ_string}
+            )
         else:
             self.quality = self.QUAL_NO_TESTCASE
         report.crash_info.configuration.addMetadata(self._extra_metadata)
@@ -661,17 +701,23 @@ def _submit_report(self, report, test_cases):
                 for file_name in dir_files:
                     zip_fp.write(
                         pathjoin(dir_name, file_name),
-                        arcname=pathjoin(arc_path, file_name))
+                        arcname=pathjoin(arc_path, file_name),
+                    )
 
         # override tool name if specified
         if self.tool is not None:
             collector.tool = self.tool
 
         # announce shortDescription if crash is not in a bucket
-        if cache_metadata["_grizzly_seen_count"] == 1 and not cache_metadata["frequent"]:
+        if (
+            cache_metadata["_grizzly_seen_count"] == 1
+            and not cache_metadata["frequent"]
+        ):
             LOG.info("Submitting new crash %r", cache_metadata["shortDescription"])
         # submit results to the FuzzManager server
-        new_entry = collector.submit(report.crash_info, testCase=zip_name, testCaseQuality=self.quality)
+        new_entry = collector.submit(
+            report.crash_info, testCase=zip_name, testCaseQuality=self.quality
+        )
         LOG.info("Logged %d with quality %d", new_entry["id"], self.quality)
 
         # remove zipfile
@@ -727,7 +773,9 @@ def _process_rr_trace(self, report):
 
         # Upload to S3
         rr_arc = self.compress_rr_trace(trace_path, report.path)
-        s3.meta.client.upload_file(rr_arc, s3_bucket, s3_key, ExtraArgs={"ACL": "public-read"})
+        s3.meta.client.upload_file(
+            rr_arc, s3_bucket, s3_key, ExtraArgs={"ACL": "public-read"}
+        )
         unlink(rr_arc)
         self.add_extra_metadata("rr-trace", s3_url)
         return s3_url
diff --git a/grizzly/common/stack_hasher.py b/grizzly/common/stack_hasher.py
index d932c1ca..1374ceac 100644
--- a/grizzly/common/stack_hasher.py
+++ b/grizzly/common/stack_hasher.py
@@ -42,16 +42,26 @@ class StackFrame:
     _re_gdb = re_compile(r"^#(?P<num>\d+)\s+(?P<off>0x[0-9a-f]+\sin\s)*(?P<line>.+)")
     _re_rr = re_compile(r"rr\((?P<loc>.+)\+(?P<off>0x[0-9a-f]+)\)\[0x[0-9a-f]+\]")
     _re_rust_frame = re_compile(r"^\s+(?P<num>\d+):\s+0x[0-9a-f]+\s+\-\s+(?P<line>.+)")
-    _re_sanitizer = re_compile(r"^\s*#(?P<num>\d+)\s0x[0-9a-f]+(?P<in>\sin)?\s+(?P<line>.+)")
-    _re_tsan = re_compile(r"^\s*#(?P<num>\d+)\s(?P<line>.+)\s\(((?P<mod>.+)\+)?(?P<off>0x[0-9a-f]+)\)")
-    _re_valgrind = re_compile(r"^==\d+==\s+(at|by)\s+0x[0-9A-F]+\:\s+(?P<func>.+?)\s+\((?P<line>.+)\)")
+    _re_sanitizer = re_compile(
+        r"^\s*#(?P<num>\d+)\s0x[0-9a-f]+(?P<in>\sin)?\s+(?P<line>.+)"
+    )
+    _re_tsan = re_compile(
+        r"^\s*#(?P<num>\d+)\s(?P<line>.+)\s\(((?P<mod>.+)\+)?(?P<off>0x[0-9a-f]+)\)"
+    )
+    _re_valgrind = re_compile(
+        r"^==\d+==\s+(at|by)\s+0x[0-9A-F]+\:\s+(?P<func>.+?)\s+\((?P<line>.+)\)"
+    )
     # TODO: add additional debugger support?
-    #_re_rust_file = re_compile(r"^\s+at\s+(?P<line>.+)")
-    #_re_windbg = re_compile(r"^(\(Inline\)|[a-f0-9]+)\s([a-f0-9]+|-+)\s+(?P<line>.+)\+(?P<off>0x[a-f0-9]+)")
+    # _re_rust_file = re_compile(r"^\s+at\s+(?P<line>.+)")
+    # _re_windbg = re_compile(
+    #   r"^(\(Inline\)|[a-f0-9]+)\s([a-f0-9]+|-+)\s+(?P<line>.+)\+(?P<off>0x[a-f0-9]+)"
+    # )
 
     __slots__ = ("function", "location", "mode", "offset", "stack_line")
 
-    def __init__(self, function=None, location=None, mode=None, offset=None, stack_line=None):
+    def __init__(
+        self, function=None, location=None, mode=None, offset=None, stack_line=None
+    ):
         self.function = function
         self.location = location
         self.mode = mode
@@ -101,7 +111,7 @@ def _parse_gdb(cls, input_line):
         if not input_line:
             return None
         sframe = cls(mode=cls.MODE_GDB, stack_line=m.group("num"))
-        #sframe.offset = m.group("off")  # ignore binary offset for now
+        # sframe.offset = m.group("off")  # ignore binary offset for now
         # find function/method name
         m = cls._re_func_name.match(input_line)
         if m is not None:
@@ -119,7 +129,15 @@ def _parse_gdb(cls, input_line):
     @classmethod
     def _parse_minidump(cls, input_line):
         try:
-            tid, stack_line, lib_name, func_name, file_name, line_no, offset = input_line.split("|")
+            (
+                tid,
+                stack_line,
+                lib_name,
+                func_name,
+                file_name,
+                line_no,
+                offset,
+            ) = input_line.split("|")
             if int(tid) < 0 or int(stack_line) < 0:
                 return None
         except ValueError:
@@ -158,8 +176,8 @@ def _parse_rust(cls, input_line):
         sframe = cls(mode=cls.MODE_RUST, stack_line=m.group("num"))
         sframe.function = m.group("line").strip().rsplit("::h", 1)[0]
         # Don't bother with the file offset stuff atm
-        #m = cls._re_rust_file.match(input_line) if frame is None else None
-        #if m is not None:
+        # m = cls._re_rust_file.match(input_line) if frame is None else None
+        # if m is not None:
         #    frame = {"function":None, "mode":cls.MODE_RUST, "offset":None, "stack_line":None}
         #    input_line = m.group("line").strip()
         #    if ":" in input_line:
@@ -337,9 +355,17 @@ def from_text(cls, input_text, major_depth=MAJOR_DEPTH, parse_mode=None):
             if int(frames[0].stack_line) != 0:
                 LOG.warning("First stack line %s not 0", frames[0].stack_line)
             if int(frames[-1].stack_line) != len(frames) - 1:
-                LOG.warning("Last stack line %s not %d (frames-1)", frames[0].stack_line, len(frames) - 1)
-
-        if frames and frames[0].mode == StackFrame.MODE_RUST and major_depth < MAJOR_DEPTH_RUST:
+                LOG.warning(
+                    "Last stack line %s not %d (frames-1)",
+                    frames[0].stack_line,
+                    len(frames) - 1,
+                )
+
+        if (
+            frames
+            and frames[0].mode == StackFrame.MODE_RUST
+            and major_depth < MAJOR_DEPTH_RUST
+        ):
             major_depth = MAJOR_DEPTH_RUST
 
         return cls(frames=frames, major_depth=major_depth)
diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 039d8ba0..7aa7b5dc 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -25,16 +25,29 @@
 
 ProfileEntry = namedtuple("ProfileEntry", "count max min name total")
 
+
 class Status:
     """Status holds status information for the Grizzly session.
     There can be multiple readers of the data but only a single writer.
     """
+
     PATH = grz_tmp("status")
     REPORT_FREQ = 60
 
     __slots__ = (
-        "_enable_profiling", "_lock", "_profiles", "_results", "data_file", "ignored",
-        "iteration", "log_size", "pid", "start_time", "test_name", "timestamp")
+        "_enable_profiling",
+        "_lock",
+        "_profiles",
+        "_results",
+        "data_file",
+        "ignored",
+        "iteration",
+        "log_size",
+        "pid",
+        "start_time",
+        "test_name",
+        "timestamp",
+    )
 
     def __init__(self, data_file, enable_profiling=False, start_time=None):
         assert data_file.endswith(".json")
@@ -97,7 +110,8 @@ def _data(self):
             "pid": self.pid,
             "start_time": self.start_time,
             "test_name": self.test_name,
-            "timestamp": self.timestamp}
+            "timestamp": self.timestamp,
+        }
 
     @property
     def duration(self):
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 75014897..13ebff2b 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -21,10 +21,12 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
+
 class StatusReporter:
     """Read and merge Grizzly status reports, including tracebacks if found.
     Output is a single textual report, e.g. for submission to EC2SpotManager.
     """
+
     CPU_POLL_INTERVAL = 1
     DISPLAY_LIMIT_LOG = 10  # don't include log results unless size exceeds 10MBs
     EXP_LIMIT = 600  # expiration limit, ignore older reports
@@ -60,7 +62,9 @@ def dump_summary(self, filename, runtime=False, sysinfo=True, timestamp=True):
             None
         """
         with open(filename, "w") as ofp:
-            ofp.write(self._summary(runtime=runtime, sysinfo=sysinfo, timestamp=timestamp))
+            ofp.write(
+                self._summary(runtime=runtime, sysinfo=sysinfo, timestamp=timestamp)
+            )
 
     @property
     def has_results(self):
@@ -146,14 +150,18 @@ def _specific(self):
             # add profiling data if it exists
             if any(report.profile_entries()):
                 txt.append(" * Profiling entries *\n")
-            for entry in sorted(report.profile_entries(), key=lambda x: x.total, reverse=True):
+            for entry in sorted(
+                report.profile_entries(), key=lambda x: x.total, reverse=True
+            ):
                 avg = entry.total / float(entry.count)
                 txt.append(" > %s: %dx " % (entry.name, entry.count))
                 if entry.total > 300:
                     txt.append(str(timedelta(seconds=int(entry.total))))
                 else:
                     txt.append("%0.3fs" % (round(entry.total, 3),))
-                txt.append(" %0.2f%%" % (round(entry.total / report.duration * 100, 2),))
+                txt.append(
+                    " %0.2f%%" % (round(entry.total / report.duration * 100, 2),)
+                )
                 txt.append(" (%0.3f avg," % (round(avg, 3),))
                 txt.append(" %0.3f max," % (round(entry.max, 3),))
                 txt.append(" %0.3f min)" % (round(entry.min, 3),))
@@ -193,13 +201,17 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
             # Rate
             txt.append("      Rate : %d @ %0.2f" % (count, round(sum(rates), 2)))
             if count > 1:
-                txt.append(" (%0.2f, %0.2f)" % (round(max(rates), 2), round(min(rates), 2)))
+                txt.append(
+                    " (%0.2f, %0.2f)" % (round(max(rates), 2), round(min(rates), 2))
+                )
             txt.append("\n")
             # Results / Signature mismatch
             txt.append("   Results : %d" % (sum(results),))
             if total_ignored:
                 ignore_pct = total_ignored / float(total_iters) * 100
-                txt.append(" (%d ignored @ %0.2f%%)" % (total_ignored, round(ignore_pct, 2)))
+                txt.append(
+                    " (%d ignored @ %0.2f%%)" % (total_ignored, round(ignore_pct, 2))
+                )
             # Runtime
             if runtime:
                 txt.append("\n")
@@ -211,9 +223,10 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
                 txt.append("\n")
                 txt.append("      Logs : %0.1fMB" % (log_usage,))
                 if count > 1:
-                    txt.append(" (%0.2fMB, %0.2fMB)" % (
-                        max(log_sizes) / 1048576.0,
-                        min(log_sizes) / 1048576.0))
+                    txt.append(
+                        " (%0.2fMB, %0.2fMB)"
+                        % (max(log_sizes) / 1048576.0, min(log_sizes) / 1048576.0)
+                    )
         else:
             txt.append("No status reports available")
         if sysinfo:
@@ -260,9 +273,13 @@ def _sys_info():
             str: System information formatted to match output from _summary()
         """
         txt = list()
-        txt.append("CPU & Load : %d @ %0.1f%%" % (
-            psutil.cpu_count(),
-            psutil.cpu_percent(interval=StatusReporter.CPU_POLL_INTERVAL)))
+        txt.append(
+            "CPU & Load : %d @ %0.1f%%"
+            % (
+                psutil.cpu_count(),
+                psutil.cpu_percent(interval=StatusReporter.CPU_POLL_INTERVAL),
+            )
+        )
         try:
             txt.append(" %s\n" % (str(os.getloadavg()),))
         except AttributeError:
@@ -310,6 +327,7 @@ class TracebackReport:
     """Read Python tracebacks from log files and store it in a manner that is helpful
     when generating reports.
     """
+
     MAX_LINES = 16  # should be no less than 6
     READ_LIMIT = 0x10000  # 64KB
 
@@ -387,10 +405,10 @@ def from_file(cls, input_log, max_preceeding=5):
             tb_end = max(line_count, cls.MAX_LINES)
         if tb_end - tb_start > cls.MAX_LINES:
             # add first entry
-            lines = data[tb_start:tb_start + 3]
+            lines = data[tb_start : tb_start + 3]
             lines += ["<--- TRACEBACK TRIMMED--->"]
             # add end entries
-            lines += data[tb_end - (cls.MAX_LINES - 3):tb_end]
+            lines += data[tb_end - (cls.MAX_LINES - 3) : tb_end]
         else:
             lines = data[tb_start:tb_end]
         return cls(input_log, lines, is_kbi=is_kbi, prev_lines=prev_lines)
@@ -420,18 +438,22 @@ def main(args=None):
 
     modes = ("status",)
     parser = argparse.ArgumentParser(description="Grizzly status report generator")
+    parser.add_argument("--dump", help="File to write report to")
     parser.add_argument(
-        "--dump",
-        help="File to write report to")
-    parser.add_argument(
-        "--mode", default="status",
-        help="Status loading mode. Available modes: %s (default: 'status')" % (", ".join(modes),))
+        "--mode",
+        default="status",
+        help="Status loading mode. Available modes: %s (default: 'status')"
+        % (", ".join(modes),),
+    )
     parser.add_argument(
-        "--system-report", action="store_true",
-        help="Output summary and system information")
+        "--system-report",
+        action="store_true",
+        help="Output summary and system information",
+    )
     parser.add_argument(
         "--tracebacks",
-        help="Scan path for Python tracebacks found in screenlog.# files")
+        help="Scan path for Python tracebacks found in screenlog.# files",
+    )
     args = parser.parse_args(args)
 
     if args.mode not in modes:
@@ -444,8 +466,8 @@ def main(args=None):
         print("Grizzly Status - No status reports to display")
         return 0
     print(
-        "Grizzly Status - %s - Instance report frequency: %ds\n" %
-        (strftime("%Y/%m/%d %X", localtime()), Status.REPORT_FREQ)
+        "Grizzly Status - %s - Instance report frequency: %ds\n"
+        % (strftime("%Y/%m/%d %X", localtime()), Status.REPORT_FREQ)
     )
     print("[Reports]")
     reporter.print_specific()
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 59029a7a..d924a453 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -38,11 +38,28 @@ class TestFileExists(Exception):
 
 class TestCase:
     __slots__ = (
-        "adapter_name", "duration", "env_vars", "hang", "input_fname", "landing_page",
-        "redirect_page", "time_limit", "timestamp", "_existing_paths", "_files")
-
-    def __init__(self, landing_page, redirect_page, adapter_name, input_fname=None,
-                 time_limit=None, timestamp=None):
+        "adapter_name",
+        "duration",
+        "env_vars",
+        "hang",
+        "input_fname",
+        "landing_page",
+        "redirect_page",
+        "time_limit",
+        "timestamp",
+        "_existing_paths",
+        "_files",
+    )
+
+    def __init__(
+        self,
+        landing_page,
+        redirect_page,
+        adapter_name,
+        input_fname=None,
+        time_limit=None,
+        timestamp=None,
+    ):
         self.adapter_name = adapter_name
         self.duration = None
         self.env_vars = dict()  # environment variables
@@ -56,7 +73,8 @@ def __init__(self, landing_page, redirect_page, adapter_name, input_fname=None,
         self._files = TestFileMap(
             meta=list(),  # environment files such as prefs.js, etc...
             optional=list(),
-            required=list())
+            required=list(),
+        )
 
     def __enter__(self):
         return self
@@ -202,8 +220,14 @@ def clone(self):
         Returns:
             TestCase: A copy of the TestCase instance.
         """
-        result = type(self)(self.landing_page, self.redirect_page, self.adapter_name,
-                            self.input_fname, self.time_limit, self.timestamp)
+        result = type(self)(
+            self.landing_page,
+            self.redirect_page,
+            self.adapter_name,
+            self.input_fname,
+            self.time_limit,
+            self.timestamp,
+        )
         result.duration = self.duration
         result.hang = self.hang
         result.env_vars.update(self.env_vars)
@@ -267,7 +291,8 @@ def dump(self, out_path, include_details=False):
                 "input": basename(self.input_fname) if self.input_fname else None,
                 "target": self.landing_page,
                 "time_limit": self.time_limit,
-                "timestamp": self.timestamp}
+                "timestamp": self.timestamp,
+            }
             with open(pathjoin(out_path, "test_info.json"), "w") as out_fp:
                 json.dump(info, out_fp, indent=2, sort_keys=True)
             # save meta files
@@ -283,7 +308,9 @@ def get_file(self, file_name):
         Returns:
             TestFile: TestFile with matching file name otherwise None.
         """
-        for tfile in chain(self._files.meta, self._files.optional, self._files.required):
+        for tfile in chain(
+            self._files.meta, self._files.optional, self._files.required
+        ):
             if tfile.file_name == file_name:
                 return tfile
         return None
@@ -344,11 +371,13 @@ def load_environ(self, path, env_data):
         known_suppressions = ("lsan.supp", "tsan.supp", "ubsan.supp")
         for supp in listdir(path):
             if supp.lower() in known_suppressions:
-                # Update *SAN_OPTIONS environment variable to use provided suppression files.
+                # Update *SAN_OPTIONS to use provided suppression files.
                 opt_key = "%s_OPTIONS" % (supp.split(".")[0].upper(),)
                 opts = sanitizer_opts(self.env_vars.get(opt_key, ""))
                 opts["suppressions"] = "'%s'" % (pathjoin(path, supp),)
-                self.env_vars[opt_key] = ":".join("=".join((k, v)) for k, v in opts.items())
+                self.env_vars[opt_key] = ":".join(
+                    "=".join((k, v)) for k, v in opts.items()
+                )
 
     @classmethod
     def load_single(cls, path, load_prefs, adjacent=False):
@@ -379,7 +408,9 @@ def load_single(cls, path, load_prefs, adjacent=False):
                 raise TestCaseLoadFailure("'test_info.json' has invalid 'target' entry")
             entry_point = basename(info["target"])
             if not isfile(pathjoin(path, entry_point)):
-                raise TestCaseLoadFailure("Entry point %r not found in '%s'" % (entry_point, path))
+                raise TestCaseLoadFailure(
+                    "Entry point %r not found in '%s'" % (entry_point, path)
+                )
             # always load all contents of a directory if a 'test_info.json' is loaded
             adjacent = True
         elif isfile(path):
@@ -395,7 +426,7 @@ def load_single(cls, path, load_prefs, adjacent=False):
             info.get("adapter", None),
             input_fname=info.get("input", None),
             time_limit=info.get("time_limit", None),
-            timestamp=info.get("timestamp", 0)
+            timestamp=info.get("timestamp", 0),
         )
         test.duration = info.get("duration", None)
         test.hang = info.get("hang", False)
@@ -419,9 +450,8 @@ def load_single(cls, path, load_prefs, adjacent=False):
                         continue
                     location = "/".join((dpath.split(path, 1)[-1], fname))
                     test.add_from_file(
-                        pathjoin(dpath, fname),
-                        file_name=location,
-                        required=False)
+                        pathjoin(dpath, fname), file_name=location, required=False
+                    )
         return test
 
     @property
@@ -502,16 +532,17 @@ def __init__(self, file_name):
             file_name = file_name.lstrip("/")
         if file_name.endswith("."):
             file_name = file_name.rstrip(".")
-        if not file_name \
-                or ("/" in file_name and not file_name.rsplit("/", 1)[-1]) \
-                or file_name.startswith("../"):
+        if (
+            not file_name
+            or ("/" in file_name and not file_name.rsplit("/", 1)[-1])
+            or file_name.startswith("../")
+        ):
             raise TypeError("file_name is invalid %r" % (file_name,))
         # name including path relative to wwwroot
         self._file_name = normpath(file_name)
         self._fp = SpooledTemporaryFile(
-            dir=grz_tmp("storage"),
-            max_size=self.CACHE_LIMIT,
-            prefix="testfile_")
+            dir=grz_tmp("storage"), max_size=self.CACHE_LIMIT, prefix="testfile_"
+        )
 
     def __enter__(self):
         return self
@@ -530,7 +561,9 @@ def clone(self):
         """
         cloned = type(self)(self._file_name)
         self._fp.seek(0)
-        copyfileobj(self._fp, cloned._fp, self.XFER_BUF)  # pylint: disable=protected-access
+        copyfileobj(
+            self._fp, cloned._fp, self.XFER_BUF
+        )  # pylint: disable=protected-access
         return cloned
 
     def close(self):
@@ -617,7 +650,9 @@ def from_file(cls, input_file, file_name=None):
             file_name = basename(input_file)
         t_file = cls(file_name)
         with open(input_file, "rb") as src_fp:
-            copyfileobj(src_fp, t_file._fp, cls.XFER_BUF)  # pylint: disable=protected-access
+            copyfileobj(
+                src_fp, t_file._fp, cls.XFER_BUF
+            )  # pylint: disable=protected-access
         return t_file
 
     @property
diff --git a/grizzly/common/test_adapter.py b/grizzly/common/test_adapter.py
index fb4cd193..3055f25c 100644
--- a/grizzly/common/test_adapter.py
+++ b/grizzly/common/test_adapter.py
@@ -16,11 +16,14 @@ def generate(self, testcase, server_map):
 
 def test_adapter_01():
     """test a bad Adapter"""
+
     class BadAdapter(SimpleAdapter):
         NAME = None
+
     with pytest.raises(AdapterError, match="BadAdapter.NAME must be a string"):
         BadAdapter()
 
+
 def test_adapter_02():
     """test a simple Adapter"""
     adpt = SimpleAdapter()
@@ -36,6 +39,7 @@ def test_adapter_02():
     adpt.pre_launch()
     adpt.cleanup()
 
+
 def test_adapter_03(tmp_path):
     """test Adapter.enable_harness()"""
     adpt = SimpleAdapter()
@@ -53,6 +57,7 @@ def test_adapter_03(tmp_path):
     adpt.enable_harness(str(ext_harness_file))
     assert adpt.get_harness() == test_data
 
+
 def test_adapter_04(tmp_path):
     """test Adapter.scan_path()"""
     # empty path
@@ -60,7 +65,7 @@ def test_adapter_04(tmp_path):
     # missing path
     assert not any(SimpleAdapter.scan_path(str(tmp_path / "none")))
     # path to file
-    file1 = (tmp_path / "test1.txt")
+    file1 = tmp_path / "test1.txt"
     file1.touch()
     found = tuple(SimpleAdapter.scan_path(str(file1)))
     assert str(file1) in found
@@ -69,9 +74,9 @@ def test_adapter_04(tmp_path):
     assert len(tuple(SimpleAdapter.scan_path(str(tmp_path)))) == 1
     # path to directory (w/ ignored)
     (tmp_path / ".ignored").touch()
-    nested = (tmp_path / "nested")
+    nested = tmp_path / "nested"
     nested.mkdir()
-    file2 = (nested / "test2.bin")
+    file2 = nested / "test2.bin"
     file2.touch()
     assert len(tuple(SimpleAdapter.scan_path(str(tmp_path)))) == 1
     # path to directory (recursive)
diff --git a/grizzly/common/test_fuzzmanager.py b/grizzly/common/test_fuzzmanager.py
index d549de67..5d8cd636 100644
--- a/grizzly/common/test_fuzzmanager.py
+++ b/grizzly/common/test_fuzzmanager.py
@@ -65,7 +65,9 @@ def test_bucket_3(mocker):
     crashes = list(bucket.iter_crashes(quality_filter=5))
     assert coll.return_value.get.call_count == 2
     assert coll.return_value.get.call_args_list[0][1]["params"]["include_raw"] == "0"
-    assert json.loads(coll.return_value.get.call_args_list[0][1]["params"]["query"]) == {
+    assert json.loads(
+        coll.return_value.get.call_args_list[0][1]["params"]["query"]
+    ) == {
         "op": "AND",
         "bucket": 123,
         "testcase__quality": 5,
@@ -96,10 +98,10 @@ def test_bucket_4(mocker):
         assert sig_path.with_suffix(".metadata").is_file()
         assert sig_path.read_text() == "sigdata"
         assert json.loads(sig_path.with_suffix(".metadata").read_text()) == {
-                        "size": 10,
-                        "frequent": True,
-                        "shortDescription": "sig desc",
-                        "testcase__quality": 0,
+            "size": 10,
+            "frequent": True,
+            "shortDescription": "sig desc",
+            "testcase__quality": 0,
         }
         assert coll.return_value.get.call_count == 1
         # second call returns same path
diff --git a/grizzly/common/test_iomanager.py b/grizzly/common/test_iomanager.py
index cd0ff713..12df2033 100644
--- a/grizzly/common/test_iomanager.py
+++ b/grizzly/common/test_iomanager.py
@@ -20,6 +20,7 @@ def test_iomanager_01():
         assert iom._report_size == 1
         assert iom._test is None
 
+
 @mark.parametrize(
     "report_size, iters",
     [
@@ -27,7 +28,7 @@ def test_iomanager_01():
         (1, 2),
         (2, 2),
         (2, 3),
-    ]
+    ],
 )
 def test_iomanager_02(report_size, iters):
     """test IOManager create_testcase(), commit() and purge()"""
@@ -49,6 +50,7 @@ def test_iomanager_02(report_size, iters):
         assert iom._test is None
         assert not iom.tests
 
+
 def test_iomanager_03():
     """test IOManager.page_name()"""
     with IOManager() as iom:
@@ -57,6 +59,7 @@ def test_iomanager_03():
         iom._generated += 1
         assert iom.page_name() == next_page
 
+
 def test_iomanager_04(mocker, tmp_path):
     """test IOManager._add_suppressions()"""
     mocker.patch.dict("grizzly.common.iomanager.environ", values={})
@@ -70,10 +73,13 @@ def test_iomanager_04(mocker, tmp_path):
                 "ASAN_OPTIONS": "blah=1:suppressions='%s':foo=2" % (str(supp_file),),
                 "DEBUG": "1",
                 "LSAN_OPTIONS": "nothing=1",
-                "JUNK": "test"})
+                "JUNK": "test",
+            },
+        )
         iom._add_suppressions()
         assert "asan.supp" in (x.file_name for x in iom._environ_files)
 
+
 def test_iomanager_05():
     """test IOManager.create_testcase()"""
     time_limit = 10
@@ -108,6 +114,7 @@ def test_iomanager_05():
         assert "grz_next_test" in iom.server_map.redirect
         assert "grz_harness" in iom.server_map.dynamic
 
+
 def test_iomanager_06(mocker):
     """test IOManager.tracked_environ()"""
     mocker.patch.dict("grizzly.common.iomanager.environ", values={})
@@ -121,8 +128,10 @@ def test_iomanager_06(mocker):
             "MOZ_CHAOSMODE": "1",
             # this should be skipped because it uses the FFPuppet debug
             "XPCOM_DEBUG_BREAK": "warn",
-            "TEST_BAD": "FAIL"},
-        clear=True)
+            "TEST_BAD": "FAIL",
+        },
+        clear=True,
+    )
     tracked = IOManager.tracked_environ()
     assert "TEST_BAD" not in tracked
     assert "XPCOM_DEBUG_BREAK" not in tracked
@@ -134,5 +143,6 @@ def test_iomanager_06(mocker):
     mocker.patch.dict(
         "grizzly.common.iomanager.environ",
         values={"ASAN_OPTIONS": "ignored=x"},
-        clear=True)
+        clear=True,
+    )
     assert not IOManager.tracked_environ()
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 18c777cf..b9400138 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -31,6 +31,7 @@ def _create_crash_log(log_path):
         log_fp.write("    #0 0xbad000 in foo /file1.c:123:234\n")
         log_fp.write("    #1 0x1337dd in bar /file2.c:1806:19")
 
+
 def test_report_01(tmp_path):
     """test Report() with boring logs (no stack)"""
     (tmp_path / "not_a_log.txt").touch()
@@ -50,6 +51,7 @@ def test_report_01(tmp_path):
     report.cleanup()
     assert not tmp_path.exists()
 
+
 def test_report_02(tmp_path):
     """test Report() with crash logs"""
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
@@ -67,6 +69,7 @@ def test_report_02(tmp_path):
     assert report.prefix is not None
     report.cleanup()
 
+
 def test_report_03(tmp_path):
     """test Report.tail()"""
     tmp_file = tmp_path / "file.txt"
@@ -81,6 +84,7 @@ def test_report_03(tmp_path):
     assert log_data.startswith(b"[LOG TAILED]\n")
     assert log_data[13:] == b"FOO"
 
+
 def test_report_04(tmp_path):
     """test Report.select_logs() uninteresting data"""
     # test with empty path
@@ -89,6 +93,7 @@ def test_report_04(tmp_path):
     (tmp_path / "not_a_log.txt").touch()
     assert Report.select_logs(str(tmp_path)) is None
 
+
 def test_report_05(tmp_path):
     """test Report.select_logs()"""
     # small log with nothing interesting
@@ -98,16 +103,24 @@ def test_report_05(tmp_path):
     # crash on another thread
     with (tmp_path / "log_asan.txt.2").open("wb") as log_fp:
         log_fp.write(b"GOOD LOG\n")
-        log_fp.write(b"==70811==ERROR: AddressSanitizer: SEGV on unknown address 0x00000BADF00D")
-        log_fp.write(b" (pc 0x7f4c0bb54c67 bp 0x7f4c07bea380 sp 0x7f4c07bea360 T0)\n")  # must be 2nd line
+        log_fp.write(
+            b"==70811==ERROR: AddressSanitizer: SEGV on unknown address 0x00000BADF00D"
+        )
+        log_fp.write(
+            b" (pc 0x7f4c0bb54c67 bp 0x7f4c07bea380 sp 0x7f4c07bea360 T0)\n"
+        )  # must be 2nd line
         # pad out to 6 lines
         for l_no in range(4):
             log_fp.write(b"    #%d blah...\n" % l_no)
     # child log that should be ignored (created when parent crashes)
     with (tmp_path / "log_asan.txt.3").open("wb") as log_fp:
         log_fp.write(b"BAD LOG\n")
-        log_fp.write(b"==70811==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000")
-        log_fp.write(b" (pc 0x7f4c0bb54c67 bp 0x7f4c07bea380 sp 0x7f4c07bea360 T2)\n")  # must be 2nd line
+        log_fp.write(
+            b"==70811==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000"
+        )
+        log_fp.write(
+            b" (pc 0x7f4c0bb54c67 bp 0x7f4c07bea380 sp 0x7f4c07bea360 T2)\n"
+        )  # must be 2nd line
         # pad out to 6 lines
         for l_no in range(4):
             log_fp.write(b"    #%d blah...\n" % l_no)
@@ -121,6 +134,7 @@ def test_report_05(tmp_path):
     assert "STDERR" in (tmp_path / log_map.stderr).read_text()
     assert "STDOUT" in (tmp_path / log_map.stdout).read_text()
 
+
 def test_report_06(tmp_path):
     """test minidump with Report.select_logs()"""
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
@@ -135,6 +149,7 @@ def test_report_06(tmp_path):
     assert (tmp_path / log_map.stdout).is_file()
     assert "minidump log" in (tmp_path / log_map.aux).read_text()
 
+
 def test_report_07(tmp_path):
     """test selecting preferred DUMP_REQUESTED minidump with Report.select_logs()"""
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
@@ -147,8 +162,12 @@ def test_report_07(tmp_path):
     with (tmp_path / "log_minidump_02.txt").open("wb") as log_fp:
         log_fp.write(b"GPU|||\n")
         log_fp.write(b"Crash|DUMP_REQUESTED|0x7f57ac9e2e14|0\n")
-        log_fp.write(b"0|0|foo.so|google_breakpad::ExceptionHandler::WriteMinidump|bar.cc:234|674|0xc\n")
-        log_fp.write(b"0|1|foo.so|google_breakpad::ExceptionHandler::WriteMinidump|bar.cc:4a2|645|0x8\n")
+        log_fp.write(
+            b"0|0|foo.so|google_breakpad::ExceptionHandler::WriteMinidump|bar.cc:234|674|0xc\n"
+        )
+        log_fp.write(
+            b"0|1|foo.so|google_breakpad::ExceptionHandler::WriteMinidump|bar.cc:4a2|645|0x8\n"
+        )
     with (tmp_path / "log_minidump_03.txt").open("wb") as log_fp:
         log_fp.write(b"GPU|||\n")
         log_fp.write(b"Crash|DUMP_REQUESTED|0x7f9518665d18|0\n")
@@ -157,7 +176,11 @@ def test_report_07(tmp_path):
     log_map = Report.select_logs(str(tmp_path))
     assert (tmp_path / log_map.stderr).is_file()
     assert (tmp_path / log_map.stdout).is_file()
-    assert "google_breakpad::ExceptionHandler::WriteMinidump" in (tmp_path / log_map.aux).read_text()
+    assert (
+        "google_breakpad::ExceptionHandler::WriteMinidump"
+        in (tmp_path / log_map.aux).read_text()
+    )
+
 
 def test_report_08(tmp_path):
     """test selecting worker logs with Report.select_logs()"""
@@ -171,6 +194,7 @@ def test_report_08(tmp_path):
     assert (tmp_path / log_map.stdout).is_file()
     assert "worker log" in (tmp_path / log_map.aux).read_text()
 
+
 def test_report_09(tmp_path):
     """test prioritizing sanitizer logs with Report._find_sanitizer()"""
     # NOTE: ordered by selection priority in order to use previously added logs
@@ -184,7 +208,8 @@ def test_report_09(tmp_path):
     assert "test" in Path(selected).read_text()
     # test UBSan log
     (tmp_path / "log_asan.txt.1").write_text(
-        "test.cc:3:5: runtime error: signed integer overflow: ...")
+        "test.cc:3:5: runtime error: signed integer overflow: ..."
+    )
     selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
     assert selected is not None
     assert "runtime error: signed integer overflow" in Path(selected).read_text()
@@ -201,7 +226,9 @@ def test_report_09(tmp_path):
     assert "AddressSanitizer: stack-overflow" in Path(selected).read_text()
     # test selecting prioritized
     with (tmp_path / "log_asan.txt.4").open("wb") as log_fp:
-        log_fp.write(b"==1942==ERROR: AddressSanitizer: heap-use-after-free on ... blah\n")
+        log_fp.write(
+            b"==1942==ERROR: AddressSanitizer: heap-use-after-free on ... blah\n"
+        )
         for l_no in range(4):
             log_fp.write(b"    #%d blah...\n" % (l_no,))
     with (tmp_path / "log_asan.txt.5").open("wb") as log_fp:
@@ -213,6 +240,7 @@ def test_report_09(tmp_path):
     assert selected is not None
     assert "heap-use-after-free" in Path(selected).read_text()
 
+
 def test_report_10(tmp_path):
     """test Report() size_limit"""
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log\n" * 200)
@@ -234,6 +262,7 @@ def test_report_10(tmp_path):
     report.cleanup()
     assert not tmp_path.is_dir()
 
+
 def test_report_11(tmp_path):
     """test selecting Valgrind logs with Report.select_logs()"""
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
@@ -244,6 +273,7 @@ def test_report_11(tmp_path):
     assert (tmp_path / log_map.stdout).is_file()
     assert "valgrind log" in (tmp_path / log_map.aux).read_text()
 
+
 def test_report_12(tmp_path):
     """test Report.crash_info"""
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
@@ -265,6 +295,7 @@ def test_report_12(tmp_path):
     assert report.crash_info is not None
     assert report._crash_info is not None
 
+
 def test_report_13(mocker, tmp_path):
     """test Report.crash_signature and Report.crash_hash"""
     mocker.patch("grizzly.common.reporter.ProgramConfiguration", autospec=True)
@@ -277,26 +308,36 @@ def test_report_13(mocker, tmp_path):
     assert report.crash_info.createShortSignature() == "[@ foo]"
     assert report.crash_hash
 
+
 def test_report_14(mocker):
     """test Report.crash_signature_max_frames()"""
     info = mocker.Mock(spec=CrashInfo)
-    info.backtrace = ("blah")
+    info.backtrace = ("blah",)
     assert Report.crash_signature_max_frames(info) == 8
-    info.backtrace = ("std::panicking::rust_panic", "std::panicking::rust_panic_with_hook")
+    info.backtrace = (
+        "std::panicking::rust_panic",
+        "std::panicking::rust_panic_with_hook",
+    )
     assert Report.crash_signature_max_frames(info) == 14
 
+
 def test_reporter_01(mocker):
     """test creating a simple Reporter"""
+
     class SimpleReporter(Reporter):
         def _pre_submit(self, report):
             pass
+
         def _post_submit(self):
             pass
+
         def _submit_report(self, report, test_cases):
             pass
+
     reporter = SimpleReporter()
     reporter.submit([], report=mocker.Mock(spec=Report))
 
+
 def test_filesystem_reporter_01(tmp_path):
     """test FilesystemReporter without testcases"""
     log_path = tmp_path / "logs"
@@ -318,6 +359,7 @@ def test_filesystem_reporter_01(tmp_path):
     assert log_dirs[0].is_dir()
     assert "_logs" in str(log_dirs[0])
 
+
 def test_filesystem_reporter_02(tmp_path, mocker):
     """test FilesystemReporter with testcases"""
     log_path = tmp_path / "logs"
@@ -344,6 +386,7 @@ def test_filesystem_reporter_02(tmp_path, mocker):
     assert len(tuple(report_path.iterdir())) == 2
     assert len(tuple(report_path.glob("NO_STACK"))) == 1
 
+
 def test_filesystem_reporter_03(tmp_path):
     """test FilesystemReporter disk space failsafe"""
     log_path = tmp_path / "logs"
@@ -355,20 +398,19 @@ def test_filesystem_reporter_03(tmp_path):
     with pytest.raises(RuntimeError, match="Running low on disk space"):
         reporter.submit([], Report(str(log_path), "fake_bin"))
 
+
 def test_filesystem_reporter_04(mocker, tmp_path):
     """test FilesystemReporter w/o major bucket"""
-    fake_report = (tmp_path / "fake_report")
+    fake_report = tmp_path / "fake_report"
     fake_report.mkdir()
-    report = mocker.Mock(
-        spec=Report,
-        path=str(fake_report),
-        prefix="test_prefix")
+    report = mocker.Mock(spec=Report, path=str(fake_report), prefix="test_prefix")
     reporter = FilesystemReporter(str(tmp_path / "dst"), major_bucket=False)
     reporter.submit([], report)
     assert not fake_report.is_dir()
     assert not report.major.call_count
     assert any((tmp_path / "dst").glob("test_prefix_logs"))
 
+
 def test_fuzzmanager_reporter_01(mocker, tmp_path):
     """test FuzzManagerReporter.sanity_check()"""
     fake_reporter = mocker.patch("grizzly.common.reporter.ProgramConfiguration")
@@ -390,15 +432,22 @@ def test_fuzzmanager_reporter_01(mocker, tmp_path):
     FuzzManagerReporter.sanity_check(str(fake_bin))
     assert fake_reporter.fromBinary.call_count == 1
 
+
 def test_fuzzmanager_reporter_02(mocker, tmp_path):
     """test FuzzManagerReporter.submit()"""
-    mocker.patch("grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path))
+    mocker.patch(
+        "grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path)
+    )
     mocker.patch("grizzly.common.reporter.getenv", autospec=True, return_value="0")
     fake_crashinfo = mocker.patch("grizzly.common.reporter.CrashInfo", autospec=True)
-    fake_crashinfo.fromRawCrashData.return_value.createShortSignature.return_value = "test [@ test]"
+    fake_crashinfo.fromRawCrashData.return_value.createShortSignature.return_value = (
+        "test [@ test]"
+    )
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     fake_collector.return_value.search.return_value = (None, None)
-    fake_collector.return_value.generate.return_value = str(tmp_path / "fm_file.signature")
+    fake_collector.return_value.generate.return_value = str(
+        tmp_path / "fm_file.signature"
+    )
     log_path = tmp_path / "log_path"
     log_path.mkdir()
     (log_path / "log_ffp_worker_blah.txt").touch()
@@ -410,25 +459,33 @@ def test_fuzzmanager_reporter_02(mocker, tmp_path):
         spec=TestCase,
         adapter_name="adapter",
         env_vars={"TEST": "1"},
-        input_fname="input")
+        input_fname="input",
+    )
     reporter = FuzzManagerReporter("fake_bin")
     reporter.submit([fake_test], Report(str(log_path), "fake_bin", is_hang=True))
     assert not log_path.is_dir()
     assert fake_test.dump.call_count == 1
     assert fake_collector.return_value.submit.call_count == 1
     meta_data = (tmp_path / "fm_file.metadata").read_text()
-    assert "\"frequent\": false" in meta_data
-    assert "\"_grizzly_seen_count\": 1" in meta_data
-    assert "\"shortDescription\": \"test [@ test]\"" in meta_data
+    assert '"frequent": false' in meta_data
+    assert '"_grizzly_seen_count": 1' in meta_data
+    assert '"shortDescription": "test [@ test]"' in meta_data
+
 
 def test_fuzzmanager_reporter_03(mocker, tmp_path):
     """test FuzzManagerReporter.submit() - no test / mark as frequent"""
-    mocker.patch("grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path))
+    mocker.patch(
+        "grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path)
+    )
     fake_crashinfo = mocker.patch("grizzly.common.reporter.CrashInfo", autospec=True)
-    fake_crashinfo.fromRawCrashData.return_value.createShortSignature.return_value = "test [@ test]"
+    fake_crashinfo.fromRawCrashData.return_value.createShortSignature.return_value = (
+        "test [@ test]"
+    )
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     fake_collector.return_value.search.return_value = (None, None)
-    fake_collector.return_value.generate.return_value = str(tmp_path / "fm_file.signature")
+    fake_collector.return_value.generate.return_value = str(
+        tmp_path / "fm_file.signature"
+    )
     log_path = tmp_path / "log_path"
     log_path.mkdir()
     (log_path / "log_stderr.txt").touch()
@@ -438,9 +495,10 @@ def test_fuzzmanager_reporter_03(mocker, tmp_path):
     reporter.submit([], Report(str(log_path), "fake_bin"))
     assert fake_collector.return_value.submit.call_count == 1
     meta_data = (tmp_path / "fm_file.metadata").read_text()
-    assert "\"frequent\": true" in meta_data
-    assert "\"_grizzly_seen_count\": 1" in meta_data
-    assert "\"shortDescription\": \"test [@ test]\"" in meta_data
+    assert '"frequent": true' in meta_data
+    assert '"_grizzly_seen_count": 1' in meta_data
+    assert '"shortDescription": "test [@ test]"' in meta_data
+
 
 def test_fuzzmanager_reporter_04(mocker, tmp_path):
     """test FuzzManagerReporter.submit() hit frequent crash"""
@@ -448,7 +506,8 @@ def test_fuzzmanager_reporter_04(mocker, tmp_path):
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     fake_collector.return_value.search.return_value = (
         None,
-        {"frequent": True, "shortDescription": "[@ test]"})
+        {"frequent": True, "shortDescription": "[@ test]"},
+    )
     log_path = tmp_path / "log_path"
     log_path.mkdir()
     (log_path / "log_stderr.txt").touch()
@@ -457,13 +516,15 @@ def test_fuzzmanager_reporter_04(mocker, tmp_path):
     reporter.submit([], Report(str(log_path), "fake_bin"))
     fake_collector.return_value.submit.assert_not_called()
 
+
 def test_fuzzmanager_reporter_05(mocker, tmp_path):
     """test FuzzManagerReporter.submit() hit existing crash"""
     mocker.patch("grizzly.common.reporter.CrashInfo", autospec=True)
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     fake_collector.return_value.search.return_value = (
         None,
-        {"bug__id":1, "frequent": False, "shortDescription": "[@ test]"})
+        {"bug__id": 1, "frequent": False, "shortDescription": "[@ test]"},
+    )
     log_path = tmp_path / "log_path"
     log_path.mkdir()
     (log_path / "log_stderr.txt").touch()
@@ -473,6 +534,7 @@ def test_fuzzmanager_reporter_05(mocker, tmp_path):
     reporter.submit([], Report(str(log_path), "fake_bin"))
     fake_collector.return_value.submit.assert_not_called()
 
+
 def test_fuzzmanager_reporter_06(mocker, tmp_path):
     """test FuzzManagerReporter.submit() no signature"""
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
@@ -486,6 +548,7 @@ def test_fuzzmanager_reporter_06(mocker, tmp_path):
     with pytest.raises(RuntimeError, match="Failed to create FM signature"):
         reporter.submit([], Report(str(log_path), "fake_bin"))
 
+
 def test_fuzzmanager_reporter_07(mocker, tmp_path):
     """test FuzzManagerReporter.submit() unsymbolized crash"""
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
@@ -500,14 +563,16 @@ def test_fuzzmanager_reporter_07(mocker, tmp_path):
     reporter.submit([], Report(str(log_path), "fake_bin"))
     fake_collector.return_value.submit.assert_not_called()
 
+
 def test_fuzzmanager_reporter_08():
     """test FuzzManagerReporter.quality_name()"""
     assert FuzzManagerReporter.quality_name(0) == "QUAL_REDUCED_RESULT"
     assert FuzzManagerReporter.quality_name(-1) == "unknown quality (-1)"
 
+
 def test_fuzzmanager_reporter_09(mocker, tmp_path):
     """test FuzzManagerReporter._ignored()"""
-    log_file = (tmp_path / "test.log")
+    log_file = tmp_path / "test.log"
     log_file.touch()
     report = mocker.Mock(spec=Report, path=str(tmp_path), preferred=str(log_file))
     # not ignored
@@ -519,18 +584,22 @@ def test_fuzzmanager_reporter_09(mocker, tmp_path):
     log_file.write_bytes(b"VEX temporary storage exhausted.")
     assert FuzzManagerReporter._ignored(report)
 
+
 def test_s3fuzzmanager_reporter_01(mocker, tmp_path):
     """test S3FuzzManagerReporter.sanity_check()"""
     mocker.patch("grizzly.common.reporter.FuzzManagerReporter", autospec=True)
     fake_bin = tmp_path / "bin"
     # test GRZ_S3_BUCKET missing
-    with pytest.raises(EnvironmentError, match="'GRZ_S3_BUCKET' is not set in environment"):
+    with pytest.raises(
+        EnvironmentError, match="'GRZ_S3_BUCKET' is not set in environment"
+    ):
         S3FuzzManagerReporter.sanity_check(str(fake_bin))
     # test GRZ_S3_BUCKET set
     pytest.importorskip("boto3")
     mocker.patch("grizzly.common.reporter.getenv", autospec=True, return_value="test")
     S3FuzzManagerReporter.sanity_check(str(fake_bin))
 
+
 def test_s3fuzzmanager_reporter_02(mocker, tmp_path):
     """test S3FuzzManagerReporter._pre_submit()"""
     pytest.importorskip("boto3")
@@ -560,19 +629,26 @@ def test_s3fuzzmanager_reporter_02(mocker, tmp_path):
     reporter._extra_metadata.clear()
     trace_dir.mkdir(parents=True)
     (trace_dir / "trace-file").touch()
+
     class FakeClientError(Exception):
         def __init__(self, message, response):
             super().__init__(message)
             self.response = response
+
     mocker.patch("grizzly.common.reporter.ClientError", new=FakeClientError)
-    fake_resource.return_value.Object.side_effect = FakeClientError("test", {"Error": {"Code": "404"}})
+    fake_resource.return_value.Object.side_effect = FakeClientError(
+        "test", {"Error": {"Code": "404"}}
+    )
     reporter._pre_submit(fake_report)
     assert not any(tmp_path.iterdir())
     assert "rr-trace" in reporter._extra_metadata
     assert fake_report.minor in reporter._extra_metadata["rr-trace"]
     assert fake_resource.return_value.meta.client.upload_file.call_count == 1
 
-@pytest.mark.skipif(not sys.platform.startswith("linux"), reason="RR only supported on Linux")
+
+@pytest.mark.skipif(
+    not sys.platform.startswith("linux"), reason="RR only supported on Linux"
+)
 def test_s3fuzzmanager_reporter_03(tmp_path):
     """test S3FuzzManagerReporter.compress_rr_trace()"""
     # create fake trace
@@ -587,7 +663,9 @@ def test_s3fuzzmanager_reporter_03(tmp_path):
     (src / "mmap").write_bytes(b"bar")
     (src / "tasks").write_bytes(b"foo")
     (src / "version").write_bytes(b"123")
-    (tmp_path / "rr-traces" / "latest-trace").symlink_to(str(src), target_is_directory=True)
+    (tmp_path / "rr-traces" / "latest-trace").symlink_to(
+        str(src), target_is_directory=True
+    )
     src = tmp_path / "rr-traces"
     dest = tmp_path / "dest"
     dest.mkdir()
@@ -600,4 +678,5 @@ def test_s3fuzzmanager_reporter_03(tmp_path):
     assert "echo-0" not in entries
     assert "latest-trace" not in entries
 
+
 # TODO: fill out tests for FuzzManagerReporter and S3FuzzManagerReporter
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index ed27ae04..a4b95ad9 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -67,7 +67,7 @@ def test_runner_01(mocker, tmp_path):
     assert target.handle_hang.call_count == 0
     # existing test path
     testcase.reset_mock()
-    tc_path = (tmp_path / "tc")
+    tc_path = tmp_path / "tc"
     tc_path.mkdir()
     serv_map = ServerMap()
     server.serve_path.return_value = (SERVED_ALL, serv_files)
@@ -81,6 +81,7 @@ def test_runner_01(mocker, tmp_path):
     assert testcase.dump.call_count == 0
     tc_path.is_dir()
 
+
 def test_runner_02(mocker):
     """test Runner.run() relaunch"""
     mocker.patch("grizzly.common.runner.time", autospec=True, return_value=1)
@@ -145,6 +146,7 @@ def test_runner_02(mocker):
     assert not smap.dynamic
     assert smap.redirect.get("grz_next_test").target == "grz_empty"
 
+
 @mark.parametrize(
     "srv_result, served",
     [
@@ -152,7 +154,7 @@ def test_runner_02(mocker):
         (SERVED_NONE, []),
         # landing page not served
         (SERVED_REQUEST, ["harness"]),
-    ]
+    ],
 )
 def test_runner_03(mocker, srv_result, served):
     """test Runner() errors"""
@@ -170,6 +172,7 @@ def test_runner_03(mocker, srv_result, served):
     assert not result.timeout
     assert target.close.call_count == 1
 
+
 @mark.parametrize(
     "ignore, status, idle, detect_failure",
     [
@@ -179,7 +182,7 @@ def test_runner_03(mocker, srv_result, served):
         (["timeout"], RunResult.IGNORED, False, 0),
         # ignore idle hang
         ([], RunResult.IGNORED, True, 0),
-    ]
+    ],
 )
 def test_runner_04(mocker, ignore, status, idle, detect_failure):
     """test reporting timeout"""
@@ -201,6 +204,7 @@ def test_runner_04(mocker, ignore, status, idle, detect_failure):
     assert target.detect_failure.call_count == detect_failure
     assert target.handle_hang.call_count == 1
 
+
 @mark.parametrize(
     "served, attempted, target_result, status",
     [
@@ -210,7 +214,7 @@ def test_runner_04(mocker, ignore, status, idle, detect_failure):
         (["a.bin"], True, Target.RESULT_IGNORED, RunResult.IGNORED),
         # failure before serving landing page
         (["harness"], False, Target.RESULT_FAILURE, RunResult.FAILED),
-    ]
+    ],
 )
 def test_runner_05(mocker, served, attempted, target_result, status):
     """test reporting failures"""
@@ -231,6 +235,7 @@ def test_runner_05(mocker, served, attempted, target_result, status):
     assert target.handle_hang.call_count == 0
     assert target.close.call_count == 1
 
+
 def test_runner_06(mocker):
     """test Runner() with idle checking"""
     server = mocker.Mock(spec=Sapphire)
@@ -243,11 +248,13 @@ def test_runner_06(mocker):
     result = runner.run(
         [],
         ServerMap(),
-        mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[]))
+        mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[]),
+    )
     assert result.status is None
     assert result.attempted
     assert target.close.call_count == 0
 
+
 def test_runner_07(mocker):
     """test Runner._keep_waiting()"""
     server = mocker.Mock(spec=Sapphire)
@@ -273,6 +280,7 @@ def test_runner_07(mocker):
     target.monitor.is_healthy.return_value = False
     assert not runner._keep_waiting()
 
+
 def test_runner_08():
     """test Runner.location()"""
     result = Runner.location("a.html", 34567)
@@ -286,6 +294,7 @@ def test_runner_08():
     result = Runner.location("a.html", 9999, close_after=10, time_limit=60)
     assert result == "http://127.0.0.1:9999/a.html?close_after=10&time_limit=60000"
 
+
 def test_runner_09(mocker):
     """test Runner.launch()"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
@@ -309,6 +318,7 @@ def test_runner_09(mocker):
         runner.launch("http://a/", max_retries=3)
     assert target.launch.call_count == 3
 
+
 def test_runner_10(mocker, tmp_path):
     """test Runner.run() adding includes to testcase"""
     server = mocker.Mock(spec=Sapphire)
@@ -316,16 +326,16 @@ def test_runner_10(mocker, tmp_path):
     target.detect_failure.return_value = target.RESULT_NONE
     runner = Runner(server, target, relaunch=10)
     # create test files
-    inc_path1 = (tmp_path / "include")
+    inc_path1 = tmp_path / "include"
     inc_path1.mkdir()
-    inc1 = (inc_path1 / "inc_file.bin")
+    inc1 = inc_path1 / "inc_file.bin"
     inc1.write_bytes(b"a")
     (inc_path1 / "nested").mkdir()
-    inc2 = (inc_path1 /  "nested" / "nested_inc.bin")
+    inc2 = inc_path1 / "nested" / "nested_inc.bin"
     inc2.write_bytes(b"a")
-    inc_path2 = (tmp_path / "include2")
+    inc_path2 = tmp_path / "include2"
     inc_path2.mkdir()
-    inc3 = (inc_path2 / "inc_file3.txt")
+    inc3 = inc_path2 / "inc_file3.txt"
     inc3.write_bytes(b"a")
     # build server map
     smap = ServerMap()
@@ -341,6 +351,7 @@ def test_runner_10(mocker, tmp_path):
         assert pathjoin("nested", "nested_inc.bin") in tcase._existing_paths
         assert pathjoin("test", "inc_file3.txt") in tcase._existing_paths
 
+
 def test_idle_check_01(mocker):
     """test simple _IdleChecker"""
     fake_time = mocker.patch("grizzly.common.runner.time", autospec=True)
@@ -355,6 +366,7 @@ def test_idle_check_01(mocker):
     ichk.schedule_poll()
     assert ichk._next_poll == 1
 
+
 def test_idle_check_02(mocker):
     """test _IdleChecker.is_idle()"""
     fake_time = mocker.patch("grizzly.common.runner.time", autospec=True)
diff --git a/grizzly/common/test_stack_hasher.py b/grizzly/common/test_stack_hasher.py
index 04a09e4d..36f3965e 100644
--- a/grizzly/common/test_stack_hasher.py
+++ b/grizzly/common/test_stack_hasher.py
@@ -15,6 +15,7 @@ def test_stack_01():
     assert isinstance(stack.frames, list)
     assert stack._major_depth > 0  # pylint: disable=protected-access
 
+
 def test_stack_02():
     """test creating a Stack with 1 frame"""
     frames = [StackFrame(function="a", location="b", offset="c", stack_line="0")]
@@ -30,11 +31,14 @@ def test_stack_02():
     assert "location: 'b'" in output
     assert "offset: 'c'" in output
 
+
 def test_stack_03():
     """test creating a Stack with 2 frames"""
     frames = list()
     for _ in range(2):
-        frames.append(StackFrame(function="a", location="b", offset="c", stack_line="0"))
+        frames.append(
+            StackFrame(function="a", location="b", offset="c", stack_line="0")
+        )
     stack = Stack(frames=frames, major_depth=2)
     assert stack.minor is not None
     assert stack.major is not None
@@ -43,11 +47,14 @@ def test_stack_03():
     assert stack.minor != stack.major
     assert len(stack.frames) == 2
 
+
 def test_stack_04():
     """test creating a Stack with 2 frames with a major depth of 0"""
     frames = list()
     for line in range(2):
-        frames.append(StackFrame(function="a", location="b", offset="c", stack_line=str(line)))
+        frames.append(
+            StackFrame(function="a", location="b", offset="c", stack_line=str(line))
+        )
     stack = Stack(frames=frames, major_depth=0)
     assert stack.minor is not None
     assert stack.major is None
@@ -56,11 +63,14 @@ def test_stack_04():
     assert stack.minor != stack.major
     assert len(stack.frames) == 2
 
+
 def test_stack_05():
     """test creating a Stack with 10 frames exceeding major depth"""
     frames = list()
     for line in range(10):
-        frames.append(StackFrame(function="a", location="b", offset="c", stack_line=str(line)))
+        frames.append(
+            StackFrame(function="a", location="b", offset="c", stack_line=str(line))
+        )
     stack = Stack(frames=frames, major_depth=5)
     assert stack.minor is not None
     assert stack.major is not None
@@ -70,48 +80,64 @@ def test_stack_05():
     assert len(stack.frames) == 10
     assert stack.major != Stack(frames=frames, major_depth=4).major
 
+
 def test_stack_06():
     """test creating a Stack by calling from_text()"""
-    input_txt = "" \
-        "=================================================================\n" \
-        "==7854==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000 (pc 0x7fcca620e0ee bp 0x7ffd946b2690 sp 0x7ffd946b25c0 T0)\n" \
-        "==7854==blah.\n" \
-        "==7854==Hint: blah.\n" \
-        "    #0 0x7fcca620e0ed in test::test::test(nsIWa*, nsICa*) /aa/bb/cc/dd/ee/ff/gg/asdf.cpp:5533:14\n" \
-        "    #1 0x7fcca3497201 in nsAs::TestTest(mz::dom::El*, int) /aa/bb/cc/dd/ee/ff/nsFilea.cpp:13733:3\n" \
-        "    #2 0x7fcca3495b9b in asdf::fasd() /aa/bb/cc/dd/ee/ff/base/nsFileb.cpp:11674:21\n" \
-        "    #3 0x7fcca02eb9d8 in nsAasd::PrNeEv(bool, bool*) /aa/bb/cc/dd/ee/xpcom/nsFilec.cpp:1396:14\n" \
-        "    #4 0x7fcca0307d40 in R_PNE(asd*, bool) /aa/bb/cc/dd/ee/xpcom/threads/asf.cpp:657:10\n" \
-        "    #5 0x2a780b25f65a  (<unknown module>)\n" \
-        "\n" \
-        "AddressSanitizer can not provide additional info.\n" \
-        "SUMMARY: AddressSanitizer: SEGV /aa/bb/cc/dd/ee/ff/asdf.cpp:5533:14 in test::test::test(nsIWa*, nsICa*)\n" \
+    input_txt = (
+        "=================================================================\n"
+        "==7854==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000"
+        " (pc 0x7fcca620e0ee bp 0x7ffd946b2690 sp 0x7ffd946b25c0 T0)\n"
+        "==7854==blah.\n"
+        "==7854==Hint: blah.\n"
+        "    #0 0x7fcca620e0ed in test::test::test(nsIWa*, nsICa*)"
+        " /aa/bb/cc/dd/ee/ff/gg/asdf.cpp:5533:14\n"
+        "    #1 0x7fcca3497201 in nsAs::TestTest(mz::dom::El*, int)"
+        " /aa/bb/cc/dd/ee/ff/nsFilea.cpp:13733:3\n"
+        "    #2 0x7fcca3495b9b in asdf::fasd()"
+        " /aa/bb/cc/dd/ee/ff/base/nsFileb.cpp:11674:21\n"
+        "    #3 0x7fcca02eb9d8 in nsAasd::PrNeEv(bool, bool*)"
+        " /aa/bb/cc/dd/ee/xpcom/nsFilec.cpp:1396:14\n"
+        "    #4 0x7fcca0307d40 in R_PNE(asd*, bool)"
+        " /aa/bb/cc/dd/ee/xpcom/threads/asf.cpp:657:10\n"
+        "    #5 0x2a780b25f65a  (<unknown module>)\n"
+        "\n"
+        "AddressSanitizer can not provide additional info.\n"
+        "SUMMARY: AddressSanitizer: SEGV /aa/bb/cc/dd/ee/ff/asdf.cpp:5533:14"
+        " in test::test::test(nsIWa*, nsICa*)\n"
         "==7854==ABORTING\n"
+    )
     stack = Stack.from_text(input_txt)
     assert len(stack.frames) == 6
     assert stack.minor != stack.major
     assert stack.frames[0].mode == StackFrame.MODE_SANITIZER
 
+
 def test_stack_07():
     """test creating a Stack by calling from_text() with mixed frames modes"""
-    input_txt = "" \
-    "    #0 0x4d2cde in a_b_c /a/lib/info.c:392:12\n" \
-    "    #1 0x491e82 in main /a/b/d_e.c:128:8\n" \
-    "    #2 0x7f090384582f in __libc_start_main /build/glibc-glibc-2.23/csu/../csu/libc-start.c:291\n" \
-    "#2  0x0000000000400545 in gdb_frame ()\n" \
-    "    #3 0x41b228 in _start (bin_name+0x41b228)\n"
+    input_txt = (
+        ""
+        "    #0 0x4d2cde in a_b_c /a/lib/info.c:392:12\n"
+        "    #1 0x491e82 in main /a/b/d_e.c:128:8\n"
+        "    #2 0x7f090384582f in __libc_start_main /build/glibc-glibc-2.23/csu/"
+        "../csu/libc-start.c:291\n"
+        "#2  0x0000000000400545 in gdb_frame ()\n"
+        "    #3 0x41b228 in _start (bin_name+0x41b228)\n"
+    )
     stack = Stack.from_text(input_txt)
     assert len(stack.frames) == 4
     assert stack.minor != stack.major
     assert stack.frames[0].mode == StackFrame.MODE_SANITIZER
 
+
 def test_stack_08():
     """test creating a Stack by calling from_text() with text containing 2 stacks"""
-    input_txt = "" \
-        "    #0 0x0bad0bad in bad::frame0(nsA*, nsB*) /aa/a.cpp:12:1\n" \
-        "    #1 0x0bad0bad in bad::frame1(mz::d::EE*, int) /aa/a.cpp:12:1\n" \
-        "    #0 0x1badf00d in good::frame0(nsA*, nsB*) /aa/a.cpp:12:1\n" \
+    input_txt = (
+        ""
+        "    #0 0x0bad0bad in bad::frame0(nsA*, nsB*) /aa/a.cpp:12:1\n"
+        "    #1 0x0bad0bad in bad::frame1(mz::d::EE*, int) /aa/a.cpp:12:1\n"
+        "    #0 0x1badf00d in good::frame0(nsA*, nsB*) /aa/a.cpp:12:1\n"
         "    #1 0xdeadbeef in good::frame1(mz::d::EE*, int) /aa/a.cpp:12:1\n"
+    )
     stack = Stack.from_text(input_txt)
     assert len(stack.frames) == 2
     assert stack.frames[0].function == "good::frame0"
@@ -119,6 +145,7 @@ def test_stack_08():
     assert stack.minor != stack.major
     assert stack.frames[0].mode == StackFrame.MODE_SANITIZER
 
+
 def test_stack_09():
     """test creating a Stack by calling from_text() with empty string"""
     stack = Stack.from_text("")
@@ -126,12 +153,15 @@ def test_stack_09():
     assert stack.minor is None
     assert stack.major is None
 
+
 def test_stack_10():
     """test creating a Stack from a Sanitizer trace with an unsymbolized lib"""
-    input_txt = "" \
-        "    #0 0x4c7702 in realloc asan/asan_malloc_linux.cc:107:3\n" \
-        "    #1 0x7f6d056ce7fc  (/lib/x86_64-linux-gnu/libdbus-1.so.3+0x2d7fc)\n" \
+    input_txt = (
+        ""
+        "    #0 0x4c7702 in realloc asan/asan_malloc_linux.cc:107:3\n"
+        "    #1 0x7f6d056ce7fc  (/lib/x86_64-linux-gnu/libdbus-1.so.3+0x2d7fc)\n"
         "    #2 0x7ffffffff  (<unknown module>)\n"
+    )
     stack = Stack.from_text(input_txt)
     assert len(stack.frames) == 3
     assert stack.frames[0].location == "asan_malloc_linux.cc"
@@ -140,13 +170,16 @@ def test_stack_10():
     assert stack.minor != stack.major
     assert stack.frames[0].mode == StackFrame.MODE_SANITIZER
 
+
 def test_stack_11():
     """test creating a Stack from a Sanitizer trace with an unsymbolized lib"""
-    input_txt = "" \
-        "    #0 0x90000223  (/usr/swr_a.so+0x231223)\n" \
-        "    #1 0x00000447  (/usr/as.so.1+0x42447)\n" \
-        "    #2 0x000098fc in fSasd /src/obj-firefox/dist/include/something.h:102:9\n" \
+    input_txt = (
+        ""
+        "    #0 0x90000223  (/usr/swr_a.so+0x231223)\n"
+        "    #1 0x00000447  (/usr/as.so.1+0x42447)\n"
+        "    #2 0x000098fc in fSasd /src/obj-firefox/dist/include/something.h:102:9\n"
         "    #3 0x000098fc in mz::as::asdf::SB() /src/Blah.cpp:655\n"
+    )
     stack = Stack.from_text(input_txt)
     assert len(stack.frames) == 4
     assert stack.frames[0].location == "swr_a.so"
@@ -156,18 +189,21 @@ def test_stack_11():
     assert stack.minor != stack.major
     assert stack.frames[0].mode == StackFrame.MODE_SANITIZER
 
+
 def test_stack_12():
     """test creating a Stack from a Valgrind trace"""
-    input_txt = "" \
-        "==4754== \n" \
-        "==4754== Use of uninitialised value of size 8\n" \
-        "==4754==    at 0x45C6C0: FooBar (decode.c:964)\n" \
-        "==4754==    by 0x462A20: main (test.cc:71)\n" \
-        "==4754==  Uninitialised value was created by a heap allocation\n" \
-        "==4754==    at 0x4C2AB80: malloc (in /usr/lib/test-linux.so)\n" \
-        "==4754==    by 0x459455: FooBar (decode.c:757)\n" \
-        "==4754==    by 0x462A20: main (test.cc:71)\n" \
+    input_txt = (
+        ""
         "==4754== \n"
+        "==4754== Use of uninitialised value of size 8\n"
+        "==4754==    at 0x45C6C0: FooBar (decode.c:964)\n"
+        "==4754==    by 0x462A20: main (test.cc:71)\n"
+        "==4754==  Uninitialised value was created by a heap allocation\n"
+        "==4754==    at 0x4C2AB80: malloc (in /usr/lib/test-linux.so)\n"
+        "==4754==    by 0x459455: FooBar (decode.c:757)\n"
+        "==4754==    by 0x462A20: main (test.cc:71)\n"
+        "==4754== \n"
+    )
     stack = Stack.from_text(input_txt)
     assert len(stack.frames) == 5
     assert stack.frames[0].location == "decode.c"
@@ -178,50 +214,68 @@ def test_stack_12():
     assert stack.minor != stack.major
     assert stack.frames[0].mode == StackFrame.MODE_VALGRIND
 
+
 def test_stack_13():
     """test creating a Stack from Rust trace"""
-    input_txt = "" \
-    "thread '<unnamed>' panicked at 'Invoking Servo_Element_IsDisplayContents on unstyled element', libcore/option.rs:917:5\n" \
-    "stack backtrace:\n" \
-    "   0:     0x7ff1c65e93d3 - std::sys::unix::backtrace::tracing::imp::unwind_backtrace::h09c1ee131a74b1c4\n" \
-    "                               at libstd/sys/unix/backtrace/tracing/gcc_s.rs:49\n" \
-    "   1:     0x7ff1c65e81c4 - std::panicking::default_hook::{{closure}}::h945a649c9017832e\n" \
-    "                               at libstd/sys_common/backtrace.rs:71\n" \
-    "                               at libstd/sys_common/backtrace.rs:59\n" \
-    "                               at libstd/panicking.rs:380\n" \
-    "   2:     0x7ff1c65e7457 - std::panicking::default_hook::hcc534c2d30fbcda3\n" \
-    "                               at libstd/panicking.rs:396\n" \
-    "   3:     0x7ff1c65e6de7 - std::panicking::rust_panic_with_hook::h09a7a3a353dc2f38\n" \
-    "                               at libstd/panicking.rs:576\n" \
-    "   4:     0x7ff1c65e6c95 - std::panicking::begin_panic::h8327f16bde15df70\n" \
-    "                               at libstd/panicking.rs:537\n" \
-    "   5:     0x7ff1c65e6c29 - std::panicking::begin_panic_fmt::h42ff1d37404632d6\n" \
-    "                               at libstd/panicking.rs:521\n" \
-    "   6:     0x7ff1c65fa46a - core::panicking::panic_fmt::h0bd854df201d1baf\n" \
-    "                               at libstd/panicking.rs:497\n" \
-    "   7:     0x7ff1c65ffba8 - core::option::expect_failed::hfa0c8a51e07f7adc\n" \
-    "                               at libcore/option.rs:917\n" \
-    "   8:     0x7ff1c632d473 - Servo_Element_IsDisplayContents\n" \
-    "                               at /checkout/src/libcore/option.rs:302\n" \
-    "                               at servo/ports/geckolib/glue.rs:1086\n" \
-    "   9:     0x7f44064ee749 - _ZNK7nsFrame24DoGetParentComputedStyleEPP8nsIFrame\n" \
-    "                                at /builds/worker/workspace/build/src/layout/generic/nsFrame.cpp:9893\n" \
-    "   10:     0x7f4406229749 - _ZN7mozilla14RestyleManager35DoReparentComputedStyleForFirstLineEP8nsIFrameRNS_13ServoStyleSetE\n" \
-    "                                at /builds/worker/workspace/build/src/layout/base/RestyleManager.cpp:3407\n" \
-    "   11:     0x7f440622a0a5 - _ZN7mozilla14RestyleManager24ReparentFrameDescendantsEP8nsIFrameS2_RNS_13ServoStyleSetE\n" \
-    "                                at /builds/worker/workspace/build/src/layout/base/RestyleManager.cpp:3538\n"
+    input_txt = (
+        "thread '<unnamed>' panicked at 'Invoking Servo_Element_IsDisplayContents"
+        " on unstyled element', libcore/option.rs:917:5\n"
+        "stack backtrace:\n"
+        "   0:     0x7ff1c65e93d3 - std::sys::unix::backtrace::tracing::imp::unwind_bac"
+        "ktrace::h09c1ee131a74b1c4\n"
+        "                               at libstd/sys/unix/backtrace/tracing/gcc_s.rs:4"
+        "9\n"
+        "   1:     0x7ff1c65e81c4 - std::panicking::default_hook::{{closure}}::h945a649"
+        "c9017832e\n"
+        "                               at libstd/sys_common/backtrace.rs:71\n"
+        "                               at libstd/sys_common/backtrace.rs:59\n"
+        "                               at libstd/panicking.rs:380\n"
+        "   2:     0x7ff1c65e7457 - std::panicking::default_hook::hcc534c2d30fbcda3\n"
+        "                               at libstd/panicking.rs:396\n"
+        "   3:     0x7ff1c65e6de7 - std::panicking::rust_panic_with_hook::h09a7a3a353dc"
+        "2f38\n"
+        "                               at libstd/panicking.rs:576\n"
+        "   4:     0x7ff1c65e6c95 - std::panicking::begin_panic::h8327f16bde15df70\n"
+        "                               at libstd/panicking.rs:537\n"
+        "   5:     0x7ff1c65e6c29 - std::panicking::begin_panic_fmt::h42ff1d3740463d6\n"
+        "                               at libstd/panicking.rs:521\n"
+        "   6:     0x7ff1c65fa46a - core::panicking::panic_fmt::h0bd854df201d1baf\n"
+        "                               at libstd/panicking.rs:497\n"
+        "   7:     0x7ff1c65ffba8 - core::option::expect_failed::hfa0c8a51e07f7adc\n"
+        "                               at libcore/option.rs:917\n"
+        "   8:     0x7ff1c632d473 - Servo_Element_IsDisplayContents\n"
+        "                               at /checkout/src/libcore/option.rs:302\n"
+        "                               at servo/ports/geckolib/glue.rs:1086\n"
+        "   9:     0x7f44064ee749 - _ZNK7nsFrame24DoGetParentComputedStyleEPPnsIFrame\n"
+        "                                at /builds/worker/workspace/build/src/layout/g"
+        "eneric/nsFrame.cpp:9893\n"
+        "   10:     0x7f4406229749 - _ZN7mozilla14RestyleManager35DoReparentComputedSty"
+        "leForFirstLineEP8nsIFrameRNS_13ServoStyleSetE\n"
+        "                                at /builds/worker/workspace/build/src/layout/b"
+        "ase/RestyleManager.cpp:3407\n"
+        "   11:     0x7f440622a0a5 - _ZN7mozilla14RestyleManager24ReparentFrameDescenda"
+        "ntsEP8nsIFrameS2_RNS_13ServoStyleSetE\n"
+        "                                at /builds/worker/workspace/build/src/layout/b"
+        "ase/RestyleManager.cpp:3538\n"
+    )
     stack = Stack.from_text(input_txt)
     assert len(stack.frames) == 12
-    assert stack.frames[0].function == "std::sys::unix::backtrace::tracing::imp::unwind_backtrace"
+    assert (
+        stack.frames[0].function
+        == "std::sys::unix::backtrace::tracing::imp::unwind_backtrace"
+    )
     assert stack.frames[8].function == "Servo_Element_IsDisplayContents"
     assert stack.minor != stack.major
     assert stack.frames[0].mode == StackFrame.MODE_RUST
 
+
 def test_stack_14():
     """test Stack.height_limit"""
     frames = list()
     for num in range(10):
-        frames.append(StackFrame(function=str(num), location="b", offset="c", stack_line=str(num)))
+        frames.append(
+            StackFrame(function=str(num), location="b", offset="c", stack_line=str(num))
+        )
     stack = Stack(frames=frames, major_depth=3)
     assert stack.height_limit is None
     no_lim_minor = stack.minor
@@ -241,11 +295,13 @@ def test_stack_14():
     assert no_lim_minor == stack.minor
     assert no_lim_major == stack.major
 
+
 def test_stackframe_01():
     """test creating an empty StackFrame"""
     stack = StackFrame()
     assert not stack.__str__()
 
+
 def test_stackframe_02():
     """test creating a StackFrame from junk"""
     assert StackFrame.from_line("#0      ") is None
@@ -263,51 +319,67 @@ def test_stackframe_02():
     assert StackFrame.from_line("==123==") is None
     assert StackFrame.from_line("==1== by 0x0: a ()") is None
 
+
 def test_sanitizer_stackframe_01():
     """test creating a StackFrame from a line with symbols"""
-    frame = StackFrame.from_line("    #1 0x7f00dad60565 in Abort(char const*) /blah/base/nsDebugImpl.cpp:472")
+    frame = StackFrame.from_line(
+        "    #1 0x7f00dad60565 in Abort(char const*) /blah/base/nsDebugImpl.cpp:472"
+    )
     assert frame.stack_line == "1"
     assert frame.function == "Abort"
     assert frame.location == "nsDebugImpl.cpp"
     assert frame.offset == "472"
     assert frame.mode == StackFrame.MODE_SANITIZER
 
+
 def test_sanitizer_stackframe_02():
     """test creating a StackFrame from a line with symbols"""
-    frame = StackFrame.from_line("    #36 0x48a6e4 in main /app/nsBrowserApp.cpp:399:11")
+    frame = StackFrame.from_line(
+        "    #36 0x48a6e4 in main /app/nsBrowserApp.cpp:399:11"
+    )
     assert frame.stack_line == "36"
     assert frame.function == "main"
     assert frame.location == "nsBrowserApp.cpp"
     assert frame.offset == "399"
     assert frame.mode == StackFrame.MODE_SANITIZER
 
+
 def test_sanitizer_stackframe_03():
     """test creating a StackFrame from a line without symbols"""
-    frame = StackFrame.from_line("    #1 0x7f00ecc1b33f (/lib/x86_64-linux-gnu/libpthread.so.0+0x1033f)")
+    frame = StackFrame.from_line(
+        "    #1 0x7f00ecc1b33f (/lib/x86_64-linux-gnu/libpthread.so.0+0x1033f)"
+    )
     assert frame.stack_line == "1"
     assert frame.function is None
     assert frame.location == "libpthread.so.0"
     assert frame.offset == "0x1033f"
     assert frame.mode == StackFrame.MODE_SANITIZER
 
+
 def test_sanitizer_stackframe_04():
     """test creating a StackFrame from a line with symbols"""
-    frame = StackFrame.from_line("    #25 0x7f0155526181 in start_thread (/l/libpthread.so.0+0x8181)")
+    frame = StackFrame.from_line(
+        "    #25 0x7f0155526181 in start_thread (/l/libpthread.so.0+0x8181)"
+    )
     assert frame.stack_line == "25"
     assert frame.function == "start_thread"
     assert frame.location == "libpthread.so.0"
     assert frame.offset == "0x8181"
     assert frame.mode == StackFrame.MODE_SANITIZER
 
+
 def test_sanitizer_stackframe_05():
     """test creating a StackFrame from a line with angle brackets"""
-    frame = StackFrame.from_line("    #123 0x7f30afea9148 in Call<nsBlah *> /a/b.cpp:356:50")
+    frame = StackFrame.from_line(
+        "    #123 0x7f30afea9148 in Call<nsBlah *> /a/b.cpp:356:50"
+    )
     assert frame.stack_line == "123"
     assert frame.function == "Call"
     assert frame.location == "b.cpp"
     assert frame.offset == "356"
     assert frame.mode == StackFrame.MODE_SANITIZER
 
+
 def test_sanitizer_stackframe_06():
     """test creating a StackFrame from a useless frame"""
     frame = StackFrame.from_line("    #2 0x7ffffffff  (<unknown module>)")
@@ -317,33 +389,43 @@ def test_sanitizer_stackframe_06():
     assert frame.offset is None
     assert frame.mode == StackFrame.MODE_SANITIZER
 
+
 def test_sanitizer_stackframe_07():
     """test creating a StackFrame from a line missing a function"""
-    frame = StackFrame.from_line("    #0 0x7f0d571e04bd  /a/glibc-2.23/../syscall-template.S:84")
+    frame = StackFrame.from_line(
+        "    #0 0x7f0d571e04bd  /a/glibc-2.23/../syscall-template.S:84"
+    )
     assert frame.stack_line == "0"
     assert frame.function is None
     assert frame.location == "syscall-template.S"
     assert frame.offset == "84"
     assert frame.mode == StackFrame.MODE_SANITIZER
 
+
 def test_sanitizer_stackframe_08():
     """test creating a StackFrame from a line with lots of spaces"""
-    frame = StackFrame.from_line("    #0 0x48a6e4 in Call<a *> /test path/file name.c:1:2")
+    frame = StackFrame.from_line(
+        "    #0 0x48a6e4 in Call<a *> /test path/file name.c:1:2"
+    )
     assert frame.stack_line == "0"
     assert frame.function == "Call"
     assert frame.location == "file name.c"
     assert frame.offset == "1"
     assert frame.mode == StackFrame.MODE_SANITIZER
 
+
 def test_gdb_stackframe_01():
     """test creating a StackFrame from a GDB line with symbols"""
-    frame = StackFrame.from_line("#0  __memmove_ssse3_back () at ../d/x86_64/a/memcpy-ssse3-back.S:1654")
+    frame = StackFrame.from_line(
+        "#0  __memmove_ssse3_back () at ../d/x86_64/a/memcpy-ssse3-back.S:1654"
+    )
     assert frame.stack_line == "0"
     assert frame.function == "__memmove_ssse3_back"
     assert frame.location == "memcpy-ssse3-back.S"
     assert frame.offset == "1654"
     assert frame.mode == StackFrame.MODE_GDB
 
+
 def test_gdb_stackframe_02():
     """test creating a StackFrame from a GDB line with symbols but no line numbers"""
     frame = StackFrame.from_line("#2  0x0000000000400545 in main ()")
@@ -353,6 +435,7 @@ def test_gdb_stackframe_02():
     assert frame.offset is None
     assert frame.mode == StackFrame.MODE_GDB
 
+
 def test_gdb_stackframe_03():
     """test creating a StackFrame from a GDB line with symbols"""
     frame = StackFrame.from_line("#3  0x0000000000400545 in main () at test.c:5")
@@ -362,15 +445,19 @@ def test_gdb_stackframe_03():
     assert frame.offset == "5"
     assert frame.mode == StackFrame.MODE_GDB
 
+
 def test_minidump_stackframe_01():
     """test creating a StackFrame from a Minidump line with symbols"""
-    frame = StackFrame.from_line("0|2|libtest|main|hg:c.a.org/m-c:a/b/file.cpp:5bf50|114|0x3a")
+    frame = StackFrame.from_line(
+        "0|2|libtest|main|hg:c.a.org/m-c:a/b/file.cpp:5bf50|114|0x3a"
+    )
     assert frame.stack_line == "2"
     assert frame.function == "main"
     assert frame.location == "file.cpp"
     assert frame.offset == "114"
     assert frame.mode == StackFrame.MODE_MINIDUMP
 
+
 def test_minidump_stackframe_02():
     """test creating a StackFrame from a Minidump line without symbols"""
     frame = StackFrame.from_line("9|42|libpthread-2.26.so||||0x10588")
@@ -380,15 +467,19 @@ def test_minidump_stackframe_02():
     assert frame.offset == "0x10588"
     assert frame.mode == StackFrame.MODE_MINIDUMP
 
+
 def test_minidump_stackframe_03():
     """test creating a StackFrame from a Minidump line without hg repo info"""
-    frame = StackFrame.from_line("0|49|libxul.so|foo|/usr/x86_64-linux-gnu/test.h|85|0x5")
+    frame = StackFrame.from_line(
+        "0|49|libxul.so|foo|/usr/x86_64-linux-gnu/test.h|85|0x5"
+    )
     assert frame.stack_line == "49"
     assert frame.function == "foo"
     assert frame.location == "/usr/x86_64-linux-gnu/test.h"
     assert frame.offset == "85"
     assert frame.mode == StackFrame.MODE_MINIDUMP
 
+
 def test_tsan_stackframe_01():
     """test creating a StackFrame from a symbolized TSan line"""
     frame = StackFrame.from_line("    #0 main race.c:10 (exe+0xa3b4)")
@@ -398,15 +489,19 @@ def test_tsan_stackframe_01():
     assert frame.offset == "10"
     assert frame.mode == StackFrame.MODE_TSAN
 
+
 def test_tsan_stackframe_02():
     """test creating a StackFrame from a symbolized TSan line"""
-    frame = StackFrame.from_line("    #1 test1 test2 /a b/c.h:51:10 (libxul.so+0x18c9873)")
+    frame = StackFrame.from_line(
+        "    #1 test1 test2 /a b/c.h:51:10 (libxul.so+0x18c9873)"
+    )
     assert frame.stack_line == "1"
     assert frame.function == "test1"
     assert frame.location == "c.h"
     assert frame.offset == "51"
     assert frame.mode == StackFrame.MODE_TSAN
 
+
 def test_tsan_stackframe_03():
     """test creating a StackFrame from an unsymbolized TSan line"""
     frame = StackFrame.from_line("    #2 <null> <null> (0xbad)")
@@ -416,6 +511,7 @@ def test_tsan_stackframe_03():
     assert frame.offset == "0xbad"
     assert frame.mode == StackFrame.MODE_TSAN
 
+
 def test_tsan_stackframe_04():
     """test creating a StackFrame from a TSan line missing file"""
     frame = StackFrame.from_line("    #0 func <null> (mod+0x123ac)")
@@ -425,6 +521,7 @@ def test_tsan_stackframe_04():
     assert frame.offset == "0x123ac"
     assert frame.mode == StackFrame.MODE_TSAN
 
+
 def test_valgrind_stackframe_01():
     frame = StackFrame.from_line("==4754==    at 0x45C6C0: FuncName (decode.c:123)")
     assert frame.stack_line is None
@@ -433,6 +530,7 @@ def test_valgrind_stackframe_01():
     assert frame.offset == "123"
     assert frame.mode == StackFrame.MODE_VALGRIND
 
+
 def test_valgrind_stackframe_02():
     frame = StackFrame.from_line("==4754==    by 0x462A20: main (foo.cc:71)")
     assert frame.stack_line is None
@@ -441,30 +539,40 @@ def test_valgrind_stackframe_02():
     assert frame.offset == "71"
     assert frame.mode == StackFrame.MODE_VALGRIND
 
+
 def test_valgrind_stackframe_03():
-    frame = StackFrame.from_line("==4754==    at 0x4C2AB80: malloc (in /usr/lib/blah-linux.so)")
+    frame = StackFrame.from_line(
+        "==4754==    at 0x4C2AB80: malloc (in /usr/lib/blah-linux.so)"
+    )
     assert frame.stack_line is None
     assert frame.function == "malloc"
     assert frame.location == "blah-linux.so"
     assert frame.offset is None
     assert frame.mode == StackFrame.MODE_VALGRIND
 
+
 def test_valgrind_stackframe_04():
-    frame = StackFrame.from_line("==2342==    by 0x4E3E71: (anon ns)::test(b2::a&, int) (main.cpp:49)")
+    frame = StackFrame.from_line(
+        "==2342==    by 0x4E3E71: (anon ns)::test(b2::a&, int) (main.cpp:49)"
+    )
     assert frame.stack_line is None
     assert frame.function == "(anon ns)::test(b2::a&, int)"
     assert frame.location == "main.cpp"
     assert frame.offset == "49"
     assert frame.mode == StackFrame.MODE_VALGRIND
 
+
 def test_valgrind_stackframe_05():
-    frame = StackFrame.from_line("==2342==    at 0xF00D: Foo::Foo(char *, int, bool) (File.h:37)")
+    frame = StackFrame.from_line(
+        "==2342==    at 0xF00D: Foo::Foo(char *, int, bool) (File.h:37)"
+    )
     assert frame.stack_line is None
     assert frame.function == "Foo::Foo(char *, int, bool)"
     assert frame.location == "File.h"
     assert frame.offset == "37"
     assert frame.mode == StackFrame.MODE_VALGRIND
 
+
 def test_rr_stackframe_01():
     frame = StackFrame.from_line("rr(main+0x244)[0x450b74]")
     assert frame.stack_line is None
@@ -473,6 +581,7 @@ def test_rr_stackframe_01():
     assert frame.offset == "0x244"
     assert frame.mode == StackFrame.MODE_RR
 
+
 def test_rust_stackframe_01():
     """test creating a Rust StackFrame from stack line"""
     frame = StackFrame.from_line("  53:    0x7ff1d7e4982f - __libc_start_main")
@@ -482,9 +591,12 @@ def test_rust_stackframe_01():
     assert frame.offset is None
     assert frame.mode == StackFrame.MODE_RUST
 
+
 def test_rust_stackframe_02():
     """test creating a Rust StackFrame from stack line"""
-    frame = StackFrame.from_line("  4:    0x10b715a5b - unwind::begin_unwind_fmt::h227376fe1e021a36n3d")
+    frame = StackFrame.from_line(
+        "  4:    0x10b715a5b - unwind::begin_unwind_fmt::h227376fe1e021a36n3d"
+    )
     assert frame.stack_line == "4"
     assert frame.location is None
     assert frame.function == "unwind::begin_unwind_fmt"
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index cf1af9c6..0de9825e 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -33,6 +33,7 @@ def test_status_01(tmp_path):
     assert not status._enable_profiling
     assert not status._profiles
 
+
 def test_status_02(tmp_path):
     """test Status.cleanup()"""
     Status.PATH = str(tmp_path)
@@ -48,6 +49,7 @@ def test_status_02(tmp_path):
     remove(status.data_file)
     status.cleanup()
 
+
 def test_status_03(tmp_path):
     """test Status.report()"""
     Status.PATH = str(tmp_path)
@@ -66,19 +68,21 @@ def test_status_03(tmp_path):
     assert status.timestamp < future
     status.cleanup()
 
+
 def test_status_04(tmp_path):
     """test Status.load() failure paths"""
     Status.PATH = str(tmp_path)
     # load no db
     assert Status.load(str(tmp_path / "missing.json")) is None
     # load empty
-    bad = (tmp_path / "bad.json")
+    bad = tmp_path / "bad.json"
     bad.touch()
     assert Status.load(str(bad)) is None
     # load invalid/incomplete json
     bad.write_bytes(b"{}")
     assert Status.load(str(bad)) is None
 
+
 def test_status_05(tmp_path):
     """test Status.load()"""
     Status.PATH = str(tmp_path)
@@ -106,9 +110,10 @@ def test_status_05(tmp_path):
     status.cleanup()
     assert not isfile(data_file)
 
+
 def test_status_06(tmp_path):
     """test Status.loadall()"""
-    working_path = (tmp_path / "status")
+    working_path = tmp_path / "status"
     Status.PATH = str(working_path)
     # missing path
     assert not any(Status.loadall())
@@ -121,6 +126,7 @@ def test_status_06(tmp_path):
     (working_path / "empty.json").touch()
     assert len(tuple(Status.loadall())) == 5
 
+
 def test_status_07(tmp_path):
     """test Status.duration and Status.rate calculations"""
     Status.PATH = str(tmp_path)
@@ -135,6 +141,7 @@ def test_status_07(tmp_path):
     status.timestamp += 1
     assert status.rate == 0.5
 
+
 def _client_writer(done, reported, working_path):
     """Used by test_status_08"""
     # NOTE: this must be at the top level to work on Windows
@@ -151,6 +158,7 @@ def _client_writer(done, reported, working_path):
     finally:
         status.cleanup()
 
+
 def test_status_08(tmp_path):
     """test Status.loadall() with multiple active reporters"""
     Status.PATH = str(tmp_path)
@@ -161,7 +169,11 @@ def test_status_08(tmp_path):
         # launch processes
         for _ in range(5):
             report_events.append(Event())
-            procs.append(Process(target=_client_writer, args=(done, report_events[-1], Status.PATH)))
+            procs.append(
+                Process(
+                    target=_client_writer, args=(done, report_events[-1], Status.PATH)
+                )
+            )
             procs[-1].start()
         # wait for processes to launch and report
         for has_reported in report_events:
@@ -178,6 +190,7 @@ def test_status_08(tmp_path):
     # verify cleanup
     assert not any(Status.loadall())
 
+
 def test_status_09(tmp_path):
     """test Status.count_result() and Status.signatures()"""
     Status.PATH = str(tmp_path)
@@ -197,6 +210,7 @@ def test_status_09(tmp_path):
     assert "sig3" in found
     assert found["sig3"] == 1
 
+
 def test_status_10(tmp_path):
     """test Status.measure() and Status.record() - profiling support"""
     Status.PATH = str(tmp_path)
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 4c4661c4..3bd082ff 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -14,9 +14,12 @@
 
 
 def _fake_sys_info():
-    return "CPU & Load : 64 @ 93.1% (85.25, 76.21, 51.06)\n" \
-           "    Memory : 183.9GB of 251.9GB free\n" \
-           "      Disk : 22.2GB of 28.7GB free"
+    return (
+        "CPU & Load : 64 @ 93.1% (85.25, 76.21, 51.06)\n"
+        "    Memory : 183.9GB of 251.9GB free\n"
+        "      Disk : 22.2GB of 28.7GB free"
+    )
+
 
 def test_status_reporter_01(tmp_path):
     """test basic StatusReporter"""
@@ -34,6 +37,7 @@ def test_status_reporter_01(tmp_path):
     assert report.is_file()
     st_rpt.print_summary()
 
+
 def test_status_reporter_02(tmp_path):
     """test StatusReporter.load()"""
     Status.PATH = str(tmp_path / "missing")
@@ -51,6 +55,7 @@ def test_status_reporter_02(tmp_path):
     assert isinstance(st_rpt.tracebacks, list)
     assert not st_rpt.tracebacks
 
+
 def test_status_reporter_03(mocker):
     """test StatusReporter._sys_info()"""
     gbs = 1024 * 1024 * 1024
@@ -61,7 +66,9 @@ def test_status_reporter_03(mocker):
     fake_psutil.disk_usage.return_value = mocker.Mock(free=12, total=gbs)
     sysinfo = StatusReporter._sys_info()
     assert "MB" in sysinfo
-    fake_psutil.virtual_memory.return_value = mocker.Mock(available=1.1 * gbs, total=2 * gbs)
+    fake_psutil.virtual_memory.return_value = mocker.Mock(
+        available=1.1 * gbs, total=2 * gbs
+    )
     fake_psutil.disk_usage.return_value = mocker.Mock(free=10.23 * gbs, total=100 * gbs)
     sysinfo = StatusReporter._sys_info()
     assert "MB" not in sysinfo
@@ -75,6 +82,7 @@ def test_status_reporter_03(mocker):
     for line in lines:
         assert line[position] == ":"
 
+
 def test_status_reporter_04(tmp_path):
     """test StatusReporter._scan()"""
     re_filter = re.compile("TEST_FILE")
@@ -88,6 +96,7 @@ def test_status_reporter_04(tmp_path):
     test_path.write_bytes(b"test")
     assert tuple(StatusReporter._scan(str(tmp_path), re_filter))
 
+
 def test_status_reporter_05(tmp_path):
     """test StatusReporter._summary()"""
     Status.PATH = str(tmp_path)
@@ -133,14 +142,17 @@ def test_status_reporter_05(tmp_path):
     # verify alignment
     position = len(lines[0].split(":")[0])
     for line in lines:
-        assert re.match(r"\S\s:\s\S", line[position - 2:])
+        assert re.match(r"\S\s:\s\S", line[position - 2 :])
+
 
 def test_status_reporter_06(mocker, tmp_path):
     """test StatusReporter._specific()"""
     Status.PATH = str(tmp_path)
     mocker.patch("grizzly.common.status_reporter.time", return_value=3661.0)
     # single report
-    mocker.patch("grizzly.common.status.time", side_effect=count(start=0.0, step=3600.0))
+    mocker.patch(
+        "grizzly.common.status.time", side_effect=count(start=0.0, step=3600.0)
+    )
     status = Status.start()
     status.ignored = 0
     status.iteration = 1
@@ -155,7 +167,9 @@ def test_status_reporter_06(mocker, tmp_path):
     assert "Results" in output
     assert "EXPIRED" not in output
     # multiple reports
-    mocker.patch("grizzly.common.status.time", side_effect=count(start=0.0, step=3661.0))
+    mocker.patch(
+        "grizzly.common.status.time", side_effect=count(start=0.0, step=3661.0)
+    )
     status = Status.start(enable_profiling=True)
     status.ignored = 1
     status.iteration = 432422
@@ -188,6 +202,7 @@ def test_status_reporter_06(mocker, tmp_path):
     assert len(output.split("\n")[:-1]) == 8
     assert "EXPIRED" in output
 
+
 def test_status_reporter_07(tmp_path):
     """test StatusReporter._results()"""
     Status.PATH = str(tmp_path)
@@ -223,6 +238,7 @@ def test_status_reporter_07(tmp_path):
     assert "1: '[@ longsignature...'" in output
     assert len(output.split("\n")[:-1]) == 3
 
+
 def test_status_reporter_08(tmp_path):
     """test StatusReporter.load() with traceback"""
     (tmp_path / "status").mkdir()
@@ -263,6 +279,7 @@ def test_status_reporter_08(tmp_path):
     assert "foo.bar.error" in merged_log
     assert "screenlog.3" not in merged_log
 
+
 def test_status_reporter_09(tmp_path):
     """test StatusReporter.load() no reports with traceback"""
     (tmp_path / "status").mkdir()
@@ -280,6 +297,7 @@ def test_status_reporter_09(tmp_path):
     assert "No status reports available" in output
     assert "IndexError" in output
 
+
 def test_status_reporter_10(tmp_path):
     """test StatusReporter.summary() limit with traceback"""
     (tmp_path / "status").mkdir()
@@ -302,7 +320,9 @@ def test_status_reporter_10(tmp_path):
         with (tmp_path / ("screenlog.%d" % (i,))).open("wb") as test_fp:
             test_fp.write(b"Traceback (most recent call last):\n")
             for j in range(TracebackReport.MAX_LINES):
-                test_fp.write(b"  File \"some/long/path/name/foobar.py\", line 5000, in <module>\n")
+                test_fp.write(
+                    b'  File "some/long/path/name/foobar.py", line 5000, in <module>\n'
+                )
                 test_fp.write(b"    some_long_name_for_a_func_%04d()\n" % (j,))
             test_fp.write(b"IndexError: list index out of range\n")
     rptr = StatusReporter.load(tb_path=str(tmp_path))
@@ -311,6 +331,7 @@ def test_status_reporter_10(tmp_path):
     merged_log = rptr._summary(runtime=True, sysinfo=True, timestamp=True)
     assert len(merged_log) < StatusReporter.SUMMARY_LIMIT
 
+
 def test_traceback_report_01():
     """test simple TracebackReport"""
     tbr = TracebackReport("log.txt", ["0", "1", "2"], prev_lines=["-2", "-1"])
@@ -321,6 +342,7 @@ def test_traceback_report_01():
     assert "2" in output
     assert "-2" in output
 
+
 def test_traceback_report_02():
     """test empty TracebackReport"""
     tbr = TracebackReport("log.txt", [])
@@ -329,15 +351,16 @@ def test_traceback_report_02():
     assert len(output.splitlines()) == 1
     assert "log.txt" in output
 
+
 def test_traceback_report_03(tmp_path):
     """test TracebackReport.from_file()"""
     test_log = tmp_path / "screenlog.0"
     with test_log.open("wb") as test_fp:
         test_fp.write(b"start junk\npre1\npre2\npre3\npre4\npre5\n")
         test_fp.write(b"Traceback (most recent call last):\n")
-        test_fp.write(b"  File \"foo.py\", line 556, in <module>\n")
+        test_fp.write(b'  File "foo.py", line 556, in <module>\n')
         test_fp.write(b"    main(parse_args())\n")
-        test_fp.write(b"  File \"foo.py\", line 207, in bar\n")
+        test_fp.write(b'  File "foo.py", line 207, in bar\n')
         test_fp.write(b"    a = b[10]\n")
         test_fp.write(b"IndexError: list index out of range\n")
         test_fp.write(b"end junk\n")
@@ -355,9 +378,9 @@ def test_traceback_report_03(tmp_path):
     with test_log.open("wb") as test_fp:
         test_fp.write(b"start junk\n")
         test_fp.write(b"Traceback (most recent call last):\n")
-        test_fp.write(b"  File \"foo.py\", line 556, in <module>\n")
+        test_fp.write(b'  File "foo.py", line 556, in <module>\n')
         test_fp.write(b"    main(parse_args())\n")
-        test_fp.write(b"  File \"foo.py\", line 207, in bar\n")
+        test_fp.write(b'  File "foo.py", line 207, in bar\n')
         test_fp.write(b"    a = b[10]\n")
         test_fp.write(b"foo.bar.error: blah\n")
         test_fp.write(b"end junk\n")
@@ -373,9 +396,9 @@ def test_traceback_report_03(tmp_path):
     # kbi
     with test_log.open("wb") as test_fp:
         test_fp.write(b"Traceback (most recent call last):\n")
-        test_fp.write(b"  File \"foo.py\", line 556, in <module>\n")
+        test_fp.write(b'  File "foo.py", line 556, in <module>\n')
         test_fp.write(b"    main(parse_args())\n")
-        test_fp.write(b"  File \"foo.py\", line 207, in bar\n")
+        test_fp.write(b'  File "foo.py", line 207, in bar\n')
         test_fp.write(b"    a = b[10]\n")
         test_fp.write(b"KeyboardInterrupt\n")
         test_fp.write(b"end junk\n")
@@ -385,17 +408,18 @@ def test_traceback_report_03(tmp_path):
     assert len(output.splitlines()) == 7
     assert "KeyboardInterrupt" in output
 
+
 def test_traceback_report_04(tmp_path):
     """test TracebackReport.from_file() exceed size limit"""
     test_log = tmp_path / "screenlog.0"
     with test_log.open("wb") as test_fp:
         test_fp.write(b"Traceback (most recent call last):\n")
-        test_fp.write(b"  File \"foo.py\", line 5, in <module>\n")
+        test_fp.write(b'  File "foo.py", line 5, in <module>\n')
         test_fp.write(b"    first()\n")
-        test_fp.write(b"  File \"foo.py\", line 5, in <module>\n")
+        test_fp.write(b'  File "foo.py", line 5, in <module>\n')
         test_fp.write(b"    second()\n")
         for i in reversed(range(TracebackReport.MAX_LINES)):
-            test_fp.write(b"  File \"foo.py\", line 5, in <module>\n")
+            test_fp.write(b'  File "foo.py", line 5, in <module>\n')
             test_fp.write(b"    func_%02d()\n" % i)
         test_fp.write(b"END_WITH_BLANK_LINE\n\n")
         test_fp.write(b"end junk\n")
@@ -410,15 +434,16 @@ def test_traceback_report_04(tmp_path):
     assert "func_06()" not in output
     assert "END_WITH_BLANK_LINE" in output
 
+
 def test_traceback_report_05(tmp_path):
     """test TracebackReport.from_file() cut off"""
     test_log = tmp_path / "screenlog.0"
     with test_log.open("wb") as test_fp:
         test_fp.write(b"Traceback (most recent call last):\n")
-        test_fp.write(b"  File \"foo.py\", line 5, in <module>\n")
+        test_fp.write(b'  File "foo.py", line 5, in <module>\n')
         test_fp.write(b"    first()\n")
         for i in range(TracebackReport.MAX_LINES * 2):
-            test_fp.write(b"  File \"foo.py\", line 5, in <module>\n")
+            test_fp.write(b'  File "foo.py", line 5, in <module>\n')
             test_fp.write(b"    func_%d()\n" % i)
     tbr = TracebackReport.from_file(str(test_log))
     assert not tbr.is_kbi
@@ -427,12 +452,13 @@ def test_traceback_report_05(tmp_path):
     assert "first()" in output
     assert "func_%d" % (TracebackReport.MAX_LINES * 2 - 1) in output
 
+
 def test_traceback_report_06(tmp_path):
     """test TracebackReport.from_file() single word error"""
     test_log = tmp_path / "screenlog.0"
     with test_log.open("wb") as test_fp:
         test_fp.write(b"Traceback (most recent call last):\n")
-        test_fp.write(b"  File \"foo.py\", line 5, in <module>\n")
+        test_fp.write(b'  File "foo.py", line 5, in <module>\n')
         test_fp.write(b"    first()\n")
         test_fp.write(b"AssertionError\n")
         test_fp.write(b"end junk\n")
@@ -444,12 +470,13 @@ def test_traceback_report_06(tmp_path):
     assert "AssertionError" in output
     assert "end junk" not in output
 
+
 def test_traceback_report_07(tmp_path):
     """test TracebackReport.from_file() with binary data"""
     test_log = tmp_path / "screenlog.0"
     with test_log.open("wb") as test_fp:
         test_fp.write(b"Traceback (most recent call last):\n")
-        test_fp.write(b"  File \"foo.py\", line 5, in <module>\n")
+        test_fp.write(b'  File "foo.py", line 5, in <module>\n')
         test_fp.write(b"    bin\xd8()\n")
         test_fp.write(b"AssertionError\n")
     tbr = TracebackReport.from_file(str(test_log))
@@ -458,13 +485,14 @@ def test_traceback_report_07(tmp_path):
     assert "bin()" in output
     assert "AssertionError" in output
 
+
 def test_traceback_report_08(tmp_path):
     """test TracebackReport.from_file() locate token across chunks"""
     test_log = tmp_path / "screenlog.0"
     with test_log.open("wb") as test_fp:
         test_fp.write(b"A" * (TracebackReport.READ_LIMIT - 5))
         test_fp.write(b"Traceback (most recent call last):\n")
-        test_fp.write(b"  File \"foo.py\", line 5, in <module>\n")
+        test_fp.write(b'  File "foo.py", line 5, in <module>\n')
         test_fp.write(b"    first()\n")
         test_fp.write(b"AssertionError\n")
     tbr = TracebackReport.from_file(str(test_log))
@@ -474,12 +502,14 @@ def test_traceback_report_08(tmp_path):
     assert "first()" in output
     assert "AssertionError" in output
 
+
 def test_main_01(tmp_path):
     """test main() with no reports"""
     Status.PATH = str(tmp_path)
     StatusReporter.CPU_POLL_INTERVAL = 0.01
     assert main([]) == 0
 
+
 def test_main_02(tmp_path):
     """test main() with a report"""
     Status.PATH = str(tmp_path)
@@ -490,6 +520,7 @@ def test_main_02(tmp_path):
     status.report(force=True)
     assert main([]) == 0
 
+
 def test_main_03(tmp_path):
     """test main() --dump"""
     Status.PATH = str(tmp_path)
@@ -501,7 +532,8 @@ def test_main_03(tmp_path):
     assert main(["--dump", str(dump_file)]) == 0
     assert dump_file.is_file()
     assert b"Runtime" not in dump_file.read_bytes()
-    #assert False, dump_file.read_bytes()
+    # assert False, dump_file.read_bytes()
+
 
 def test_main_04():
     """test main() with invalid mode"""
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index a37e0c47..2fe40977 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -40,9 +40,12 @@ def test_testcase_01(tmp_path):
         tcase.dump(str(tmp_path), include_details=True)
         assert (tmp_path / "test_info.json").is_file()
 
+
 def test_testcase_02(tmp_path):
     """test TestCase with TestFiles"""
-    tcase = TestCase("land_page.html", "redirect.html", "test-adapter", input_fname="testinput.bin")
+    tcase = TestCase(
+        "land_page.html", "redirect.html", "test-adapter", input_fname="testinput.bin"
+    )
     try:
         in_file = tmp_path / "testfile1.bin"
         in_file.write_bytes(b"test_req")
@@ -73,6 +76,7 @@ def test_testcase_02(tmp_path):
     finally:
         tcase.cleanup()
 
+
 def test_testcase_03(tmp_path):
     """test TestCase.add_meta()"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
@@ -86,6 +90,7 @@ def test_testcase_03(tmp_path):
         assert meta_file.is_file()
         assert meta_file.read_bytes() == meta_data
 
+
 def test_testcase_04(tmp_path):
     """test TestCase.add_environ_var() and TestCase.env_vars"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
@@ -101,6 +106,7 @@ def test_testcase_04(tmp_path):
         assert data["env"]["TEST_ENV_VAR"] == "1"
         assert data["env"]["TEST_NONE"] is None
 
+
 def test_testcase_05():
     """test TestCase.purge_optional()"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
@@ -125,6 +131,7 @@ def test_testcase_05():
         tcase.purge_optional(["testfile1.bin"])
         assert not any(tcase.optional)
 
+
 def test_testcase_06():
     """test TestCase.data_size"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
@@ -136,6 +143,7 @@ def test_testcase_06():
         tcase.add_meta(TestFile.from_data("123", "meta.bin"))
         assert tcase.data_size == 6
 
+
 def test_testcase_07(tmp_path):
     """test TestCase.load_single() using a directory - fail cases"""
     # missing test_info.json
@@ -147,10 +155,12 @@ def test_testcase_07(tmp_path):
         TestCase.load_single(str(tmp_path), True)
     # test_info.json missing 'target' entry
     (tmp_path / "test_info.json").write_bytes(b"{}")
-    with pytest.raises(TestCaseLoadFailure, match="'test_info.json' has invalid 'target' entry"):
+    with pytest.raises(
+        TestCaseLoadFailure, match="'test_info.json' has invalid 'target' entry"
+    ):
         TestCase.load_single(str(tmp_path), True)
     # build a test case
-    src_dir = (tmp_path / "src")
+    src_dir = tmp_path / "src"
     src_dir.mkdir()
     (src_dir / "prefs.js").touch()
     entry_point = src_dir / "target.bin"
@@ -160,27 +170,32 @@ def test_testcase_07(tmp_path):
         src.dump(str(src_dir), include_details=True)
     # bad 'target' entry in test_info.json
     entry_point.unlink()
-    with pytest.raises(TestCaseLoadFailure, match="Entry point 'target.bin' not found in"):
+    with pytest.raises(
+        TestCaseLoadFailure, match="Entry point 'target.bin' not found in"
+    ):
         TestCase.load_single(str(src_dir), True)
     # bad 'env' entry in test_info.json
     entry_point.touch()
     with TestCase("target.bin", None, "test-adapter") as src:
         src.add_environ_var("TEST_ENV_VAR", 100)
         src.dump(str(src_dir), include_details=True)
-    with pytest.raises(TestCaseLoadFailure, match="'env_data' contains invalid 'env' entries"):
+    with pytest.raises(
+        TestCaseLoadFailure, match="'env_data' contains invalid 'env' entries"
+    ):
         TestCase.load_single(str(src_dir), True)
 
+
 def test_testcase_08(tmp_path):
     """test TestCase.load_single() using a directory"""
     # build a valid test case
-    src_dir = (tmp_path / "src")
+    src_dir = tmp_path / "src"
     src_dir.mkdir()
     (src_dir / "prefs.js").touch()
     entry_point = src_dir / "target.bin"
     entry_point.touch()
     (src_dir / "optional.bin").touch()
     (src_dir / "x.bin").touch()
-    nested = (tmp_path / "src" / "nested")
+    nested = tmp_path / "src" / "nested"
     nested.mkdir()
     # overlap file name in different directories
     (nested / "x.bin").touch()
@@ -196,17 +211,20 @@ def test_testcase_08(tmp_path):
         assert "target.bin" in (x.file_name for x in dst._files.required)
         assert "optional.bin" in (x.file_name for x in dst._files.optional)
         assert "x.bin" in (x.file_name for x in dst._files.optional)
-        assert os.path.join("nested", "x.bin") in (x.file_name for x in dst._files.optional)
+        assert os.path.join("nested", "x.bin") in (
+            x.file_name for x in dst._files.optional
+        )
         assert dst.env_vars["TEST_ENV_VAR"] == "100"
         assert dst.timestamp > 0
 
+
 def test_testcase_09(tmp_path):
     """test TestCase.load_single() using a file"""
     # invalid entry_point specified
     with pytest.raises(TestCaseLoadFailure, match="Missing or invalid TestCase"):
         TestCase.load_single(str(tmp_path / "missing_file"), False)
     # valid test case
-    src_dir = (tmp_path / "src")
+    src_dir = tmp_path / "src"
     src_dir.mkdir()
     (src_dir / "prefs.js").touch()
     entry_point = src_dir / "target.bin"
@@ -226,6 +244,7 @@ def test_testcase_09(tmp_path):
         assert "target.bin" in (x.file_name for x in tcase._files.required)
         assert "optional.bin" in (x.file_name for x in tcase._files.optional)
 
+
 def test_testcase_10(tmp_path):
     """test TestCase - dump, load and compare"""
     with TestCase("a.html", "b.html", "adpt") as org:
@@ -247,6 +266,7 @@ def test_testcase_10(tmp_path):
         finally:
             loaded.cleanup()
 
+
 def test_testcase_11(tmp_path):
     """test TestCase.load() - missing file and empty directory"""
     # missing file
@@ -255,9 +275,10 @@ def test_testcase_11(tmp_path):
     # empty path
     assert not TestCase.load(str(tmp_path), True)
 
+
 def test_testcase_12(tmp_path):
     """test TestCase.load() - single file"""
-    tfile = (tmp_path / "testcase.html")
+    tfile = tmp_path / "testcase.html"
     tfile.touch()
     testcases = TestCase.load(str(tfile), False)
     try:
@@ -265,6 +286,7 @@ def test_testcase_12(tmp_path):
     finally:
         map(lambda x: x.cleanup, testcases)
 
+
 def test_testcase_13(tmp_path):
     """test TestCase.load() - single directory"""
     with TestCase("target.bin", None, "test-adapter") as src:
@@ -276,9 +298,10 @@ def test_testcase_13(tmp_path):
     finally:
         map(lambda x: x.cleanup, testcases)
 
+
 def test_testcase_14(tmp_path):
     """test TestCase.load() - multiple directories"""
-    nested = (tmp_path / "nested")
+    nested = tmp_path / "nested"
     nested.mkdir()
     with TestCase("target.bin", None, "test-adapter") as src:
         src.add_from_data("test", "target.bin")
@@ -293,6 +316,7 @@ def test_testcase_14(tmp_path):
     # try loading testcases that are nested too deep
     assert not TestCase.load(str(tmp_path), False)
 
+
 def test_testcase_15(tmp_path):
     """test TestCase.load() - archive"""
     archive = tmp_path / "testcase.zip"
@@ -310,19 +334,23 @@ def test_testcase_15(tmp_path):
     (tmp_path / "log_dummy.txt").touch()
     (tmp_path / "not_a_tc").mkdir()
     (tmp_path / "not_a_tc" / "file.txt").touch()
-    with zipfile.ZipFile(str(archive), mode="w", compression=zipfile.ZIP_DEFLATED) as zfp:
+    with zipfile.ZipFile(
+        str(archive), mode="w", compression=zipfile.ZIP_DEFLATED
+    ) as zfp:
         for dir_name, _, dir_files in os.walk(str(tmp_path)):
             arc_path = os.path.relpath(dir_name, str(tmp_path))
             for file_name in dir_files:
                 zfp.write(
                     os.path.join(dir_name, file_name),
-                    arcname=os.path.join(arc_path, file_name))
+                    arcname=os.path.join(arc_path, file_name),
+                )
     testcases = TestCase.load(str(archive), True)
     try:
         assert len(tuple(testcases)) == 3
     finally:
         map(lambda x: x.cleanup, testcases)
 
+
 def test_testcase_16(tmp_path):
     """test TestCase.load_environ()"""
     (tmp_path / "ubsan.supp").touch()
@@ -340,16 +368,17 @@ def test_testcase_16(tmp_path):
         assert "b=2" in opts
         assert len(opts) == 3
 
+
 def test_testcase_17(tmp_path):
     """test TestCase.add_batch()"""
-    include = (tmp_path / "inc_path")
+    include = tmp_path / "inc_path"
     include.mkdir()
-    inc_1 = (include / "file.bin")
+    inc_1 = include / "file.bin"
     inc_1.write_bytes(b"a")
     (include / "nested").mkdir()
-    inc_2 = (include / "nested" / "nested.js")
+    inc_2 = include / "nested" / "nested.js"
     inc_2.write_bytes(b"a")
-    other_path = (tmp_path / "other_path")
+    other_path = tmp_path / "other_path"
     other_path.mkdir()
     (other_path / "no_include.bin").write_bytes(b"a")
     with TestCase("a.b", "a.b", "simple") as tcase:
@@ -364,7 +393,10 @@ def test_testcase_17(tmp_path):
         tcase.add_batch(str(include), ["file.bin"])
         assert not tcase._existing_paths
         # valid list
-        tcase.add_batch(str(include), [str(inc_1), str(inc_2), str(tmp_path / "inc_path2" / "extra.bin")])
+        tcase.add_batch(
+            str(include),
+            [str(inc_1), str(inc_2), str(tmp_path / "inc_path2" / "extra.bin")],
+        )
         assert tcase.contains("file.bin")
         assert tcase.contains(os.path.join("nested", "nested.js"))
         assert len(tcase._existing_paths) == 2
@@ -376,6 +408,7 @@ def test_testcase_17(tmp_path):
         with pytest.raises(TestFileExists, match="'file.bin' exists in test"):
             tcase.add_batch(str(include), [str(inc_1)])
 
+
 def test_testcase_18(tmp_path):
     """test TestCase.scan_path()"""
     # empty path
@@ -393,6 +426,7 @@ def test_testcase_18(tmp_path):
     tc_paths = list(TestCase.scan_path(str(paths[0])))
     assert len(tc_paths) == 1
 
+
 def test_testcase_19():
     """test TestCase.get_file()"""
     with TestCase("test.htm", None, "test-adapter") as src:
@@ -400,6 +434,7 @@ def test_testcase_19():
         assert src.get_file("missing") is None
         assert src.get_file("test.htm").data == b"test"
 
+
 def test_testcase_20():
     """test TestCase.clone()"""
     with TestCase("a.htm", "b.htm", "adpt", input_fname="fn", time_limit=2) as src:
@@ -415,7 +450,11 @@ def test_testcase_20():
                     continue
                 assert getattr(src, prop) == getattr(tgt, prop)
             assert src.data_size == tgt.data_size
-            for file, data in (("test.htm", b"123"), ("opt.htm", b"456"), ("prefs.js", b"pref")):
+            for file, data in (
+                ("test.htm", b"123"),
+                ("opt.htm", b"456"),
+                ("prefs.js", b"pref"),
+            ):
                 src.get_file(file).write(b"src")
                 tgt.get_file(file).write(b"tgt")
                 assert src.get_file(file).data == data + b"src"
@@ -425,6 +464,7 @@ def test_testcase_20():
             assert src.env_vars == {"foo": "bar", "go": "away"}
             assert tgt.env_vars == {"hello": "kitty", "go": "away"}
 
+
 def test_testfile_01():
     """test simple TestFile"""
     with TestFile("test_file.txt") as tfile:
@@ -434,6 +474,7 @@ def test_testfile_01():
         tfile.close()
         assert tfile._fp.closed
 
+
 def test_testfile_02():
     """test TestFile file names"""
     # empty file name
@@ -464,6 +505,7 @@ def test_testfile_02():
     with TestFile(".file") as tfile:
         assert tfile.file_name == ".file"
 
+
 def test_testfile_03(tmp_path):
     """test TestFile.write() and TestFile.dump()"""
     out_file = tmp_path / "test_file.txt"
@@ -477,6 +519,7 @@ def test_testfile_03(tmp_path):
         tfile.dump(str(tmp_path))
         assert out_file.read_text() == "foobar"
 
+
 def test_testfile_04(tmp_path):
     """test TestFile.dump() file with nested path"""
     file_path = "test/dir/path/file.txt"
@@ -487,6 +530,7 @@ def test_testfile_04(tmp_path):
         tfile.dump(str(tmp_path))
         assert out_file.is_file()
 
+
 def test_testfile_05(tmp_path):
     """test TestFile.from_data()"""
     # TODO: different encodings
@@ -496,6 +540,7 @@ def test_testfile_05(tmp_path):
         assert out_file.is_file()
         assert out_file.read_text() == "foo"
 
+
 def test_testfile_06(tmp_path):
     """test TestFile.from_file()"""
     in_file = tmp_path / "infile.txt"
@@ -511,6 +556,7 @@ def test_testfile_06(tmp_path):
         assert out_file.is_file()
         assert out_file.read_text() == "foobar"
 
+
 def test_testfile_07(tmp_path):
     """test TestFile.clone()"""
     out_file = tmp_path / "test_file.txt"
@@ -530,6 +576,7 @@ def test_testfile_07(tmp_path):
         assert out_file.is_file()
         assert out_file.read_text() == "foobar"
 
+
 def test_testfile_08(tmp_path):
     """test TestFile.data()"""
     in_file = tmp_path / "infile.txt"
diff --git a/grizzly/common/test_utils.py b/grizzly/common/test_utils.py
index 5f935d33..594a65a7 100644
--- a/grizzly/common/test_utils.py
+++ b/grizzly/common/test_utils.py
@@ -8,7 +8,9 @@
 
 def test_testcase_01(mocker, tmp_path):
     """test grz_tmp()"""
-    mocker.patch("grizzly.common.utils.gettempdir", autospec=True, return_value=str(tmp_path))
+    mocker.patch(
+        "grizzly.common.utils.gettempdir", autospec=True, return_value=str(tmp_path)
+    )
     # create temp path
     path = grz_tmp()
     assert path == str(tmp_path / "grizzly")
diff --git a/grizzly/common/utils.py b/grizzly/common/utils.py
index 223a7c81..cea57c09 100644
--- a/grizzly/common/utils.py
+++ b/grizzly/common/utils.py
@@ -18,6 +18,7 @@
 
 class ConfigError(Exception):
     """Raised to indicate invalid configuration a state"""
+
     def __init__(self, message, exit_code):
         super().__init__(message)
         self.exit_code = exit_code
diff --git a/grizzly/main.py b/grizzly/main.py
index a9248e08..3eea11b0 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -25,6 +25,7 @@
 
 LOG = getLogger(__name__)
 
+
 def configure_logging(log_level):
     if getenv("DEBUG") == "1":
         log_level = DEBUG
@@ -36,6 +37,7 @@ def configure_logging(log_level):
         log_fmt = "[%(asctime)s] %(message)s"
     basicConfig(format=log_fmt, datefmt=date_fmt, level=log_level)
 
+
 def main(args):
     configure_logging(args.log_level)
     LOG.info("Starting Grizzly (%d)", getpid())
@@ -75,8 +77,10 @@ def main(args):
             LOG.error("Timeout must be at least test time limit if not greater")
             return Session.EXIT_ARGS
         if adapter.HARNESS_FILE and time_limit == timeout:
-            LOG.warning("To avoid relaunches due to tests failing to close"
-                        " themselves use a timeout greater than time limit")
+            LOG.warning(
+                "To avoid relaunches due to tests failing to close"
+                " themselves use a timeout greater than time limit"
+            )
 
         if adapter.RELAUNCH > 0:
             LOG.info("Relaunch (%d) set in Adapter", adapter.RELAUNCH)
@@ -93,7 +97,8 @@ def main(args):
             args.memory,
             rr=args.rr,
             valgrind=args.valgrind,
-            xvfb=args.xvfb)
+            xvfb=args.xvfb,
+        )
         if args.prefs:
             target.prefs = args.prefs
             LOG.info("Using prefs %r", args.prefs)
@@ -104,7 +109,9 @@ def main(args):
             LOG.info("Results will be reported via FuzzManager")
             reporter = FuzzManagerReporter(tool=args.tool)
         elif args.s3_fuzzmanager:
-            LOG.info("Results will be reported via FuzzManager w/ large attachments in S3")
+            LOG.info(
+                "Results will be reported via FuzzManager w/ large attachments in S3"
+            )
             reporter = S3FuzzManagerReporter(tool=args.tool)
         else:
             reporter = FilesystemReporter(pathjoin(getcwd(), "results"))
@@ -128,7 +135,8 @@ def main(args):
                 coverage=args.coverage,
                 enable_profiling=args.enable_profiling,
                 relaunch=relaunch,
-                report_size=args.collect)
+                report_size=args.collect,
+            )
             if args.log_level == DEBUG or args.verbose:
                 display_mode = Session.DISPLAY_VERBOSE
             else:
@@ -138,7 +146,8 @@ def main(args):
                 time_limit,
                 input_path=args.input,
                 iteration_limit=args.limit,
-                display_mode=display_mode)
+                display_mode=display_mode,
+            )
 
     except KeyboardInterrupt:
         LOG.info("Ctrl+C detected.")
diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 27289833..15499906 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -26,25 +26,35 @@ def __init__(self):
         # these arguments have other defaults vs how they are defined in ReplayArgs
         self.parser.set_defaults(
             include_test=True,
-            logs='.',
+            logs=".",
         )
 
         reduce_args = self.parser.add_argument_group("Reduce Arguments")
         reduce_args.add_argument(
-            "--no-analysis", action="store_true",
-            help="Disable analysis to auto-set --repeat/--min-crashes.")
+            "--no-analysis",
+            action="store_true",
+            help="Disable analysis to auto-set --repeat/--min-crashes.",
+        )
         reduce_args.add_argument(
-            "--report-period", type=int,
+            "--report-period",
+            type=int,
             help="Periodically report the best testcase for long-running strategies."
-            " (value in seconds, default: no)")
+            " (value in seconds, default: no)",
+        )
         reduce_args.add_argument(
-            "--static-timeout", action="store_true",
-            help="Disable automatically updating the iteration timeout.")
+            "--static-timeout",
+            action="store_true",
+            help="Disable automatically updating the iteration timeout.",
+        )
         reduce_args.add_argument(
-            "--strategy", nargs="+", default=DEFAULT_STRATEGIES, metavar="STRATEGY",
+            "--strategy",
+            nargs="+",
+            default=DEFAULT_STRATEGIES,
+            metavar="STRATEGY",
             dest="strategies",
             help="One or more strategies (space-separated). Available: %s (default: %s)"
-            % (" ".join(sorted(STRATEGIES)), " ".join(DEFAULT_STRATEGIES)))
+            % (" ".join(sorted(STRATEGIES)), " ".join(DEFAULT_STRATEGIES)),
+        )
 
     def sanity_check(self, args):
         """Sanity check reducer args.
@@ -83,20 +93,20 @@ def sanity_check(self, args):
                 error_str = " and ".join(errors)
                 LOG.warning(
                     "%s specified, with analysis enabled, they will be ignored",
-                    error_str
+                    error_str,
                 )
 
 
 class ReduceFuzzManagerIDArgs(ReduceArgs):
-
     def __init__(self):
         """Initialize argument parser."""
         super().__init__()
 
         # madhax alert!
         #
-        # We need to modify the meaning of the 'input' positional to accept an int ID instead of a
-        # local testcase. This is not possible with the public argparse API.
+        # We need to modify the meaning of the 'input' positional to accept an int ID
+        # instead of a local testcase.
+        # This is not possible with the public argparse API.
         #
         # refs: https://stackoverflow.com/questions/32807319/disable-remove-argument-in-argparse
         #       https://bugs.python.org/issue19462
@@ -118,13 +128,12 @@ def __init__(self):
 
 
 class ReduceFuzzManagerIDQualityArgs(ReduceFuzzManagerIDArgs):
-
     def __init__(self):
         """Initialize argument parser."""
         super().__init__()
         self.parser.add_argument(
-            "--quality", type=int,
-            help="Only try crashes with a given quality value")
+            "--quality", type=int, help="Only try crashes with a given quality value"
+        )
 
     def sanity_check(self, args):
         super().sanity_check(args)
diff --git a/grizzly/reduce/conftest.py b/grizzly/reduce/conftest.py
index 990bf2ac..971caf05 100644
--- a/grizzly/reduce/conftest.py
+++ b/grizzly/reduce/conftest.py
@@ -30,4 +30,5 @@ def reporter_sequential_strftime(mocker):
 
     def report_prefix(_):
         return "%04d" % (prefix.call_count,)
+
     prefix.side_effect = report_prefix
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index d9aa6090..633784e9 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -51,6 +51,7 @@ class ReduceManager:
         testcases (list(grizzly.common.storage.TestCase)): List of one or more Grizzly
                                                            testcases to reduce.
     """
+
     ANALYSIS_ITERATIONS = 11  # number of iterations to analyze
     # --min-crashes value when analysis is used and reliability is less than perfect
     ANALYSIS_MIN_CRASHES = 1
@@ -65,11 +66,28 @@ class ReduceManager:
     ITER_TIMEOUT_MIN = 10
     ITER_TIMEOUT_DURATION_MULTIPLIER = 2
 
-    def __init__(self, ignore, server, target, testcases, strategies, log_path,
-                 any_crash=False, expect_hang=False, idle_delay=0, idle_threshold=0,
-                 relaunch=1, report_period=None, report_to_fuzzmanager=False,
-                 signature=None, signature_desc=None, static_timeout=False, tool=None,
-                 use_analysis=True, use_harness=True):
+    def __init__(
+        self,
+        ignore,
+        server,
+        target,
+        testcases,
+        strategies,
+        log_path,
+        any_crash=False,
+        expect_hang=False,
+        idle_delay=0,
+        idle_threshold=0,
+        relaunch=1,
+        report_period=None,
+        report_to_fuzzmanager=False,
+        signature=None,
+        signature_desc=None,
+        static_timeout=False,
+        tool=None,
+        use_analysis=True,
+        use_harness=True,
+    ):
         """Initialize reduction manager. Many arguments are common with `ReplayManager`.
 
         Args:
@@ -146,8 +164,11 @@ def update_timeout(self, results):
         """
         # TODO: properly handle test duration and timeout
         assert self._static_timeout or not self._expect_hang
-        if (self._static_timeout or self._any_crash or
-                getattr(self.target, "use_valgrind", False)):
+        if (
+            self._static_timeout
+            or self._any_crash
+            or getattr(self.target, "use_valgrind", False)
+        ):
             # the amount of time it can take to replay a test case can vary
             # when under Valgrind so do not update the timeout in that case
 
@@ -155,26 +176,31 @@ def update_timeout(self, results):
             # expected), so lowering timeout or idle delay will only hide crashes
             return
 
-        durations = list(chain.from_iterable(result.durations
-                                             for result in results if result.expected))
+        durations = list(
+            chain.from_iterable(
+                result.durations for result in results if result.expected
+            )
+        )
         if not durations:
             # no expected results
             return
         run_time = max(durations)
 
         # If `run_time * multiplier` is less than idle poll delay, update it
-        LOG.debug('Run time %r', run_time)
-        new_idle_delay = max(self.IDLE_DELAY_MIN,
-                             min(run_time * self.IDLE_DELAY_DURATION_MULTIPLIER,
-                                 self._idle_delay))
+        LOG.debug("Run time %r", run_time)
+        new_idle_delay = max(
+            self.IDLE_DELAY_MIN,
+            min(run_time * self.IDLE_DELAY_DURATION_MULTIPLIER, self._idle_delay),
+        )
         if new_idle_delay < self._idle_delay:
             LOG.info("Updating poll delay to: %r", new_idle_delay)
             self._idle_delay = new_idle_delay
         # If `run_time * multiplier` is less than iter_timeout, update it
         # in other words, decrease the timeout if this ran in less than half the timeout
-        new_iter_timeout = max(self.ITER_TIMEOUT_MIN,
-                               min(run_time * self.ITER_TIMEOUT_DURATION_MULTIPLIER,
-                                   self.server.timeout))
+        new_iter_timeout = max(
+            self.ITER_TIMEOUT_MIN,
+            min(run_time * self.ITER_TIMEOUT_DURATION_MULTIPLIER, self.server.timeout),
+        )
         if new_iter_timeout < self.server.timeout:
             LOG.info("Updating max timeout to: %r", new_iter_timeout)
             self.server.timeout = new_iter_timeout
@@ -206,16 +232,20 @@ def run_reliability_analysis(self, stats):
         #   on every call to interesting.
 
         # N.B. We only use `last_test_only` if `len(self.testcases) > 1` ..
-        # if `self.testcases` only has 1 entry to begin with, we don't need `last_test_only` to trim it
-        for (use_harness, last_test_only) in [
-                (True, True),
-                (True, False),
-                # only one of the two use_harness=False cases will run:
-                (False, True),  # input is len(self.testcases)>1 and we will only try the last testcase
-                (False, False)]:  # input is len(self.testcases)==1 already and there's no need to trim
+        # if `self.testcases` only has 1 entry to begin with, we don't need
+        # `last_test_only` to trim it
+        for (use_harness, last_test_only) in (
+            (True, True),
+            (True, False),
+            # only one of the two use_harness=False cases will run:
+            # input is len(self.testcases)>1 and we will only try the last testcase
+            (False, True),
+            # input is len(self.testcases)==1 already and there's no need to trim
+            (False, False),
+        ):
             if use_harness and (not self._original_use_harness or harness_crashes):
-                # Don't test with harness again if we already found crashes with the harness (last_test_only)
-                # or if it was disabled by command-line.
+                # Don't test with harness again if we already found crashes with the
+                # harness (last_test_only) or if it was disabled by command-line.
                 continue
             if not use_harness and harness_crashes >= self.ANALYSIS_ITERATIONS / 2:
                 # Don't test without harness if harness found > 50% crashes
@@ -224,7 +254,8 @@ def run_reliability_analysis(self, stats):
                 # Only set `last_test_only` if we have more than one testcase to begin with
                 continue
             if not use_harness and (not last_test_only and len(self.testcases) > 1):
-                # Can't run without harness if we have more than one testcase (`last_test_only` will run)
+                # Can't run without harness if we have more than one testcase
+                # (`last_test_only` will run)
                 continue
 
             if use_harness and (last_test_only or len(self.testcases) == 1):
@@ -233,36 +264,54 @@ def run_reliability_analysis(self, stats):
                 relaunch = 1
 
             with ReplayManager(
-                self.ignore, self.server, self.target, any_crash=self._any_crash,
-                relaunch=relaunch, signature=self._signature, use_harness=use_harness,
+                self.ignore,
+                self.server,
+                self.target,
+                any_crash=self._any_crash,
+                relaunch=relaunch,
+                signature=self._signature,
+                use_harness=use_harness,
             ) as replay:
-                LOG.info("Running for %d iterations to assess reliability %s harness.",
-                         self.ANALYSIS_ITERATIONS,
-                         "using" if use_harness else "without")
+                LOG.info(
+                    "Running for %d iterations to assess reliability %s harness.",
+                    self.ANALYSIS_ITERATIONS,
+                    "using" if use_harness else "without",
+                )
                 testcases = self.testcases
                 if last_test_only:
                     if use_harness:
                         LOG.warning("Checking reliability with only the last testcase.")
                     else:
-                        LOG.warning("Only the last testcase of %d given will be used to "
-                                    "assess reliability without harness.", len(testcases))
+                        LOG.warning(
+                            "Only the last testcase of %d given will be used to "
+                            "assess reliability without harness.",
+                            len(testcases),
+                        )
                     testcases = [testcases[-1]]
                 results = replay.run(
-                    testcases, self.server.timeout, repeat=self.ANALYSIS_ITERATIONS,
-                    min_results=1, exit_early=False, idle_delay=self._idle_delay,
+                    testcases,
+                    self.server.timeout,
+                    repeat=self.ANALYSIS_ITERATIONS,
+                    min_results=1,
+                    exit_early=False,
+                    idle_delay=self._idle_delay,
                     idle_threshold=self._idle_threshold,
                 )
                 try:
                     stats.add_iterations(replay.status.iteration)
                     crashes = sum(x.count for x in results if x.expected)
                     if crashes and not self._any_crash and self._signature_desc is None:
-                        first_expected = next((report for report in results
-                                               if report.expected), None)
-                        self._signature_desc = (first_expected.report.crash_info
-                                                .createShortSignature())
+                        first_expected = next(
+                            (report for report in results if report.expected), None
+                        )
+                        self._signature_desc = (
+                            first_expected.report.crash_info.createShortSignature()
+                        )
                     self.report(
                         [result for result in results if not result.expected],
-                        testcases, self._stats.copy(stats))
+                        testcases,
+                        self._stats.copy(stats),
+                    )
                     if use_harness:
                         # set harness_crashes in both cases (last_test True/False)
                         # we only want to iterate through all testcases if the last
@@ -279,8 +328,12 @@ def run_reliability_analysis(self, stats):
                 key = ("using" if use_harness else "without") + " harness"
                 if last_test_only:
                     key += "/last test only"
-                LOG.info("Testcase was interesting %0.1f%% of %d attempts %s.",
-                         100.0 * reliability, self.ANALYSIS_ITERATIONS, key)
+                LOG.info(
+                    "Testcase was interesting %0.1f%% of %d attempts %s.",
+                    100.0 * reliability,
+                    self.ANALYSIS_ITERATIONS,
+                    key,
+                )
                 info[key] = reliability
                 # ensure same signature is always used
                 self._signature = replay.signature
@@ -294,18 +347,22 @@ def run_reliability_analysis(self, stats):
 
         # should we use the harness? go with harness unless no-harness crashed 50% more
         self._use_harness = not (
-            non_harness_crashes > harness_crashes and (
-                harness_crashes == 0 or
-                (non_harness_crashes - harness_crashes) / harness_crashes >= 0.5
+            non_harness_crashes > harness_crashes
+            and (
+                harness_crashes == 0
+                or (non_harness_crashes - harness_crashes) / harness_crashes >= 0.5
             )
         )
 
-        if ((self._use_harness and harness_last_crashes)
-                or (not self._use_harness and len(self.testcases) > 1)):
-            LOG.warning("Last testcase %s harness was selected, other %d "
-                        "testcases in the original will be ignored.",
-                        "with" if self._use_harness else "without",
-                        len(self.testcases) - 1)
+        if (self._use_harness and harness_last_crashes) or (
+            not self._use_harness and len(self.testcases) > 1
+        ):
+            LOG.warning(
+                "Last testcase %s harness was selected, other %d "
+                "testcases in the original will be ignored.",
+                "with" if self._use_harness else "without",
+                len(self.testcases) - 1,
+            )
             while len(self.testcases) > 1:
                 self.testcases.pop(0).cleanup()
 
@@ -319,20 +376,31 @@ def run_reliability_analysis(self, stats):
         else:
             min_crashes = self.ANALYSIS_MIN_CRASHES
         # crashes_percent is max 99.9% to avoid domain errors
-        repeat = int(ceil(log(1 - self.ANALYSIS_TARGET_PROBABILITY,
-                              1 - min(crashes_percent, 0.9999))) * min_crashes)
+        repeat = int(
+            ceil(
+                log(
+                    1 - self.ANALYSIS_TARGET_PROBABILITY,
+                    1 - min(crashes_percent, 0.9999),
+                )
+            )
+            * min_crashes
+        )
 
         LOG.info("Analysis results:")
         if harness_crashes >= self.ANALYSIS_ITERATIONS / 2:
-            LOG.info("* testcase was better than 50% reliable with the harness "
-                     "(--no-harness not assessed)")
+            LOG.info(
+                "* testcase was better than 50% reliable with the harness "
+                "(--no-harness not assessed)"
+            )
         elif harness_crashes == non_harness_crashes:
             LOG.info("* testcase was equally reliable with/without the harness")
         elif not self._original_use_harness:
             LOG.info("* --no-harness was already set")
         else:
-            LOG.info("* testcase was %s reliable with the harness",
-                     "more" if harness_crashes > non_harness_crashes else "less")
+            LOG.info(
+                "* testcase was %s reliable with the harness",
+                "more" if harness_crashes > non_harness_crashes else "less",
+            )
         return (repeat, min_crashes, info)
 
     def testcase_size(self):
@@ -364,8 +432,11 @@ def run(self, repeat=1, min_results=1):
         with self._stats.add_timed("final", self.testcase_size) as total_stats:
             if self._use_analysis:
                 with total_stats.add_timed("analysis") as stats:
-                    repeat, min_results, reliability_info = \
-                        self.run_reliability_analysis(stats)
+                    (
+                        repeat,
+                        min_results,
+                        reliability_info,
+                    ) = self.run_reliability_analysis(stats)
                 self._stats.add_info("Analysis", reliability_info)
                 any_success = True  # analysis ran and didn't raise
             # multi part test cases should always use relaunch == 1
@@ -374,24 +445,39 @@ def run(self, repeat=1, min_results=1):
                 relaunch = min(self._original_relaunch, repeat)
             else:
                 relaunch = 1
-            LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
-                     repeat, min_results, relaunch)
-            self._stats.add_info("Run Parameters", {
-                "Repeat": repeat,
-                "Min Crashes": min_results,
-                "Relaunch": relaunch,
-                "Harness": self._use_harness,
-            })
+            LOG.info(
+                "Repeat: %d, Minimum crashes: %d, Relaunch %d",
+                repeat,
+                min_results,
+                relaunch,
+            )
+            self._stats.add_info(
+                "Run Parameters",
+                {
+                    "Repeat": repeat,
+                    "Min Crashes": min_results,
+                    "Relaunch": relaunch,
+                    "Harness": self._use_harness,
+                },
+            )
 
             for strategy_no, strategy in enumerate(self.strategies):
                 LOG.info("")
-                LOG.info("Using strategy %s (%d/%d)", strategy, strategy_no + 1,
-                         len(self.strategies))
-                replay = ReplayManager(self.ignore, self.server, self.target,
-                                       any_crash=self._any_crash,
-                                       relaunch=relaunch,
-                                       signature=self._signature,
-                                       use_harness=self._use_harness)
+                LOG.info(
+                    "Using strategy %s (%d/%d)",
+                    strategy,
+                    strategy_no + 1,
+                    len(self.strategies),
+                )
+                replay = ReplayManager(
+                    self.ignore,
+                    self.server,
+                    self.target,
+                    any_crash=self._any_crash,
+                    relaunch=relaunch,
+                    signature=self._signature,
+                    use_harness=self._use_harness,
+                )
                 strategy = STRATEGIES[strategy](self.testcases)
                 if last_tried is not None:
                     strategy.update_tried(last_tried)
@@ -415,14 +501,17 @@ def run(self, repeat=1, min_results=1):
                                     idle_delay=self._idle_delay,
                                     idle_threshold=self._idle_threshold,
                                     min_results=min_results,
-                                    repeat=repeat)
+                                    repeat=repeat,
+                                )
                                 strategy_stats.add_iterations(replay.status.iteration)
                                 strategy_stats.add_attempts(1)
                                 self.update_timeout(results)
                                 # get the first expected result (if any),
                                 #   and update the strategy
-                                first_expected = next((report for report in results
-                                                       if report.expected), None)
+                                first_expected = next(
+                                    (report for report in results if report.expected),
+                                    None,
+                                )
                                 success = first_expected is not None
                                 if success:
                                     strategy_stats.add_successes(1)
@@ -430,10 +519,9 @@ def run(self, repeat=1, min_results=1):
                                         not self._any_crash
                                         and self._signature_desc is None
                                     ):
-                                        self._signature_desc = (first_expected
-                                                                .report
-                                                                .crash_info
-                                                                .createShortSignature())
+                                        self._signature_desc = (
+                                            first_expected.report.crash_info.createShortSignature()
+                                        )
                                 served = None
                                 if success and not self._any_crash:
                                     served = first_expected.served
@@ -453,25 +541,34 @@ def run(self, repeat=1, min_results=1):
                                     for result in best_results:
                                         result.report.cleanup()
                                     # filter expected results out into `best_results`
-                                    best_results = [result for result in results
-                                                    if result.expected]
-                                    results = [result for result in results
-                                               if not result.expected]
+                                    best_results = [
+                                        result for result in results if result.expected
+                                    ]
+                                    results = [
+                                        result
+                                        for result in results
+                                        if not result.expected
+                                    ]
                                 else:
                                     LOG.info("Attempt failed")
                                 # if the reduction found other crashes,
                                 #   report those immediately
                                 self.report(
-                                    results, reduction,
-                                    self._stats.copy(strategy_stats))
+                                    results, reduction, self._stats.copy(strategy_stats)
+                                )
 
                                 now = time()
-                                if self._report_periodically and \
-                                        best_results and \
-                                        now - strategy_last_report > self._report_periodically:
+                                if (
+                                    self._report_periodically
+                                    and best_results
+                                    and now - strategy_last_report
+                                    > self._report_periodically
+                                ):
                                     last_reports = self.report(
-                                        best_results, self.testcases,
-                                        self._stats.copy(strategy_stats))
+                                        best_results,
+                                        self.testcases,
+                                        self._stats.copy(strategy_stats),
+                                    )
                                     for result in best_results:
                                         result.report.cleanup()
                                     best_results = []
@@ -491,16 +588,18 @@ def run(self, repeat=1, min_results=1):
 
                     if best_results:
                         last_reports = self.report(
-                            best_results, self.testcases,
-                            self._stats.copy(total_stats))
+                            best_results, self.testcases, self._stats.copy(total_stats)
+                        )
 
                 except KeyboardInterrupt:
                     if best_results:
                         last_reports = self.report(
-                            best_results, self.testcases,
-                            self._stats.copy(total_stats))
-                        LOG.warning("Ctrl+C detected, best reduction so far "
-                                    "reported as %r", last_reports)
+                            best_results, self.testcases, self._stats.copy(total_stats)
+                        )
+                        LOG.warning(
+                            "Ctrl+C detected, best reduction so far " "reported as %r",
+                            last_reports,
+                        )
                     raise
                 finally:
                     for result in best_results:
@@ -512,22 +611,35 @@ def run(self, repeat=1, min_results=1):
             # if we complete all strategies, mark the last reported crashes as reduced
             if self._report_to_fuzzmanager and last_reports:
                 for crash_id in last_reports:
-                    LOG.info("Updating crash %d to quality %s", crash_id,
-                             FuzzManagerReporter.quality_name(FuzzManagerReporter.QUAL_REDUCED_RESULT))
-                    CrashEntry(crash_id).testcase_quality = FuzzManagerReporter.QUAL_REDUCED_RESULT
+                    LOG.info(
+                        "Updating crash %d to quality %s",
+                        crash_id,
+                        FuzzManagerReporter.quality_name(
+                            FuzzManagerReporter.QUAL_REDUCED_RESULT
+                        ),
+                    )
+                    CrashEntry(
+                        crash_id
+                    ).testcase_quality = FuzzManagerReporter.QUAL_REDUCED_RESULT
 
         # it's possible we made it this far without ever setting signature_desc.
         # this is only possible if --no-analysis is given
         # just give None instead of trying to format the CrashSignature
-        self._stats.add_info("Signature", {
-            "given": sig_given,
-            "any": self._any_crash,
-            "description": self._signature_desc,
-        })
+        self._stats.add_info(
+            "Signature",
+            {
+                "given": sig_given,
+                "any": self._any_crash,
+                "description": self._signature_desc,
+            },
+        )
 
         # log a summary of what was done.
-        LOG.info("Reduction summary:%s%s", os.linesep,
-                 os.linesep.join(self._stats.format_lines()))
+        LOG.info(
+            "Reduction summary:%s%s",
+            os.linesep,
+            os.linesep.join(self._stats.format_lines()),
+        )
 
         if any_success:
             return Session.EXIT_SUCCESS
@@ -554,8 +666,8 @@ def report(self, results, testcases, stats=None):
             else:
                 report_dir = "reports" if result.expected else "other_reports"
                 reporter = FilesystemReporter(
-                    report_path=str(self._log_path / report_dir),
-                    major_bucket=False)
+                    report_path=str(self._log_path / report_dir), major_bucket=False
+                )
             # write reduction stats
             if stats is not None:
                 report_path = Path(result.report.path)
@@ -619,16 +731,17 @@ def main(cls, args):
 
             try:
                 testcases = ReplayManager.load_testcases(
-                    args.input,
-                    args.prefs is None,
-                    subset=args.test_index)
+                    args.input, args.prefs is None, subset=args.test_index
+                )
             except TestCaseLoadFailure as exc:
                 LOG.error("Error: %s", str(exc))
                 return Session.EXIT_ERROR
 
             if args.tool is None and testcases[0].adapter_name is not None:
-                LOG.warning("Setting default --tool=grizzly-%s from testcase",
-                            testcases[0].adapter_name)
+                LOG.warning(
+                    "Setting default --tool=grizzly-%s from testcase",
+                    testcases[0].adapter_name,
+                )
                 args.tool = "grizzly-%s" % (testcases[0].adapter_name,)
 
             expect_hang = ReplayManager.expect_hang(args.ignore, signature, testcases)
@@ -637,7 +750,8 @@ def main(cls, args):
                 if len(testcases) > 1:
                     LOG.error(
                         "Error: '--no-harness' cannot be used with multiple "
-                        "testcases. Perhaps '--test-index' can help.")
+                        "testcases. Perhaps '--test-index' can help."
+                    )
                     return Session.EXIT_ARGS
                 LOG.debug("--no-harness specified relaunch set to 1")
                 args.relaunch = 1
@@ -645,9 +759,8 @@ def main(cls, args):
             # check test time limit and timeout
             # TODO: add support for test time limit, use timeout in both cases for now
             _, timeout = ReplayManager.time_limits(
-                args.timeout,
-                args.timeout,
-                testcases)
+                args.timeout, args.timeout, testcases
+            )
 
             args.repeat = max(args.min_crashes, args.repeat)
             relaunch = min(args.relaunch, args.repeat)
@@ -660,7 +773,8 @@ def main(cls, args):
                 args.memory,
                 rr=args.rr,
                 valgrind=args.valgrind,
-                xvfb=args.xvfb)
+                xvfb=args.xvfb,
+            )
             # prioritize specified prefs.js file over included file
             if args.prefs is not None:
                 for testcase in testcases:
@@ -671,8 +785,9 @@ def main(cls, args):
                 for testcase in testcases:
                     prefs_tf = testcase.get_file("prefs.js")
                     if prefs_tf:
-                        tmp_prefs = Path(mkdtemp(prefix="prefs_",
-                                                 dir=grz_tmp("replay")))
+                        tmp_prefs = Path(
+                            mkdtemp(prefix="prefs_", dir=grz_tmp("replay"))
+                        )
                         prefs_tf.dump(str(tmp_prefs))
                         LOG.info("Using prefs.js from testcase")
                         target.prefs = str(tmp_prefs / "prefs.js")
@@ -701,7 +816,8 @@ def main(cls, args):
                     static_timeout=args.static_timeout,
                     tool=args.tool,
                     use_analysis=not args.no_analysis,
-                    use_harness=not args.no_harness)
+                    use_harness=not args.no_harness,
+                )
                 return_code = mgr.run(repeat=args.repeat, min_results=args.min_crashes)
             return return_code
 
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index aa3ae201..41ef0124 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -50,9 +50,7 @@ def main(args):
                 Session.EXIT_ABORT: crash.testcase_quality,
                 Session.EXIT_SUCCESS: FuzzManagerReporter.QUAL_REDUCED_ORIGINAL,
                 Session.EXIT_FAILURE: FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE,
-            }.get(
-                result, FuzzManagerReporter.QUAL_UNREDUCED
-            )
+            }.get(result, FuzzManagerReporter.QUAL_UNREDUCED)
             # don't ever set things back to Q4, default to Q5 for that case.
             # Q4 is only used in automation, so ABORT should never happen.
             if quality == FuzzManagerReporter.QUAL_REDUCING:
diff --git a/grizzly/reduce/exceptions.py b/grizzly/reduce/exceptions.py
index 5a9b1d0f..7781a91e 100644
--- a/grizzly/reduce/exceptions.py
+++ b/grizzly/reduce/exceptions.py
@@ -8,6 +8,7 @@
 
 class GrizzlyReduceBaseException(Exception):
     """Base for other Grizzly Reducer specific exceptions."""
+
     def __init__(self, msg, code=Session.EXIT_ERROR):
         super().__init__()
         self.msg = msg
@@ -16,5 +17,6 @@ def __init__(self, msg, code=Session.EXIT_ERROR):
 
 class NotReproducible(GrizzlyReduceBaseException):
     """Crash was not observed when expected during reduction."""
+
     def __init__(self, msg):
         super().__init__(msg, code=Session.EXIT_FAILURE)
diff --git a/grizzly/reduce/stats.py b/grizzly/reduce/stats.py
index 1f3473a1..8a83c8c3 100644
--- a/grizzly/reduce/stats.py
+++ b/grizzly/reduce/stats.py
@@ -12,12 +12,13 @@
 from time import time
 
 ReductionStat = namedtuple(
-    "ReductionStat", "name, duration, successes, attempts, size, iterations")
+    "ReductionStat", "name, duration, successes, attempts, size, iterations"
+)
 
 
 class _FormatTable:
-    """Format tabular data in a table.
-    """
+    """Format tabular data in a table."""
+
     def __init__(self, columns, formatters, vsep=" | ", hsep="-"):
         """Initialize a FormatTable instance.
 
@@ -29,8 +30,9 @@ def __init__(self, columns, formatters, vsep=" | ", hsep="-"):
             hsep (str): Horizontal separation between header and data.
         """
         assert len(columns) == len(formatters)
-        self._columns = tuple(column for (column, fmt) in zip(columns, formatters)
-                              if fmt is not None)
+        self._columns = tuple(
+            column for (column, fmt) in zip(columns, formatters) if fmt is not None
+        )
         self._formatters = formatters
         self._vsep = vsep
         self._hsep = hsep
@@ -118,8 +120,15 @@ def __deepcopy__(self, memo):
         result._data = deepcopy(self._data, memo)  # pylint: disable=protected-access
         return result
 
-    def add(self, name, testcase_size, elapsed=None, iterations=None, attempts=None,
-            successes=None):
+    def add(
+        self,
+        name,
+        testcase_size,
+        elapsed=None,
+        iterations=None,
+        attempts=None,
+        successes=None,
+    ):
         """Record reduction stats for a given point in time:
 
         - name of the milestone (eg. init, strategy name completed)
@@ -238,16 +247,27 @@ def _stop_early(sub, other):
                 """
                 elapsed = time() - sub._start
                 other.add(
-                    name, testcase_size_cb(), elapsed=elapsed, attempts=sub._attempts,
-                    successes=sub._successes, iterations=sub._iterations)
+                    name,
+                    testcase_size_cb(),
+                    elapsed=elapsed,
+                    attempts=sub._attempts,
+                    successes=sub._successes,
+                    iterations=sub._iterations,
+                )
                 if sub._parent is not None:
                     sub._parent._stop_early(other)  # pylint: disable=protected-access
 
             def __exit__(sub, exc_type, exc_value, traceback):
                 elapsed = time() - sub._start
-                self.add(sub._name, testcase_size_cb(), elapsed=elapsed,
-                         attempts=sub._attempts, successes=sub._successes,
-                         iterations=sub._iterations)
+                self.add(
+                    sub._name,
+                    testcase_size_cb(),
+                    elapsed=elapsed,
+                    attempts=sub._attempts,
+                    successes=sub._successes,
+                    iterations=sub._iterations,
+                )
+
         return _MilestoneTimer(name)
 
     def copy(self, stop_timer=None):
@@ -287,7 +307,7 @@ def format_lines(self):
                 successes=partial(_format_number, total=stats[-1].successes),
                 iterations=None,  # hide
                 size=partial(_format_number, total=stats[0].size),
-            )
+            ),
         )
         yield from tabulator.format_rows(stats)
 
diff --git a/grizzly/reduce/strategies/__init__.py b/grizzly/reduce/strategies/__init__.py
index ee6e9f69..57b31c66 100644
--- a/grizzly/reduce/strategies/__init__.py
+++ b/grizzly/reduce/strategies/__init__.py
@@ -63,7 +63,8 @@ def _load_strategies():
         assert (
             strategy in strategies
         ), "Unknown entry in DEFAULT_STRATEGIES: %s (STRATEGIES: [%s])" % (
-            strategy, ",".join(strategies)
+            strategy,
+            ",".join(strategies),
         )
     return MappingProxyType(strategies)
 
@@ -82,6 +83,7 @@ class Strategy(ABC):
     Class Attributes:
         name (str): The strategy name.
     """
+
     name = None
 
     def __init__(self, testcases):
@@ -119,7 +121,8 @@ def _calculate_testcase_hash(self):
             in_tried = result in self._tried
             LOG.debug(
                 "Testcase hash: %s (%sin cache)",
-                print_hash.hexdigest()[:32], "" if in_tried else "not "
+                print_hash.hexdigest()[:32],
+                "" if in_tried else "not ",
             )
 
         return result
@@ -248,8 +251,11 @@ def purge_unserved(self, testcases, served):
         LOG.debug("purging from %d testcases", len(testcases))
         anything_purged = False
         while len(served) < len(testcases):
-            LOG.debug("not all %d testcases served (%d served), popping one",
-                      len(testcases), len(served))
+            LOG.debug(
+                "not all %d testcases served (%d served), popping one",
+                len(testcases),
+                len(served),
+            )
             testcases.pop().cleanup()
             anything_purged = True
         remove_testcases = []
diff --git a/grizzly/reduce/strategies/beautify.py b/grizzly/reduce/strategies/beautify.py
index f286fd4a..c68e397a 100644
--- a/grizzly/reduce/strategies/beautify.py
+++ b/grizzly/reduce/strategies/beautify.py
@@ -16,11 +16,13 @@
 
 try:
     import cssbeautifier
+
     HAVE_CSSBEAUTIFIER = True
 except ImportError:  # pragma: no cover
     HAVE_CSSBEAUTIFIER = False
 try:
     import jsbeautifier
+
     HAVE_JSBEAUTIFIER = True
 except ImportError:  # pragma: no cover
     HAVE_JSBEAUTIFIER = False
@@ -45,6 +47,7 @@ class _BeautifyStrategy(Strategy, ABC):
         native_extension (str): The native file extension for this type.
         tag_name (str): Tag name to search for in other (non-native) extensions.
     """
+
     all_extensions = None
     ignore_files = {"test_info.json", "prefs.js"}
     import_available = None
@@ -63,16 +66,21 @@ def __init__(self, testcases):
         super().__init__(testcases)
         self._files_to_beautify = []
         for path in self._testcase_root.glob("**/*"):
-            if (path.is_file() and path.suffix in self.all_extensions
-                    and path.name not in self.ignore_files):
+            if (
+                path.is_file()
+                and path.suffix in self.all_extensions
+                and path.name not in self.ignore_files
+            ):
                 if _contains_dd(path):
                     self._files_to_beautify.append(path)
         self._current_feedback = None
         tag_bytes = self.tag_name.encode("ascii")
-        self._re_tag_start = re.compile(br"<\s*" + tag_bytes + br".*?>",
-                                        flags=re.DOTALL | re.IGNORECASE)
-        self._re_tag_end = re.compile(br"</\s*" + tag_bytes + br"\s*>",
-                                      flags=re.IGNORECASE)
+        self._re_tag_start = re.compile(
+            br"<\s*" + tag_bytes + br".*?>", flags=re.DOTALL | re.IGNORECASE
+        )
+        self._re_tag_end = re.compile(
+            br"</\s*" + tag_bytes + br"\s*>", flags=re.IGNORECASE
+        )
 
     @classmethod
     def sanity_check_cls_attrs(cls):
@@ -145,7 +153,7 @@ def _chunks_to_beautify(self, before, to_beautify, file):
             # there was an open <tag>
             last_tag_start is not None
             # and it isn't followed by a closing </tag>
-            and self._re_tag_end.search(before[last_tag_start.end(0):]) is None
+            and self._re_tag_end.search(before[last_tag_start.end(0) :]) is None
         )
         if in_tag_already:
             tag_end = self._re_tag_end.search(to_beautify)
@@ -191,9 +199,12 @@ def __iter__(self):
 
         LOG.info("Beautifying %d files", len(self._files_to_beautify))
         for file_no, file in enumerate(self._files_to_beautify):
-            LOG.info("Beautifying %s (file %d/%d)",
-                     file.relative_to(self._testcase_root), file_no + 1,
-                     len(self._files_to_beautify))
+            LOG.info(
+                "Beautifying %s (file %d/%d)",
+                file.relative_to(self._testcase_root),
+                file_no + 1,
+                len(self._files_to_beautify),
+            )
 
             # Use Lithium just to split the file at DDBEGIN/END.
             # Lithium already has the right logic for DDBEGIN/END and line endings.
@@ -226,8 +237,10 @@ def __iter__(self):
                     elif to_beautify.strip():  # pragma: no cover
                         # this should never happen, but just in case...
                         # pragma: no cover
-                        LOG.warning("No output from beautify! Writing %s unmodified.",
-                                    self.tag_name)
+                        LOG.warning(
+                            "No output from beautify! Writing %s unmodified.",
+                            self.tag_name,
+                        )
                         testcase_fp.write(to_beautify)  # pragma: no cover
                     last = end
                 testcase_fp.write(raw[last:])
@@ -265,16 +278,17 @@ class CSSBeautify(_BeautifyStrategy):
     This should make the CSS more reducible if there are long lines with compound
     definitions.
     """
+
     all_extensions = {".css", ".htm", ".html", ".xhtml"}
     import_available = HAVE_CSSBEAUTIFIER
     import_name = "cssbeautifier"
     name = "cssbeautify"
     native_extension = ".css"
     opts = (
-        ('end_with_newline', False),
-        ('indent_size', 2),
-        ('newline_between_rules', False),
-        ('preserve_newlines', False),
+        ("end_with_newline", False),
+        ("indent_size", 2),
+        ("newline_between_rules", False),
+        ("preserve_newlines", False),
     )
     tag_name = "style"
 
@@ -290,9 +304,9 @@ def beautify_bytes(cls, data):
         """
         assert cls.import_available
         data = data.decode("utf-8", errors="surrogateescape")
-        return (cssbeautifier
-                .beautify(data, cls.opts)
-                .encode("utf-8", errors="surrogateescape"))
+        return cssbeautifier.beautify(data, cls.opts).encode(
+            "utf-8", errors="surrogateescape"
+        )
 
 
 class JSBeautify(_BeautifyStrategy):
@@ -301,6 +315,7 @@ class JSBeautify(_BeautifyStrategy):
     This should make the javascript more reducible if there are long lines with
     compound statements.
     """
+
     all_extensions = {".js", ".htm", ".html", ".xhtml"}
     import_available = HAVE_JSBEAUTIFIER
     import_name = "jsbeautifier"
diff --git a/grizzly/reduce/strategies/lithium.py b/grizzly/reduce/strategies/lithium.py
index 77f7c398..459e0d75 100644
--- a/grizzly/reduce/strategies/lithium.py
+++ b/grizzly/reduce/strategies/lithium.py
@@ -31,6 +31,7 @@ class _LithiumStrategy(Strategy, ABC):
         strategy_cls (lithium.strategies.Strategy): Lithium strategy type.
         testcase_cls (lithium.testcases.Testcase): Lithium testcase type.
     """
+
     strategy_cls = None
     testcase_cls = None
 
@@ -114,9 +115,13 @@ def __iter__(self):
             LOG.debug("Reduce queue: %r", reduce_queue)
             file = reduce_queue.pop(0)
             file_no += 1
-            LOG.info("[%s] Reducing %s (file %d/%d)", self.name,
-                     file.relative_to(self._testcase_root), file_no,
-                     len(self._files_to_reduce))
+            LOG.info(
+                "[%s] Reducing %s (file %d/%d)",
+                self.name,
+                file.relative_to(self._testcase_root),
+                file_no,
+                len(self._files_to_reduce),
+            )
             lithium_testcase = self.testcase_cls()  # pylint: disable=not-callable
             lithium_testcase.load(file)
             strategy = self.strategy_cls()  # pylint: disable=not-callable
@@ -157,8 +162,7 @@ def __iter__(self):
                     LOG.debug("files being reduced after: %r", self._files_to_reduce)
                     files_to_reduce = set(self._files_to_reduce)
                     reduce_queue = list(sorted(set(reduce_queue) & files_to_reduce))
-                    testcase_root_dirty = \
-                        len(self._files_to_reduce) != num_files_before
+                    testcase_root_dirty = len(self._files_to_reduce) != num_files_before
                     if file not in files_to_reduce:
                         # current reduction was for a purged file
                         break
@@ -182,6 +186,7 @@ class Check(_LithiumStrategy):
     This strategy does no reduction, and only yields once. It is intended to provide a
     pass/fail result in a reduction pipeline.
     """
+
     name = "check"
     strategy_cls = CheckOnly
     testcase_cls = TestcaseLine
@@ -204,14 +209,15 @@ class CollapseEmptyBraces(_LithiumStrategy):
     This strategy tries to collapse empty braces onto the same line between each
     iteration, so that empty blocks can be removed if otherwise possible.
     """
+
     name = "collapsebraces"
     strategy_cls = LithCollapseEmptyBraces
     testcase_cls = TestcaseLine
 
 
 class MinimizeChars(_LithiumStrategy):
-    """Minimize all bytes in the testcase.
-    """
+    """Minimize all bytes in the testcase."""
+
     name = "chars"
     strategy_cls = Minimize
     testcase_cls = TestcaseChar
@@ -224,14 +230,15 @@ class MinimizeJSChars(_LithiumStrategy):
     looks like a quoted string. It also treats escaped characters as a single token
     for reduction.
     """
+
     name = "jschars"
     strategy_cls = Minimize
     testcase_cls = TestcaseJsStr
 
 
 class MinimizeLines(_LithiumStrategy):
-    """Minimize all lines in the testcase.
-    """
+    """Minimize all lines in the testcase."""
+
     name = "lines"
     strategy_cls = Minimize
     testcase_cls = TestcaseLine
@@ -239,6 +246,7 @@ class MinimizeLines(_LithiumStrategy):
 
 class MinimizeAttrs(_LithiumStrategy):
     """Remove HTML/XML attributes and their values."""
+
     name = "attrs"
     strategy_cls = Minimize
     testcase_cls = TestcaseAttrs
diff --git a/grizzly/reduce/strategies/testcases.py b/grizzly/reduce/strategies/testcases.py
index 086efee0..46d90667 100644
--- a/grizzly/reduce/strategies/testcases.py
+++ b/grizzly/reduce/strategies/testcases.py
@@ -24,6 +24,7 @@ class MinimizeTestcaseList(Strategy):
                     4       1 2 3   5
                     5       1 2 3 4
     """
+
     name = "list"
 
     def __init__(self, testcases):
@@ -76,8 +77,10 @@ def __iter__(self):
             testcase_root_dirty = False
             while True:
                 if n_testcases <= 1:
-                    LOG.info("Testcase list has length %d, not enough to reduce!",
-                             n_testcases)
+                    LOG.info(
+                        "Testcase list has length %d, not enough to reduce!",
+                        n_testcases,
+                    )
                     break
                 if idx >= n_testcases:
                     LOG.info("Attempted to remove every single testcase")
@@ -93,15 +96,17 @@ def __iter__(self):
 
                 if self._current_feedback:
                     testcase_root_dirty = False
-                    LOG.info("Removing testcase %d/%d was successful!", idx + 1,
-                             n_testcases)
+                    LOG.info(
+                        "Removing testcase %d/%d was successful!", idx + 1, n_testcases
+                    )
                     testcases = TestCase.load(str(self._testcase_root), True)
                     try:
                         # remove the actual testcase we were reducing
                         testcases.pop(idx).cleanup()
                         if testcases and self._current_served is not None:
-                            testcase_root_dirty = \
-                                self.purge_unserved(testcases, self._current_served)
+                            testcase_root_dirty = self.purge_unserved(
+                                testcases, self._current_served
+                            )
                         else:
                             self.dump_testcases(testcases, recreate_tcroot=True)
                     finally:
@@ -123,8 +128,9 @@ def __iter__(self):
                 LOG.info("[%s] final iteration triggered by purge_optional", self.name)
                 yield testcases
                 testcases = None  # caller owns testcases now
-                assert self._current_feedback, \
-                    "Purging unserved files broke the testcase."
+                assert (
+                    self._current_feedback
+                ), "Purging unserved files broke the testcase."
         finally:
             if testcases is not None:
                 for testcase in testcases:
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index a2eb9c12..d97f7363 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -25,6 +25,7 @@ def test_args_01(capsys, tmp_path, mocker):
     """test args in common with grizzly.replay"""
     # pylint: disable=import-outside-toplevel
     from ..replay.test_main import test_args_01 as real_test
+
     mocker.patch("grizzly.replay.test_main.ReplayArgs", new=ReduceArgs)
     real_test(capsys, tmp_path)
 
@@ -51,8 +52,9 @@ def test_args_02(tmp_path):
     logs_dir.mkdir()
     ReduceArgs().parse_args([str(exe), str(inp), "--logs", str(logs_dir)])
     # test no-analysis
-    ReduceArgs().parse_args([str(exe), str(inp), "--no-analysis", "--repeat", "99",
-                             "--min-crashes", "99"])
+    ReduceArgs().parse_args(
+        [str(exe), str(inp), "--no-analysis", "--repeat", "99", "--min-crashes", "99"]
+    )
     # these should both log a warning that the args will be ignored due to analysis
     ReduceArgs().parse_args([str(exe), str(inp), "--repeat", "99"])
     ReduceArgs().parse_args([str(exe), str(inp), "--min-crashes", "99"])
@@ -68,32 +70,45 @@ def test_args_02(tmp_path):
     [
         (
             "grizzly.reduce.core.ReduceManager.run",
-            TargetLaunchError("error", None), None, {}, 1
+            TargetLaunchError("error", None),
+            None,
+            {},
+            1,
         ),
         ("grizzly.reduce.core.ReduceManager.run", TargetLaunchTimeout, None, {}, 1),
         ("grizzly.reduce.core.load_target", KeyboardInterrupt, None, {}, 1),
         (
             "grizzly.reduce.core.load_target",
-            GrizzlyReduceBaseException(""), None, {}, 1
+            GrizzlyReduceBaseException(""),
+            None,
+            {},
+            1,
         ),
         (
             "grizzly.reduce.core.ReplayManager.load_testcases",
-            TestCaseLoadFailure, None, {}, 1
+            TestCaseLoadFailure,
+            None,
+            {},
+            1,
         ),
         ("grizzly.reduce.core.ReplayManager.load_testcases", None, [], {}, 1),
         (
-            "grizzly.reduce.core.ReplayManager.load_testcases", None,
+            "grizzly.reduce.core.ReplayManager.load_testcases",
+            None,
             [Mock(hang=False), Mock(hang=False)],
-            {"no_harness": True}, 2
+            {"no_harness": True},
+            2,
         ),
-    ]
+    ],
 )
 def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, result):
     """test ReduceManager.main() failure cases"""
     mocker.patch(
-        "grizzly.reduce.core.FuzzManagerReporter", autospec=True,
+        "grizzly.reduce.core.FuzzManagerReporter",
+        autospec=True,
         QUAL_NO_TESTCASE=7,
-        QUAL_REDUCER_ERROR=9)
+        QUAL_REDUCER_ERROR=9,
+    )
     mocker.patch("grizzly.reduce.core.load_target", autospec=True)
     mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
     # setup args
@@ -105,7 +120,8 @@ def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, result
         relaunch=1,
         repeat=1,
         sig=None,
-        **kwargs)
+        **kwargs
+    )
 
     mocker.patch(patch_func, side_effect=side_effect, return_value=return_value)
     assert ReduceManager.main(args) == result
@@ -116,7 +132,7 @@ def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, result
     [
         TargetLaunchError,
         TargetLaunchTimeout,
-    ]
+    ],
 )
 def test_main_launch_error(mocker, exc_type):
     mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
@@ -139,8 +155,9 @@ def test_main_launch_error(mocker, exc_type):
         sig=None,
     )
 
-    exc_obj = exc_type("error",
-                       mocker.Mock() if exc_type is TargetLaunchError else None)
+    exc_obj = exc_type(
+        "error", mocker.Mock() if exc_type is TargetLaunchError else None
+    )
     run.side_effect = exc_obj
     assert ReduceManager.main(args) == 4
     if exc_type is TargetLaunchError:
diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
index bd7488a1..07bab57b 100644
--- a/grizzly/reduce/test_main_fm.py
+++ b/grizzly/reduce/test_main_fm.py
@@ -26,8 +26,7 @@
         ("arg_sig.json", None, 789, "arg_sig.json", "test-tool"),
         # --tool respected
         (None, "tool2", None, None, "tool2"),
-
-    ]
+    ],
 )
 def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_tool):
     """tests for `grizzly.reduce.crash.main`"""
@@ -62,7 +61,7 @@ def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_
         (3, 0, 0),
         (4, 6, 5),
         (5, 5, 10),
-    ]
+    ],
 )
 def test_crash_main_quality(mocker, mgr_exit_code, pre_quality, post_quality):
     """test that quality is updated"""
@@ -100,7 +99,7 @@ def test_crash_main_quality(mocker, mgr_exit_code, pre_quality, post_quality):
         ([(123, "test-tool")], [0], 0, None, "test-tool-arg"),
         # abort in crash main should also abort bucket main
         ([(123, "test-tool")], [3], 3, None, None),
-    ]
+    ],
 )
 def test_bucket_main(mocker, crashes, main_exit_codes, result, arg_sig, arg_tool):
     """tests for `grizzly.reduce.bucket.main`"""
@@ -109,10 +108,12 @@ def test_bucket_main(mocker, crashes, main_exit_codes, result, arg_sig, arg_tool
     def copy_args(args):
         call_args.append(deepcopy(args))
         return main_exit_codes[main.call_count - 1]
+
     mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
     bucket = mocker.patch("grizzly.reduce.bucket.Bucket", autospec=True)
-    main = mocker.patch("grizzly.reduce.bucket.crash_main", autospec=True,
-                        side_effect=copy_args)
+    main = mocker.patch(
+        "grizzly.reduce.bucket.crash_main", autospec=True, side_effect=copy_args
+    )
     bucket.return_value.signature_path.return_value = "test_sig.json"
     bucket.return_value.iter_crashes.return_value = [
         mocker.Mock(crash_id=crash, tool=tool) for crash, tool in crashes
@@ -125,7 +126,7 @@ def copy_args(args):
     )
     assert bucket_main(args) == result
     assert main.call_count == len(main_exit_codes)
-    for idx, (crash, _tool) in enumerate(crashes[:main.call_count]):
+    for idx, (crash, _tool) in enumerate(crashes[: main.call_count]):
         assert call_args[idx].input == crash
         if arg_tool is not None:
             assert call_args[idx].tool == arg_tool
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 92fff9ad..4da90b0c 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -23,7 +23,9 @@
 from .strategies import Strategy
 
 LOG = getLogger(__name__)
-pytestmark = pytest.mark.usefixtures("tmp_path_fm_config", "reporter_sequential_strftime")
+pytestmark = pytest.mark.usefixtures(
+    "tmp_path_fm_config", "reporter_sequential_strftime"
+)
 
 
 def _fake_save_logs_foo(result_logs, meta=False):  # pylint: disable=unused-argument
@@ -53,7 +55,7 @@ def _fake_save_logs_bar(result_logs, meta=False):  # pylint: disable=unused-argu
 AnalysisTestParams = namedtuple(
     "AnalysisTestParams",
     "harness_last_crashes, harness_crashes, no_harness_crashes, expected_repeat, "
-    "expected_min_crashes, use_harness, result_harness"
+    "expected_min_crashes, use_harness, result_harness",
 )
 
 
@@ -224,12 +226,19 @@ def _fake_save_logs_bar(result_logs, meta=False):  # pylint: disable=unused-argu
         AnalysisTestParams(None, 1, 0, 32, 1, True, True),
         # last test doesn't repro, harness+all tests is (11/11), skip without harness
         AnalysisTestParams(None, 11, None, 2, 2, True, True),
-
-    ]
+    ],
 )
-def test_analysis(mocker, tmp_path, harness_last_crashes, harness_crashes,
-                  no_harness_crashes, expected_repeat, expected_min_crashes,
-                  use_harness, result_harness):
+def test_analysis(
+    mocker,
+    tmp_path,
+    harness_last_crashes,
+    harness_crashes,
+    no_harness_crashes,
+    expected_repeat,
+    expected_min_crashes,
+    use_harness,
+    result_harness,
+):
     """test that analysis sets reasonable params"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value.__enter__.return_value
@@ -254,14 +263,13 @@ def replay_run(_tests, _time_limit, **kw):
         for _ in range(repeat):
             LOG.debug("interesting: %r", crashes[0])
             if crashes.pop(0):
-                log_path = tmp_path / (
-                    "crash%d_logs" % (replayer.run.call_count,)
-                )
+                log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
                 log_path.mkdir(exist_ok=True)
                 _fake_save_logs_foo(log_path)
                 report = Report(str(log_path), "bin")
                 results.append(ReplayResult(report, [["test.html"]], [], True))
         return results
+
     replayer.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
@@ -286,9 +294,15 @@ def _stop_early(_):
 
     stats = _ReduceStats()
     try:
-        mgr = ReduceManager(None, mocker.Mock(spec=Sapphire, timeout=30),
-                            mocker.Mock(spec=Target),
-                            tests, None, log_path, use_harness=use_harness)
+        mgr = ReduceManager(
+            None,
+            mocker.Mock(spec=Sapphire, timeout=30),
+            mocker.Mock(spec=Target),
+            tests,
+            None,
+            log_path,
+            use_harness=use_harness,
+        )
         repeat, min_crashes, _ = mgr.run_reliability_analysis(stats)
     finally:
         for test in tests:
@@ -303,16 +317,18 @@ def _stop_early(_):
 
 def _ignore_arg(func):
     """Function wrapper that simply ignores 1 argument"""
+
     @wraps(func)
     def wrapped(_):
         return func()
+
     return wrapped
 
 
 ReproTestParams = namedtuple(
     "ReproTestParams",
     "original, strategies, detect_failure, interesting_str, is_expected,"
-    "expected_run_calls, n_reports, reports, n_other, other_reports, result"
+    "expected_run_calls, n_reports, reports, n_other, other_reports, result",
 )
 
 
@@ -351,8 +367,10 @@ def wrapped(_):
         ReproTestParams(
             original="odd\neven\n" * 3,
             strategies=["check", "lines"],
-            detect_failure=lambda contents: sum(1 for line in contents.splitlines()
-                                                if line == "odd") == 3,
+            detect_failure=lambda contents: sum(
+                1 for line in contents.splitlines() if line == "odd"
+            )
+            == 3,
             interesting_str="%r contains 3x 'odd'",
             is_expected=lambda _: True,
             expected_run_calls=8,
@@ -397,7 +415,9 @@ def wrapped(_):
             detect_failure=(
                 lambda contents: (
                     len(contents.splitlines()) == 6
-                    and set(contents.splitlines()) >= {"A1", "A3", "A5"})),
+                    and set(contents.splitlines()) >= {"A1", "A3", "A5"}
+                )
+            ),
             interesting_str="%r contains {'A1', 'A3', 'A5'} and len() == 6",
             is_expected=lambda _: True,
             expected_run_calls=43,
@@ -413,8 +433,10 @@ def wrapped(_):
             original="A1\nA2\nA3\nA4\nA5\nA6\n",
             strategies=["check", "lines", "chars"],
             detect_failure=(
-                lambda contents: (set(contents.splitlines(keepends=True))
-                                  >= {"A1\n", "A3\n", "A5\n"})),
+                lambda contents: (
+                    set(contents.splitlines(keepends=True)) >= {"A1\n", "A3\n", "A5\n"}
+                )
+            ),
             interesting_str="%r contains {'A1\\n', 'A3\\n', 'A5\\n'}",
             is_expected=lambda _: True,
             expected_run_calls=34,
@@ -436,8 +458,19 @@ def wrapped(_):
             n_reports=1,
             reports={"1\n2\n3\n"},
             n_other=15,
-            other_reports={"\n2\n3\n", "1\n", "1\n\n3\n", "1\n2\n", "1\n2\n\n",
-                           "1\n2\n3", "1\n23\n", "1\n3\n", "12\n3\n", "2\n3\n", "3\n"},
+            other_reports={
+                "\n2\n3\n",
+                "1\n",
+                "1\n\n3\n",
+                "1\n2\n",
+                "1\n2\n\n",
+                "1\n2\n3",
+                "1\n23\n",
+                "1\n3\n",
+                "12\n3\n",
+                "2\n3\n",
+                "3\n",
+            },
             result=0,
         ),
         # reproduces, one strategy, testcase reduces to 0
@@ -459,8 +492,8 @@ def wrapped(_):
             original="1\n2\n3\n",
             strategies=["check", "lines", "lines"],
             detect_failure=_ignore_arg(
-                partial(
-                    [True, False, False, False, False, False, True, True].pop, 0)),
+                partial([True, False, False, False, False, False, True, True].pop, 0)
+            ),
             interesting_str="%r is anything, only in second strategy",
             is_expected=lambda _: True,
             expected_run_calls=8,
@@ -470,12 +503,24 @@ def wrapped(_):
             other_reports=None,
             result=0,
         ),
-    ]
+    ],
 )
 @pytest.mark.usefixtures("reporter_sequential_strftime")
-def test_repro(mocker, tmp_path, original, strategies, detect_failure, interesting_str,
-               is_expected, expected_run_calls, n_reports, reports, n_other,
-               other_reports, result):
+def test_repro(
+    mocker,
+    tmp_path,
+    original,
+    strategies,
+    detect_failure,
+    interesting_str,
+    is_expected,
+    expected_run_calls,
+    n_reports,
+    reports,
+    n_other,
+    other_reports,
+    result,
+):
     """test ReduceManager, difference scenarios produce correct expected/other
     results"""
     mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
@@ -489,9 +534,7 @@ def replay_run(testcases, _time_limit, **_):
             # pylint: disable=logging-not-lazy
             LOG.debug("interesting if " + interesting_str, contents)
             if detect_failure(contents):
-                log_path = tmp_path / (
-                    "crash%d_logs" % (replayer.run.call_count,)
-                )
+                log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
                 log_path.mkdir()
                 expected = is_expected(contents)
                 if expected:
@@ -501,6 +544,7 @@ def replay_run(testcases, _time_limit, **_):
                 report = Report(str(log_path), "bin")
                 return [ReplayResult(report, [["test.html"]], [], expected)]
         return []
+
     replayer.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
@@ -511,8 +555,15 @@ def replay_run(testcases, _time_limit, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target, tests,
-                            strategies, log_path, use_analysis=False)
+        mgr = ReduceManager(
+            [],
+            mocker.Mock(spec=Sapphire, timeout=30),
+            target,
+            tests,
+            strategies,
+            log_path,
+            use_analysis=False,
+        )
         if isinstance(result, type) and issubclass(result, BaseException):
             with raises(result):
                 mgr.run()
@@ -532,14 +583,17 @@ def replay_run(testcases, _time_limit, **_):
     if n_reports:
         tests = {test.read_text() for test in log_path.glob("reports/*-0/test.html")}
         assert tests == reports
-        assert sum(1 for _ in (log_path / "reports").iterdir()) \
-            == n_reports * 2, list((log_path / "reports").iterdir())
+        assert sum(1 for _ in (log_path / "reports").iterdir()) == n_reports * 2, list(
+            (log_path / "reports").iterdir()
+        )
     if n_other:
-        other_tests = {test.read_text()
-                       for test in log_path.glob("other_reports/*-0/test.html")}
+        other_tests = {
+            test.read_text() for test in log_path.glob("other_reports/*-0/test.html")
+        }
         assert other_tests == other_reports
-        assert sum(1 for _ in (log_path / "other_reports").iterdir()) \
-            == n_other * 2, list((log_path / "other_reports").iterdir())
+        assert (
+            sum(1 for _ in (log_path / "other_reports").iterdir()) == n_other * 2
+        ), list((log_path / "other_reports").iterdir())
     assert replayer.run.call_count == expected_run_calls
 
 
@@ -584,9 +638,16 @@ def fake_iter():
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target,
-                            testcases, ["fake"], log_path, use_analysis=False,
-                            report_period=30)
+        mgr = ReduceManager(
+            [],
+            mocker.Mock(spec=Sapphire, timeout=30),
+            target,
+            testcases,
+            ["fake"],
+            log_path,
+            use_analysis=False,
+            report_period=30,
+        )
         assert mgr.run() == 0
     finally:
         for test in testcases:
@@ -601,8 +662,9 @@ def fake_iter():
     assert set(log_path.iterdir()) == expected_dirs
     tests = {test.read_text() for test in log_path.glob("reports/*-0/test.html")}
     assert tests == reports
-    assert sum(1 for _ in (log_path / "reports").iterdir()) \
-        == n_reports * 2, list((log_path / "reports").iterdir())
+    assert sum(1 for _ in (log_path / "reports").iterdir()) == n_reports * 2, list(
+        (log_path / "reports").iterdir()
+    )
 
 
 def test_report_02(mocker, tmp_path):
@@ -647,8 +709,15 @@ def fake_iter():
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target,
-                            testcases, ["fake"], log_path, use_analysis=False)
+        mgr = ReduceManager(
+            [],
+            mocker.Mock(spec=Sapphire, timeout=30),
+            target,
+            testcases,
+            ["fake"],
+            log_path,
+            use_analysis=False,
+        )
         with raises(KeyboardInterrupt):
             mgr.run()
     finally:
@@ -662,8 +731,9 @@ def fake_iter():
     assert set(log_path.iterdir()) == expected_dirs
     tests = {test.read_text() for test in log_path.glob("reports/*-0/test.html")}
     assert tests == reports
-    assert sum(1 for _ in (log_path / "reports").iterdir()) \
-        == n_reports * 2, list((log_path / "reports").iterdir())
+    assert sum(1 for _ in (log_path / "reports").iterdir()) == n_reports * 2, list(
+        (log_path / "reports").iterdir()
+    )
 
 
 def test_quality_update(mocker, tmp_path):
@@ -684,6 +754,7 @@ def replay_run(testcases, _time_limit, **_kw):
             report = Report(str(log_path), "bin")
             return [ReplayResult(report, [["test.html"]], [], True)]
         return []
+
     replayer.run.side_effect = replay_run
 
     (tmp_path / "test.html").write_text("123\n")
@@ -698,9 +769,16 @@ def replay_run(testcases, _time_limit, **_kw):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target,
-                            testcases, ["check", "lines"], log_path, use_analysis=False,
-                            report_to_fuzzmanager=True)
+        mgr = ReduceManager(
+            [],
+            mocker.Mock(spec=Sapphire, timeout=30),
+            target,
+            testcases,
+            ["check", "lines"],
+            log_path,
+            use_analysis=False,
+            report_to_fuzzmanager=True,
+        )
         assert mgr.run() == 0
     finally:
         for test in testcases:
@@ -723,7 +801,7 @@ def replay_run(testcases, _time_limit, **_kw):
 TimeoutTestParams = namedtuple(
     "TimeoutTestParams",
     "durations, interesting, static_timeout, idle_input, idle_output, iter_input,"
-    "iter_output, result"
+    "iter_output, result",
 )
 
 
@@ -785,10 +863,20 @@ def replay_run(testcases, _time_limit, **_kw):
             iter_output=20,
             result=0,
         ),
-    ]
+    ],
 )
-def test_timeout_update(mocker, tmp_path, durations, interesting, static_timeout,
-                        idle_input, idle_output, iter_input, iter_output, result):
+def test_timeout_update(
+    mocker,
+    tmp_path,
+    durations,
+    interesting,
+    static_timeout,
+    idle_input,
+    idle_output,
+    iter_input,
+    iter_output,
+    result,
+):
     "timeout will be updated based on time to crash"
     mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
@@ -802,6 +890,7 @@ def replay_run(_testcases, _time_limit, **_):
         _fake_save_logs_foo(log_path)
         report = Report(str(log_path), "bin")
         return [ReplayResult(report, [["test.html"]], durations, interesting)]
+
     replayer.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
@@ -814,9 +903,17 @@ def replay_run(_testcases, _time_limit, **_):
     server = mocker.Mock(spec=Sapphire)
     server.timeout = iter_input
     try:
-        mgr = ReduceManager([], server, target, tests, ["check"], log_path,
-                            use_analysis=False, idle_delay=idle_input,
-                            static_timeout=static_timeout)
+        mgr = ReduceManager(
+            [],
+            server,
+            target,
+            tests,
+            ["check"],
+            log_path,
+            use_analysis=False,
+            idle_delay=idle_input,
+            static_timeout=static_timeout,
+        )
         mgr.IDLE_DELAY_MIN = 10
         mgr.IDLE_DELAY_DURATION_MULTIPLIER = 1.5
         mgr.ITER_TIMEOUT_MIN = 10
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 995fca48..142e3163 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -26,13 +26,15 @@
 )
 
 LOG = getLogger(__name__)
-pytestmark = pytest.mark.usefixtures("tmp_path_fm_config",
-                                     "reporter_sequential_strftime")
+pytestmark = pytest.mark.usefixtures(
+    "tmp_path_fm_config", "reporter_sequential_strftime"
+)
 
 
 @pytest.mark.parametrize("is_hang", [True, False])
 def test_strategy_tc_load(is_hang):
     """test that strategy base class dump and load doesn't change testcase metadata"""
+
     class _TestStrategy(Strategy):
         def __iter__(self):
             yield TestCase.load(str(self._testcase_root), False)
@@ -67,8 +69,10 @@ def _fake_save_logs_foo(result_logs):
 
 def test_strategy_load_fail(mocker):
     """test that a broken strategy doesn't block other strategies"""
+
     class _GoodStrategy:
         name = "good"
+
         @classmethod
         def sanity_check_cls_attrs(cls):
             pass
@@ -79,6 +83,7 @@ def load(cls):
 
     class _BadStrategy:
         name = "bad"
+
         @classmethod
         def load(cls):
             raise RuntimeError("oops")
@@ -101,7 +106,7 @@ def entries(_):
 ListStrategyParams = namedtuple(
     "ListStrategyParams",
     "test_data, strategies, required_first, expected_run_calls, expected_results,"
-    "expected_num_reports"
+    "expected_num_reports",
 )
 
 
@@ -135,10 +140,18 @@ def entries(_):
             expected_results={"required", "123"},
             expected_num_reports=3,
         ),
-    ]
+    ],
 )
-def test_list(mocker, tmp_path, test_data, strategies, required_first,
-              expected_run_calls, expected_results, expected_num_reports):
+def test_list(
+    mocker,
+    tmp_path,
+    test_data,
+    strategies,
+    required_first,
+    expected_run_calls,
+    expected_results,
+    expected_num_reports,
+):
     """tests for the "list" strategy"""
     mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
@@ -153,15 +166,15 @@ def replay_run(testcases, _time_limit, **_):
             if contents == "required" and required_first:
                 required_seen = True
             elif contents == "123" and (required_seen or not required_first):
-                log_path = tmp_path / (
-                    "crash%d_logs" % (replayer.run.call_count,)
-                )
+                log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
                 log_path.mkdir()
                 _fake_save_logs_foo(log_path)
                 report = Report(str(log_path), "bin")
-                return [ReplayResult(report, [["test.html"]] * len(testcases), [],
-                                     True)]
+                return [
+                    ReplayResult(report, [["test.html"]] * len(testcases), [], True)
+                ]
         return []
+
     replayer.run.side_effect = replay_run
 
     tests = []
@@ -174,8 +187,15 @@ def replay_run(testcases, _time_limit, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target, tests,
-                            strategies, log_path, use_analysis=False)
+        mgr = ReduceManager(
+            [],
+            mocker.Mock(spec=Sapphire, timeout=30),
+            target,
+            tests,
+            strategies,
+            log_path,
+            use_analysis=False,
+        )
         assert mgr.run() == 0
     finally:
         for test in tests:
@@ -185,14 +205,15 @@ def replay_run(testcases, _time_limit, **_):
     assert set(log_path.iterdir()) == {log_path / "reports"}
     tests = {test.read_text() for test in log_path.glob("reports/*-*/test.html")}
     assert tests == expected_results
-    assert sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports, \
-        list((log_path / "reports").iterdir())
+    assert (
+        sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports
+    ), list((log_path / "reports").iterdir())
 
 
 BeautifyStrategyParams = namedtuple(
     "BeautifyStrategyParams",
     "test_data, test_name, expected_run_calls, expected_results, expected_num_reports,"
-    "strategies, have_beautifiers"
+    "strategies, have_beautifiers",
 )
 
 
@@ -212,8 +233,9 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["jsbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
-                                     reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
+            ),
         ),
         # test beautify js embedded in html
         pytest.param(
@@ -221,14 +243,17 @@ def replay_run(testcases, _time_limit, **_):
                 test_data="<script>try{'fluff';'required'}catch(e){}</script>\n",
                 test_name="test.html",
                 expected_run_calls=1,
-                expected_results={"<script>\ntry {\n    'fluff';\n    'required'\n} "
-                                  "catch (e) {}\n</script>\n"},
+                expected_results={
+                    "<script>\ntry {\n    'fluff';\n    'required'\n} "
+                    "catch (e) {}\n</script>\n"
+                },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
-                                     reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
+            ),
         ),
         # test beautify multiple js embedded in html
         pytest.param(
@@ -237,15 +262,18 @@ def replay_run(testcases, _time_limit, **_):
                 "<script>'fluff';'requisite'</script>\n",
                 test_name="test.html",
                 expected_run_calls=1,
-                expected_results={"<script>\ntry {\n    'fluff';\n    'required'\n} "
-                                  "catch (e) {}\n</script><script>\n'fluff';\n'"
-                                  "requisite'\n</script>\n"},
+                expected_results={
+                    "<script>\ntry {\n    'fluff';\n    'required'\n} "
+                    "catch (e) {}\n</script><script>\n'fluff';\n'"
+                    "requisite'\n</script>\n"
+                },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
-                                     reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
+            ),
         ),
         # test beautify js embedded in html with no end
         pytest.param(
@@ -260,8 +288,9 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["jsbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
-                                     reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
+            ),
         ),
         # test DDBEGIN/END respected in .js file
         pytest.param(
@@ -276,14 +305,15 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["jsbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
-                                     reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
+            ),
         ),
         # test DDBEGIN/END respected for js embedded in html, DD outside <script>
         pytest.param(
             *BeautifyStrategyParams(
                 test_data="<!--DDBEGIN-->\n<script>\ntry{'fluff';'required'}"
-                          "catch(e){}\n</script><!--DDEND-->\n",
+                "catch(e){}\n</script><!--DDEND-->\n",
                 test_name="test.html",
                 expected_run_calls=1,
                 expected_results={
@@ -294,14 +324,15 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["jsbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
-                                     reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
+            ),
         ),
         # test DDBEGIN/END respected for js embedded in html, DD inside <script>
         pytest.param(
             *BeautifyStrategyParams(
                 test_data="<script>try{\n//DDBEGIN\n'fluff';'required'\n//DDEND\n}"
-                          "catch(e){}</script>\n",
+                "catch(e){}</script>\n",
                 test_name="test.html",
                 expected_run_calls=1,
                 expected_results={
@@ -312,15 +343,16 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["jsbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
-                                     reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
+            ),
         ),
         # test DDBEGIN/END respected for js embedded in html, DD straddle before
         # <script>
         pytest.param(
             *BeautifyStrategyParams(
                 test_data="<!--DDBEGIN-->\n<script>\ntry{'fluff';'required'}catch(e){}"
-                          "\n//DDEND\n",
+                "\n//DDEND\n",
                 test_name="test.html",
                 expected_run_calls=1,
                 expected_results={
@@ -331,14 +363,15 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["jsbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
-                                     reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
+            ),
         ),
         # test DDBEGIN/END respected for js embedded in html, DD straddle after <script>
         pytest.param(
             *BeautifyStrategyParams(
                 test_data="<script>\n//DDBEGIN\ntry{'fluff';'required'}catch(e){}\n"
-                          "//DDEND\n",
+                "//DDEND\n",
                 test_name="test.html",
                 expected_run_calls=1,
                 expected_results={
@@ -349,15 +382,16 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["jsbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
-                                     reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
+            ),
         ),
         # test DDBEGIN/END respected for js embedded in html, DD straddle after
         # </script>
         pytest.param(
             *BeautifyStrategyParams(
                 test_data="<script>\n//DDBEGIN\ntry{'fluff';'required'}catch(e){}\n"
-                          "</script>\n<!--DDEND-->\n",
+                "</script>\n<!--DDEND-->\n",
                 test_name="test.html",
                 expected_run_calls=1,
                 expected_results={
@@ -368,8 +402,9 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["jsbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
-                                     reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
+            ),
         ),
         # test beautify js embedded in html (no <script>)
         pytest.param(
@@ -383,8 +418,9 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["jsbeautify", "check"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
-                                     reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
+            ),
         ),
         # test beautify js where beautification breaks
         pytest.param(
@@ -398,8 +434,9 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["jsbeautify", "check"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_JSBEAUTIFIER,
-                                     reason="jsbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
+            ),
         ),
         # test beautify a .css file
         pytest.param(
@@ -412,8 +449,9 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["cssbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
-                                     reason="cssbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"
+            ),
         ),
         # test beautify css embedded in html
         pytest.param(
@@ -428,8 +466,9 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["cssbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
-                                     reason="cssbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"
+            ),
         ),
         # test beautify css embedded in html with no end
         pytest.param(
@@ -442,14 +481,16 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["cssbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
-                                     reason="cssbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"
+            ),
         ),
         # test already beautified css (beautify does nothing)
         pytest.param(
             *BeautifyStrategyParams(
                 test_data=(
-                    "<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n</style>\n"),
+                    "<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n</style>\n"
+                ),
                 test_name="test.html",
                 expected_run_calls=1,
                 expected_results={
@@ -459,8 +500,9 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["check", "cssbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
-                                     reason="cssbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"
+            ),
         ),
         # test almost beautified css (any change breaks test, beautify only removes an
         # extra blank line so `lines` will have already tried it, and this will hit the
@@ -469,7 +511,8 @@ def replay_run(testcases, _time_limit, **_):
             *BeautifyStrategyParams(
                 test_data=(
                     "<style nochange=true>\n/*DDBEGIN*/\n\nrequisite {\n"
-                    "  required: 1\n}\n/*DDEND*/\n</style>\n"),
+                    "  required: 1\n}\n/*DDEND*/\n</style>\n"
+                ),
                 test_name="test.html",
                 expected_run_calls=8,
                 expected_results={
@@ -480,8 +523,9 @@ def replay_run(testcases, _time_limit, **_):
                 strategies=["check", "lines", "cssbeautify"],
                 have_beautifiers=True,
             ),
-            marks=pytest.mark.skipif(not HAVE_CSSBEAUTIFIER,
-                                     reason="cssbeautifier required"),
+            marks=pytest.mark.skipif(
+                not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"
+            ),
         ),
         # test that when beautifiers are not available, the strategies have no effect
         BeautifyStrategyParams(
@@ -493,11 +537,19 @@ def replay_run(testcases, _time_limit, **_):
             strategies=["check", "cssbeautify"],
             have_beautifiers=False,
         ),
-    ]
+    ],
 )
-def test_beautifier(mocker, tmp_path, test_data, test_name, expected_run_calls,
-                    expected_results, expected_num_reports, strategies,
-                    have_beautifiers):
+def test_beautifier(
+    mocker,
+    tmp_path,
+    test_data,
+    test_name,
+    expected_run_calls,
+    expected_results,
+    expected_num_reports,
+    strategies,
+    have_beautifiers,
+):
     """test for the "beautify" strategies"""
     if not have_beautifiers:
         mocker.patch.object(CSSBeautify, "import_available", False)
@@ -515,22 +567,25 @@ def replay_run(testcases, _time_limit, **_):
                 LOG.debug("interesting if test unchanged")
                 interesting = test_data == contents
             elif "requisite" in test_data:
-                LOG.debug("interesting if ('requisite' and 'required') or "
-                          "'requi'+'red' in %r", contents)
-                interesting = ("required" in contents and "requisite" in contents) \
-                    or "'requi'+'red'" in contents
+                LOG.debug(
+                    "interesting if ('requisite' and 'required') or "
+                    "'requi'+'red' in %r",
+                    contents,
+                )
+                interesting = (
+                    "required" in contents and "requisite" in contents
+                ) or "'requi'+'red'" in contents
             else:
                 LOG.debug("interesting if 'required' or 'requi'+'red' in %r", contents)
                 interesting = "required" in contents or "'requi'+'red'" in contents
             if interesting:
-                log_path = tmp_path / (
-                    "crash%d_logs" % (replayer.run.call_count,)
-                )
+                log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
                 log_path.mkdir()
                 _fake_save_logs_foo(log_path)
                 report = Report(str(log_path), "bin")
                 return [ReplayResult(report, [[test_name]], [], True)]
         return []
+
     replayer.run.side_effect = replay_run
 
     test = TestCase(test_name, None, "test-adapter")
@@ -541,8 +596,15 @@ def replay_run(testcases, _time_limit, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target, tests,
-                            strategies, log_path, use_analysis=False)
+        mgr = ReduceManager(
+            [],
+            mocker.Mock(spec=Sapphire, timeout=30),
+            target,
+            tests,
+            strategies,
+            log_path,
+            use_analysis=False,
+        )
         assert mgr.run() == 0
     finally:
         for test in tests:
@@ -552,14 +614,15 @@ def replay_run(testcases, _time_limit, **_):
     assert set(log_path.iterdir()) == {log_path / "reports"}
     tests = {test.read_text() for test in log_path.glob("reports/*-*/" + test_name)}
     assert tests == expected_results
-    assert sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports, \
-        list((log_path / "reports").iterdir())
+    assert (
+        sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports
+    ), list((log_path / "reports").iterdir())
 
 
 PurgeUnservedTestParams = namedtuple(
     "PurgeUnservedTestParams",
     "strategies, test_data, served, expected_results, expected_run_calls,"
-    "expected_num_reports, purging_breaks"
+    "expected_num_reports, purging_breaks",
 )
 
 
@@ -601,11 +664,15 @@ def replay_run(testcases, _time_limit, **_):
         # second test.
         PurgeUnservedTestParams(
             strategies=["chars"],
-            test_data=[{"test.html": "123", "opt.html": "456"},
-                       {"test.html": "789", "opt.html": "abc"}],
-            served=[[["test.html", "opt.html"], ["test.html", "opt.html"]],
-                    [["test.html", "opt.html"], ["test.html"]],
-                    [["test.html", "opt.html"], ["test.html"]]],
+            test_data=[
+                {"test.html": "123", "opt.html": "456"},
+                {"test.html": "789", "opt.html": "abc"},
+            ],
+            served=[
+                [["test.html", "opt.html"], ["test.html", "opt.html"]],
+                [["test.html", "opt.html"], ["test.html"]],
+                [["test.html", "opt.html"], ["test.html"]],
+            ],
             expected_results={"1", "4", "7"},
             expected_run_calls=6,
             expected_num_reports=3,
@@ -615,11 +682,15 @@ def replay_run(testcases, _time_limit, **_):
         # (first test remains)
         PurgeUnservedTestParams(
             strategies=["chars"],
-            test_data=[{"test.html": "123", "opt.html": "456"},
-                       {"test.html": "789", "opt.html": "abc"}],
-            served=[[["test.html", "opt.html"], ["test.html", "opt.html"]],
-                    [["test.html", "opt.html"], ["opt.html"]],
-                    [["test.html", "opt.html"]]],
+            test_data=[
+                {"test.html": "123", "opt.html": "456"},
+                {"test.html": "789", "opt.html": "abc"},
+            ],
+            served=[
+                [["test.html", "opt.html"], ["test.html", "opt.html"]],
+                [["test.html", "opt.html"], ["opt.html"]],
+                [["test.html", "opt.html"]],
+            ],
             expected_results={"1", "4"},
             expected_run_calls=5,
             expected_num_reports=2,
@@ -628,11 +699,12 @@ def replay_run(testcases, _time_limit, **_):
         # triple test, list strategy. first test gets reduced, third gets eliminated
         PurgeUnservedTestParams(
             strategies=["list"],
-            test_data=[{"test.html": "123"}, {"test.html": "456"},
-                       {"test.html": "789"}],
-            served=[[["test.html"]],
-                    [["test.html"]],
-                    [["test.html"]]],
+            test_data=[
+                {"test.html": "123"},
+                {"test.html": "456"},
+                {"test.html": "789"},
+            ],
+            served=[[["test.html"]], [["test.html"]], [["test.html"]]],
             expected_results={"456"},
             expected_run_calls=2,
             expected_num_reports=2,
@@ -641,19 +713,30 @@ def replay_run(testcases, _time_limit, **_):
         # triple test, list strategy. None for served still eliminates first two tests
         PurgeUnservedTestParams(
             strategies=["list"],
-            test_data=[{"test.html": "123"}, {"test.html": "456"},
-                       {"test.html": "789"}],
+            test_data=[
+                {"test.html": "123"},
+                {"test.html": "456"},
+                {"test.html": "789"},
+            ],
             served=[None, None, None],
             expected_results={"789"},
             expected_run_calls=2,
             expected_num_reports=2,
             purging_breaks=False,
         ),
-    ]
+    ],
 )
-def test_purge_unserved(mocker, tmp_path, strategies, test_data, served,
-                        expected_results, expected_run_calls, expected_num_reports,
-                        purging_breaks):
+def test_purge_unserved(
+    mocker,
+    tmp_path,
+    strategies,
+    test_data,
+    served,
+    expected_results,
+    expected_run_calls,
+    expected_num_reports,
+    purging_breaks,
+):
     """test purging unserved files"""
     mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
@@ -679,6 +762,7 @@ def replay_run(testcases, _time_limit, **_):
         _fake_save_logs_foo(log_path)
         report = Report(str(log_path), "bin")
         return [ReplayResult(report, served.pop(0), [], True)]
+
     replayer.run.side_effect = replay_run
 
     tests = []
@@ -693,8 +777,15 @@ def replay_run(testcases, _time_limit, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target, tests,
-                            strategies, log_path, use_analysis=False)
+        mgr = ReduceManager(
+            [],
+            mocker.Mock(spec=Sapphire, timeout=30),
+            target,
+            tests,
+            strategies,
+            log_path,
+            use_analysis=False,
+        )
         if purging_breaks:
             with raises(AssertionError):
                 mgr.run()
@@ -710,15 +801,17 @@ def replay_run(testcases, _time_limit, **_):
     assert set(log_path.iterdir()) == {log_path / "reports"}
     tests = {test.read_text() for test in log_path.glob("reports/*-*/*.html")}
     assert tests == expected_results
-    assert sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports, \
-        list((log_path / "reports").iterdir())
+    assert (
+        sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports
+    ), list((log_path / "reports").iterdir())
     # each input has 2 files, so if there are more than 2 reports, the result has 2
     # testcases
     assert (
         sum(1 for _ in log_path.glob("reports/*-*/prefs.js"))
         == (expected_num_reports + 1) // 2
     ), "prefs.js missing in %r" % [
-        str(p.relative_to(log_path)) for p in log_path.glob("reports/**/*")
+        str(p.relative_to(log_path))
+        for p in log_path.glob("reports/**/*")
         if p.is_file()
     ]
 
@@ -735,14 +828,13 @@ def replay_run(testcases, _time_limit, **_):
             LOG.debug("interesting if 'required' in %r", contents)
             interesting = "required" in contents
             if interesting:
-                log_path = tmp_path / (
-                    "crash%d_logs" % (replayer.run.call_count,)
-                )
+                log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
                 log_path.mkdir()
                 _fake_save_logs_foo(log_path)
                 report = Report(str(log_path), "bin")
                 return [ReplayResult(report, [["test.html", "other.html"]], [], True)]
         return []
+
     replayer.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
@@ -754,8 +846,15 @@ def replay_run(testcases, _time_limit, **_):
     target = mocker.Mock(spec=Target)
     target.relaunch = 1
     try:
-        mgr = ReduceManager([], mocker.Mock(spec=Sapphire, timeout=30), target, tests,
-                            ["lines"], log_path, use_analysis=False)
+        mgr = ReduceManager(
+            [],
+            mocker.Mock(spec=Sapphire, timeout=30),
+            target,
+            tests,
+            ["lines"],
+            log_path,
+            use_analysis=False,
+        )
         assert mgr.run() == 0
     finally:
         for test in tests:
@@ -769,7 +868,8 @@ def replay_run(testcases, _time_limit, **_):
     assert set(log_path.iterdir()) == {log_path / "reports"}
     tests = {test.read_text() for test in log_path.glob("reports/*-*/test.html")}
     assert tests == expected_results
-    assert sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports, \
-        list((log_path / "reports").iterdir())
+    assert (
+        sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports
+    ), list((log_path / "reports").iterdir())
     others = {test.read_text() for test in log_path.glob("reports/*-*/other.html")}
     assert others == {"blah\n"}
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index 2dcbc995..6757ae11 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -8,59 +8,83 @@
 
 
 class ReplayArgs(CommonArgs):
-
     def __init__(self):
         super().__init__()
         self.parser.add_argument(
             "input",
-            help="Accepted input includes: " \
-                "1) A directory containing testcase data. " \
-                "2) A directory with one or more subdirectories containing testcase data. " \
-                "3) A zip archive containing testcase data or subdirectories containing testcase data. " \
-                "4) A single file to be used as a testcase. " \
-                "When using a directory it must contain a 'test_info.json' file.")
+            help="Accepted input includes: "
+            "1) A directory containing testcase data. "
+            "2) A directory with one or more subdirectories containing testcase data. "
+            "3) A zip archive containing testcase data or subdirectories containing"
+            " testcase data. "
+            "4) A single file to be used as a testcase. "
+            "When using a directory it must contain a 'test_info.json' file.",
+        )
 
         replay_args = self.parser.add_argument_group("Replay Arguments")
         replay_args.add_argument(
-            "--any-crash", action="store_true",
-            help="Any crash is interesting, not only crashes which match the original signature.")
-        replay_args.add_argument(
-            "--idle-delay", type=int, default=30,
-            help="Number of seconds to wait before polling for idle (default: %(default)s)")
+            "--any-crash",
+            action="store_true",
+            help="Any crash is interesting, not only crashes which match the original"
+            " signature.",
+        )
         replay_args.add_argument(
-            "--idle-threshold", type=int, default=0,
-            help="CPU usage threshold to mark the process as idle (default: disabled)")
+            "--idle-delay",
+            type=int,
+            default=30,
+            help="Number of seconds to wait before polling for idle"
+            " (default: %(default)s)",
+        )
         replay_args.add_argument(
-            "-l", "--logs",
-            help="Location to save logs. If the path exists it must be empty, if it " \
-                "does not exist it will be created.")
+            "--idle-threshold",
+            type=int,
+            default=0,
+            help="CPU usage threshold to mark the process as idle (default: disabled)",
+        )
         replay_args.add_argument(
-            "--min-crashes", type=int, default=1,
-            help="Require the testcase to crash n times before accepting the result." \
-                " Helpful for intermittent testcases (default: %(default)sx)")
+            "-l",
+            "--logs",
+            help="Location to save logs. If the path exists it must be empty, if it "
+            "does not exist it will be created.",
+        )
         replay_args.add_argument(
-            "--no-harness", action="store_true",
-            help="Don't use the harness for redirection. Implies '--relaunch=1'.")
+            "--min-crashes",
+            type=int,
+            default=1,
+            help="Require the testcase to crash n times before accepting the result."
+            " Helpful for intermittent testcases (default: %(default)sx)",
+        )
         replay_args.add_argument(
-            "--repeat", type=int, default=1,
-            help="Run the testcase n times." \
-                " Helpful for intermittent testcases (default: %(default)sx)")
+            "--no-harness",
+            action="store_true",
+            help="Don't use the harness for redirection. Implies '--relaunch=1'.",
+        )
         replay_args.add_argument(
-            "--sig",
-            help="Signature (JSON) file to match.")
+            "--repeat",
+            type=int,
+            default=1,
+            help="Run the testcase n times."
+            " Helpful for intermittent testcases (default: %(default)sx)",
+        )
+        replay_args.add_argument("--sig", help="Signature (JSON) file to match.")
         replay_args.add_argument(
-            "--test-index", type=int, nargs="+",
-            help="Select a testcase to run when multiple testcases are loaded. " \
-                 "Testscases are ordered oldest to newest. Indexing is 0 based. " \
-                 "0 == Oldest, n-1 == Newest (default: run all testcases)")
+            "--test-index",
+            type=int,
+            nargs="+",
+            help="Select a testcase to run when multiple testcases are loaded. "
+            "Testscases are ordered oldest to newest. Indexing is 0 based. "
+            "0 == Oldest, n-1 == Newest (default: run all testcases)",
+        )
 
         self.launcher_grp.add_argument(
-            "--rr", action="store_true",
-            help="Use RR (Linux only)")
+            "--rr", action="store_true", help="Use RR (Linux only)"
+        )
 
         self.reporter_grp.add_argument(
-            "--include-test", action="store_true",
-            help="Include the testcase when reporting results.")
+            "--include-test",
+            action="store_true",
+            help="Include the testcase when reporting results.",
+        )
 
     def sanity_check(self, args):
         super().sanity_check(args)
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 0b237289..9a45b462 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -44,11 +44,28 @@ class ReplayManager:
     HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
     DEFAULT_TIME_LIMIT = 30
 
-    __slots__ = ("ignore", "server", "status", "target", "_any_crash",
-                 "_harness", "_signature", "_relaunch", "_unpacked")
-
-    def __init__(self, ignore, server, target, any_crash=False,
-                 relaunch=1, signature=None, use_harness=True):
+    __slots__ = (
+        "ignore",
+        "server",
+        "status",
+        "target",
+        "_any_crash",
+        "_harness",
+        "_signature",
+        "_relaunch",
+        "_unpacked",
+    )
+
+    def __init__(
+        self,
+        ignore,
+        server,
+        target,
+        any_crash=False,
+        relaunch=1,
+        signature=None,
+        use_harness=True,
+    ):
         self.ignore = ignore
         self.server = server
         self.status = None
@@ -113,12 +130,12 @@ def expect_hang(ignore, signature, tests):
         if is_hang:
             if signature is None:
                 raise ConfigError(
-                    "Hangs require a signature to replay",
-                    Session.EXIT_ERROR)
+                    "Hangs require a signature to replay", Session.EXIT_ERROR
+                )
             if "timeout" in ignore:
                 raise ConfigError(
-                    "Cannot ignore 'timeout' when detecting hangs",
-                    Session.EXIT_ERROR)
+                    "Cannot ignore 'timeout' when detecting hangs", Session.EXIT_ERROR
+                )
         return is_hang
 
     @classmethod
@@ -166,7 +183,9 @@ def report_to_filesystem(path, results, tests=None):
         """
         others = list(x.report for x in results if not x.expected)
         if others:
-            reporter = FilesystemReporter(pathjoin(path, "other_reports"), major_bucket=False)
+            reporter = FilesystemReporter(
+                pathjoin(path, "other_reports"), major_bucket=False
+            )
             for report in others:
                 reporter.submit(tests or [], report=report)
         expected = list(x for x in results if x.expected)
@@ -190,7 +209,7 @@ def run(
         exit_early=True,
         expect_hang=False,
         idle_delay=0,
-        idle_threshold=0
+        idle_threshold=0,
     ):
         """Run testcase replay.
 
@@ -229,7 +248,9 @@ def run(
 
         server_map = ServerMap()
         if self._harness is not None:
-            server_map.set_dynamic_response("grz_harness", lambda: self._harness, mime_type="text/html")
+            server_map.set_dynamic_response(
+                "grz_harness", lambda: self._harness, mime_type="text/html"
+            )
 
         # track unprocessed results
         reports = dict()
@@ -249,21 +270,23 @@ def run(
                 self.target,
                 idle_threshold=idle_threshold,
                 idle_delay=idle_delay,
-                relaunch=relaunch * test_count)
+                relaunch=relaunch * test_count,
+            )
             # perform iterations
             for _ in range(repeat):
                 self.status.iteration += 1
                 if self.target.closed:
                     if self._harness is None:
                         location = runner.location(
-                            "/grz_current_test",
-                            self.server.port)
+                            "/grz_current_test", self.server.port
+                        )
                     else:
                         location = runner.location(
                             "/grz_harness",
                             self.server.port,
                             close_after=relaunch * test_count,
-                            time_limit=time_limit)
+                            time_limit=time_limit,
+                        )
                     startup_error = False
                     # The environment from the initial testcase is used because
                     # a sequence of testcases is expected to be run without
@@ -276,28 +299,38 @@ def run(
                 served = list()
                 for test_idx in range(test_count):
                     if test_count > 1:
-                        LOG.info("Running test, part %d/%d (%d/%d)...",
-                                 test_idx + 1, test_count, self.status.iteration, repeat)
+                        LOG.info(
+                            "Running test, part %d/%d (%d/%d)...",
+                            test_idx + 1,
+                            test_count,
+                            self.status.iteration,
+                            repeat,
+                        )
                     else:
-                        LOG.info("Running test (%d/%d)...", self.status.iteration, repeat)
+                        LOG.info(
+                            "Running test (%d/%d)...", self.status.iteration, repeat
+                        )
                     # update redirects
                     if self._harness is not None:
                         next_idx = (test_idx + 1) % test_count
                         server_map.set_redirect(
                             "grz_next_test",
                             testcases[next_idx].landing_page,
-                            required=True)
+                            required=True,
+                        )
                     server_map.set_redirect(
                         "grz_current_test",
                         testcases[test_idx].landing_page,
-                        required=False)
+                        required=False,
+                    )
                     # run testcase
                     run_result = runner.run(
                         self.ignore,
                         server_map,
                         testcases[test_idx],
                         test_path=unpacked[test_idx],
-                        wait_for_callback=self._harness is None)
+                        wait_for_callback=self._harness is None,
+                    )
                     durations.append(run_result.duration)
                     served.append(run_result.served)
                     if run_result.status is not None or not run_result.attempted:
@@ -317,9 +350,7 @@ def run(
                     log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
                     self.target.save_logs(log_path)
                     report = Report(
-                        log_path,
-                        self.target.binary,
-                        is_hang=run_result.timeout
+                        log_path, self.target.binary, is_hang=run_result.timeout
                     )
                     # check signatures
                     if run_result.timeout:
@@ -339,35 +370,47 @@ def run(
                         self._signature = report.crash_signature
                     # bucket result
                     if short_sig == "No crash detected":
-                        # TODO: verify report.major == "NO_STACK" otherwise FM failed to parse the logs
+                        # TODO: verify report.major == "NO_STACK"
+                        # otherwise FM failed to parse the logs
                         # TODO: change this to support hangs/timeouts, etc
                         LOG.info("Result: No crash detected")
-                    elif (
-                        not startup_error
-                        and (self._any_crash
-                            or self.check_match(self._signature, report, expect_hang))
+                    elif not startup_error and (
+                        self._any_crash
+                        or self.check_match(self._signature, report, expect_hang)
                     ):
                         self.status.count_result(short_sig)
-                        LOG.info("Result: %s (%s:%s)",
-                                 short_sig, report.major[:8], report.minor[:8])
+                        LOG.info(
+                            "Result: %s (%s:%s)",
+                            short_sig,
+                            report.major[:8],
+                            report.minor[:8],
+                        )
                         if sig_hash:
                             LOG.debug("using provided signature (hash) to bucket")
                             bucket_hash = sig_hash
                         else:
                             bucket_hash = report.crash_hash
                         if bucket_hash not in reports:
-                            reports[bucket_hash] = ReplayResult(report, served, durations, True)
+                            reports[bucket_hash] = ReplayResult(
+                                report, served, durations, True
+                            )
                             LOG.debug("now tracking %s", bucket_hash)
                             report = None  # don't remove report
                         else:
                             reports[bucket_hash].count += 1
                             LOG.debug("already tracking %s", bucket_hash)
                     else:
-                        LOG.info("Result: Different signature: %s (%s:%s)",
-                                 short_sig, report.major[:8], report.minor[:8])
+                        LOG.info(
+                            "Result: Different signature: %s (%s:%s)",
+                            short_sig,
+                            report.major[:8],
+                            report.minor[:8],
+                        )
                         self.status.ignored += 1
                         if report.crash_hash not in reports:
-                            reports[report.crash_hash] = ReplayResult(report, served, durations, False)
+                            reports[report.crash_hash] = ReplayResult(
+                                report, served, durations, False
+                            )
                             LOG.debug("now tracking %s", report.crash_hash)
                             report = None  # don't remove report
                         else:
@@ -383,12 +426,19 @@ def run(
 
                 if exit_early:
                     # failed to meet minimum number of results
-                    if repeat - self.status.iteration + self.status.results < min_results:
+                    if (
+                        repeat - self.status.iteration + self.status.results
+                        < min_results
+                    ):
                         if self.status.iteration < repeat:
                             LOG.debug("skipping remaining attempts")
                         # failed to reproduce issue
-                        LOG.debug("results (%d) < minimum (%d), after %d attempts",
-                                  self.status.results, min_results, self.status.iteration)
+                        LOG.debug(
+                            "results (%d) < minimum (%d), after %d attempts",
+                            self.status.results,
+                            min_results,
+                            self.status.iteration,
+                        )
                         # NOTE: this can be tricky if the harness is used because it can
                         # skip the shutdown performed in the harness and runner, if this
                         # is an issue for now use relaunch=1
@@ -396,15 +446,18 @@ def run(
                     # check if complete (minimum number of results found)
                     if self.status.results >= min_results:
                         assert self.status.results == min_results
-                        assert sum(x.count for x in reports.values() if x.expected) >= min_results
-                        LOG.debug("results == expected (%d), after %d attempts",
-                                  min_results, self.status.iteration)
+                        assert (
+                            sum(x.count for x in reports.values() if x.expected)
+                            >= min_results
+                        )
+                        LOG.debug(
+                            "results == expected (%d), after %d attempts",
+                            min_results,
+                            self.status.iteration,
+                        )
                         break
 
-                # warn about large browser logs
-                #self.status.log_size = self.target.log_size()
-                #if self.status.log_size > self.TARGET_LOG_SIZE_WARN:
-                #    LOG.warning("Large browser logs: %dMBs", (self.status.log_size / 0x100000))
+                # TODO: should we warn about large browser logs?
 
             # process results
             results = list()
@@ -413,7 +466,11 @@ def run(
                 if sum(x.count for x in reports.values()) >= min_results:
                     results = list(reports.values())
                 else:
-                    LOG.debug("%d (any_crash) less than minimum %d", self.status.results, min_results)
+                    LOG.debug(
+                        "%d (any_crash) less than minimum %d",
+                        self.status.results,
+                        min_results,
+                    )
                     for report in reports.values():
                         report.report.cleanup()
             else:
@@ -421,14 +478,23 @@ def run(
                 # filter out unreliable expected results
                 for crash_hash, report in reports.items():
                     if report.expected and report.count < min_results:
-                        LOG.debug("%r less than minimum (%d/%d)", crash_hash, report.count, min_results)
+                        LOG.debug(
+                            "%r less than minimum (%d/%d)",
+                            crash_hash,
+                            report.count,
+                            min_results,
+                        )
                         report.report.cleanup()
                         continue
                     results.append(report)
             # this should only be displayed when both conditions are met:
             # 1) runner does not close target (no delay was given before shutdown)
             # 2) result has not been successfully reproduced
-            if self._relaunch > 1 and not self.target.closed and not any(x.expected for x in results):
+            if (
+                self._relaunch > 1
+                and not self.target.closed
+                and not any(x.expected for x in results)
+            ):
                 LOG.info("Perhaps try with --relaunch=1")
             # active reports have been moved to results
             # clear reports to avoid cleanup of active reports
@@ -467,8 +533,10 @@ def time_limits(cls, time_limit, timeout, tests):
             timeout = time_limit + TIMEOUT_DELAY
         if timeout < time_limit:
             raise ConfigError(
-                "Timeout (%d) cannot be less than time limit (%d)" % (timeout, time_limit),
-                Session.EXIT_ARGS)
+                "Timeout (%d) cannot be less than time limit (%d)"
+                % (timeout, time_limit),
+                Session.EXIT_ARGS,
+            )
         return time_limit, timeout
 
     @classmethod
@@ -496,9 +564,8 @@ def main(cls, args):
 
         try:
             testcases = cls.load_testcases(
-                args.input,
-                args.prefs is None,
-                subset=args.test_index)
+                args.input, args.prefs is None, subset=args.test_index
+            )
         except TestCaseLoadFailure as exc:
             LOG.error("Error: %s", str(exc))
             return Session.EXIT_ERROR
@@ -510,20 +577,24 @@ def main(cls, args):
             if args.no_harness and len(testcases) > 1:
                 LOG.error(
                     "'--no-harness' cannot be used with multiple testcases. "
-                    "Perhaps '--test-index' can help.")
+                    "Perhaps '--test-index' can help."
+                )
                 return Session.EXIT_ARGS
             # check if hangs are expected
             expect_hang = cls.expect_hang(args.ignore, signature, testcases)
             # check test time limit and timeout
             time_limit, timeout = cls.time_limits(
-                args.time_limit,
-                args.timeout,
-                testcases)
+                args.time_limit, args.timeout, testcases
+            )
             LOG.info("Using time limit: %ds, timeout: %ds", time_limit, timeout)
             repeat = max(args.min_crashes, args.repeat)
             relaunch = min(args.relaunch, repeat)
-            LOG.info("Repeat: %d, Minimum crashes: %d, Relaunch %d",
-                     repeat, args.min_crashes, relaunch)
+            LOG.info(
+                "Repeat: %d, Minimum crashes: %d, Relaunch %d",
+                repeat,
+                args.min_crashes,
+                relaunch,
+            )
             LOG.debug("initializing the Target")
             target = load_target(args.platform)(
                 args.binary,
@@ -533,7 +604,8 @@ def main(cls, args):
                 args.memory,
                 rr=args.rr,
                 valgrind=args.valgrind,
-                xvfb=args.xvfb)
+                xvfb=args.xvfb,
+            )
             # prioritize specified prefs.js file over included file
             if args.prefs is not None:
                 for testcase in testcases:
@@ -560,7 +632,7 @@ def main(cls, args):
                     any_crash=args.any_crash,
                     relaunch=relaunch,
                     signature=signature,
-                    use_harness=not args.no_harness
+                    use_harness=not args.no_harness,
                 ) as replay:
                     results = replay.run(
                         testcases,
@@ -569,7 +641,8 @@ def main(cls, args):
                         idle_delay=args.idle_delay,
                         idle_threshold=args.idle_threshold,
                         min_results=args.min_crashes,
-                        repeat=repeat)
+                        repeat=repeat,
+                    )
             # handle results
             success = any(x.expected for x in results)
             if success:
@@ -578,9 +651,8 @@ def main(cls, args):
                 LOG.info("Failed to reproduce results")
             if args.logs and results:
                 cls.report_to_filesystem(
-                    args.logs,
-                    results,
-                    testcases if args.include_test else None)
+                    args.logs, results, testcases if args.include_test else None
+                )
             # TODO: add fuzzmanager reporting
             return Session.EXIT_SUCCESS if success else Session.EXIT_FAILURE
 
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 1e9c36c6..a5770f8e 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -39,7 +39,9 @@ def test_args_01(capsys, tmp_path):
     (inp / "prefs.js").touch()
     ReplayArgs().parse_args([str(exe), str(inp)])
     # test case file
-    ReplayArgs().parse_args([str(exe), str(inp / "somefile"), "--prefs", str(inp / "prefs.js")])
+    ReplayArgs().parse_args(
+        [str(exe), str(inp / "somefile"), "--prefs", str(inp / "prefs.js")]
+    )
     # test negative min-crashes value
     with raises(SystemExit):
         ReplayArgs().parse_args([str(exe), str(inp), "--min-crashes", "-1"])
@@ -55,14 +57,19 @@ def test_args_01(capsys, tmp_path):
     # test any crash and signature
     with raises(SystemExit):
         ReplayArgs().parse_args([str(exe), str(inp), "--any-crash", "--sig", "x"])
-    assert "error: signature is ignored when running with '--any-crash'" in capsys.readouterr()[-1]
+    assert (
+        "error: signature is ignored when running with '--any-crash'"
+        in capsys.readouterr()[-1]
+    )
     # test multiple debuggers
     with raises(SystemExit):
         ReplayArgs().parse_args([str(exe), str(inp), "--rr", "--valgrind"])
     assert "'--rr' and '--valgrind' cannot be used together" in capsys.readouterr()[-1]
     # test idle args
     with raises(SystemExit):
-        ReplayArgs().parse_args([str(exe), str(inp), "--idle-threshold", "1", "--idle-delay", "0"])
+        ReplayArgs().parse_args(
+            [str(exe), str(inp), "--idle-threshold", "1", "--idle-delay", "0"]
+        )
     assert "'--idle-delay' value must be positive" in capsys.readouterr()[-1]
     # force relaunch == 1 with --no-harness
     args = ReplayArgs().parse_args([str(exe), str(inp), "--no-harness"])
@@ -76,22 +83,33 @@ def test_main_01(mocker, tmp_path):
     # and the forth attempt should be skipped.
     # mock Sapphire.serve_path only
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
-    serve_path.return_value = (SERVED_ALL, ["test.html"])  # passed to mocked Target.detect_failure
+    serve_path = mocker.patch(
+        "grizzly.replay.replay.Sapphire.serve_path", autospec=True
+    )
+    serve_path.return_value = (
+        SERVED_ALL,
+        ["test.html"],
+    )  # passed to mocked Target.detect_failure
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_target")
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
-    target.detect_failure.side_effect = (Target.RESULT_FAILURE, Target.RESULT_NONE, Target.RESULT_FAILURE)
+    target.detect_failure.side_effect = (
+        Target.RESULT_FAILURE,
+        Target.RESULT_NONE,
+        Target.RESULT_FAILURE,
+    )
     target.save_logs = _fake_save_logs
     load_target.return_value.return_value = target
     # setup args
-    log_path = (tmp_path / "logs")
+    log_path = tmp_path / "logs"
     (tmp_path / "test.html").touch()
     (tmp_path / "prefs.js").touch()
-    (tmp_path / "sig.json").write_bytes(b"{\"symptoms\": [{\"type\": \"crashAddress\", \"address\": \"0\"}]}")
+    (tmp_path / "sig.json").write_bytes(
+        b'{"symptoms": [{"type": "crashAddress", "address": "0"}]}'
+    )
     args = mocker.Mock(
         fuzzmanager=False,
         idle_delay=0,
@@ -109,7 +127,8 @@ def test_main_01(mocker, tmp_path):
         test_index=None,
         time_limit=10,
         timeout=None,
-        valgrind=False)
+        valgrind=False,
+    )
     assert ReplayManager.main(args) == Session.EXIT_SUCCESS
     assert target.reverse.call_count == 1
     assert target.launch.call_count == 3
@@ -123,12 +142,18 @@ def test_main_01(mocker, tmp_path):
     assert any(log_path.glob("reports/*/log_stderr.txt"))
     assert any(log_path.glob("reports/*/log_stdout.txt"))
 
+
 def test_main_02(mocker, tmp_path):
     """test ReplayManager.main() - no repro"""
     # mock Sapphire.serve_path only
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
-    serve_path.return_value = (SERVED_ALL, ["test.html"])  # passed to mocked Target.detect_failure
+    serve_path = mocker.patch(
+        "grizzly.replay.replay.Sapphire.serve_path", autospec=True
+    )
+    serve_path.return_value = (
+        SERVED_ALL,
+        ["test.html"],
+    )  # passed to mocked Target.detect_failure
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_target")
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
@@ -154,12 +179,14 @@ def test_main_02(mocker, tmp_path):
         test_index=None,
         time_limit=10,
         timeout=None,
-        valgrind=False)
+        valgrind=False,
+    )
     assert ReplayManager.main(args) == Session.EXIT_FAILURE
     assert target.detect_failure.call_count == 1
     assert target.close.call_count == 2
     assert target.cleanup.call_count == 1
 
+
 def test_main_03(mocker):
     """test ReplayManager.main() error cases"""
     fake_sig = mocker.patch("grizzly.replay.replay.CrashSignature", autospec=True)
@@ -179,7 +206,8 @@ def test_main_03(mocker):
         sig=None,
         test_index=None,
         time_limit=10,
-        timeout=None)
+        timeout=None,
+    )
     # user abort
     fake_load_target.side_effect = KeyboardInterrupt
     # coverage
@@ -220,6 +248,7 @@ def test_main_03(mocker):
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
 
+
 def test_main_04(mocker, tmp_path):
     """test ReplayManager.main() target exceptions"""
     mocker.patch("grizzly.replay.replay.FuzzManagerReporter", autospec=True)
@@ -228,9 +257,11 @@ def test_main_04(mocker, tmp_path):
     target = mocker.Mock(spec=Target, launch_timeout=30)
     load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
     load_target.return_value.return_value = target
-    fake_tmp = (tmp_path / "grz_tmp")
+    fake_tmp = tmp_path / "grz_tmp"
     fake_tmp.mkdir()
-    mocker.patch("grizzly.replay.replay.grz_tmp", autospec=True, return_value=str(fake_tmp))
+    mocker.patch(
+        "grizzly.replay.replay.grz_tmp", autospec=True, return_value=str(fake_tmp)
+    )
     # setup args
     args = mocker.Mock(
         ignore=list(),
@@ -243,23 +274,35 @@ def test_main_04(mocker, tmp_path):
         sig=None,
         test_index=None,
         time_limit=10,
-        timeout=None)
+        timeout=None,
+    )
     # target launch error
-    fake_logs = (tmp_path / "fake_report")
+    fake_logs = tmp_path / "fake_report"
     fake_logs.mkdir()
     report = mocker.Mock(spec=Report, prefix="fake_report", path=str(fake_logs))
-    mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchError("", report))
+    mocker.patch(
+        "grizzly.replay.replay.ReplayManager.run",
+        side_effect=TargetLaunchError("", report),
+    )
     assert ReplayManager.main(args) == Session.EXIT_LAUNCH_FAILURE
     assert not fake_logs.is_dir()
     assert "fake_report_logs" in (x.name for x in fake_tmp.iterdir())
     # target launch timeout
-    mocker.patch("grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchTimeout)
+    mocker.patch(
+        "grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchTimeout
+    )
     assert ReplayManager.main(args) == Session.EXIT_LAUNCH_FAILURE
 
+
 def test_main_05(mocker, tmp_path):
     """test ReplayManager.main() loading/generating prefs.js"""
-    serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
-    serve_path.return_value = (None, ["test.html"])  # passed to mocked Target.detect_failure
+    serve_path = mocker.patch(
+        "grizzly.replay.replay.Sapphire.serve_path", autospec=True
+    )
+    serve_path.return_value = (
+        None,
+        ["test.html"],
+    )  # passed to mocked Target.detect_failure
     # setup Target
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
@@ -281,13 +324,14 @@ def test_main_05(mocker, tmp_path):
         sig=None,
         test_index=None,
         time_limit=1,
-        timeout=None)
-    log_path = (tmp_path / "logs")
+        timeout=None,
+    )
+    log_path = tmp_path / "logs"
     args.logs = str(log_path)
-    input_path = (tmp_path / "input")
+    input_path = tmp_path / "input"
     input_path.mkdir()
     # build a test case
-    entry_point = (input_path / "test.html")
+    entry_point = input_path / "test.html"
     entry_point.touch()
     with TestCase("test.html", None, "test-adapter") as src:
         src.add_from_file(str(entry_point))
@@ -301,7 +345,7 @@ def test_main_05(mocker, tmp_path):
     assert target.detect_failure.call_count == 1
     assert serve_path.call_count == 1
     assert log_path.is_dir()
-    assert not any(log_path.glob('**/prefs.js'))
+    assert not any(log_path.glob("**/prefs.js"))
 
     target.reset_mock()
     serve_path.reset_mock()
@@ -314,7 +358,7 @@ def test_main_05(mocker, tmp_path):
     assert target.detect_failure.call_count == 1
     assert serve_path.call_count == 1
     assert log_path.is_dir()
-    prefs = next(log_path.glob('**/prefs.js'))
+    prefs = next(log_path.glob("**/prefs.js"))
     assert prefs.read_bytes() == b"included"
 
     target.reset_mock()
@@ -329,9 +373,10 @@ def test_main_05(mocker, tmp_path):
     assert target.detect_failure.call_count == 1
     assert serve_path.call_count == 1
     assert log_path.is_dir()
-    prefs = next(log_path.glob('**/prefs.js'))
+    prefs = next(log_path.glob("**/prefs.js"))
     assert prefs.read_bytes() == b"specified"
 
+
 @mark.parametrize(
     "arg_timelimit, arg_timeout, test_timelimit, result",
     [
@@ -347,14 +392,19 @@ def test_main_05(mocker, tmp_path):
         (10, 11, None, Session.EXIT_FAILURE),
         # set test time limit greater than timeout
         (11, 10, None, Session.EXIT_ARGS),
-    ]
+    ],
 )
 def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, result):
     """test ReplayManager.main() - test time limit and timeout"""
     # mock Sapphire.serve_path only
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    serve_path = mocker.patch("grizzly.replay.replay.Sapphire.serve_path", autospec=True)
-    serve_path.return_value = (SERVED_ALL, ["test.html"])  # passed to mocked Target.detect_failure
+    serve_path = mocker.patch(
+        "grizzly.replay.replay.Sapphire.serve_path", autospec=True
+    )
+    serve_path.return_value = (
+        SERVED_ALL,
+        ["test.html"],
+    )  # passed to mocked Target.detect_failure
     # setup Target
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
@@ -388,5 +438,6 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
         test_index=None,
         time_limit=arg_timelimit,
         timeout=arg_timeout,
-        valgrind=False)
+        valgrind=False,
+    )
     assert ReplayManager.main(args) == result
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 1b1ded74..3a1ec9ce 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -18,7 +18,7 @@
 from .replay import ReplayManager, ReplayResult
 
 
-def _fake_save_logs(result_logs, meta=False):  # pylint: disable=unused-argument
+def _fake_save_logs(result_logs, _meta=False):
     """write fake log data to disk"""
     with open(pathjoin(result_logs, "log_stderr.txt"), "w") as log_fp:
         log_fp.write("STDERR log\n")
@@ -30,13 +30,17 @@ def _fake_save_logs(result_logs, meta=False):  # pylint: disable=unused-argument
         log_fp.write("    #0 0xbad000 in foo /file1.c:123:234\n")
         log_fp.write("    #1 0x1337dd in bar /file2.c:1806:19\n")
 
+
 def test_replay_01(mocker):
     """test ReplayManager.cleanup()"""
-    replay = ReplayManager([], mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target), [mocker.Mock()])
+    replay = ReplayManager(
+        [], mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target), [mocker.Mock()]
+    )
     replay.status = mocker.Mock(spec=Status)
     replay.cleanup()
     assert replay.status.cleanup.call_count == 1
 
+
 def test_replay_02(mocker, tmp_path):
     """test ReplayManager.run() - no repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
@@ -57,6 +61,7 @@ def test_replay_02(mocker, tmp_path):
             assert target.close.call_count == 2
         assert not any(tmp_path.iterdir())
 
+
 def test_replay_03(mocker):
     """test ReplayManager.run() - no repro - with repeats"""
     server = mocker.Mock(spec=Sapphire, port=0x1337)
@@ -66,7 +71,9 @@ def test_replay_03(mocker):
     target.detect_failure.return_value = Target.RESULT_NONE
     target.monitor.is_healthy.return_value = False
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
-        with ReplayManager([], server, target, use_harness=True, relaunch=100) as replay:
+        with ReplayManager(
+            [], server, target, use_harness=True, relaunch=100
+        ) as replay:
             assert not replay.run([testcase], 10, repeat=10, min_results=1)
             assert replay.signature is None
             assert replay.status.ignored == 0
@@ -76,6 +83,7 @@ def test_replay_03(mocker):
             assert target.monitor.is_healthy.call_count == 1
             assert target.close.call_count == 2
 
+
 def test_replay_04(mocker):
     """test ReplayManager.run() - exit - skip shutdown in runner"""
     # this will make runner appear to have just relaunched the target
@@ -83,14 +91,17 @@ def test_replay_04(mocker):
     mocker.patch(
         "grizzly.common.runner.Runner._tests_run",
         new_callable=mocker.PropertyMock,
-        return_value=0)
+        return_value=0,
+    )
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     target = mocker.Mock(spec=Target, closed=False, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
-        with ReplayManager([], server, target, use_harness=True, relaunch=100) as replay:
+        with ReplayManager(
+            [], server, target, use_harness=True, relaunch=100
+        ) as replay:
             assert not replay.run([testcase], 10, repeat=10, min_results=1)
             assert replay.status.ignored == 0
             assert replay.status.iteration == 10
@@ -99,6 +110,7 @@ def test_replay_04(mocker):
             assert target.monitor.is_healthy.call_count == 0
             assert target.close.call_count == 1
 
+
 def test_replay_05(mocker, tmp_path):
     """test ReplayManager.run() - successful repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
@@ -131,6 +143,7 @@ def test_replay_05(mocker, tmp_path):
         results[0].report.cleanup()
         assert not any(tmp_path.iterdir())
 
+
 def test_replay_06(mocker, tmp_path):
     """test ReplayManager.run() - error - landing page not requested"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
@@ -138,7 +151,9 @@ def test_replay_06(mocker, tmp_path):
     target = mocker.Mock(spec=Target, binary="bin", closed=True, launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+    ]
     # test target unresponsive
     target.detect_failure.return_value = Target.RESULT_NONE
     server.serve_path.return_value = (SERVED_NONE, [])
@@ -165,8 +180,10 @@ def test_replay_06(mocker, tmp_path):
     assert results[0].count == 1
     assert not results[0].expected
 
+
 def test_replay_07(mocker, tmp_path):
-    """test ReplayManager.run() - delayed failure - following test landing page not requested"""
+    """test ReplayManager.run()
+    delayed failure - following test landing page not requested"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
@@ -176,8 +193,13 @@ def test_replay_07(mocker, tmp_path):
     target.detect_failure.side_effect = (Target.RESULT_NONE, Target.RESULT_FAILURE)
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    server.serve_path.side_effect = ((SERVED_ALL, ["index.html"]), (SERVED_REQUEST, ["x"]))
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+    ]
+    server.serve_path.side_effect = (
+        (SERVED_ALL, ["index.html"]),
+        (SERVED_REQUEST, ["x"]),
+    )
     with ReplayManager([], server, target, use_harness=True, relaunch=10) as replay:
         assert replay.run(testcases, 10, repeat=2)
         assert replay.status.ignored == 0
@@ -186,6 +208,7 @@ def test_replay_07(mocker, tmp_path):
         # target.close() called once in runner and once by ReplayManager.run()
         assert target.close.call_count == 2
 
+
 def test_replay_08(mocker, tmp_path):
     """test ReplayManager.run() - ignored"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
@@ -195,7 +218,9 @@ def test_replay_08(mocker, tmp_path):
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = Target.RESULT_IGNORED
     target.monitor.is_healthy.return_value = False
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+    ]
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases, 10)
         assert target.monitor.is_healthy.call_count == 1
@@ -205,6 +230,7 @@ def test_replay_08(mocker, tmp_path):
         assert replay.status.results == 0
     assert not any(tmp_path.iterdir())
 
+
 def test_replay_09(mocker, tmp_path):
     """test ReplayManager.run() - early exit"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
@@ -216,9 +242,15 @@ def test_replay_09(mocker, tmp_path):
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
     target.save_logs = _fake_save_logs
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+    ]
     # early failure
-    target.detect_failure.side_effect = (Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_NONE)
+    target.detect_failure.side_effect = (
+        Target.RESULT_FAILURE,
+        Target.RESULT_IGNORED,
+        Target.RESULT_NONE,
+    )
     target.monitor.is_healthy.side_effect = (False, False, True, False)
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases, 10, repeat=4, min_results=3)
@@ -228,7 +260,11 @@ def test_replay_09(mocker, tmp_path):
         assert replay.status.ignored == 1
     # early success
     target.reset_mock()
-    target.detect_failure.side_effect = (Target.RESULT_FAILURE, Target.RESULT_IGNORED, Target.RESULT_FAILURE)
+    target.detect_failure.side_effect = (
+        Target.RESULT_FAILURE,
+        Target.RESULT_IGNORED,
+        Target.RESULT_FAILURE,
+    )
     target.monitor.is_healthy.side_effect = (False, False, False)
     with ReplayManager([], server, target, use_harness=False) as replay:
         results = replay.run(testcases, 10, repeat=4, min_results=2)
@@ -263,17 +299,26 @@ def test_replay_09(mocker, tmp_path):
     assert len(results) == 1
     assert sum(x.count for x in results) == 4
 
+
 def test_replay_10(mocker, tmp_path):
     """test ReplayManager.run() - test signatures - fail to meet minimum"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
+    mocker.patch(
+        "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
+    )
     report_0 = mocker.Mock(spec=Report)
     report_0.crash_info.createShortSignature.return_value = "No crash detected"
-    report_1 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
+    report_1 = mocker.Mock(
+        spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
+    )
     report_1.crash_info.createShortSignature.return_value = "[@ test1]"
-    report_2 = mocker.Mock(spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876")
+    report_2 = mocker.Mock(
+        spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
+    )
     report_2.crash_info.createShortSignature.return_value = "[@ test2]"
-    report_3 = mocker.Mock(spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876")
+    report_3 = mocker.Mock(
+        spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
+    )
     report_3.crash_info.createShortSignature.return_value = "[@ test2]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1, report_2, report_3)
@@ -285,8 +330,12 @@ def test_replay_10(mocker, tmp_path):
     target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, signature=signature, use_harness=False) as replay:
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+    ]
+    with ReplayManager(
+        [], server, target, signature=signature, use_harness=False
+    ) as replay:
         results = replay.run(testcases, 10, repeat=4, min_results=2)
         assert target.close.call_count == 5
         assert replay.signature == signature
@@ -303,12 +352,19 @@ def test_replay_10(mocker, tmp_path):
     assert report_3.cleanup.call_count == 1
     assert signature.matches.call_count == 3
 
+
 def test_replay_11(mocker, tmp_path):
     """test ReplayManager.run() - test signatures - multiple matches"""
-    mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
-    report_0 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
+    mocker.patch(
+        "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
+    )
+    report_0 = mocker.Mock(
+        spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
+    )
     report_0.crash_info.createShortSignature.return_value = "[@ test1]"
-    report_1 = mocker.Mock(spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876")
+    report_1 = mocker.Mock(
+        spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
+    )
     report_1.crash_info.createShortSignature.return_value = "[@ test2]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1)
@@ -321,8 +377,12 @@ def test_replay_11(mocker, tmp_path):
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[])]
-    with ReplayManager([], server, target, signature=signature, use_harness=False) as replay:
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[])
+    ]
+    with ReplayManager(
+        [], server, target, signature=signature, use_harness=False
+    ) as replay:
         results = replay.run(testcases, 10, repeat=2, min_results=2)
         assert target.close.call_count == 3
         assert replay.signature == signature
@@ -337,14 +397,21 @@ def test_replay_11(mocker, tmp_path):
     assert report_1.cleanup.call_count == 1
     assert signature.matches.call_count == 2
 
+
 def test_replay_12(mocker, tmp_path):
     """test ReplayManager.run() - any crash - success"""
-    mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
+    mocker.patch(
+        "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
+    )
     report_0 = mocker.Mock(spec=Report)
     report_0.crash_info.createShortSignature.return_value = "No crash detected"
-    report_1 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
+    report_1 = mocker.Mock(
+        spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
+    )
     report_1.crash_info.createShortSignature.return_value = "[@ test1]"
-    report_2 = mocker.Mock(spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876")
+    report_2 = mocker.Mock(
+        spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
+    )
     report_2.crash_info.createShortSignature.return_value = "[@ test2]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1, report_2)
@@ -354,7 +421,9 @@ def test_replay_12(mocker, tmp_path):
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+    ]
     with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
         results = replay.run(testcases, 10, repeat=3, min_results=2)
         assert target.close.call_count == 4
@@ -370,14 +439,21 @@ def test_replay_12(mocker, tmp_path):
     assert report_1.cleanup.call_count == 0
     assert report_2.cleanup.call_count == 0
 
+
 def test_replay_13(mocker, tmp_path):
     """test ReplayManager.run() - any crash - fail to meet minimum"""
-    mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
+    mocker.patch(
+        "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
+    )
     report_0 = mocker.Mock(spec=Report)
     report_0.crash_info.createShortSignature.return_value = "No crash detected"
-    report_1 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
+    report_1 = mocker.Mock(
+        spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
+    )
     report_1.crash_info.createShortSignature.return_value = "[@ test1]"
-    report_2 = mocker.Mock(spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876")
+    report_2 = mocker.Mock(
+        spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
+    )
     report_2.crash_info.createShortSignature.return_value = "[@ test2]"
     report_3 = mocker.Mock(spec=Report)
     report_3.crash_info.createShortSignature.return_value = "No crash detected"
@@ -389,7 +465,9 @@ def test_replay_13(mocker, tmp_path):
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+    ]
     with ReplayManager([], server, target, any_crash=True) as replay:
         assert not replay.run(testcases, 10, repeat=4, min_results=3)
         assert target.close.call_count == 5
@@ -403,9 +481,12 @@ def test_replay_13(mocker, tmp_path):
     assert report_2.cleanup.call_count == 1
     assert report_3.cleanup.call_count == 1
 
+
 def test_replay_14(mocker, tmp_path):
     """test ReplayManager.run() - no signature - use first crash"""
-    mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
+    mocker.patch(
+        "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
+    )
     report_1 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123", minor="9999")
     report_1.crash_info.createShortSignature.return_value = "[@ test1]"
     auto_sig = mocker.Mock()
@@ -423,7 +504,9 @@ def test_replay_14(mocker, tmp_path):
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+    ]
     with ReplayManager([], server, target, use_harness=False) as replay:
         results = replay.run(testcases, 10, repeat=3, min_results=2)
         assert target.close.call_count == 4
@@ -439,10 +522,15 @@ def test_replay_14(mocker, tmp_path):
     assert report_2.cleanup.call_count == 0
     assert report_3.cleanup.call_count == 1
 
+
 def test_replay_15(mocker, tmp_path):
     """test ReplayManager.run() - unexpected exception"""
-    mocker.patch("grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path))
-    report_0 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999")
+    mocker.patch(
+        "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
+    )
+    report_0 = mocker.Mock(
+        spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
+    )
     report_0.crash_info.createShortSignature.return_value = "[@ test1]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0,)
@@ -451,8 +539,12 @@ def test_replay_15(mocker, tmp_path):
     target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
-    testcases = [mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
-    with ReplayManager([], server, target, any_crash=True, use_harness=True, relaunch=2) as replay:
+    testcases = [
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+    ]
+    with ReplayManager(
+        [], server, target, any_crash=True, use_harness=True, relaunch=2
+    ) as replay:
         with raises(KeyboardInterrupt):
             replay.run(testcases, 10, repeat=3, min_results=2)
         assert replay.signature is None
@@ -464,6 +556,7 @@ def test_replay_15(mocker, tmp_path):
     assert fake_report.call_count == 1
     assert report_0.cleanup.call_count == 1
 
+
 def test_replay_16(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
@@ -475,7 +568,8 @@ def test_replay_16(mocker):
     testcases = [
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
+    ]
     with ReplayManager([], server, target, use_harness=True) as replay:
         assert not replay.run(testcases, 10)
         assert replay.status.ignored == 0
@@ -484,6 +578,7 @@ def test_replay_16(mocker):
     assert target.close.call_count == 2
     assert all(x.dump.call_count == 1 for x in testcases)
 
+
 def test_replay_17(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
     server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
@@ -497,7 +592,8 @@ def test_replay_17(mocker):
     testcases = [
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])]
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
+    ]
     with ReplayManager([], server, target, use_harness=True, relaunch=2) as replay:
         assert not replay.run(testcases, 10, repeat=10)
         assert server.serve_path.call_count == 30
@@ -509,6 +605,7 @@ def test_replay_17(mocker):
     assert target.monitor.is_healthy.call_count == 5
     assert all(x.dump.call_count == 1 for x in testcases)
 
+
 def test_replay_18(mocker, tmp_path):
     """test ReplayManager.run() - multiple TestCases - successful repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
@@ -516,20 +613,23 @@ def test_replay_18(mocker, tmp_path):
     server.serve_path.side_effect = (
         (SERVED_ALL, ["a.html"]),
         (SERVED_ALL, ["b.html"]),
-        (SERVED_ALL, ["c.html"]))
+        (SERVED_ALL, ["c.html"]),
+    )
     target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.side_effect = (
         Target.RESULT_NONE,
         Target.RESULT_NONE,
-        Target.RESULT_FAILURE)
+        Target.RESULT_FAILURE,
+    )
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     testcases = [
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[]),
         mocker.Mock(spec=TestCase, env_vars=[], landing_page="b.html", optional=[]),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="c.html", optional=[])]
+        mocker.Mock(spec=TestCase, env_vars=[], landing_page="c.html", optional=[]),
+    ]
     with ReplayManager([], server, target, use_harness=True) as replay:
         results = replay.run(testcases, 30)
         assert target.close.call_count == 2
@@ -544,6 +644,7 @@ def test_replay_18(mocker, tmp_path):
     assert len(results[0].durations) == len(testcases)
     assert all(x.dump.call_count == 1 for x in testcases)
 
+
 def test_replay_19(mocker, tmp_path):
     """test ReplayManager.run() - multiple calls"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
@@ -563,6 +664,7 @@ def test_replay_19(mocker, tmp_path):
             assert replay.status.iteration == 1
     assert server.serve_path.call_count == 3
 
+
 def test_replay_20(mocker, tmp_path):
     """test ReplayManager.report_to_filesystem()"""
     # no reports
@@ -570,26 +672,31 @@ def test_replay_20(mocker, tmp_path):
     assert not any(tmp_path.iterdir())
     # with reports and tests
     (tmp_path / "report_expected").mkdir()
-    result0 = mocker.Mock(ReplayResult, count=1, durations=[1], expected=True, served=[])
+    result0 = mocker.Mock(
+        ReplayResult, count=1, durations=[1], expected=True, served=[]
+    )
     result0.report = mocker.Mock(
-        spec=Report,
-        path=str(tmp_path / "report_expected"),
-        prefix="expected")
+        spec=Report, path=str(tmp_path / "report_expected"), prefix="expected"
+    )
     (tmp_path / "report_other1").mkdir()
-    result1 = mocker.Mock(ReplayResult, count=1, durations=[1], expected=False, served=None)
+    result1 = mocker.Mock(
+        ReplayResult, count=1, durations=[1], expected=False, served=None
+    )
     result1.report = mocker.Mock(
-        spec=Report,
-        path=str(tmp_path / "report_other1"),
-        prefix="other1")
+        spec=Report, path=str(tmp_path / "report_other1"), prefix="other1"
+    )
     (tmp_path / "report_other2").mkdir()
-    result2 = mocker.Mock(ReplayResult, count=1, durations=[1], expected=False, served=None)
+    result2 = mocker.Mock(
+        ReplayResult, count=1, durations=[1], expected=False, served=None
+    )
     result2.report = mocker.Mock(
-        spec=Report,
-        path=str(tmp_path / "report_other2"),
-        prefix="other2")
+        spec=Report, path=str(tmp_path / "report_other2"), prefix="other2"
+    )
     test = mocker.Mock(spec=TestCase)
     path = tmp_path / "dest"
-    ReplayManager.report_to_filesystem(str(path), [result0, result1, result2], tests=[test])
+    ReplayManager.report_to_filesystem(
+        str(path), [result0, result1, result2], tests=[test]
+    )
     assert test.dump.call_count == 3  # called once per report
     assert not (tmp_path / "report_expected").is_dir()
     assert not (tmp_path / "report_other1").is_dir()
@@ -609,6 +716,7 @@ def test_replay_20(mocker, tmp_path):
     assert path.is_dir()
     assert (path / "reports" / "expected_logs").is_dir()
 
+
 def test_replay_21(mocker, tmp_path):
     """test ReplayManager.load_testcases()"""
     fake_load = mocker.patch("grizzly.replay.replay.TestCase.load")
@@ -643,6 +751,7 @@ def test_replay_21(mocker, tmp_path):
     assert test1.cleanup.call_count == 1
     assert test2.cleanup.call_count == 0
 
+
 @mark.parametrize(
     "is_hang, use_sig, match_sig, ignored, results",
     [
@@ -656,7 +765,7 @@ def test_replay_21(mocker, tmp_path):
         (False, True, False, 1, 0),
         # unexpected hang (no signature)
         (False, False, False, 1, 0),
-    ]
+    ],
 )
 def test_replay_22(mocker, tmp_path, is_hang, use_sig, match_sig, ignored, results):
     """test ReplayManager.run() - detect hangs"""
@@ -677,7 +786,9 @@ def test_replay_22(mocker, tmp_path, is_hang, use_sig, match_sig, ignored, resul
     target.save_logs = _fake_save_logs
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         testcase.hang = is_hang
-        with ReplayManager([], server, target, signature=signature, relaunch=10) as replay:
+        with ReplayManager(
+            [], server, target, signature=signature, relaunch=10
+        ) as replay:
             found = replay.run([testcase], 10, expect_hang=is_hang)
             assert replay.status.iteration == 1
             assert replay.status.ignored == ignored
diff --git a/grizzly/session.py b/grizzly/session.py
index ed9f6be3..15df2ec8 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -21,7 +21,14 @@ class SessionError(Exception):
 
 
 class LogOutputLimiter:
-    __slots__ = ("_delay", "_iterations", "_launches", "_multiplier", "_time", "_verbose")
+    __slots__ = (
+        "_delay",
+        "_iterations",
+        "_launches",
+        "_multiplier",
+        "_time",
+        "_verbose",
+    )
 
     def __init__(self, delay=300, delta_multiplier=2, verbose=False):
         self._delay = delay  # maximum time delay between output
@@ -59,7 +66,8 @@ class Session:
     EXIT_LAUNCH_FAILURE = 4  # unrelated Target failure (browser startup crash, etc)
     EXIT_FAILURE = 5  # expected results not reproduced (opposite of EXIT_SUCCESS)
 
-    TARGET_LOG_SIZE_WARN = 0x1900000  # display warning when target log files exceed limit (25MB)
+    # display warning when target log files exceed limit (25MB)
+    TARGET_LOG_SIZE_WARN = 0x1900000
 
     __slots__ = (
         "_coverage",
@@ -70,7 +78,7 @@ class Session:
         "reporter",
         "server",
         "status",
-        "target"
+        "target",
     )
 
     def __init__(
@@ -82,7 +90,7 @@ def __init__(
         coverage=False,
         enable_profiling=False,
         relaunch=1,
-        report_size=1
+        report_size=1,
     ):
         assert relaunch > 0
         assert report_size > 0
@@ -116,7 +124,8 @@ def display_status(self, log_limiter):
                 self.status.iteration,
                 self.adapter.remaining,
                 self.status.results,
-                self.status.test_name)
+                self.status.test_name,
+            )
         elif log_limiter.ready(self.status.iteration, self.target.monitor.launches):
             LOG.info("I%04d-R%02d ", self.status.iteration, self.status.results)
 
@@ -138,7 +147,7 @@ def run(
         time_limit,
         input_path=None,
         iteration_limit=0,
-        display_mode=DISPLAY_NORMAL
+        display_mode=DISPLAY_NORMAL,
     ):
         assert time_limit > 0
         assert iteration_limit >= 0
@@ -174,16 +183,19 @@ def run(
                         "/grz_harness",
                         self.server.port,
                         close_after=relaunch,
-                        time_limit=time_limit)
+                        time_limit=time_limit,
+                    )
                 try:
                     with self.status.measure("launch"):
                         runner.launch(location, max_retries=3, retry_delay=0)
                 except TargetLaunchError as exc:
                     short_sig = exc.report.crash_info.createShortSignature()
-                    LOG.info("Result: %s (%s:%s)",
+                    LOG.info(
+                        "Result: %s (%s:%s)",
                         short_sig,
                         exc.report.major[:8],
-                        exc.report.minor[:8])
+                        exc.report.minor[:8],
+                    )
                     self.reporter.submit([], exc.report)
                     exc.report.cleanup()
                     self.status.count_result(short_sig)
@@ -200,7 +212,8 @@ def run(
                     ignore,
                     self.iomanager.server_map,
                     current_test,
-                    coverage=self._coverage)
+                    coverage=self._coverage,
+                )
             current_test.duration = result.duration
             # adapter callbacks
             if result.timeout:
@@ -239,10 +252,9 @@ def run(
                     short_sig = "Potential hang detected"
                 else:
                     short_sig = report.crash_info.createShortSignature()
-                LOG.info("Result: %s (%s:%s)",
-                    short_sig,
-                    report.major[:8],
-                    report.minor[:8])
+                LOG.info(
+                    "Result: %s (%s:%s)", short_sig, report.major[:8], report.minor[:8]
+                )
                 self.reporter.submit(self.iomanager.tests, report)
                 report.cleanup()
                 self.status.count_result(short_sig)
@@ -265,4 +277,6 @@ def run(
             # warn about large browser logs
             self.status.log_size = self.target.log_size()
             if self.status.log_size > self.TARGET_LOG_SIZE_WARN:
-                LOG.warning("Large browser logs: %dMBs", (self.status.log_size / 0x100000))
+                LOG.warning(
+                    "Large browser logs: %dMBs", (self.status.log_size / 0x100000)
+                )
diff --git a/grizzly/target/__init__.py b/grizzly/target/__init__.py
index adf315bd..1b65654f 100644
--- a/grizzly/target/__init__.py
+++ b/grizzly/target/__init__.py
@@ -16,8 +16,15 @@
     sanitizer_opts,
 )
 
-__all__ = ("Target", "TargetError", "TargetLaunchError", "TargetLaunchTimeout",
-           "available", "load", "sanitizer_opts")
+__all__ = (
+    "Target",
+    "TargetError",
+    "TargetLaunchError",
+    "TargetLaunchTimeout",
+    "available",
+    "load",
+    "sanitizer_opts",
+)
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
@@ -28,21 +35,32 @@
 def _load_targets():
     global TARGETS  # pylint: disable=global-statement
     TARGETS = {}
-    for entry_point in iter_entry_points('grizzly_targets'):
+    for entry_point in iter_entry_points("grizzly_targets"):
         LOG.debug("scanning target %r", entry_point.name)
         try:
             target = entry_point.load()
         except Exception:  # pylint: disable=broad-except
             exc_type, exc_obj, exc_tb = exc_info()
             tbinfo = extract_tb(exc_tb)[-1]
-            LOG.warning("Target %r raised an exception %s: %s (%s:%d)", entry_point.name, exc_type.__name__,
-                        exc_obj, tbinfo[0], tbinfo[1])
+            LOG.warning(
+                "Target %r raised an exception %s: %s (%s:%d)",
+                entry_point.name,
+                exc_type.__name__,
+                exc_obj,
+                tbinfo[0],
+                tbinfo[1],
+            )
             continue
         if not issubclass(target, Target):
-            LOG.warning("Target %r doesn't inherit from grizzly.target.Target, skipping.", entry_point.name)
+            LOG.warning(
+                "Target %r doesn't inherit from grizzly.target.Target, skipping.",
+                entry_point.name,
+            )
         elif entry_point.name in TARGETS:
-            raise RuntimeError("Target %r already exists as %r. (duplicate: %r)" %
-                               (entry_point.name, TARGETS[entry_point.name], target))
+            raise RuntimeError(
+                "Target %r already exists as %r. (duplicate: %r)"
+                % (entry_point.name, TARGETS[entry_point.name], target)
+            )
         else:
             TARGETS[entry_point.name] = target
 
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 894a8cb8..c9ed4e06 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -34,7 +34,9 @@
 class PuppetTarget(Target):
     __slots__ = ("use_rr", "use_valgrind", "_puppet", "_remove_prefs")
 
-    def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, **kwds):
+    def __init__(
+        self, binary, extension, launch_timeout, log_limit, memory_limit, **kwds
+    ):
         super().__init__(binary, extension, launch_timeout, log_limit, memory_limit)
         self.use_rr = kwds.pop("rr", False)
         self.use_valgrind = kwds.pop("valgrind", False)
@@ -43,9 +45,12 @@ def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, *
         self._puppet = FFPuppet(
             use_rr=self.use_rr,
             use_valgrind=self.use_valgrind,
-            use_xvfb=kwds.pop("xvfb", False))
+            use_xvfb=kwds.pop("xvfb", False),
+        )
         if kwds:
-            LOG.warning("PuppetTarget ignoring unsupported arguments: %s", ", ".join(kwds))
+            LOG.warning(
+                "PuppetTarget ignoring unsupported arguments: %s", ", ".join(kwds)
+            )
 
     def add_abort_token(self, token):
         self._puppet.add_abort_token(token)
@@ -80,19 +85,25 @@ def create_report(self, is_hang=False):
     @property
     def monitor(self):
         if self._monitor is None:
+
             class _PuppetMonitor(TargetMonitor):
                 # pylint: disable=no-self-argument,protected-access
                 def clone_log(_, log_id, offset=0):
                     return self._puppet.clone_log(log_id, offset=offset)
+
                 def is_running(_):
                     return self._puppet.is_running()
+
                 def is_healthy(_):
                     return self._puppet.is_healthy()
+
                 @property
                 def launches(_):
                     return self._puppet.launches
+
                 def log_length(_, log_id):
                     return self._puppet.log_length(log_id)
+
             self._monitor = _PuppetMonitor()
         return self._monitor
 
@@ -198,7 +209,9 @@ def dump_coverage(self, timeout=15):
                     break
                 if elapsed >= timeout:
                     # timeout failure
-                    LOG.warning("gcda file open by pid %d after %0.2fs", gcda_open, elapsed)
+                    LOG.warning(
+                        "gcda file open by pid %d after %0.2fs", gcda_open, elapsed
+                    )
                     try:
                         kill(gcda_open, SIGABRT)
                     except OSError:
@@ -233,7 +246,8 @@ def launch(self, location, env_mod=None):
                 memory_limit=self.memory_limit,
                 prefs_js=self.prefs,
                 extension=self.extension,
-                env_mod=env_mod)
+                env_mod=env_mod,
+            )
         except LaunchError as exc:
             LOG.error("FFPuppet LaunchError: %s", str(exc))
             self.close()
@@ -251,7 +265,9 @@ def prefs(self):
             for prefs_template in PrefPicker.templates():
                 if prefs_template.endswith("browser-fuzzing.yml"):
                     LOG.debug("using prefpicker template %r", prefs_template)
-                    tmp_fd, self._prefs = mkstemp(prefix="prefs_", suffix=".js", dir=grz_tmp())
+                    tmp_fd, self._prefs = mkstemp(
+                        prefix="prefs_", suffix=".js", dir=grz_tmp()
+                    )
                     close(tmp_fd)
                     PrefPicker.load_template(prefs_template).create_prefsjs(self._prefs)
                     LOG.debug("generated prefs.js %r", self._prefs)
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 4ff5a044..50ec0576 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -41,6 +41,7 @@ class TargetError(Exception):
 
 class TargetLaunchError(TargetError):
     """Raised if a failure during launch occurs"""
+
     def __init__(self, message, report):
         super().__init__(message)
         self.report = report
@@ -56,8 +57,15 @@ class Target(metaclass=ABCMeta):
     RESULT_IGNORED = 2
 
     __slots__ = (
-        "_lock", "_monitor", "_prefs", "binary", "extension", "launch_timeout",
-        "log_limit", "memory_limit")
+        "_lock",
+        "_monitor",
+        "_prefs",
+        "binary",
+        "extension",
+        "launch_timeout",
+        "log_limit",
+        "memory_limit",
+    )
 
     def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit):
         assert log_limit >= 0
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 5101dc22..b12957c1 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -41,6 +41,7 @@ def test_puppet_target_01(mocker, tmp_path):
     with PuppetTarget(str(fake_file), None, 1, 1, 1, rr=True, fake=1) as target:
         pass
 
+
 def test_puppet_target_02(mocker, tmp_path):
     """test PuppetTarget.launch()"""
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
@@ -65,12 +66,17 @@ def test_puppet_target_02(mocker, tmp_path):
         fake_ffp.reset_mock()
         (tmp_path / "log_stderr.txt").write_text("fake log")
         (tmp_path / "log_stdout.txt").write_text("fake log")
-        mocker.patch("grizzly.target.puppet_target.mkdtemp", autospec=True, return_value=str(tmp_path))
+        mocker.patch(
+            "grizzly.target.puppet_target.mkdtemp",
+            autospec=True,
+            return_value=str(tmp_path),
+        )
         fake_ffp.return_value.launch.side_effect = BrowserTerminatedError("fail")
         with raises(TargetLaunchError, match="fail"):
             target.launch("launch_target_page")
         assert fake_ffp.return_value.save_logs.call_count == 1
 
+
 @mark.parametrize(
     "healthy, reason, ignore, result, closes",
     [
@@ -88,7 +94,7 @@ def test_puppet_target_02(mocker, tmp_path):
         (False, FFPuppet.RC_WORKER, ["memory"], Target.RESULT_IGNORED, 1),
         # ffpuppet check ignored (log-limit)
         (False, FFPuppet.RC_WORKER, ["log-limit"], Target.RESULT_IGNORED, 1),
-    ]
+    ],
 )
 def test_puppet_target_03(mocker, tmp_path, healthy, reason, ignore, result, closes):
     """test PuppetTarget.detect_failure()"""
@@ -109,6 +115,7 @@ def test_puppet_target_03(mocker, tmp_path, healthy, reason, ignore, result, clo
     assert target.detect_failure(ignore) == result
     assert fake_ffp.return_value.close.call_count == closes
 
+
 @mark.parametrize(
     "healthy, usage, os_name, killed",
     [
@@ -120,12 +127,13 @@ def test_puppet_target_03(mocker, tmp_path, healthy, reason, ignore, result, clo
         (True, [(234, 10), (236, 75), (238, 60)], "Linux", 1),
         # ignore idle timeout (close don't abort)
         (True, [(234, 10)], "Linux", 0),
-
-    ]
+    ],
 )
 def test_puppet_target_04(mocker, tmp_path, healthy, usage, os_name, killed):
     """test PuppetTarget.handle_hang()"""
-    mocker.patch("grizzly.target.puppet_target.system", autospec=True, return_value=os_name)
+    mocker.patch(
+        "grizzly.target.puppet_target.system", autospec=True, return_value=os_name
+    )
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_kill = mocker.patch("grizzly.target.puppet_target.kill", autospec=True)
     # raise OSError for code coverage
@@ -141,13 +149,16 @@ def test_puppet_target_04(mocker, tmp_path, healthy, usage, os_name, killed):
     assert fake_ffp.return_value.cpu_usage.call_count == (1 if usage else 0)
     assert fake_kill.call_count == fake_ffp.return_value.wait.call_count == killed
 
+
 @mark.skipif(system() == "Windows", reason="Unsupported on Windows")
 def test_puppet_target_05(mocker, tmp_path):
     """test PuppetTarget.dump_coverage()"""
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_proc = mocker.patch("grizzly.target.puppet_target.Process", autospec=True)
     fake_proc.return_value.children.return_value = (mocker.Mock(pid=101),)
-    fake_proc_iter = mocker.patch("grizzly.target.puppet_target.process_iter", autospec=True)
+    fake_proc_iter = mocker.patch(
+        "grizzly.target.puppet_target.process_iter", autospec=True
+    )
     mocker.patch("grizzly.target.puppet_target.sleep", autospec=True)
     fake_time = mocker.patch("grizzly.target.puppet_target.time", autospec=True)
     fake_file = tmp_path / "fake"
@@ -187,7 +198,9 @@ def test_puppet_target_05(mocker, tmp_path):
     fake_ffp.return_value.is_healthy.side_effect = None
     fake_ffp.return_value.get_pid.return_value = 100
     fake_proc_iter.return_value = (
-        mocker.Mock(info={"pid": 100, "ppid": 0, "open_files": (mocker.Mock(path="a.gcda"),)}),
+        mocker.Mock(
+            info={"pid": 100, "ppid": 0, "open_files": (mocker.Mock(path="a.gcda"),)}
+        ),
     )
     fake_time.side_effect = (0, 1, 20, 20)
     target.dump_coverage(timeout=15)
@@ -203,17 +216,40 @@ def test_puppet_target_05(mocker, tmp_path):
     fake_time.return_value = 1.0
     fake_proc_iter.side_effect = (
         (
-            mocker.Mock(info={"pid": 100, "ppid": 0, "open_files": (mocker.Mock(path="a.bin"), mocker.Mock(path="/a/s/d"))}),
+            mocker.Mock(
+                info={
+                    "pid": 100,
+                    "ppid": 0,
+                    "open_files": (
+                        mocker.Mock(path="a.bin"),
+                        mocker.Mock(path="/a/s/d"),
+                    ),
+                }
+            ),
             mocker.Mock(info={"pid": 101, "ppid": 100, "open_files": None}),
-            mocker.Mock(info={"pid": 999, "ppid": 0, "open_files": None})
+            mocker.Mock(info={"pid": 999, "ppid": 0, "open_files": None}),
         ),
         (
-            mocker.Mock(info={"pid": 100, "ppid": 0, "open_files": (mocker.Mock(path="a.gcda"),)}),
+            mocker.Mock(
+                info={
+                    "pid": 100,
+                    "ppid": 0,
+                    "open_files": (mocker.Mock(path="a.gcda"),),
+                }
+            ),
         ),
         (
-            mocker.Mock(info={"pid": 100, "ppid": 0, "open_files": (mocker.Mock(path="a.bin"),)}),
-            mocker.Mock(info={"pid": 999, "ppid": 0, "open_files": (mocker.Mock(path="ignore.gcda"),)})
-        )
+            mocker.Mock(
+                info={"pid": 100, "ppid": 0, "open_files": (mocker.Mock(path="a.bin"),)}
+            ),
+            mocker.Mock(
+                info={
+                    "pid": 999,
+                    "ppid": 0,
+                    "open_files": (mocker.Mock(path="ignore.gcda"),),
+                }
+            ),
+        ),
     )
     target.dump_coverage()
     assert fake_proc_iter.call_count == 3
@@ -233,6 +269,7 @@ def test_puppet_target_05(mocker, tmp_path):
     fake_kill.reset_mock()
     fake_proc_iter.reset_mock()
 
+
 def test_puppet_target_06(mocker, tmp_path):
     """test PuppetTarget.is_idle()"""
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
@@ -244,6 +281,7 @@ def test_puppet_target_06(mocker, tmp_path):
         assert not target.is_idle(25)
         assert target.is_idle(50)
 
+
 def test_puppet_target_07(mocker, tmp_path):
     """test PuppetTarget.monitor"""
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
@@ -266,6 +304,7 @@ def test_puppet_target_07(mocker, tmp_path):
         target.monitor.clone_log("somelog")
         assert fake_ffp.return_value.clone_log.call_count == 1
 
+
 def test_puppet_target_08(mocker, tmp_path):
     """test PuppetTarget.prefs"""
     mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index 6e11b557..bfd39b22 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -9,28 +9,38 @@
 class SimpleTarget(Target):
     def cleanup(self):
         pass
+
     def close(self):
         pass
+
     @property
     def closed(self):
         pass
+
     def create_report(self, is_hang=False):
         pass
+
     def detect_failure(self, ignored):
         pass
+
     def handle_hang(self, ignore_idle=True):
         pass
+
     def launch(self):
         pass
+
     @property
     def monitor(self):
         return self._monitor
+
     @property
     def prefs(self):
         pass
+
     def save_logs(self, *_args, **_kwargs):
         pass
 
+
 def test_target_01(tmp_path):
     """test creating a simple Target"""
     fake_file = tmp_path / "fake"
@@ -49,6 +59,7 @@ def test_target_01(tmp_path):
     target.dump_coverage()
     target.reverse(1, 2)
 
+
 def test_sanitizer_opts_01(tmp_path):
     """test sanitizer_opts()"""
     # test empty string
@@ -69,7 +80,7 @@ def test_sanitizer_opts_01(tmp_path):
     assert opts["p2"] == "'x:\\a.1'"
     assert opts["p3"] == "'/test/path/'"
     assert opts["p4"] == "''"
-    assert opts["p5"] == "\"x:/a.a\""
+    assert opts["p5"] == '"x:/a.a"'
     # platform specific parsing
     fake_file = tmp_path / "fake.log"
     opts = sanitizer_opts("bar=1:file='%s':foo=2" % (str(fake_file),))
diff --git a/grizzly/target/test_target_loader.py b/grizzly/target/test_target_loader.py
index 833e5c08..2d82663a 100644
--- a/grizzly/target/test_target_loader.py
+++ b/grizzly/target/test_target_loader.py
@@ -20,100 +20,112 @@ class _FakeTarget2(Target):  # pylint: disable=abstract-method
 
 
 def test_target_load_01(mocker):
-    '''If no targets are available, available() should return nothing.'''
-    mocker.patch('grizzly.target.TARGETS', None)
-    mocker.patch('grizzly.target.iter_entry_points', lambda _: [])
+    """If no targets are available, available() should return nothing."""
+    mocker.patch("grizzly.target.TARGETS", None)
+    mocker.patch("grizzly.target.iter_entry_points", lambda _: [])
     assert not available()
 
 
 def test_target_load_02(mocker):
-    '''Loading targets works.'''
-    mocker.patch('grizzly.target.TARGETS', None)
+    """Loading targets works."""
+    mocker.patch("grizzly.target.TARGETS", None)
 
     class _FakeEntryPoint1:
-        name = 'test1'
+        name = "test1"
 
         @staticmethod
         def load():
             return _FakeTarget1
 
     class _FakeEntryPoint2:
-        name = 'test2'
+        name = "test2"
 
         @staticmethod
         def load():
             return _FakeTarget2
 
-    mocker.patch('grizzly.target.iter_entry_points', lambda _: [_FakeEntryPoint1, _FakeEntryPoint2])
-    assert set(available()) == {'test1', 'test2'}
-    assert load('test1') is _FakeTarget1
-    assert load('test2') is _FakeTarget2
+    mocker.patch(
+        "grizzly.target.iter_entry_points",
+        lambda _: [_FakeEntryPoint1, _FakeEntryPoint2],
+    )
+    assert set(available()) == {"test1", "test2"}
+    assert load("test1") is _FakeTarget1
+    assert load("test2") is _FakeTarget2
 
 
 def test_target_load_03(mocker):
-    '''Non-Target will be skipped.'''
-    mocker.patch('grizzly.target.TARGETS', None)
+    """Non-Target will be skipped."""
+    mocker.patch("grizzly.target.TARGETS", None)
 
     class _FakeEntryPoint1:
-        name = 'test1'
+        name = "test1"
 
         @staticmethod
         def load():
             return Target
 
     class _FakeEntryPoint2:
-        name = 'test2'
+        name = "test2"
 
         @staticmethod
         def load():
             return object
 
-    mocker.patch('grizzly.target.iter_entry_points', lambda _: [_FakeEntryPoint1, _FakeEntryPoint2])
-    assert set(available()) == {'test1'}
-    assert load('test1') is Target
+    mocker.patch(
+        "grizzly.target.iter_entry_points",
+        lambda _: [_FakeEntryPoint1, _FakeEntryPoint2],
+    )
+    assert set(available()) == {"test1"}
+    assert load("test1") is Target
 
 
 def test_target_load_04(mocker):
-    '''test load() with name collision'''
-    mocker.patch('grizzly.target.TARGETS', None)
+    """test load() with name collision"""
+    mocker.patch("grizzly.target.TARGETS", None)
 
     class _FakeEntryPoint1:
-        name = 'test'
+        name = "test"
 
         @staticmethod
         def load():
             return _FakeTarget1
 
     class _FakeEntryPoint2:
-        name = 'test'
+        name = "test"
 
         @staticmethod
         def load():
             return _FakeTarget2
 
-    mocker.patch('grizzly.target.iter_entry_points', lambda _: [_FakeEntryPoint1, _FakeEntryPoint2])
+    mocker.patch(
+        "grizzly.target.iter_entry_points",
+        lambda _: [_FakeEntryPoint1, _FakeEntryPoint2],
+    )
     with pytest.raises(RuntimeError, match=r"Target (.)test\1 already exists"):
         available()
 
 
 def test_target_load_05(mocker):
-    '''test load() with broken Target'''
-    mocker.patch('grizzly.target.TARGETS', None)
+    """test load() with broken Target"""
+    mocker.patch("grizzly.target.TARGETS", None)
 
     class _FakeEntryPoint1:
-        name = 'test1'
+        name = "test1"
 
         @staticmethod
         def load():
             return Target
 
     class _FakeEntryPoint2:
-        name = 'test2'
+        name = "test2"
 
         @staticmethod
         def load():
             raise Exception("boo!")
 
-    mocker.patch('grizzly.target.iter_entry_points', lambda _: [_FakeEntryPoint1, _FakeEntryPoint2])
-    assert set(available()) == {'test1'}
-    assert load('test1') is Target
+    mocker.patch(
+        "grizzly.target.iter_entry_points",
+        lambda _: [_FakeEntryPoint1, _FakeEntryPoint2],
+    )
+    assert set(available()) == {"test1"}
+    assert load("test1") is Target
diff --git a/grizzly/target/test_target_monitor.py b/grizzly/target/test_target_monitor.py
index 53a8fd30..3d255b0d 100644
--- a/grizzly/target/test_target_monitor.py
+++ b/grizzly/target/test_target_monitor.py
@@ -8,21 +8,27 @@
 
 def test_target_monitor_01(tmp_path):
     """test a basic TargetMonitor"""
+
     class _BasicMonitor(TargetMonitor):
         # pylint: disable=no-self-argument
         def clone_log(_, log_id, offset=0):
             log_file = tmp_path / "test_log.txt"
             log_file.write_bytes(b"test")
             return str(log_file)
+
         def is_healthy(_):
             return True
+
         def is_running(_):
             return True
+
         @property
         def launches(_):
             return 1
+
         def log_length(_, log_id):
             return 100
+
     mon = _BasicMonitor()
     test_log = mon.clone_log("test_log", offset=0)
     assert os.path.isfile(test_log)
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index 9caa1b61..e91ce4ec 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -16,12 +16,13 @@ def test_grizzly_args_01(capsys, tmp_path):
     out, _ = capsys.readouterr()
     assert "For addition help check out the wiki" in out
     # test success
-    fake_bin = (tmp_path / "fake.bin")
+    fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
     argp = GrizzlyArgs()
     argp._adapters = ["test_adapter"]
     assert argp.parse_args(argv=[str(fake_bin), "test_adapter"])
 
+
 def test_grizzly_args_03(capsys):
     """test GrizzlyArgs.parse_args() handling binary"""
     # test missing required args
@@ -35,9 +36,10 @@ def test_grizzly_args_03(capsys):
     _, err = capsys.readouterr()
     assert "error: file not found: 'missing_bin'" in err
 
+
 def test_grizzly_args_04(capsys, tmp_path):
     """test GrizzlyArgs.parse_args() handling adapter"""
-    fake_bin = (tmp_path / "fake.bin")
+    fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
     # no adapters
     with raises(SystemExit):
@@ -52,4 +54,5 @@ def test_grizzly_args_04(capsys, tmp_path):
     _, err = capsys.readouterr()
     assert "error: Adapter 'missing' does not exist. Available adapters: a1, b2" in err
 
+
 # TODO: Add CommonArgs tests
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 6a950327..198136e8 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -41,15 +41,19 @@ def __init__(self):
         self.verbose = False
         self.xvfb = False
 
+
 # TODO: these could use call_count checks
 
+
 def test_main_01(mocker):
     """test main()"""
     fake_adapter = mocker.Mock(spec=Adapter)
     fake_adapter.NAME = "fake"
     fake_adapter.TIME_LIMIT = 10
     mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
-    mocker.patch.dict("grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)})
+    mocker.patch.dict(
+        "grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)}
+    )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.return_value.server = mocker.Mock(spec=Sapphire)
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
@@ -95,13 +99,16 @@ def test_main_01(mocker):
     args.s3_fuzzmanager = True
     assert main(args) == Session.EXIT_SUCCESS
 
+
 def test_main_02(mocker):
     """test main() exit codes"""
     fake_adapter = mocker.Mock(spec=Adapter)
     fake_adapter.TIME_LIMIT = 10
     fake_adapter.RELAUNCH = 0
     mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
-    mocker.patch.dict("grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)})
+    mocker.patch.dict(
+        "grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)}
+    )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     fake_session.EXIT_ABORT = Session.EXIT_ABORT
@@ -117,6 +124,7 @@ def test_main_02(mocker):
     fake_session.return_value.run.side_effect = TargetLaunchError("test", None)
     assert main(args) == Session.EXIT_LAUNCH_FAILURE
 
+
 @mark.parametrize(
     "arg_testlimit, arg_timeout, result",
     [
@@ -130,7 +138,7 @@ def test_main_02(mocker):
         (10, 11, Session.EXIT_SUCCESS),
         # set test time limit greater than timeout
         (11, 10, Session.EXIT_ARGS),
-    ]
+    ],
 )
 def test_main_03(mocker, arg_testlimit, arg_timeout, result):
     """test main() time-limit and timeout"""
@@ -139,7 +147,9 @@ def test_main_03(mocker, arg_testlimit, arg_timeout, result):
     fake_adapter.RELAUNCH = 1
     fake_adapter.TIME_LIMIT = 10
     mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
-    mocker.patch.dict("grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)})
+    mocker.patch.dict(
+        "grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)}
+    )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.return_value.server = mocker.Mock(spec=Sapphire)
     fake_session.EXIT_ARGS = Session.EXIT_ARGS
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 9cbc81f7..6ab65908 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -17,14 +17,17 @@
 
 class SimpleAdapter(Adapter):
     NAME = "simple"
+
     def __init__(self, use_harness, remaining=None):
         super().__init__()
         self.remaining = remaining
         self._use_harness = use_harness
+
     def setup(self, input_path, server_map):
         if self._use_harness:
             self.enable_harness()
         self.fuzz["input"] = input_path
+
     def generate(self, testcase, server_map):
         assert testcase.adapter_name == self.NAME
         testcase.input_fname = self.fuzz["input"]
@@ -53,7 +56,7 @@ def generate(self, testcase, server_map):
         (True, True, False, 10, 10),
         # test Session.dump_coverage()
         (True, True, True, 2, 2),
-    ]
+    ],
 )
 def test_session_01(mocker, tmp_path, harness, profiling, coverage, relaunch, iters):
     """test Session with typical fuzzer Adapter"""
@@ -81,7 +84,7 @@ def test_session_01(mocker, tmp_path, harness, profiling, coverage, relaunch, it
     ) as session:
         server.serve_path = lambda *a, **kv: (
             SERVED_ALL,
-            [session.iomanager.page_name(offset=-1)]
+            [session.iomanager.page_name(offset=-1)],
         )
         session.run([], 10, input_path="file.bin", iteration_limit=iters)
         assert session.status.iteration == iters
@@ -98,6 +101,7 @@ def test_session_01(mocker, tmp_path, harness, profiling, coverage, relaunch, it
         else:
             assert target.dump_coverage.call_count == 0
 
+
 @mark.parametrize(
     "harness, relaunch, remaining",
     [
@@ -111,7 +115,7 @@ def test_session_01(mocker, tmp_path, harness, profiling, coverage, relaunch, it
         (True, 2, 10),
         # harness, 10 iterations
         (True, 10, 10),
-    ]
+    ],
 )
 def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
     """test Session with playback Adapter"""
@@ -131,11 +135,11 @@ def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
         None,
         server,
         target,
-        relaunch=relaunch
+        relaunch=relaunch,
     ) as session:
         server.serve_path = lambda *a, **kv: (
             SERVED_ALL,
-            [session.iomanager.page_name(offset=-1)]
+            [session.iomanager.page_name(offset=-1)],
         )
         session.run([], 10)
         assert session.status.iteration == remaining
@@ -143,6 +147,7 @@ def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
         assert target.detect_failure.call_count == remaining
         assert target.handle_hang.call_count == 0
 
+
 @mark.parametrize(
     "harness, report_size, relaunch, iters",
     [
@@ -189,19 +194,23 @@ def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
     ) as session:
         server.serve_path = lambda *a, **kv: (
             SERVED_ALL,
-            [session.iomanager.page_name(offset=-1)]
+            [session.iomanager.page_name(offset=-1)],
         )
         session.run([], 10, input_path="file.bin", iteration_limit=iters)
         assert reporter.submit.call_count == 1
         assert len(reporter.submit.call_args[0][0]) == min(report_size, relaunch)
         assert reporter.submit.call_args[0][1].major == "major123"
 
+
 def test_session_04(mocker, tmp_path):
     """test Adapter creating invalid test case"""
+
     class FuzzAdapter(Adapter):
         NAME = "fuzz"
+
         def generate(self, testcase, server_map):
             pass
+
     Status.PATH = str(tmp_path)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_NONE, [])
@@ -211,6 +220,7 @@ def generate(self, testcase, server_map):
         with raises(SessionError, match="Test case is missing landing page"):
             session.run([], 10)
 
+
 def test_session_05(mocker, tmp_path):
     """test Target not requesting landing page"""
     Status.PATH = str(tmp_path)
@@ -222,6 +232,7 @@ def test_session_05(mocker, tmp_path):
         with raises(SessionError, match="Please check Adapter and Target"):
             session.run([], 10)
 
+
 @mark.parametrize(
     "harness, report_size",
     [
@@ -254,7 +265,7 @@ def test_session_06(mocker, tmp_path, harness, report_size):
         server,
         target,
         relaunch=2,
-        report_size=report_size
+        report_size=report_size,
     ) as session:
         server.serve_path.side_effect = (
             (SERVED_ALL, [session.iomanager.page_name()]),
@@ -265,6 +276,7 @@ def test_session_06(mocker, tmp_path, harness, report_size):
         assert len(reporter.submit.call_args[0][0]) == 1
         assert reporter.submit.call_args[0][1].major == "major123"
 
+
 @mark.parametrize(
     "srv_results, target_result, ignored, results",
     [
@@ -298,6 +310,7 @@ def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, resul
         assert target.detect_failure.call_count == results
         assert target.handle_hang.call_count == ignored
 
+
 def test_session_08(tmp_path, mocker):
     """test Session.run() ignoring failures"""
     Status.PATH = str(tmp_path)
@@ -321,6 +334,7 @@ def test_session_08(tmp_path, mocker):
         assert session.status.results == 0
         assert session.status.ignored == 1
 
+
 def test_session_09(tmp_path, mocker):
     """test Session.run() handle TargetLaunchError"""
     Status.PATH = str(tmp_path)
@@ -339,6 +353,7 @@ def test_session_09(tmp_path, mocker):
         assert session.status.results == 1
         assert session.status.ignored == 0
 
+
 def test_session_10(tmp_path, mocker):
     """test Session.run() report hang"""
     Status.PATH = str(tmp_path)
@@ -365,6 +380,7 @@ def test_session_10(tmp_path, mocker):
         assert session.status.results == 1
         assert session.status.ignored == 0
 
+
 def test_log_output_limiter_01(mocker):
     """test LogOutputLimiter.ready() not ready"""
     fake_time = mocker.patch("grizzly.session.time", autospec=True)
@@ -384,6 +400,7 @@ def test_log_output_limiter_01(mocker):
     lol._verbose = True
     assert lol.ready(0, 0)
 
+
 def test_log_output_limiter_02(mocker):
     """test LogOutputLimiter.ready() due to iterations"""
     fake_time = mocker.patch("grizzly.session.time", autospec=True)
@@ -396,6 +413,7 @@ def test_log_output_limiter_02(mocker):
     assert lol._launches == 2
     assert lol._time == 1.1
 
+
 def test_log_output_limiter_03(mocker):
     """test LogOutputLimiter.ready() due to launches"""
     fake_time = mocker.patch("grizzly.session.time", autospec=True)
@@ -407,6 +425,7 @@ def test_log_output_limiter_03(mocker):
     assert lol._iterations == 4
     assert lol._time == 1.0
 
+
 def test_log_output_limiter_04(mocker):
     """test LogOutputLimiter.ready() due to time"""
     fake_time = mocker.patch("grizzly.session.time", autospec=True)
diff --git a/loki/args.py b/loki/args.py
index 4252936e..dd5fd7e6 100644
--- a/loki/args.py
+++ b/loki/args.py
@@ -11,25 +11,41 @@
 
 def parse_args(argv=None):
     parser = ArgumentParser(description="Loki fuzzing library")
+    parser.add_argument("input", help="Output will be generated based on this file")
     parser.add_argument(
-        "input",
-        help="Output will be generated based on this file")
+        "-a",
+        "--aggression",
+        default=0.001,
+        type=float,
+        help="Maximum fuzz rate. 1.0 == 100%% (default: %(default)s)",
+    )
     parser.add_argument(
-        "-a", "--aggression", default=0.001, type=float,
-        help="Maximum fuzz rate. 1.0 == 100%% (default: %(default)s)")
+        "-b",
+        "--byte-order",
+        default=None,
+        help="Byte order to use when mutating multiple bytes at once. "
+        "Use '>' for big-endian or '<' for little-endian (default: random)",
+    )
     parser.add_argument(
-        "-b", "--byte-order", default=None,
-        help="Byte order to use when mutating multiple bytes at once. " \
-             "Use '>' for big-endian or '<' for little-endian (default: random)")
+        "-c",
+        "--count",
+        default=1,
+        type=int,
+        help="Number test cases to generate, minimum 1 (default: %(default)s)",
+    )
     parser.add_argument(
-        "-c", "--count", default=1, type=int,
-        help="Number test cases to generate, minimum 1 (default: %(default)s)")
+        "-q",
+        "--quiet",
+        default=False,
+        action="store_true",
+        help="Display limited output (default: %(default)s)",
+    )
     parser.add_argument(
-        "-q", "--quiet", default=False, action="store_true",
-        help="Display limited output (default: %(default)s)")
-    parser.add_argument(
-        "-o", "--output", default=None,
-        help="Output directory for fuzzed test cases (default: '.')")
+        "-o",
+        "--output",
+        default=None,
+        help="Output directory for fuzzed test cases (default: '.')",
+    )
     args = parser.parse_args(argv)
 
     if args.byte_order and args.byte_order not in Loki.BYTE_ORDERS:
diff --git a/loki/loki.py b/loki/loki.py
index d4764457..1b224d63 100644
--- a/loki/loki.py
+++ b/loki/loki.py
@@ -74,9 +74,7 @@ def _fuzz(self, tgt_fp):
         max_mutations = max(int(round(length * self.aggr)), 1)
         mutations = randint(1, max_mutations)
         LOG.debug(
-            "%d of a possible %d mutations will be performed",
-            mutations,
-            max_mutations
+            "%d of a possible %d mutations will be performed", mutations, max_mutations
         )
         if self.byte_order is not None:
             assert self.byte_order in ("<", ">", "@", "!", "=")
@@ -144,10 +142,7 @@ def main(cls, args):
         LOG.info("Output directory is %r", abspath(out_dir))
         count = max(args.count, 1)
         LOG.info("Generating %d fuzzed test cases...", count)
-        loki = Loki(
-            aggression=args.aggression,
-            byte_order=args.byte_order
-        )
+        loki = Loki(aggression=args.aggression, byte_order=args.byte_order)
         try:
             start_time = time()
             success = loki.fuzz_file(args.input, count, out_dir)
diff --git a/loki/test_loki.py b/loki/test_loki.py
index 4dbea7d1..4da23619 100644
--- a/loki/test_loki.py
+++ b/loki/test_loki.py
@@ -22,7 +22,7 @@
         (4, 0.1, None),
         (5, 0.5, None),
         (100, 0.2, None),
-    ]
+    ],
 )
 def test_loki_fuzz_file(tmp_path, in_size, aggression, byte_order):
     """test Loki.fuzz_file() with different file sizes"""
@@ -45,6 +45,7 @@ def test_loki_fuzz_file(tmp_path, in_size, aggression, byte_order):
     else:
         raise AssertionError("failed to fuzz data")
 
+
 def test_loki_01(tmp_path):
     """test Loki.fuzz_file() error cases"""
     fuzzer = Loki(aggression=0.1)
@@ -59,6 +60,7 @@ def test_loki_01(tmp_path):
     assert not fuzzer.fuzz_file(str(tmp_fn), 1, str(out_path))
     assert not list(out_path.iterdir())
 
+
 def test_loki_02():
     """test Loki.fuzz_data()"""
     in_data = b"This is test DATA!"
@@ -73,6 +75,7 @@ def test_loki_02():
     else:
         raise AssertionError("failed to fuzz data")
 
+
 def test_loki_fuzz_01(mocker):
     """test Loki._fuzz()"""
     loki = Loki(aggression=1)
@@ -101,6 +104,7 @@ def test_loki_fuzz_01(mocker):
         tmp_fp.write(b"1")
         loki._fuzz(tmp_fp)
 
+
 def test_loki_fuzz_02(mocker):
     """test Loki._fuzz_data() paths"""
     fake_randint = mocker.patch("loki.loki.randint", autospec=True)
@@ -128,6 +132,7 @@ def test_loki_fuzz_02(mocker):
     with raises(AssertionError, match=r"Unsupported data size:"):
         Loki._fuzz_data(b"", ">")
 
+
 def test_loki_stress_01():
     """test Loki._fuzz_data() with random input"""
     orders = ("<", ">")
@@ -142,28 +147,24 @@ def test_loki_stress_01():
             in_data = pack("I", getrandbits(32))
         assert len(Loki._fuzz_data(in_data, choice(orders))) == size
 
+
 def test_main_01(mocker, tmp_path):
     """test main()"""
     out_path = tmp_path / "out"
     out_path.mkdir()
     # no output path provided
     fake_mkdtemp = mocker.patch(
-        "loki.loki.mkdtemp",
-        autospec=True,
-        return_value=str(out_path)
+        "loki.loki.mkdtemp", autospec=True, return_value=str(out_path)
     )
     sample = tmp_path / "file.bin"
     sample.write_bytes(b"test!")
     args = mocker.Mock(
-        aggression=0.1,
-        byte_order=None,
-        count=15,
-        input=str(sample),
-        output=None
+        aggression=0.1, byte_order=None, count=15, input=str(sample), output=None
     )
     assert Loki.main(args) == 0
     assert fake_mkdtemp.call_count == 1
 
+
 def test_args_01(capsys):
     """test parse_args()"""
     assert parse_args(argv=["sample"])
diff --git a/sapphire/__init__.py b/sapphire/__init__.py
index 49c6cb9f..7103f0ab 100644
--- a/sapphire/__init__.py
+++ b/sapphire/__init__.py
@@ -10,6 +10,13 @@
 from .job import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
 from .server_map import ServerMap
 
-__all__ = ("Sapphire", "SERVED_ALL", "SERVED_NONE", "SERVED_REQUEST", "SERVED_TIMEOUT", "ServerMap")
+__all__ = (
+    "Sapphire",
+    "SERVED_ALL",
+    "SERVED_NONE",
+    "SERVED_REQUEST",
+    "SERVED_TIMEOUT",
+    "ServerMap",
+)
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
diff --git a/sapphire/__main__.py b/sapphire/__main__.py
index a1c6b2ca..b0a1436f 100644
--- a/sapphire/__main__.py
+++ b/sapphire/__main__.py
@@ -18,26 +18,31 @@ def configure_logging(log_level):
         log_fmt = "[%(asctime)s] %(message)s"
     basicConfig(format=log_fmt, datefmt=date_fmt, level=log_level)
 
+
 def parse_args(argv=None):
     # log levels for console logging
     level_map = {"DEBUG": DEBUG, "INFO": INFO}
     parser = ArgumentParser()
+    parser.add_argument("path", help="Specify a directory to act as wwwroot")
     parser.add_argument(
-        "path",
-        help="Specify a directory to act as wwwroot")
-    parser.add_argument(
-        "--log-level", default="INFO",
-        help="Configure console logging. Options: %s (default: %%(default)s)" %
-        ", ".join(k for k, v in sorted(level_map.items(), key=lambda x: x[1])))
+        "--log-level",
+        default="INFO",
+        help="Configure console logging. Options: %s (default: %%(default)s)"
+        % ", ".join(k for k, v in sorted(level_map.items(), key=lambda x: x[1])),
+    )
     parser.add_argument(
-        "--port", type=int,
-        help="Specify a port to bind to (default: random)")
+        "--port", type=int, help="Specify a port to bind to (default: random)"
+    )
     parser.add_argument(
-        "--remote", action="store_true",
-        help="Allow connections from addresses other than 127.0.0.1")
+        "--remote",
+        action="store_true",
+        help="Allow connections from addresses other than 127.0.0.1",
+    )
     parser.add_argument(
-        "--timeout", type=int,
-        help="Duration in seconds to serve before exiting. Default run forever.")
+        "--timeout",
+        type=int,
+        help="Duration in seconds to serve before exiting. Default run forever.",
+    )
     args = parser.parse_args(argv)
     # sanity check
     if not isdir(args.path):
@@ -50,6 +55,7 @@ def parse_args(argv=None):
     args.log_level = log_level
     return args
 
+
 ARGS = parse_args()
 configure_logging(ARGS.log_level)
 Sapphire.main(ARGS)
diff --git a/sapphire/conftest.py b/sapphire/conftest.py
index d42ef5fa..a30993a4 100644
--- a/sapphire/conftest.py
+++ b/sapphire/conftest.py
@@ -42,8 +42,17 @@ def close(self):
                 self.thread = None
             self._idle.set()
 
-        def launch(self, addr, port, files_to_serve, delay=0, in_order=False, indicate_failure=False,
-                   skip_served=True, throttle=0):
+        def launch(
+            self,
+            addr,
+            port,
+            files_to_serve,
+            delay=0,
+            in_order=False,
+            indicate_failure=False,
+            skip_served=True,
+            throttle=0,
+        ):
             assert self._idle.is_set()
             assert self.thread is None
             self._idle.clear()
@@ -55,12 +64,25 @@ def launch(self, addr, port, files_to_serve, delay=0, in_order=False, indicate_f
                     "in_order": in_order,
                     "indicate_failure": indicate_failure,
                     "skip_served": skip_served,
-                    "throttle": throttle})
+                    "throttle": throttle,
+                },
+            )
             self.thread.start()
 
-        def _handle_request(self, addr, port, files_to_request, delay=0, in_order=False,
-                            indicate_failure=False, skip_served=True, throttle=0):
-            assert isinstance(files_to_request, list), "files_to_request should be a list"
+        def _handle_request(
+            self,
+            addr,
+            port,
+            files_to_request,
+            delay=0,
+            in_order=False,
+            indicate_failure=False,
+            skip_served=True,
+            throttle=0,
+        ):
+            assert isinstance(
+                files_to_request, list
+            ), "files_to_request should be a list"
             if delay:
                 time.sleep(delay)
             indexes = list(range(len(files_to_request)))
@@ -72,14 +94,16 @@ def _handle_request(self, addr, port, files_to_request, delay=0, in_order=False,
                     # check if the file has been served
                     if skip_served and t_file.code is not None:
                         continue
-                    # if t_file.md5_org is set to anything but None the test client will calculate
-                    # the md5 hash
+                    # if t_file.md5_org is set to anything but None the test client
+                    # will calculate the md5 hash
                     data_hash = hashlib.md5() if t_file.md5_org is not None else None
                     target_url = quote(t_file.url)
                 cli = None
                 try:
                     if t_file.custom_request is None:
-                        cli = urlopen("http://%s:%d/%s" % (addr, port, target_url), timeout=10)
+                        cli = urlopen(
+                            "http://%s:%d/%s" % (addr, port, target_url), timeout=10
+                        )
                         resp_code = cli.getcode()
                         content_type = cli.info().get("Content-Type")
                         if resp_code == 200:
@@ -91,7 +115,8 @@ def _handle_request(self, addr, port, files_to_request, delay=0, in_order=False,
                                     data_hash.update(data)
                                 if len(data) < self.rx_size:
                                     break
-                                if throttle > 0:  # try to simulate a slow connection
+                                if throttle > 0:
+                                    # try to simulate a slow connection
                                     time.sleep(throttle)
                             if data_hash is not None:
                                 data_hash = data_hash.hexdigest()
@@ -99,16 +124,24 @@ def _handle_request(self, addr, port, files_to_request, delay=0, in_order=False,
                         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                         try:
                             sock.connect((addr, port))
-                            sock.settimeout(10)  # safety, so test doesn't hang on failure
+                            # safety, so test doesn't hang on failure
+                            sock.settimeout(10)
                             sock.sendall(t_file.custom_request)
-                            data = sock.recv(self.rx_size) if t_file.custom_request else b""
+                            data = (
+                                sock.recv(self.rx_size)
+                                if t_file.custom_request
+                                else b""
+                            )
                         finally:
                             sock.close()
                         content_type = None
                         data_length = len(data)
                         try:
-                            resp_code = int(re.match(r"HTTP/1\.\d\s(?P<code>\d+)\s",
-                                                     data.decode("ascii")).group("code"))
+                            resp_code = int(
+                                re.match(
+                                    r"HTTP/1\.\d\s(?P<code>\d+)\s", data.decode("ascii")
+                                ).group("code")
+                            )
                         except AttributeError:
                             # set code to zero to help testing
                             resp_code = 0 if indicate_failure else None
@@ -138,7 +171,8 @@ def _handle_request(self, addr, port, files_to_request, delay=0, in_order=False,
                             exc_type.__name__,
                             exc_obj,
                             exc_tb.tb_lineno,
-                            t_file.url)
+                            t_file.url,
+                        )
                         if indicate_failure:
                             if not skip_served or t_file.code is None:
                                 t_file.code = 0
diff --git a/sapphire/connection_manager.py b/sapphire/connection_manager.py
index edc7316a..f3ca796b 100644
--- a/sapphire/connection_manager.py
+++ b/sapphire/connection_manager.py
@@ -44,7 +44,8 @@ def close(self):
             exc_type, exc_obj, exc_tb = self._job.exceptions.get()
             LOG.error(
                 "Unexpected exception:\n%s",
-                "".join(format_exception(exc_type, exc_obj, exc_tb)))
+                "".join(format_exception(exc_type, exc_obj, exc_tb)),
+            )
             # re-raise exception from worker once all workers are closed
             raise exc_obj
 
@@ -54,7 +55,8 @@ def start(self):
         listener = Thread(
             target=self.listener,
             args=(self._socket, self._job, self._workers),
-            kwargs={"shutdown_delay": self.SHUTDOWN_DELAY})
+            kwargs={"shutdown_delay": self.SHUTDOWN_DELAY},
+        )
         # launch listener thread and handle thread errors
         for retry in reversed(range(10)):
             try:
@@ -106,7 +108,9 @@ def listener(serv_sock, serv_job, max_workers, shutdown_delay=0):
                     pool_size += 1
                 # manage worker pool
                 if pool_size >= max_workers:
-                    LOG.debug("pool size: %d, waiting for worker to finish...", pool_size)
+                    LOG.debug(
+                        "pool size: %d, waiting for worker to finish...", pool_size
+                    )
                     serv_job.worker_complete.wait()
                     serv_job.worker_complete.clear()
                     # remove complete workers
diff --git a/sapphire/core.py b/sapphire/core.py
index 337e9a04..b2b7d7a8 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -27,7 +27,9 @@ class Sapphire:
 
     __slots__ = ("_auto_close", "_max_workers", "_socket", "_timeout")
 
-    def __init__(self, allow_remote=False, auto_close=-1, max_workers=10, port=None, timeout=60):
+    def __init__(
+        self, allow_remote=False, auto_close=-1, max_workers=10, port=None, timeout=60
+    ):
         self._auto_close = auto_close  # call 'window.close()' on 4xx error pages
         self._max_workers = max_workers  # limit worker threads
         self._socket = Sapphire._create_listening_socket(allow_remote, port)
@@ -126,7 +128,14 @@ def port(self):
         """
         return self._socket.getsockname()[1]
 
-    def serve_path(self, path, continue_cb=None, forever=False, optional_files=None, server_map=None):
+    def serve_path(
+        self,
+        path,
+        continue_cb=None,
+        forever=False,
+        optional_files=None,
+        server_map=None,
+    ):
         """Serve files in path. On completion a list served files and a status
         code will be returned.
         The status codes include:
@@ -153,7 +162,8 @@ def serve_path(self, path, continue_cb=None, forever=False, optional_files=None,
             auto_close=self._auto_close,
             forever=forever,
             optional_files=optional_files,
-            server_map=server_map)
+            server_map=server_map,
+        )
         if not job.pending:
             job.finish()
             LOG.debug("nothing to serve")
@@ -195,12 +205,15 @@ def timeout(self, value):
     @classmethod
     def main(cls, args):
         try:
-            with cls(allow_remote=args.remote, port=args.port, timeout=args.timeout) as serv:
+            with cls(
+                allow_remote=args.remote, port=args.port, timeout=args.timeout
+            ) as serv:
                 LOG.info(
                     "Serving %r @ http://%s:%d/",
                     abspath(args.path),
                     gethostname() if args.remote else "127.0.0.1",
-                    serv.port)
+                    serv.port,
+                )
                 status = serv.serve_path(args.path)[0]
             if status == SERVED_ALL:
                 LOG.info("All test case content was served")
diff --git a/sapphire/job.py b/sapphire/job.py
index 9328cab4..84157167 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -24,8 +24,8 @@
 
 
 # job status codes
-SERVED_ALL = 0      # all expected requests for required files have been received
-SERVED_NONE = 1     # no requests for required files have been received
+SERVED_ALL = 0  # all expected requests for required files have been received
+SERVED_NONE = 1  # no requests for required files have been received
 SERVED_REQUEST = 2  # some requests for required files have been received
 SERVED_TIMEOUT = 3  # timeout occurred
 
@@ -41,14 +41,31 @@ class Job:
         ".bmp": "image/bmp",
         ".ico": "image/x-icon",
         ".wave": "audio/x-wav",
-        ".webp": "image/webp"
+        ".webp": "image/webp",
     }
 
     __slots__ = (
-        "_complete", "_pending", "_served", "auto_close", "accepting", "base_path",
-        "exceptions", "forever", "initial_queue_size", "server_map", "worker_complete")
-
-    def __init__(self, base_path, auto_close=-1, forever=False, optional_files=None, server_map=None):
+        "_complete",
+        "_pending",
+        "_served",
+        "auto_close",
+        "accepting",
+        "base_path",
+        "exceptions",
+        "forever",
+        "initial_queue_size",
+        "server_map",
+        "worker_complete",
+    )
+
+    def __init__(
+        self,
+        base_path,
+        auto_close=-1,
+        forever=False,
+        optional_files=None,
+        server_map=None,
+    ):
         self._complete = Event()
         self._pending = Tracker(files=set(), lock=Lock())
         self._served = Tracker(files=defaultdict(int), lock=Lock())
@@ -76,13 +93,15 @@ def _build_queue(self, optional_files):
                     continue
                 file_path = abspath(file_path)
                 if "?" in file_path:
-                    LOG.warning("Cannot add files with '?' in path. Skipping %r", file_path)
+                    LOG.warning(
+                        "Cannot add files with '?' in path. Skipping %r", file_path
+                    )
                     continue
                 self._pending.files.add(file_path)
                 LOG.debug("required: %r", location)
         # if nothing was found check if the path exists
         if not self._pending.files and not isdir(self.base_path):
-            raise OSError("%r does not exist" % (self.base_path),)
+            raise OSError("%r does not exist" % (self.base_path,))
         if self.server_map:
             for redirect, resource in self.server_map.redirect.items():
                 if resource.required:
@@ -91,7 +110,8 @@ def _build_queue(self, optional_files):
                     "%s: %r -> %r",
                     "required" if resource.required else "optional",
                     redirect,
-                    resource.target)
+                    resource.target,
+                )
             for dyn_resp, resource in self.server_map.dynamic.items():
                 if resource.required:
                     self._pending.files.add(dyn_resp)
@@ -122,7 +142,9 @@ def check_request(self, request):
             if request in self.server_map.dynamic:
                 return self.server_map.dynamic[request]
             # collect possible include matches
-            includes = tuple(x for x in self.server_map.include if request.startswith(x))
+            includes = tuple(
+                x for x in self.server_map.include if request.startswith(x)
+            )
             if includes:
                 LOG.debug("potential include matches %r", includes)
                 # attempt to find match
@@ -130,12 +152,14 @@ def check_request(self, request):
                 while True:
                     if url in includes:
                         LOG.debug("found include match %r", url)
-                        location = request.split(url, 1)[-1].lstrip("/") if url else request
+                        location = (
+                            request.split(url, 1)[-1].lstrip("/") if url else request
+                        )
                         # check location points to something
                         if location:
                             target = pathjoin(
-                                self.server_map.include[url].target,
-                                location)
+                                self.server_map.include[url].target, location
+                            )
                             # if the mapping url is empty check the file exists
                             if url or isfile(target):
                                 mime = self.server_map.include[url].mime
@@ -145,7 +169,8 @@ def check_request(self, request):
                                     Resource.URL_INCLUDE,
                                     normpath(target),
                                     mime=mime,
-                                    required=self.server_map.include[url].required)
+                                    required=self.server_map.include[url].required,
+                                )
                     if "/" in url:
                         url = url.rsplit("/", 1)[0]
                     elif url:
diff --git a/sapphire/server_map.py b/sapphire/server_map.py
index 8e50886f..8a61b16a 100644
--- a/sapphire/server_map.py
+++ b/sapphire/server_map.py
@@ -53,7 +53,9 @@ def _check_url(url):
             raise InvalidURLError("Only alphanumeric characters accepted in URL.")
         return url
 
-    def set_dynamic_response(self, url, callback, mime_type="application/octet-stream", required=False):
+    def set_dynamic_response(
+        self, url, callback, mime_type="application/octet-stream", required=False
+    ):
         url = self._check_url(url)
         if not callable(callback):
             raise TypeError("callback must be callable")
@@ -63,10 +65,8 @@ def set_dynamic_response(self, url, callback, mime_type="application/octet-strea
             raise MapCollisionError("URL collision on %r" % (url,))
         LOG.debug("mapping dynamic response %r -> %r (%r)", url, callback, mime_type)
         self.dynamic[url] = Resource(
-            Resource.URL_DYNAMIC,
-            callback,
-            mime=mime_type,
-            required=required)
+            Resource.URL_DYNAMIC, callback, mime=mime_type, required=required
+        )
 
     def set_include(self, url, target_path):
         url = self._check_url(url)
@@ -85,14 +85,16 @@ def set_include(self, url, target_path):
                 continue
             if not relpath(target_path, resource.target).startswith(".."):
                 LOG.error("%r mapping includes path %r", existing_url, target_path)
-                raise MapCollisionError("%r and %r include %r" % (url, existing_url, target_path))
+                raise MapCollisionError(
+                    "%r and %r include %r" % (url, existing_url, target_path)
+                )
             if not relpath(resource.target, target_path).startswith(".."):
                 LOG.error("%r mapping includes path %r", url, resource.target)
-                raise MapCollisionError("%r and %r include %r" % (url, existing_url, resource.target))
+                raise MapCollisionError(
+                    "%r and %r include %r" % (url, existing_url, resource.target)
+                )
         LOG.debug("mapping include %r -> %r", url, target_path)
-        self.include[url] = Resource(
-            Resource.URL_INCLUDE,
-            target_path)
+        self.include[url] = Resource(Resource.URL_INCLUDE, target_path)
 
     def set_redirect(self, url, target, required=True):
         url = self._check_url(url)
@@ -102,7 +104,4 @@ def set_redirect(self, url, target, required=True):
             raise TypeError("target must not be an empty string")
         if url in self.dynamic or url in self.include:
             raise MapCollisionError("URL collision on %r" % (url,))
-        self.redirect[url] = Resource(
-            Resource.URL_REDIRECT,
-            target,
-            required=required)
+        self.redirect[url] = Resource(Resource.URL_REDIRECT, target, required=required)
diff --git a/sapphire/test_connection_manager.py b/sapphire/test_connection_manager.py
index aca1b6bf..f99d7397 100644
--- a/sapphire/test_connection_manager.py
+++ b/sapphire/test_connection_manager.py
@@ -30,6 +30,7 @@ def test_connection_manager_01(mocker, tmp_path):
     assert not job.accepting.is_set()
     assert job.exceptions.empty()
 
+
 def test_connection_manager_02(mocker):
     """test ConnectionManager.start() failure"""
     mocker.patch("sapphire.connection_manager.sleep", autospec=True)
@@ -43,6 +44,7 @@ def test_connection_manager_02(mocker):
     loadmgr.close()
     assert job.is_complete()
 
+
 def test_connection_manager_03(mocker, tmp_path):
     """test ConnectionManager multiple files and requests"""
     (tmp_path / "test1").touch()
@@ -58,7 +60,8 @@ def test_connection_manager_03(mocker, tmp_path):
         b"GET /test2 HTTP/1.1",
         b"GET /test1 HTTP/1.1",
         b"GET /test1 HTTP/1.1",
-        b"GET /test3 HTTP/1.1")
+        b"GET /test3 HTTP/1.1",
+    )
     serv_sock = mocker.Mock(spec=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
     assert not job.is_complete()
@@ -67,6 +70,7 @@ def test_connection_manager_03(mocker, tmp_path):
     assert clnt_sock.close.call_count == 8
     assert job.is_complete()
 
+
 def test_connection_manager_04(mocker, tmp_path):
     """test ConnectionManager.wait()"""
     (tmp_path / "test1").touch()
@@ -88,6 +92,7 @@ def test_connection_manager_04(mocker, tmp_path):
     with ConnectionManager(job, serv_sock, max_workers=10) as loadmgr:
         assert not loadmgr.wait(1, continue_cb=lambda: False, poll=0.01)
 
+
 def test_connection_manager_05(mocker, tmp_path):
     """test ConnectionManager re-raise worker exceptions"""
     (tmp_path / "test1").touch()
@@ -103,6 +108,7 @@ def test_connection_manager_05(mocker, tmp_path):
     assert job.is_complete()
     assert job.exceptions.empty()
 
+
 def test_connection_manager_06(mocker, tmp_path):
     """test ConnectionManager re-raise launcher exceptions"""
     (tmp_path / "test1").touch()
diff --git a/sapphire/test_job.py b/sapphire/test_job.py
index d60ec9ea..29e28682 100644
--- a/sapphire/test_job.py
+++ b/sapphire/test_job.py
@@ -30,6 +30,7 @@ def test_job_01(tmp_path):
     assert not any(job.served)
     assert job.is_complete()
 
+
 def test_job_02(tmp_path):
     """test Job proper handling of required and optional files"""
     opt1_path = tmp_path / "opt_file_1.txt"
@@ -42,8 +43,7 @@ def test_job_02(tmp_path):
     req2_path = tmp_path / "nested" / "req_file_2.txt"
     req2_path.write_bytes(b"d")
     job = Job(
-        str(tmp_path),
-        optional_files=[opt1_path.name, "nested/%s" % (opt2_path.name,)]
+        str(tmp_path), optional_files=[opt1_path.name, "nested/%s" % (opt2_path.name,)]
     )
     assert job.status == SERVED_NONE
     assert not job.is_complete()
@@ -74,6 +74,7 @@ def test_job_02(tmp_path):
     job.finish()
     assert job.is_complete()
 
+
 def test_job_03(tmp_path):
     """test Job redirects"""
     smap = ServerMap()
@@ -90,6 +91,7 @@ def test_job_03(tmp_path):
     assert job.remove_pending("two")
     assert job.pending == 0
 
+
 def test_job_04(mocker, tmp_path):
     """test Job includes"""
     srv_root = tmp_path / "root"
@@ -142,6 +144,7 @@ def test_job_04(mocker, tmp_path):
     assert not job.is_forbidden(str(srv_root / ".." / "test" / "test_file.txt"))
     assert not job.is_forbidden(str(srv_include / ".." / "root" / "req_file.txt"))
 
+
 def test_job_05(tmp_path):
     """test Job.check_request() with tricky includes"""
     srv_root = tmp_path / "root"
@@ -176,17 +179,18 @@ def test_job_05(tmp_path):
     assert resource.target == str(file_a)
     # inc and inc subdir collision
     # TODO: This can fail. How do we detect or support it?
-    #smap.include.clear()
-    #(inc_dir / "c").mkdir()
-    #inc_c_d = (inc_dir / "c" / "d.bin")
-    #inc_c_d.write_bytes(b"a")
-    #inc_d = (inc_dir / "d.bin")
-    #inc_d.write_bytes(b"a")
-    #smap.include["c"] = Resource(Resource.URL_INCLUDE, str(inc_dir))
-    #smap.include[""] = Resource(Resource.URL_INCLUDE, str(inc_dir / "c"))
-    #resource = job.check_request("c/d.bin")
-    #assert resource.type == Resource.URL_INCLUDE
-    #assert resource.target == str(inc_c_d)
+    # smap.include.clear()
+    # (inc_dir / "c").mkdir()
+    # inc_c_d = (inc_dir / "c" / "d.bin")
+    # inc_c_d.write_bytes(b"a")
+    # inc_d = (inc_dir / "d.bin")
+    # inc_d.write_bytes(b"a")
+    # smap.include["c"] = Resource(Resource.URL_INCLUDE, str(inc_dir))
+    # smap.include[""] = Resource(Resource.URL_INCLUDE, str(inc_dir / "c"))
+    # resource = job.check_request("c/d.bin")
+    # assert resource.type == Resource.URL_INCLUDE
+    # assert resource.target == str(inc_c_d)
+
 
 def test_job_06(tmp_path):
     """test Job dynamic"""
@@ -206,6 +210,7 @@ def test_job_06(tmp_path):
     assert callable(resource.target)
     assert isinstance(resource.mime, str)
 
+
 def test_job_07(tmp_path):
     """test accessing forbidden files"""
     srv_root = tmp_path / "root"
@@ -223,8 +228,8 @@ def test_job_07(tmp_path):
     assert not job.is_forbidden(str(test_1))
     assert job.is_forbidden(str(srv_root / "../no_access.txt"))
 
-@pytest.mark.skipif(platform.system() == "Windows",
-                    reason="Unsupported on Windows")
+
+@pytest.mark.skipif(platform.system() == "Windows", reason="Unsupported on Windows")
 def test_job_08(tmp_path):
     """test Job with file names containing invalid characters"""
     test_file = tmp_path / "test.txt"
@@ -235,11 +240,13 @@ def test_job_08(tmp_path):
     assert job.pending == 1
     assert job.check_request("test.txt").target == str(test_file)
 
+
 def test_job_09():
     """test Job with missing directory"""
     with pytest.raises(OSError):
         Job("missing")
 
+
 def test_job_10(tmp_path):
     """test Job.increment_served() and Job.served"""
     job = Job(str(tmp_path))
@@ -249,6 +256,7 @@ def test_job_10(tmp_path):
     job.increment_served("/some/include/path/inc.bin")
     assert "/some/include/path/inc.bin" in job.served
 
+
 def test_job_11():
     """test Job.lookup_mime()"""
     assert Job.lookup_mime("unknown") == "application/octet-stream"
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index b6931bf9..4a155188 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -56,11 +56,16 @@ def test_sapphire_00(client, tmp_path):
     assert test.code == 200
     assert test.len_srv == test.len_org
 
+
 def test_sapphire_01(client, tmp_path):
     """test requesting multiple files (test cleanup code)"""
     to_serve = list()
     for i in range(100):
-        to_serve.append(_create_test("test_%03d.html" % i, tmp_path, data=os.urandom(5), calc_hash=True))
+        to_serve.append(
+            _create_test(
+                "test_%03d.html" % i, tmp_path, data=os.urandom(5), calc_hash=True
+            )
+        )
     with Sapphire(timeout=30) as serv:
         client.launch("127.0.0.1", serv.port, to_serve)
         status, files_served = serv.serve_path(str(tmp_path))
@@ -72,6 +77,7 @@ def test_sapphire_01(client, tmp_path):
         assert t_file.len_srv == t_file.len_org
         assert t_file.md5_srv == t_file.md5_org
 
+
 def test_sapphire_02(client, tmp_path):
     """test serving optional file"""
     files_to_serve = list()
@@ -88,6 +94,7 @@ def test_sapphire_02(client, tmp_path):
         assert t_file.code == 200
         assert t_file.len_srv == t_file.len_org
 
+
 def test_sapphire_03(client, tmp_path):
     """test skipping optional file"""
     files_to_serve = list()
@@ -106,6 +113,7 @@ def test_sapphire_03(client, tmp_path):
         assert t_file.code == 200
         assert t_file.len_srv == t_file.len_org
 
+
 def test_sapphire_04(client, tmp_path):
     """test requesting invalid file (404)"""
     files_to_serve = list()
@@ -119,6 +127,7 @@ def test_sapphire_04(client, tmp_path):
     assert files_to_serve[0].code == 404
     assert files_to_serve[1].code == 200
 
+
 def test_sapphire_05(client, tmp_path):
     """test requesting a file outside of the server root (403)"""
     files_to_serve = list()
@@ -127,7 +136,9 @@ def test_sapphire_05(client, tmp_path):
     # add invalid file
     files_to_serve.append(_TestFile(os.path.abspath(__file__)))
     # add file in parent of root_dir
-    files_to_serve.append(_create_test("no_access.html", tmp_path, data=b"no_access", url_prefix="../"))
+    files_to_serve.append(
+        _create_test("no_access.html", tmp_path, data=b"no_access", url_prefix="../")
+    )
     assert (tmp_path / "no_access.html").is_file()
     # add valid test
     files_to_serve.append(_create_test("test_case.html", root_dir))
@@ -143,6 +154,7 @@ def test_sapphire_05(client, tmp_path):
     assert files_to_serve[1].code == 403
     assert files_to_serve[2].code == 200
 
+
 def test_sapphire_06(client, tmp_path):
     """test serving no files... this should never happen but..."""
     with Sapphire(timeout=10) as serv:
@@ -151,6 +163,7 @@ def test_sapphire_06(client, tmp_path):
     assert status == SERVED_NONE
     assert not files_served
 
+
 def test_sapphire_07(tmp_path):
     """test timeout of the server"""
     with Sapphire(timeout=60) as serv:
@@ -167,6 +180,7 @@ def test_sapphire_07(tmp_path):
     assert status == SERVED_TIMEOUT
     assert not files_served
 
+
 def test_sapphire_08(client, tmp_path):
     """test only serving some files (SERVED_REQUEST)"""
     cb_status = {"count": 0}
@@ -184,6 +198,7 @@ def is_running():
     assert status == SERVED_REQUEST
     assert len(files_served) < len(files_to_serve)
 
+
 def test_sapphire_09(client, tmp_path):
     """test serving interesting sized files"""
     tests = [
@@ -196,7 +211,9 @@ def test_sapphire_09(client, tmp_path):
     ]
     for test in tests:
         test["file"] = _TestFile(test["name"])
-        t_data = "".join(random.choice("ABCD1234") for _ in range(test["size"])).encode("ascii")
+        t_data = "".join(random.choice("ABCD1234") for _ in range(test["size"])).encode(
+            "ascii"
+        )
         (tmp_path / test["file"].url).write_bytes(t_data)
         test["file"].md5_org = hashlib.md5(t_data).hexdigest()
     with Sapphire(timeout=10) as serv:
@@ -210,6 +227,7 @@ def test_sapphire_09(client, tmp_path):
         assert test["file"].len_srv == test["size"]
         assert test["file"].md5_srv == test["file"].md5_org
 
+
 def test_sapphire_10(client, tmp_path):
     """test serving a large (100MB) file"""
     t_file = _TestFile("test_case.html")
@@ -229,9 +247,12 @@ def test_sapphire_10(client, tmp_path):
     assert t_file.len_srv == (100 * 1024 * 1024)
     assert t_file.md5_srv == t_file.md5_org
 
+
 def test_sapphire_11(client, tmp_path):
     """test serving a binary file"""
-    t_file = _create_test("test_case.html", tmp_path, data=os.urandom(512), calc_hash=True)
+    t_file = _create_test(
+        "test_case.html", tmp_path, data=os.urandom(512), calc_hash=True
+    )
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [t_file])
         assert serv.serve_path(str(tmp_path))[0] == SERVED_ALL
@@ -240,12 +261,14 @@ def test_sapphire_11(client, tmp_path):
     assert t_file.len_srv == t_file.len_org
     assert t_file.md5_srv == t_file.md5_org
 
+
 def test_sapphire_12():
     """test requested port is used"""
     test_port = 0x1337
     with Sapphire(port=test_port, timeout=1) as serv:
         assert test_port == serv.port
 
+
 def test_sapphire_13(client, tmp_path):
     """test serving multiple content types"""
     files_to_serve = list()
@@ -266,6 +289,7 @@ def test_sapphire_13(client, tmp_path):
         assert test.content_type == content_type
     assert len(content_types) == 2
 
+
 def test_sapphire_14(tmp_path):
     """test callback"""
     cb_status = {"count": 0}
@@ -277,9 +301,12 @@ def _test_callback():
 
     with Sapphire(timeout=10) as serv:
         _create_test("test_case.html", tmp_path)
-        assert serv.serve_path(str(tmp_path), continue_cb=_test_callback)[0] == SERVED_NONE
+        assert (
+            serv.serve_path(str(tmp_path), continue_cb=_test_callback)[0] == SERVED_NONE
+        )
     assert cb_status["count"] == 2
 
+
 def test_sapphire_15(client, tmp_path):
     """test calling serve_path multiple times"""
     with Sapphire(timeout=10) as serv:
@@ -293,6 +320,7 @@ def test_sapphire_15(client, tmp_path):
             assert test.len_srv == test.len_org
             (tmp_path / test.url).unlink()
 
+
 def test_sapphire_16(client, tmp_path):
     """test non required mapped redirects"""
     smap = ServerMap()
@@ -305,13 +333,16 @@ def test_sapphire_16(client, tmp_path):
     assert test.code == 200
     assert test.len_srv == test.len_org
 
+
 def test_sapphire_17(client, tmp_path):
     """test required mapped redirects"""
     smap = ServerMap()
     with Sapphire(timeout=10) as serv:
         files_to_serve = list()
         # redir_target will be requested indirectly via the redirect
-        redir_target = _create_test("redir_test_case.html", tmp_path, data=b"Redirect DATA!")
+        redir_target = _create_test(
+            "redir_test_case.html", tmp_path, data=b"Redirect DATA!"
+        )
         redir_test = _TestFile("redirect_test")
         smap.set_redirect(redir_test.url, redir_target.url, required=True)
         files_to_serve.append(redir_test)
@@ -327,6 +358,7 @@ def test_sapphire_17(client, tmp_path):
     assert redir_test.code == 200
     assert redir_test.len_srv == redir_target.len_org
 
+
 def test_sapphire_18(client, tmp_path):
     """test include directories and permissions"""
     inc1_path = tmp_path / "inc1"
@@ -345,21 +377,27 @@ def test_sapphire_18(client, tmp_path):
         nest_path = inc1_path / "nested"
         nest_path.mkdir()
         # add file in a nested dir in inc1
-        nest = _create_test("nested_file.html", nest_path, data=b"blah... .nested", url_prefix="nested/")
+        nest = _create_test(
+            "nested_file.html", nest_path, data=b"blah... .nested", url_prefix="nested/"
+        )
         assert nest_path / "nested_file.html"
         files_to_serve.append(nest)
         # test 404 in nested dir in inc1
         nest_404 = _TestFile("nested/nested_file_404.html")
         files_to_serve.append(nest_404)
         # test path mounted somewhere other than /
-        inc2 = _create_test("included_file2.html", inc2_path, data=b"blah....2", url_prefix="inc_test/")
+        inc2 = _create_test(
+            "included_file2.html", inc2_path, data=b"blah....2", url_prefix="inc_test/"
+        )
         files_to_serve.append(inc2)
         # test 404 in include dir
         inc404 = _TestFile("inc_test/included_file_404.html")
         assert not (nest_path / "included_file_404.html").is_file()
         files_to_serve.append(inc404)
         # test 403
-        inc403 = _create_test("no_access.html", tmp_path, data=b"no_access", url_prefix="inc_test/../")
+        inc403 = _create_test(
+            "no_access.html", tmp_path, data=b"no_access", url_prefix="inc_test/../"
+        )
         assert (tmp_path / "no_access.html").is_file()
         files_to_serve.append(inc403)
         # test file (used to keep sever job alive)
@@ -384,6 +422,7 @@ def test_sapphire_18(client, tmp_path):
     assert inc404.code == 404
     assert inc403.code == 403
 
+
 def test_sapphire_19(client, tmp_path):
     """test dynamic response - not required"""
     _data = b"dynamic response -- TEST DATA!"
@@ -403,6 +442,7 @@ def test_sapphire_19(client, tmp_path):
     assert test_dr.len_srv == test_dr.len_org
     assert test_dr.md5_srv == test_dr.md5_org
 
+
 def test_sapphire_20(client, tmp_path):
     """test dynamic response - required"""
     _data = b"dynamic response -- TEST DATA!"
@@ -410,7 +450,9 @@ def test_sapphire_20(client, tmp_path):
     test_dr.len_org = len(_data)
     test_dr.md5_org = hashlib.md5(_data).hexdigest()
     smap = ServerMap()
-    smap.set_dynamic_response("dyn_test", lambda: _data, mime_type="text/plain", required=True)
+    smap.set_dynamic_response(
+        "dyn_test", lambda: _data, mime_type="text/plain", required=True
+    )
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [test_dr], in_order=True)
         assert serv.serve_path(str(tmp_path), server_map=smap)[0] == SERVED_ALL
@@ -419,6 +461,7 @@ def test_sapphire_20(client, tmp_path):
     assert test_dr.len_srv == test_dr.len_org
     assert test_dr.md5_srv == test_dr.md5_org
 
+
 def test_sapphire_21(client_factory, tmp_path):
     """test pending_files == 0 in worker thread"""
     client_defer = client_factory(rx_size=2)
@@ -429,7 +472,9 @@ def test_sapphire_21(client_factory, tmp_path):
     with Sapphire(timeout=10) as serv:
         # this test needs to wait just long enough to have the required file served
         # but not too long or the connection will be closed by the server
-        client_defer.launch("127.0.0.1", serv.port, [test_defer], delay=0.1, indicate_failure=True)
+        client_defer.launch(
+            "127.0.0.1", serv.port, [test_defer], delay=0.1, indicate_failure=True
+        )
         client = client_factory(rx_size=2)
         client.launch("127.0.0.1", serv.port, [test], throttle=0.1)
         assert serv.serve_path(str(tmp_path), optional_files=optional)[0] == SERVED_ALL
@@ -438,6 +483,7 @@ def test_sapphire_21(client_factory, tmp_path):
     assert test.code == 200
     assert test_defer.code == 0
 
+
 def test_sapphire_22(client, tmp_path):
     """test handling an invalid request"""
     bad_test = _TestFile("bad.html")
@@ -451,6 +497,7 @@ def test_sapphire_22(client, tmp_path):
     assert test.code == 200
     assert bad_test.code == 400
 
+
 def test_sapphire_23(client, tmp_path):
     """test handling an empty request"""
     bad_test = _TestFile("bad.html")
@@ -458,12 +505,19 @@ def test_sapphire_23(client, tmp_path):
     optional = [bad_test.url]
     test = _create_test("test_case.html", tmp_path)
     with Sapphire(timeout=10) as serv:
-        client.launch("127.0.0.1", serv.port, [bad_test, test], indicate_failure=True, in_order=True)
+        client.launch(
+            "127.0.0.1",
+            serv.port,
+            [bad_test, test],
+            indicate_failure=True,
+            in_order=True,
+        )
         assert serv.serve_path(str(tmp_path), optional_files=optional)[0] == SERVED_ALL
     assert client.wait(timeout=10)
     assert test.code == 200
     assert bad_test.code == 0
 
+
 def test_sapphire_24(client_factory, tmp_path):
     """test requesting multiple files via multiple connections"""
     to_serve = list()
@@ -476,7 +530,9 @@ def test_sapphire_24(client_factory, tmp_path):
             for _ in range(max_workers):  # number of clients to spawn
                 clients.append(client_factory(rx_size=1))
             for client in clients:
-                client.launch("127.0.0.1", serv.port, to_serve, in_order=True, throttle=0.05)
+                client.launch(
+                    "127.0.0.1", serv.port, to_serve, in_order=True, throttle=0.05
+                )
             status, files_served = serv.serve_path(str(tmp_path))
             # call serv.close() instead of waiting for the clients to timeout
             serv.close()
@@ -490,8 +546,10 @@ def test_sapphire_24(client_factory, tmp_path):
         assert t_file.code == 200
         assert t_file.len_srv == t_file.len_org
 
+
 def test_sapphire_25(client_factory, tmp_path):
     """test all request types via multiple connections"""
+
     def _dyn_test_cb():
         return b"A" if random.getrandbits(1) else b"AA"
 
@@ -500,7 +558,9 @@ def _dyn_test_cb():
         to_serve = list()
         for i in range(50):
             # add required files
-            to_serve.append(_create_test("test_%03d.html" % i, tmp_path, data=b"A" * ((i % 2) + 1)))
+            to_serve.append(
+                _create_test("test_%03d.html" % i, tmp_path, data=b"A" * ((i % 2) + 1))
+            )
             # add a missing files
             to_serve.append(_TestFile("missing_%03d.html" % i))
             # add optional files
@@ -510,10 +570,14 @@ def _dyn_test_cb():
             # add redirects
             redir_target = _create_test("redir_%03d.html" % i, tmp_path, data=b"AA")
             to_serve.append(_TestFile("redir_%03d" % i))
-            smap.set_redirect(to_serve[-1].url, redir_target.url, required=random.getrandbits(1) > 0)
+            smap.set_redirect(
+                to_serve[-1].url, redir_target.url, required=random.getrandbits(1) > 0
+            )
             # add dynamic responses
             to_serve.append(_TestFile("dynm_%03d" % i))
-            smap.set_dynamic_response(to_serve[-1].url, _dyn_test_cb, mime_type="text/plain")
+            smap.set_dynamic_response(
+                to_serve[-1].url, _dyn_test_cb, mime_type="text/plain"
+            )
         clients = list()
         for _ in range(100):  # number of clients to spawn
             clients.append(client_factory(rx_size=1))
@@ -521,6 +585,7 @@ def _dyn_test_cb():
             clients[-1].launch("127.0.0.1", serv.port, to_serve, throttle=throttle)
         assert serv.serve_path(str(tmp_path), server_map=smap)[0] == SERVED_ALL
 
+
 def test_sapphire_26(client, tmp_path):
     """test dynamic response with bad callbacks"""
     test_dr = _TestFile("dynm_test")
@@ -532,10 +597,13 @@ def test_sapphire_26(client, tmp_path):
         with pytest.raises(TypeError):
             serv.serve_path(str(tmp_path), server_map=smap)
 
+
 def test_sapphire_27(client, tmp_path):
     """test serving to a slow client"""
     t_data = "".join(random.choice("ABCD1234") for _ in range(0x19000))  # 100KB
-    t_file = _create_test("test_case.html", tmp_path, data=t_data.encode("ascii"), calc_hash=True)
+    t_file = _create_test(
+        "test_case.html", tmp_path, data=t_data.encode("ascii"), calc_hash=True
+    )
     # rx_size 10KB and throttle to 0.25 sec, which will be ~50KB/s
     # also taking 2.5 seconds to complete will hopefully find problems
     # with any assumptions that were made
@@ -548,19 +616,25 @@ def test_sapphire_27(client, tmp_path):
     assert t_file.len_srv == t_file.len_org
     assert t_file.md5_srv == t_file.md5_org
 
+
 def test_sapphire_28(client, tmp_path):
     """test timeout while requesting multiple files"""
     files_to_serve = list()
     t_data = "".join(random.choice("ABCD1234") for _ in range(1024)).encode("ascii")
     for i in range(50):
-        files_to_serve.append(_create_test("test_case_%03d.html" % i, tmp_path, data=t_data))
+        files_to_serve.append(
+            _create_test("test_case_%03d.html" % i, tmp_path, data=t_data)
+        )
     client.rx_size = 512
     with Sapphire(timeout=1) as serv:  # minimum timeout is 1 second
-        client.launch("127.0.0.1", serv.port, files_to_serve, indicate_failure=True, throttle=0.1)
+        client.launch(
+            "127.0.0.1", serv.port, files_to_serve, indicate_failure=True, throttle=0.1
+        )
         status, files_served = serv.serve_path(str(tmp_path))
     assert status == SERVED_TIMEOUT
     assert len(files_served) < len(files_to_serve)
 
+
 def test_sapphire_29(client_factory, tmp_path):
     """test Sapphire.serve_path() with forever=True"""
     clients = list()
@@ -571,10 +645,15 @@ def test_sapphire_29(client_factory, tmp_path):
             clients.append(client_factory())
         for client in clients:
             client.launch("127.0.0.1", serv.port, [test], skip_served=False)
+
         def _test_callback():
             with test.lock:
                 return test.requested < 3
-        assert serv.serve_path(str(tmp_path), continue_cb=_test_callback, forever=True)[0] == SERVED_ALL
+
+        assert (
+            serv.serve_path(str(tmp_path), continue_cb=_test_callback, forever=True)[0]
+            == SERVED_ALL
+        )
     for client in clients:
         assert client.wait(timeout=10)
         client.close()
@@ -582,19 +661,22 @@ def _test_callback():
     assert test.code == 200
     assert test.len_srv == test.len_org
 
+
 def test_sapphire_30(client, tmp_path):
     """test interesting file names"""
     to_serve = [
         # space in file name
         _create_test("test case.html", tmp_path),
         # non-alphanumeric chars (valid characters to use on filesystem)
-        _create_test("!@#$%^&(_+-=[]),;'~`{}", tmp_path)]
+        _create_test("!@#$%^&(_+-=[]),;'~`{}", tmp_path),
+    ]
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, to_serve)
         assert serv.serve_path(str(tmp_path))[0] == SERVED_ALL
     assert client.wait(timeout=10)
     assert all(t_file.code == 200 for t_file in to_serve)
 
+
 def test_sapphire_31(client, tmp_path):
     """test interesting path string"""
     all_bytes = "".join(chr(i) for i in range(256))
@@ -602,13 +684,17 @@ def test_sapphire_31(client, tmp_path):
         # should not trigger crash
         _TestFile(all_bytes),
         # used to keep server running
-        _create_test("a.html", tmp_path)]
+        _create_test("a.html", tmp_path),
+    ]
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, to_serve, in_order=True)
-        assert serv.serve_path(str(tmp_path), optional_files=[all_bytes])[0] == SERVED_ALL
+        assert (
+            serv.serve_path(str(tmp_path), optional_files=[all_bytes])[0] == SERVED_ALL
+        )
     assert client.wait(timeout=10)
     assert all(t_file.code is not None for t_file in to_serve)
 
+
 def test_sapphire_32(mocker):
     """test Sapphire._create_listening_socket()"""
     fake_sleep = mocker.patch("sapphire.core.sleep", autospec=True)
@@ -637,6 +723,7 @@ def test_sapphire_32(mocker):
     assert fake_sock.return_value.listen.call_count == 1
     assert fake_sleep.call_count == 1
 
+
 def test_sapphire_33(mocker):
     """test Sapphire.clear_backlog()"""
     mocker.patch("sapphire.core.socket", autospec=True)
@@ -650,13 +737,10 @@ def test_sapphire_33(mocker):
         assert serv._socket.settimeout.call_count == 2
     assert pending.close.call_count == 1
 
+
 def test_main_01(mocker, tmp_path):
     """test Sapphire.main()"""
-    args = mocker.Mock(
-        path=str(tmp_path),
-        port=4536,
-        remote=False,
-        timeout=None)
+    args = mocker.Mock(path=str(tmp_path), port=4536, remote=False, timeout=None)
     fake_srv = mocker.patch("sapphire.core.Sapphire.serve_path", autospec=True)
     fake_srv.return_value = (SERVED_ALL, None)
     Sapphire.main(args)
diff --git a/sapphire/test_server_map.py b/sapphire/test_server_map.py
index a25c16c0..5bb5fa9b 100644
--- a/sapphire/test_server_map.py
+++ b/sapphire/test_server_map.py
@@ -16,10 +16,13 @@ def test_servermap_01():
     assert not srv_map.include
     assert not srv_map.redirect
 
+
 def test_servermap_02(tmp_path):
     """test ServerMap dynamic responses"""
+
     def fake_cb():
         pass
+
     srv_map = ServerMap()
     srv_map.set_dynamic_response("url_01", fake_cb, mime_type="test/type")
     assert len(srv_map.dynamic) == 1
@@ -36,6 +39,7 @@ def fake_cb():
     with pytest.raises(MapCollisionError):
         srv_map.set_redirect("url_01", "test_file")
 
+
 def test_servermap_03(tmp_path):
     """test ServerMap includes"""
     srv_map = ServerMap()
@@ -47,12 +51,12 @@ def test_servermap_03(tmp_path):
     assert "url_01" in srv_map.include
     assert srv_map.include["url_01"].target == str(tmp_path)
     # overwrite existing
-    inc1 = (tmp_path / "includes" / "a")
+    inc1 = tmp_path / "includes" / "a"
     inc1.mkdir(parents=True)
     srv_map.set_include("url_01", str(inc1))
     assert srv_map.include["url_01"].target == str(inc1)
     # add another
-    inc2 = (tmp_path / "includes" / "b")
+    inc2 = tmp_path / "includes" / "b"
     inc2.mkdir()
     srv_map.set_include("url_02", str(inc2))
     assert len(srv_map.include) == 2
@@ -65,11 +69,12 @@ def test_servermap_03(tmp_path):
     # test overlapping includes
     with pytest.raises(MapCollisionError, match=r"'url_01' and '\w+' include"):
         srv_map.set_include("url_01", str(tmp_path))
-    inc3 = (tmp_path / "includes" / "b" / "c")
+    inc3 = tmp_path / "includes" / "b" / "c"
     inc3.mkdir()
     with pytest.raises(MapCollisionError, match=r"'url_01' and '\w+' include"):
         srv_map.set_include("url_01", str(inc3))
 
+
 def test_servermap_04(tmp_path):
     """test ServerMap redirects"""
     srv_map = ServerMap()
@@ -88,6 +93,7 @@ def test_servermap_04(tmp_path):
     with pytest.raises(MapCollisionError):
         srv_map.set_dynamic_response("url_01", lambda: 0, mime_type="test/type")
 
+
 def test_servermap_05():
     """test ServerMap._check_url()"""
     assert ServerMap._check_url("test") == "test"
diff --git a/sapphire/test_worker.py b/sapphire/test_worker.py
index a910bd6c..feb6ae92 100644
--- a/sapphire/test_worker.py
+++ b/sapphire/test_worker.py
@@ -34,16 +34,16 @@ def test_worker_01(mocker):
     assert worker._thread is None
     assert worker.done
 
+
 def test_worker_02(mocker):
     """test simple Worker fails to close"""
-    worker = Worker(
-        mocker.Mock(spec=socket.socket),
-        mocker.Mock(spec=threading.Thread))
+    worker = Worker(mocker.Mock(spec=socket.socket), mocker.Mock(spec=threading.Thread))
     # it is assumed that launch() has already been called at this point
     worker._thread.is_alive.return_value = True
     with pytest.raises(WorkerError, match="Worker thread failed to join!"):
         worker.close()
 
+
 def test_worker_03(mocker):
     """test Worker.launch() fail cases"""
     serv_con = mocker.Mock(spec=socket.socket)
@@ -63,6 +63,7 @@ def test_worker_03(mocker):
     assert serv_job.accepting.clear.call_count == 0
     assert serv_job.accepting.set.call_count == 1
 
+
 def test_worker_04(mocker, tmp_path):
     """test Worker.launch()"""
     (tmp_path / "testfile").touch()
@@ -81,6 +82,7 @@ def test_worker_04(mocker, tmp_path):
     assert serv_sock.accept.call_count == 1
     assert clnt_sock.close.call_count == 2
 
+
 def test_worker_05(mocker):
     """test Worker.handle_request() socket errors"""
     serv_con = mocker.Mock(spec=socket.socket)
@@ -91,17 +93,20 @@ def test_worker_05(mocker):
     assert serv_con.sendall.call_count == 0
     assert serv_con.close.call_count == 1
 
+
 def test_response_data_01():
     """test _200_header()"""
     output = Worker._200_header(10, "text/html")
     assert b"Content-Length: 10" in output
     assert b"Content-Type: text/html" in output
 
+
 def test_response_data_02():
     """test _307_redirect()"""
     output = Worker._307_redirect("http://some.test.url")
     assert b"Location: http://some.test.url" in output
 
+
 def test_response_data_03():
     """test _4xx_page() without close timeout"""
     output = Worker._4xx_page(400, "Bad Request")
@@ -109,6 +114,7 @@ def test_response_data_03():
     assert b"HTTP/1.1 400 Bad Request" in output
     assert b"400!" in output
 
+
 def test_response_data_04():
     """test _4xx_page() with close timeout"""
     output = Worker._4xx_page(404, "Not Found", close=10)
diff --git a/sapphire/worker.py b/sapphire/worker.py
index 268b481d..a930e144 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -42,18 +42,22 @@ def __init__(self, conn, thread):
     @staticmethod
     def _200_header(c_length, c_type, encoding="ascii"):
         assert c_type is not None
-        data = "HTTP/1.1 200 OK\r\n" \
-               "Cache-Control: max-age=0, no-cache\r\n" \
-               "Content-Length: %d\r\n" \
-               "Content-Type: %s\r\n" \
-               "Connection: close\r\n\r\n" % (c_length, c_type)
+        data = (
+            "HTTP/1.1 200 OK\r\n"
+            "Cache-Control: max-age=0, no-cache\r\n"
+            "Content-Length: %d\r\n"
+            "Content-Type: %s\r\n"
+            "Connection: close\r\n\r\n" % (c_length, c_type)
+        )
         return data.encode(encoding)
 
     @staticmethod
     def _307_redirect(redirct_to, encoding="ascii"):
-        data = "HTTP/1.1 307 Temporary Redirect\r\n" \
-               "Location: %s\r\n" \
-               "Connection: close\r\n\r\n" % (redirct_to,)
+        data = (
+            "HTTP/1.1 307 Temporary Redirect\r\n"
+            "Location: %s\r\n"
+            "Connection: close\r\n\r\n" % (redirct_to,)
+        )
         return data.encode(encoding)
 
     @staticmethod
@@ -61,14 +65,18 @@ def _4xx_page(code, hdr_msg, close=-1, encoding="ascii"):
         if close < 0:
             content = "<h3>%d!</h3>" % (code,)
         else:
-            content = "<script>window.setTimeout(window.close, %d)</script>\n" \
-                      "<body style=\"background-color:#ffffe0\">\n" \
-                      "<h3>%d! - Calling window.close() in %d seconds</h3>\n" \
-                      "</body>\n" % (close * 1000, code, close)
-        data = "HTTP/1.1 %d %s\r\n" \
-               "Content-Length: %d\r\n" \
-               "Content-Type: text/html\r\n" \
-               "Connection: close\r\n\r\n%s" % (code, hdr_msg, len(content), content)
+            content = (
+                "<script>window.setTimeout(window.close, %d)</script>\n"
+                '<body style="background-color:#ffffe0">\n'
+                "<h3>%d! - Calling window.close() in %d seconds</h3>\n"
+                "</body>\n" % (close * 1000, code, close)
+            )
+        data = (
+            "HTTP/1.1 %d %s\r\n"
+            "Content-Length: %d\r\n"
+            "Content-Type: text/html\r\n"
+            "Connection: close\r\n\r\n%s" % (code, hdr_msg, len(content), content)
+        )
         return data.encode(encoding)
 
     def close(self):
@@ -102,7 +110,11 @@ def handle_request(cls, conn, serv_job):
             if request is None:
                 serv_job.accepting.set()
                 conn.sendall(cls._4xx_page(400, "Bad Request", serv_job.auto_close))
-                LOG.debug("400 request length %d (%d to go)", len(raw_request), serv_job.pending)
+                LOG.debug(
+                    "400 request length %d (%d to go)",
+                    len(raw_request),
+                    serv_job.pending,
+                )
                 return
 
             request = unquote_plus(request.group("request").decode("ascii"))
@@ -134,7 +146,9 @@ def handle_request(cls, conn, serv_job):
             if resource.type in (Resource.URL_FILE, Resource.URL_INCLUDE):
                 LOG.debug("target %r", resource.target)
                 # isfile() check for Resource.URL_FILE happens in serv_job.check_request()
-                if resource.type == Resource.URL_INCLUDE and not isfile(resource.target):
+                if resource.type == Resource.URL_INCLUDE and not isfile(
+                    resource.target
+                ):
                     conn.sendall(cls._4xx_page(404, "Not Found", serv_job.auto_close))
                     LOG.debug("404 %r (%d to go)", request, serv_job.pending)
                     return
@@ -147,7 +161,12 @@ def handle_request(cls, conn, serv_job):
                     return
             elif resource.type == Resource.URL_REDIRECT:
                 conn.sendall(cls._307_redirect(resource.target))
-                LOG.debug("307 %r -> %r (%d to go)", request, resource.target, serv_job.pending)
+                LOG.debug(
+                    "307 %r -> %r (%d to go)",
+                    request,
+                    resource.target,
+                    serv_job.pending,
+                )
                 return
             elif resource.type == Resource.URL_DYNAMIC:
                 data = resource.target()
@@ -156,13 +175,17 @@ def handle_request(cls, conn, serv_job):
                     raise TypeError("dynamic request callback must return 'bytes'")
                 conn.sendall(cls._200_header(len(data), resource.mime))
                 conn.sendall(data)
-                LOG.debug("200 %r - dynamic request (%d to go)", request, serv_job.pending)
+                LOG.debug(
+                    "200 %r - dynamic request (%d to go)", request, serv_job.pending
+                )
                 return
 
             # at this point we know "resource.target" maps to a file on disk
             # serve the file
             data_size = stat(resource.target).st_size
-            LOG.debug("sending: %s bytes, mime: %r", format(data_size, ","), resource.mime)
+            LOG.debug(
+                "sending: %s bytes, mime: %r", format(data_size, ","), resource.mime
+            )
             with open(resource.target, "rb") as in_fp:
                 conn.sendall(cls._200_header(data_size, resource.mime))
                 offset = 0
diff --git a/tox.ini b/tox.ini
index 8c342b20..276e3a91 100644
--- a/tox.ini
+++ b/tox.ini
@@ -32,7 +32,7 @@ allowlist_externals =
     bash
 commands =
     isort {toxinidir}
-#    black {toxinidir}
+    black {toxinidir}
     # codespell trips over the regex in 'sapphire/worker.py' saying 'sHTTP ==> https'
     # https://github.com/codespell-project/codespell/issues/1774
     # ignoring it is broken so we need to ignore the file

From ea532d9042f19b4e525a5ca1542879840bd26ac9 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 18 Mar 2021 15:01:08 -0700
Subject: [PATCH 230/531] Enable flake8

---
 grizzly/common/runner.py          | 15 +++++++++------
 grizzly/common/stack_hasher.py    |  7 ++++++-
 grizzly/common/status_reporter.py | 14 ++++++++------
 grizzly/common/test_reporter.py   |  6 ++++--
 grizzly/reduce/args.py            |  4 ++--
 grizzly/reduce/core.py            |  4 ++--
 sapphire/connection_manager.py    |  4 ++--
 sapphire/core.py                  |  2 +-
 sapphire/worker.py                |  2 +-
 tox.ini                           |  2 +-
 10 files changed, 36 insertions(+), 24 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 971c73e7..b8b77c75 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -18,13 +18,16 @@
 
 LOG = getLogger(__name__)
 
-# _IdleChecker is used to help determine if the target is hung (actively using CPU)
-# or if it has not made expected the HTTP requests for other reasons (idle).
-# This will allow the framework to move on without interrupting execution of
-# long running test cases.
-# This is not perfect! It is to be used AFTER the test case timeout
-# (initial_delay) has elapsed.
+
 class _IdleChecker:
+    """_IdleChecker is used to help determine if the target is hung (actively using CPU)
+    or if it has not made expected the HTTP requests for other reasons (idle).
+    This will allow the framework to move on without interrupting execution of long
+    running test cases.
+    This is not perfect! It is to be used AFTER the test case timeout (initial_delay)
+    has elapsed.
+    """
+
     __slots__ = ("_check_cb", "_init_delay", "_poll_delay", "_threshold", "_next_poll")
 
     def __init__(self, check_cb, threshold, initial_delay, poll_delay=1):
diff --git a/grizzly/common/stack_hasher.py b/grizzly/common/stack_hasher.py
index 1374ceac..b7857ae5 100644
--- a/grizzly/common/stack_hasher.py
+++ b/grizzly/common/stack_hasher.py
@@ -178,7 +178,12 @@ def _parse_rust(cls, input_line):
         # Don't bother with the file offset stuff atm
         # m = cls._re_rust_file.match(input_line) if frame is None else None
         # if m is not None:
-        #    frame = {"function":None, "mode":cls.MODE_RUST, "offset":None, "stack_line":None}
+        #    frame = {
+        #        "function": None,
+        #        "mode": cls.MODE_RUST,
+        #        "offset": None,
+        #        "stack_line": None,
+        #    }
         #    input_line = m.group("line").strip()
         #    if ":" in input_line:
         #        frame["location"], frame["offset"] = input_line.rsplit(":", 1)
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 13ebff2b..b986eb71 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -72,13 +72,13 @@ def has_results(self):
 
     @classmethod
     def load(cls, tb_path=None):
-        """Read Grizzly status reports and create a StatusReporter object
+        """Read Grizzly status reports and create a StatusReporter object.
 
         Args:
-            tb_path (str): Directory to scan for files containing Python tracebacks
+            tb_path (str): Directory to scan for files containing Python tracebacks.
 
         Returns:
-            StatusReporter: Contains status reports and traceback reports that were found
+            StatusReporter: Contains available status reports and traceback reports.
         """
         if tb_path is not None and not os.path.isdir(tb_path):
             raise OSError("%r is not a directory" % (tb_path,))
@@ -307,10 +307,11 @@ def _tracebacks(path, ignore_kbi=True, max_preceeding=5):
         Args:
             path (str): Directory containing log files.
             ignore_kbi (bool): Do not include KeyboardInterupts in results
-            max_preceeding (int): Maximum number of lines preceding traceback to include.
+            max_preceeding (int): Maximum number of lines preceding traceback to
+                                  include.
 
         Returns:
-            list: A list of TracebackReports
+            list: A list of TracebackReports.
         """
         tracebacks = list()
         for screen_log in StatusReporter._scan(path, re.compile(r"screenlog\.\d+")):
@@ -345,7 +346,8 @@ def from_file(cls, input_log, max_preceeding=5):
 
         Args:
             input_log (str): File to parse.
-            max_preceeding (int): Number of lines to collect leading up to the traceback.
+            max_preceeding (int): Number of lines to collect leading up to the
+                                  traceback.
 
         Returns:
             TracebackReport: Contains data from input_log.
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index b9400138..81da417c 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -163,10 +163,12 @@ def test_report_07(tmp_path):
         log_fp.write(b"GPU|||\n")
         log_fp.write(b"Crash|DUMP_REQUESTED|0x7f57ac9e2e14|0\n")
         log_fp.write(
-            b"0|0|foo.so|google_breakpad::ExceptionHandler::WriteMinidump|bar.cc:234|674|0xc\n"
+            b"0|0|foo.so|google_breakpad::ExceptionHandler::WriteMinidump|"
+            b"bar.cc:234|674|0xc\n"
         )
         log_fp.write(
-            b"0|1|foo.so|google_breakpad::ExceptionHandler::WriteMinidump|bar.cc:4a2|645|0x8\n"
+            b"0|1|foo.so|google_breakpad::ExceptionHandler::WriteMinidump|"
+            b"bar.cc:4a2|645|0x8\n"
         )
     with (tmp_path / "log_minidump_03.txt").open("wb") as log_fp:
         log_fp.write(b"GPU|||\n")
diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 15499906..d4b8608b 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -108,8 +108,8 @@ def __init__(self):
         # instead of a local testcase.
         # This is not possible with the public argparse API.
         #
-        # refs: https://stackoverflow.com/questions/32807319/disable-remove-argument-in-argparse
-        #       https://bugs.python.org/issue19462
+        # refs: stackoverflow.com/questions/32807319/disable-remove-argument-in-argparse
+        #       bugs.python.org/issue19462
 
         # look up the action for the positional `input` arg
         action = None
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 633784e9..31dbeeb9 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -251,7 +251,7 @@ def run_reliability_analysis(self, stats):
                 # Don't test without harness if harness found > 50% crashes
                 continue
             if last_test_only and len(self.testcases) == 1:
-                # Only set `last_test_only` if we have more than one testcase to begin with
+                # Only set `last_test_only` if we initially have more than one testcase
                 continue
             if not use_harness and (not last_test_only and len(self.testcases) > 1):
                 # Can't run without harness if we have more than one testcase
@@ -520,7 +520,7 @@ def run(self, repeat=1, min_results=1):
                                         and self._signature_desc is None
                                     ):
                                         self._signature_desc = (
-                                            first_expected.report.crash_info.createShortSignature()
+                                            first_expected.report.crash_info.createShortSignature()  # noqa: E501
                                         )
                                 served = None
                                 if success and not self._any_crash:
diff --git a/sapphire/connection_manager.py b/sapphire/connection_manager.py
index f3ca796b..daf6dbf1 100644
--- a/sapphire/connection_manager.py
+++ b/sapphire/connection_manager.py
@@ -115,8 +115,8 @@ def listener(serv_sock, serv_job, max_workers, shutdown_delay=0):
                     serv_job.worker_complete.clear()
                     # remove complete workers
                     LOG.debug("trimming worker pool")
-                    # sometimes the thread that triggered the event doesn't quite cleanup in time
-                    # so add a retry (10x with 0.5 second sleep on failure)
+                    # sometimes the thread that triggered the event doesn't quite
+                    # cleanup in time, so retry (10x with 0.5 second sleep on failure)
                     for _ in range(10):
                         worker_pool = list(w for w in worker_pool if not w.done)
                         pool_size = len(worker_pool)
diff --git a/sapphire/core.py b/sapphire/core.py
index b2b7d7a8..caf8cb20 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -65,7 +65,7 @@ def _create_listening_socket(cls, remote, port=None, retries=20):
                 sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
                 sock.settimeout(cls.LISTEN_TIMEOUT)
                 # find an unused port and avoid blocked ports
-                # see: dxr.mozilla.org/mozilla-central/source/netwerk/base/nsIOService.cpp
+                # see: searchfox.org/mozilla-central/source/netwerk/base/nsIOService.cpp
                 sock.bind((addr, port or randint(0x2000, 0xFFFF)))
                 sock.listen(5)
             except OSError as soc_e:
diff --git a/sapphire/worker.py b/sapphire/worker.py
index a930e144..9fea2d9e 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -145,7 +145,7 @@ def handle_request(cls, conn, serv_job):
                 return
             if resource.type in (Resource.URL_FILE, Resource.URL_INCLUDE):
                 LOG.debug("target %r", resource.target)
-                # isfile() check for Resource.URL_FILE happens in serv_job.check_request()
+                # isfile() check for Resource.URL_FILE done by serv_job.check_request()
                 if resource.type == Resource.URL_INCLUDE and not isfile(
                     resource.target
                 ):
diff --git a/tox.ini b/tox.ini
index 276e3a91..be7ea615 100644
--- a/tox.ini
+++ b/tox.ini
@@ -40,7 +40,7 @@ commands =
 #    pylint {toxinidir}/grizzly
 #    pylint {toxinidir}/loki
 #    pylint {toxinidir}/sapphire
-#    flake8 {toxinidir}
+    flake8 {toxinidir}
 deps =
     black
     codespell

From c76693e4d7f182b3a60644721aa88c95d1446e22 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 18 Mar 2021 17:05:27 -0700
Subject: [PATCH 231/531] Enable pylint

---
 grizzly/adapters/NoOpAdapter/__init__.py |   2 +
 grizzly/adapters/__init__.py             |   2 -
 grizzly/args.py                          |   2 +-
 grizzly/common/reporter.py               |  13 ++-
 grizzly/common/stack_hasher.py           | 125 ++++++++++++-----------
 grizzly/common/storage.py                |   8 +-
 grizzly/common/test_adapter.py           |   2 +-
 grizzly/common/test_reporter.py          |   4 +-
 grizzly/common/test_storage.py           |   2 +-
 grizzly/reduce/core.py                   |   2 +
 grizzly/reduce/test_reduce.py            |   4 -
 grizzly/target/target.py                 |   8 +-
 grizzly/target/test_target.py            |   2 +-
 grizzly/test_main.py                     |   2 +-
 pyproject.toml                           |   8 +-
 sapphire/worker.py                       |   1 +
 tox.ini                                  |   6 +-
 17 files changed, 100 insertions(+), 93 deletions(-)

diff --git a/grizzly/adapters/NoOpAdapter/__init__.py b/grizzly/adapters/NoOpAdapter/__init__.py
index 271d49d1..21d9049a 100644
--- a/grizzly/adapters/NoOpAdapter/__init__.py
+++ b/grizzly/adapters/NoOpAdapter/__init__.py
@@ -1,6 +1,8 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# pylint: disable=invalid-name
+
 from grizzly.common import Adapter
 
 __author__ = "Tyson Smith"
diff --git a/grizzly/adapters/__init__.py b/grizzly/adapters/__init__.py
index b71ae222..248f3226 100644
--- a/grizzly/adapters/__init__.py
+++ b/grizzly/adapters/__init__.py
@@ -66,8 +66,6 @@ def load(path=None, skip_failures=True):
                         % (cls.NAME, __adapters__[cls.NAME].__name__, cls.__name__)
                     )
                 __adapters__[cls.NAME] = cls
-        else:
-            LOG.debug("ignored %r", sub)
     LOG.debug("%d adapters loaded", len(__adapters__))
 
 
diff --git a/grizzly/args.py b/grizzly/args.py
index cd7a635f..b53830a7 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -159,7 +159,7 @@ def parse_args(self, argv=None):
 
     def sanity_check(self, args):
         if hasattr(super(), "sanity_check"):
-            super().sanity_check(args)
+            super().sanity_check(args)  # pylint: disable=no-member
 
         if "binary" not in self._sanity_skip and not isfile(args.binary):
             self.parser.error("file not found: %r" % args.binary)
diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 9159c931..e90fe91b 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -477,6 +477,7 @@ class FilesystemReporter(Reporter):
 
     def __init__(self, report_path, major_bucket=True):
         self.major_bucket = major_bucket
+        self.min_space = FilesystemReporter.DISK_SPACE_ABORT
         assert isinstance(report_path, str) and report_path
         self.report_path = report_path
 
@@ -507,7 +508,7 @@ def _submit_report(self, report, test_cases):
         move(report.path, log_path)
         # avoid filling the disk
         free_space = disk_usage(log_path).free
-        if free_space < self.DISK_SPACE_ABORT:
+        if free_space < self.min_space:
             raise RuntimeError(
                 "Running low on disk space (%0.1fMB)" % (free_space / 1048576.0,)
             )
@@ -533,6 +534,7 @@ class FuzzManagerReporter(Reporter):
     def __init__(self, tool=None):
         self._extra_metadata = {}
         self.force_report = False
+        self.max_reports = FuzzManagerReporter.MAX_REPORTS
         self.quality = self.QUAL_UNREDUCED
         self.tool = tool  # optional tool name
 
@@ -652,7 +654,7 @@ def _submit_report(self, report, test_cases):
                 raise RuntimeError("Failed to create FM signature")
             # limit the number of times we report per cycle
             cache_metadata["_grizzly_seen_count"] += 1
-            if cache_metadata["_grizzly_seen_count"] >= self.MAX_REPORTS:
+            if cache_metadata["_grizzly_seen_count"] >= self.max_reports:
                 # we will still report this one, but no more
                 cache_metadata["frequent"] = True
             metadata_file = cache_sig_file.replace(".signature", ".metadata")
@@ -751,11 +753,12 @@ def _process_rr_trace(self, report):
         s3_bucket = getenv("GRZ_S3_BUCKET")
         assert s3_bucket is not None
         # check for existing minor hash in S3
-        s3 = resource("s3")
+        s3_res = resource("s3")
         s3_key = "rr-%s.tar.bz2" % (report.minor,)
         s3_url = "http://%s.s3.amazonaws.com/%s" % (s3_bucket, s3_key)
         try:
-            s3.Object(s3_bucket, s3_key).load()  # HEAD, doesn't fetch the whole object
+            # HEAD, doesn't fetch the whole object
+            s3_res.Object(s3_bucket, s3_key).load()
         except ClientError as exc:
             if exc.response["Error"]["Code"] == "404":
                 # The object does not exist.
@@ -773,7 +776,7 @@ def _process_rr_trace(self, report):
 
         # Upload to S3
         rr_arc = self.compress_rr_trace(trace_path, report.path)
-        s3.meta.client.upload_file(
+        s3_res.meta.client.upload_file(
             rr_arc, s3_bucket, s3_key, ExtraArgs={"ACL": "public-read"}
         )
         unlink(rr_arc)
diff --git a/grizzly/common/stack_hasher.py b/grizzly/common/stack_hasher.py
index b7857ae5..93321a44 100644
--- a/grizzly/common/stack_hasher.py
+++ b/grizzly/common/stack_hasher.py
@@ -104,18 +104,18 @@ def from_line(cls, input_line, parse_mode=None):
     def _parse_gdb(cls, input_line):
         if "#" not in input_line:
             return None
-        m = cls._re_gdb.match(input_line)
-        if m is None:
+        match = cls._re_gdb.match(input_line)
+        if match is None:
             return None
-        input_line = m.group("line").strip()
+        input_line = match.group("line").strip()
         if not input_line:
             return None
-        sframe = cls(mode=cls.MODE_GDB, stack_line=m.group("num"))
+        sframe = cls(mode=cls.MODE_GDB, stack_line=match.group("num"))
         # sframe.offset = m.group("off")  # ignore binary offset for now
         # find function/method name
-        m = cls._re_func_name.match(input_line)
-        if m is not None:
-            sframe.function = m.group("func")
+        match = cls._re_func_name.match(input_line)
+        if match is not None:
+            sframe.function = match.group("func")
         # find file name and line number
         if ") at " in input_line:
             input_line = input_line.split(") at ")[-1]
@@ -163,28 +163,30 @@ def _parse_minidump(cls, input_line):
     def _parse_rr(cls, input_line):
         if "rr(" not in input_line:
             return None
-        m = cls._re_rr.match(input_line)
-        if m is None:
+        match = cls._re_rr.match(input_line)
+        if match is None:
             return None
-        return cls(location=m.group("loc"), mode=cls.MODE_RR, offset=m.group("off"))
+        return cls(
+            location=match.group("loc"), mode=cls.MODE_RR, offset=match.group("off")
+        )
 
     @classmethod
     def _parse_rust(cls, input_line):
-        m = cls._re_rust_frame.match(input_line)
-        if m is None:
+        match = cls._re_rust_frame.match(input_line)
+        if match is None:
             return None
-        sframe = cls(mode=cls.MODE_RUST, stack_line=m.group("num"))
-        sframe.function = m.group("line").strip().rsplit("::h", 1)[0]
+        sframe = cls(mode=cls.MODE_RUST, stack_line=match.group("num"))
+        sframe.function = match.group("line").strip().rsplit("::h", 1)[0]
         # Don't bother with the file offset stuff atm
-        # m = cls._re_rust_file.match(input_line) if frame is None else None
-        # if m is not None:
+        # match = cls._re_rust_file.match(input_line) if frame is None else None
+        # if match is not None:
         #    frame = {
         #        "function": None,
         #        "mode": cls.MODE_RUST,
         #        "offset": None,
         #        "stack_line": None,
         #    }
-        #    input_line = m.group("line").strip()
+        #    input_line = match.group("line").strip()
         #    if ":" in input_line:
         #        frame["location"], frame["offset"] = input_line.rsplit(":", 1)
         #    else:
@@ -195,17 +197,17 @@ def _parse_rust(cls, input_line):
     def _parse_sanitizer(cls, input_line):
         if "#" not in input_line:
             return None
-        m = cls._re_sanitizer.match(input_line)
-        if m is None:
+        match = cls._re_sanitizer.match(input_line)
+        if match is None:
             return None
-        sframe = cls(mode=cls.MODE_SANITIZER, stack_line=m.group("num"))
-        input_line = m.group("line")
+        sframe = cls(mode=cls.MODE_SANITIZER, stack_line=match.group("num"))
+        input_line = match.group("line")
         # check if line is symbolized
-        if m.group("in"):
+        if match.group("in"):
             # find function/method name
-            m = cls._re_func_name.match(input_line)
-            if m is not None:
-                sframe.function = m.group("func")
+            match = cls._re_func_name.match(input_line)
+            if match is not None:
+                sframe.function = match.group("func")
         if input_line.startswith("("):
             input_line = input_line.strip("()")
         # find location (file name or module) and offset (line # or offset)
@@ -221,11 +223,11 @@ def _parse_sanitizer(cls, input_line):
     def _parse_tsan(cls, input_line):
         if "#" not in input_line:
             return None
-        m = cls._re_tsan.match(input_line)
-        if m is None:
+        match = cls._re_tsan.match(input_line)
+        if match is None:
             return None
-        sframe = cls(mode=cls.MODE_TSAN, stack_line=m.group("num"))
-        input_line = m.group("line")
+        sframe = cls(mode=cls.MODE_TSAN, stack_line=match.group("num"))
+        input_line = match.group("line")
         location = basename(input_line)
         # try to parse file name and line number
         if location:
@@ -236,13 +238,13 @@ def _parse_tsan(cls, input_line):
                     sframe.offset = location.pop(0)
         # use module name if file name cannot be found
         if not sframe.location:
-            sframe.location = m.group("mod")
+            sframe.location = match.group("mod")
         # use module offset if line number cannot be found
         if not sframe.offset:
-            sframe.offset = m.group("off")
-        m = cls._re_func_name.match(input_line)
-        if m is not None:
-            function = m.group("func")
+            sframe.offset = match.group("off")
+        match = cls._re_func_name.match(input_line)
+        if match is not None:
+            function = match.group("func")
             if function and function != "<null>":
                 sframe.function = function
         return sframe
@@ -251,15 +253,15 @@ def _parse_tsan(cls, input_line):
     def _parse_valgrind(cls, input_line):
         if "== " not in input_line:
             return None
-        m = cls._re_valgrind.match(input_line)
-        if m is None:
+        match = cls._re_valgrind.match(input_line)
+        if match is None:
             return None
-        input_line = m.group("line")
+        input_line = match.group("line")
         if input_line is None:  # pragma: no cover
             # this should not happen
             LOG.warning("failure in _parse_valgrind()")
             return None
-        sframe = cls(function=m.group("func"), mode=cls.MODE_VALGRIND)
+        sframe = cls(function=match.group("func"), mode=cls.MODE_VALGRIND)
         try:
             location, sframe.offset = input_line.split(":")
             sframe.location = location.strip()
@@ -291,7 +293,7 @@ def __str__(self):
     def _calculate_hash(self, major=False):
         if not self.frames or (major and self._major_depth < 1):
             return None
-        h = sha1()
+        shash = sha1()
         if self._height_limit is None:
             offset = 0
         else:
@@ -300,16 +302,16 @@ def _calculate_hash(self, major=False):
             if major and depth > self._major_depth:
                 break
             if frame.location is not None:
-                h.update(frame.location.encode("utf-8", errors="ignore"))
+                shash.update(frame.location.encode("utf-8", errors="ignore"))
             if frame.function is not None:
-                h.update(frame.function.encode("utf-8", errors="ignore"))
+                shash.update(frame.function.encode("utf-8", errors="ignore"))
             if major and depth > 1:
                 # only add the offset from the top frame when calculating
                 # the major hash and skip the rest
                 continue
             if frame.offset is not None:
-                h.update(frame.offset.encode("utf-8", errors="ignore"))
-        return h.hexdigest()
+                shash.update(frame.offset.encode("utf-8", errors="ignore"))
+        return shash.hexdigest()
 
     def from_file(self, file_name):  # pragma: no cover
         raise NotImplementedError()  # TODO
@@ -406,24 +408,25 @@ def minor(self):
     from argparse import ArgumentParser
     from os import getenv  # pylint: disable=ungrouped-imports
 
-    parser = ArgumentParser()
-    parser.add_argument("input", help="")
-    args = parser.parse_args()
-
     # set output verbosity
     if getenv("DEBUG"):
-        log_level = DEBUG
-        log_fmt = "[%(levelname).1s] %(message)s"
+        basicConfig(
+            format="[%(levelname).1s] %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+            level=DEBUG,
+        )
     else:
-        log_level = INFO
-        log_fmt = "%(message)s"
-    basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
-
-    with open(args.input, "rb") as fp:
-        stack = Stack.from_text(fp.read().decode("utf-8", errors="ignore"))
-
-    for frame in stack.frames:
-        LOG.info(frame)
-    LOG.info("Minor: %s", stack.minor)
-    LOG.info("Major: %s", stack.major)
-    LOG.info("Frames: %d", len(stack.frames))
+        basicConfig(format="%(message)s", datefmt="%Y-%m-%d %H:%M:%S", level=INFO)
+
+    def main(args):
+        with open(args.input, "rb") as in_fp:
+            stack = Stack.from_text(in_fp.read().decode("utf-8", errors="ignore"))
+        for frame in stack.frames:
+            LOG.info(frame)
+        LOG.info("Minor: %s", stack.minor)
+        LOG.info("Major: %s", stack.major)
+        LOG.info("Frames: %d", len(stack.frames))
+
+    parser = ArgumentParser()
+    parser.add_argument("input", help="File to scan for stack trace")
+    main(parser.parse_args())
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index d924a453..8549bee7 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -562,8 +562,8 @@ def clone(self):
         cloned = type(self)(self._file_name)
         self._fp.seek(0)
         copyfileobj(
-            self._fp, cloned._fp, self.XFER_BUF
-        )  # pylint: disable=protected-access
+            self._fp, cloned._fp, self.XFER_BUF  # pylint: disable=protected-access
+        )
         return cloned
 
     def close(self):
@@ -651,8 +651,8 @@ def from_file(cls, input_file, file_name=None):
         t_file = cls(file_name)
         with open(input_file, "rb") as src_fp:
             copyfileobj(
-                src_fp, t_file._fp, cls.XFER_BUF
-            )  # pylint: disable=protected-access
+                src_fp, t_file._fp, cls.XFER_BUF  # pylint: disable=protected-access
+            )
         return t_file
 
     @property
diff --git a/grizzly/common/test_adapter.py b/grizzly/common/test_adapter.py
index 3055f25c..46e78814 100644
--- a/grizzly/common/test_adapter.py
+++ b/grizzly/common/test_adapter.py
@@ -47,7 +47,7 @@ def test_adapter_03(tmp_path):
     harness_file = tmp_path / "harness.html"
     test_data = b"default_harness_data"
     harness_file.write_bytes(test_data)
-    adpt.HARNESS_FILE = str(harness_file)
+    adpt.HARNESS_FILE = str(harness_file)  # pylint: disable=invalid-name
     adpt.enable_harness()
     assert adpt.get_harness() == test_data
     # external harness
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 81da417c..58a4ad22 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -396,7 +396,7 @@ def test_filesystem_reporter_03(tmp_path):
     (log_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (log_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     reporter = FilesystemReporter(str(tmp_path / "reports"))
-    reporter.DISK_SPACE_ABORT = 2 ** 50
+    reporter.min_space = 2 ** 50
     with pytest.raises(RuntimeError, match="Running low on disk space"):
         reporter.submit([], Report(str(log_path), "fake_bin"))
 
@@ -493,7 +493,7 @@ def test_fuzzmanager_reporter_03(mocker, tmp_path):
     (log_path / "log_stderr.txt").touch()
     (log_path / "log_stdout.txt").touch()
     reporter = FuzzManagerReporter("fake_bin")
-    reporter.MAX_REPORTS = 1
+    reporter.max_reports = 1
     reporter.submit([], Report(str(log_path), "fake_bin"))
     assert fake_collector.return_value.submit.call_count == 1
     meta_data = (tmp_path / "fm_file.metadata").read_text()
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 2fe40977..2868275d 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -259,7 +259,7 @@ def test_testcase_10(tmp_path):
         loaded = TestCase.load_single(str(tmp_path), False)
         try:
             for prop in TestCase.__slots__:
-                if prop.startswith("_") or "redirect_page":
+                if prop.startswith("_") or prop == "redirect_page":
                     continue
                 assert getattr(loaded, prop) == getattr(org, prop)
             assert org._existing_paths == loaded._existing_paths
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 31dbeeb9..6e83da7d 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -520,6 +520,7 @@ def run(self, repeat=1, min_results=1):
                                         and self._signature_desc is None
                                     ):
                                         self._signature_desc = (
+                                            # pylint: disable=line-too-long
                                             first_expected.report.crash_info.createShortSignature()  # noqa: E501
                                         )
                                 served = None
@@ -700,6 +701,7 @@ def main(cls, args):
         Returns:
             int: 0 for success. non-0 indicates a problem.
         """
+        # pylint: disable=too-many-return-statements
         configure_logging(args.log_level)
         setlocale(LC_ALL, "")
         if args.fuzzmanager:
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 4da90b0c..dd9928eb 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -914,10 +914,6 @@ def replay_run(_testcases, _time_limit, **_):
             idle_delay=idle_input,
             static_timeout=static_timeout,
         )
-        mgr.IDLE_DELAY_MIN = 10
-        mgr.IDLE_DELAY_DURATION_MULTIPLIER = 1.5
-        mgr.ITER_TIMEOUT_MIN = 10
-        mgr.ITER_TIMEOUT_DURATION_MULTIPLIER = 2
         if isinstance(result, type) and issubclass(result, BaseException):
             with raises(result):
                 mgr.run()
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 50ec0576..e1d20107 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -86,7 +86,7 @@ def __enter__(self):
     def __exit__(self, *exc):
         self.cleanup()
 
-    def add_abort_token(self, token):  # pylint: disable=no-self-use,unused-argument
+    def add_abort_token(self, _token):  # pylint: disable=no-self-use
         LOG.warning("add_abort_token() not implemented!")
 
     @abstractmethod
@@ -109,7 +109,7 @@ def create_report(self, is_hang=False):
     def detect_failure(self, ignored):
         pass
 
-    def dump_coverage(self):  # pylint: disable=no-self-use
+    def dump_coverage(self, _timeout=0):  # pylint: disable=no-self-use
         LOG.warning("dump_coverage() is not supported!")
 
     @abstractmethod
@@ -117,12 +117,12 @@ def handle_hang(self, ignore_idle=True):
         pass
 
     # TODO: move to monitor?
-    def is_idle(self, threshold):  # pylint: disable=no-self-use,unused-argument
+    def is_idle(self, _threshold):  # pylint: disable=no-self-use
         LOG.debug("Target.is_idle() not implemented! returning False")
         return False
 
     @abstractmethod
-    def launch(self):
+    def launch(self, _location, _env_mod=None):
         pass
 
     def log_size(self):  # pylint: disable=no-self-use
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index bfd39b22..572b78da 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -26,7 +26,7 @@ def detect_failure(self, ignored):
     def handle_hang(self, ignore_idle=True):
         pass
 
-    def launch(self):
+    def launch(self, _location, _env_mod=None):
         pass
 
     @property
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 198136e8..70de6665 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -31,7 +31,7 @@ def __init__(self):
         self.memory = 0
         self.platform = "fake-target"
         self.prefs = None
-        self.rr = False
+        self.rr = False  # pylint: disable=invalid-name
         self.relaunch = 1000
         self.s3_fuzzmanager = False
         self.time_limit = None
diff --git a/pyproject.toml b/pyproject.toml
index 6a2166d2..e8c92190 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -28,11 +28,13 @@ max-line-length = 88
 
 [tool.pylint.messages_control]
 disable = [
-    "C0330",
-    "C0326",
-    "bad-continuation",
+    "duplicate-code",
     "fixme",
     "import-error",
+    # need to finish adding docs...
+    "missing-class-docstring",
+    "missing-function-docstring",
+    "missing-module-docstring",
     "subprocess-run-check",
     "too-few-public-methods",
     "too-many-arguments",
diff --git a/sapphire/worker.py b/sapphire/worker.py
index 9fea2d9e..d221bf57 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -97,6 +97,7 @@ def done(self):
 
     @classmethod
     def handle_request(cls, conn, serv_job):
+        # pylint: disable=too-many-return-statements
         finish_job = False  # call finish() on return
         try:
             # receive all the incoming data
diff --git a/tox.ini b/tox.ini
index be7ea615..3557d1f7 100644
--- a/tox.ini
+++ b/tox.ini
@@ -37,9 +37,9 @@ commands =
     # https://github.com/codespell-project/codespell/issues/1774
     # ignoring it is broken so we need to ignore the file
     codespell --skip=".git,.tox,htmlcov,results,./sapphire/worker.py" {toxinidir}
-#    pylint {toxinidir}/grizzly
-#    pylint {toxinidir}/loki
-#    pylint {toxinidir}/sapphire
+    pylint {toxinidir}/grizzly
+    pylint {toxinidir}/loki
+    pylint {toxinidir}/sapphire
     flake8 {toxinidir}
 deps =
     black

From 548860af251099666ce706e5790d880f3557ef1f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 18 Mar 2021 17:18:03 -0700
Subject: [PATCH 232/531] Add pre-commit config

---
 .pre-commit-config.yaml | 52 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 .pre-commit-config.yaml

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 00000000..2489c387
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,52 @@
+repos:
+  - repo: https://github.com/pycqa/isort
+    rev: 5.7.0
+    hooks:
+      - id: isort
+  - repo: https://github.com/asottile/yesqa
+    rev: v1.2.2
+    hooks:
+      - id: yesqa
+  - repo: https://github.com/ambv/black
+    rev: 20.8b1
+    hooks:
+      - id: black
+  - repo: https://github.com/pycqa/pylint
+    rev: pylint-2.7.2
+    hooks:
+      - id: pylint
+  - repo: https://gitlab.com/pycqa/flake8
+    rev: 3.9.0
+    hooks:
+      - id: flake8
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.4.0
+    hooks:
+      - id: check-ast
+      - id: check-docstring-first
+      - id: check-executables-have-shebangs
+      - id: check-merge-conflict
+      - id: check-symlinks
+      - id: debug-statements
+      - id: trailing-whitespace
+      - id: check-yaml
+      - id: mixed-line-ending
+      - id: name-tests-test
+        args: ['--django']
+      - id: check-json
+      - id: requirements-txt-fixer
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.0.0
+    hooks:
+      - id: codespell
+        exclude_types: [json]
+  - repo: https://github.com/marco-c/taskcluster_yml_validator
+    rev: v0.0.7
+    hooks:
+      - id: taskcluster_yml
+  - repo: meta
+    hooks:
+      - id: check-useless-excludes
+
+default_language_version:
+  python: python3

From 827f36ed0c622b24f96bec476ad3078030d3cd60 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 19 Mar 2021 13:17:09 -0700
Subject: [PATCH 233/531] [ci] Switch to TaskCluster

---
 .taskcluster.yml | 174 +++++++++++++++++++++++++++++++++++++++++++++++
 .travis.yml      |  37 ----------
 README.md        |   2 +-
 3 files changed, 175 insertions(+), 38 deletions(-)
 create mode 100644 .taskcluster.yml
 delete mode 100644 .travis.yml

diff --git a/.taskcluster.yml b/.taskcluster.yml
new file mode 100644
index 00000000..aa953a56
--- /dev/null
+++ b/.taskcluster.yml
@@ -0,0 +1,174 @@
+version: 1
+policy:
+  pullRequests: collaborators
+tasks:
+  $let:
+    user: ${event.sender.login}
+
+    fetch_rev:
+      $if: 'tasks_for == "github-pull-request"'
+      then: ${event.pull_request.head.sha}
+      else:
+        $if: 'tasks_for == "github-push"'
+        then: ${event.after}
+        else: ${event.release.tag_name}
+
+    fetch_ref:
+      $if: 'tasks_for == "github-pull-request"'
+      then: ${event.pull_request.head.sha}
+      else:
+        $if: 'tasks_for == "github-push"'
+        then: ${event.after}
+        else: "refs/tags/${event.release.tag_name}:refs/tags/${event.release.tag_name}"
+
+    http_repo:
+      $if: 'tasks_for == "github-pull-request"'
+      then: ${event.pull_request.base.repo.clone_url}
+      else: ${event.repository.clone_url}
+
+    codecov_secret:
+      codecov-grizzly
+
+    pypi_secret:
+      pypi-grizzly
+
+    project_name:
+      Grizzly
+
+  in:
+    $if: 'tasks_for in ["github-push", "github-release"] || (tasks_for == "github-pull-request" && event["action"] in ["opened", "reopened", "synchronize"])'
+    then:
+      $flatten:
+        - $map: []
+          #- {msys: 'NmOU83KwRJGjk-btMbOOPA', toxenv: 'py38', name: 'tests python 3.8'}
+          each(build):
+            taskId: {$eval: as_slugid(build.toxenv + '-win')}
+            provisionerId: proj-fuzzing
+            workerType: ci-windows
+            created: {$fromNow: ''}
+            deadline: {$fromNow: '1 hour'}
+            scopes:
+              - secrets:get:project/fuzzing/${codecov_secret}
+            dependencies:
+              - ${build.msys}
+            payload:
+              env:
+                MSYSTEM: MINGW64
+                TOXENV: ${build.toxenv}
+                CODECOV_SECRET: ${codecov_secret}
+                FETCH_REF: ${fetch_ref}
+                FETCH_REV: ${fetch_rev}
+                CLONE_REPO: ${http_repo}
+              mounts:
+                - format: tar.bz2
+                  content:
+                    taskId: ${build.msys}
+                    artifact: public/msys2.tar.bz2
+                  directory: .
+              command:
+                - "set HOME=%CD%"
+                - "set ARTIFACTS=%CD%"
+                - "set PATH=%CD%\\msys64\\MINGW64\\bin;%PATH%"
+                - "set PATH=%CD%\\msys64\\usr\\bin;%PATH%"
+                - >-
+                  bash -x -e -c "
+                  . py-ci.sh;
+                  clone;
+                  tox;
+                  tox_codecov;"
+              features:
+                taskclusterProxy: true
+              maxRunTime: 900
+            metadata:
+              name: ${project_name} ${build.name} (windows)
+              description: ${project_name} ${build.name} (windows)
+              owner: '${user}@users.noreply.github.com'
+              source: ${http_repo}/raw/${fetch_rev}/.taskcluster.yml
+        - $map:
+          - {image: ci-py-36, toxenv: 'py36', name: 'tests python 3.6'}
+          - {image: ci-py-37, toxenv: 'py37', name: 'tests python 3.7'}
+          - {image: ci-py-38, toxenv: 'py38', name: 'tests python 3.8'}
+          - {image: ci-py-39, toxenv: 'py39', name: 'tests python 3.9'}
+          - {image: ci-py-39, toxenv: 'lint', name: 'lint'}
+          each(build):
+            taskId: {$eval: as_slugid(build.toxenv)}
+            provisionerId: proj-fuzzing
+            workerType: ci
+            created: {$fromNow: ''}
+            deadline: {$fromNow: '1 hour'}
+            scopes:
+              - secrets:get:project/fuzzing/${codecov_secret}
+            payload:
+              maxRunTime: 900
+              image:
+                type: indexed-image
+                path: public/${build.image}.tar.zst
+                namespace: project.fuzzing.orion.${build.image}.master
+              env:
+                TOXENV: ${build.toxenv}
+                CODECOV_SECRET: ${codecov_secret}
+                FETCH_REF: ${fetch_ref}
+                FETCH_REV: ${fetch_rev}
+                CLONE_REPO: ${http_repo}
+              features:
+                taskclusterProxy: true
+              command:
+                - /bin/bash
+                - '--login'
+                - '-x'
+                - '-e'
+                - '-c'
+                - >-
+                  . py-ci.sh;
+                  clone;
+                  tox;
+                  if [[ "${build.toxenv}" != "lint" ]]; then tox_codecov; fi;
+            metadata:
+              name: ${project_name} ${build.name}
+              description: ${project_name} ${build.name}
+              owner: '${user}@users.noreply.github.com'
+              source: ${http_repo}/raw/${fetch_rev}/.taskcluster.yml
+        - $if: 'tasks_for in ["github-release"]'
+          then:
+            - provisionerId: proj-fuzzing
+              workerType: ci
+              dependencies:
+                - {$eval: as_slugid("py36")}
+                - {$eval: as_slugid("py37")}
+                - {$eval: as_slugid("py38")}
+                #- {$eval: as_slugid("py38-win")}
+                - {$eval: as_slugid("py39")}
+                - {$eval: as_slugid("lint")}
+              created: {$fromNow: ''}
+              deadline: {$fromNow: '1 hour'}
+              scopes:
+                - secrets:get:project/fuzzing/${pypi_secret}
+              payload:
+                maxRunTime: 900
+                image:
+                  type: indexed-image
+                  path: public/ci-py-38.tar.zst
+                  namespace: project.fuzzing.orion.ci-py-38.master
+                features:
+                  taskclusterProxy: true
+                env:
+                  TOXENV: pypi
+                  FETCH_REF: ${fetch_ref}
+                  FETCH_REV: ${fetch_rev}
+                  CLONE_REPO: ${http_repo}
+                  PYPI_SECRET: ${pypi_secret}
+                command:
+                  - /bin/bash
+                  - '--login'
+                  - '-x'
+                  - '-e'
+                  - '-c'
+                  - >-
+                    . py-ci.sh;
+                    clone;
+                    tox_pypi;
+              metadata:
+                name: ${project_name} PyPI upload
+                description: ${project_name} PyPI upload
+                owner: '${user}@users.noreply.github.com'
+                source: ${http_repo}/raw/${fetch_rev}/.taskcluster.yml
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 0980405f..00000000
--- a/.travis.yml
+++ /dev/null
@@ -1,37 +0,0 @@
-dist: bionic
-cache: pip
-language: python
-os: linux
-python:
-  - 3.6
-  - 3.7
-  - 3.8
-  - 3.9
-jobs:
-  include:
-    - os: windows
-      language: shell
-      before_install:
-        - choco install python --version 3.9
-      env: PATH=/c/Python39:/c/Python39/Scripts:$PATH
-before_install:
-  - pip3 install --upgrade setuptools pip
-install:
-  - pip3 install -e .[all]
-before_script:
-  - pip3 install --upgrade pytest pytest-mock pytest-pylint pytest-cov codecov
-script:
-  - pytest
-after_success:
-  - codecov
-deploy:
-  provider: pypi
-  distributions: sdist bdist_wheel
-  username: mozillasecurity
-  password:
-    secure: V3f+OpShnYZdxHSB8i6OwUMbFeqQ8NnfmYzm8s/YH4awSbn5TqjL1wQn7cqWR7trIUgUzp+RGafHy5agk7pTUM6Pj2tLb3w336c6KJmeub0vfifRFZJySjXTFN09DX64J2FD4KeiTIyOUemgQSU0jxCpwJXQrgdInHC3EEolE0loAydVdKWwYy6W5u+BPkY64zTHsEconDmc6TMqpKTI5UN4Iy/FPKTtJ4ifHUTv0uowI5JxbjgxYpzXmqD9XgtHo8k5jwPsu0QS7LuPNnDUN8sCFQ5WPJtnkE9SLfrNkCYnSzFrxJIfKbJBDZRjNp9v2Uz2jwCvvTyGKLQeVmVacLB4IwmT0ENXiDk7wtqVEO9lPXlvRVVt0w3xV5tOV8jfNcW8dookuZSzGtZ2sxWYwcro7uzNc36le6suhmJTq6w0uoj9ubcHnrbY2A181roAWPEtyCBf25lpM+C8jGmCgXEci9LhCZH79jrSgVds4jiXd+rXMo/qU86ye/6j/o7l5fnJmw/Or7dA3JsHIvYgBy9Ryh52uhCeggIcgFohgmhcRyLD5zkdLfzqNl+kY0nI12qeSAmceP8JCiUc0LX9/3e6B4X/knJ4s/ArbF5X/V4GzorE6tNxcpfwTMh4QnzraQgSAt/JhJz1QeYMMKJ0SVzAkGePNqDCWXHFGFoS+FE=
-  on:
-    branch: master
-    tags: true
-    os: linux
-    python: 3.8
diff --git a/README.md b/README.md
index 241482a8..c6c74dbe 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 Grizzly
 =======
-[![Build Status](https://travis-ci.com/MozillaSecurity/grizzly.svg?branch=master)](https://travis-ci.com/MozillaSecurity/grizzly)
+[![Task Status](https://community-tc.services.mozilla.com/api/github/v1/repository/MozillaSecurity/grizzly/master/badge.svg)](https://community-tc.services.mozilla.com/api/github/v1/repository/MozillaSecurity/grizzly/master/latest)
 [![codecov](https://codecov.io/gh/MozillaSecurity/grizzly/branch/master/graph/badge.svg)](https://codecov.io/gh/MozillaSecurity/grizzly)
 [![Matrix](https://img.shields.io/badge/dynamic/json?color=green&label=chat&query=%24.chunk[%3F(%40.canonical_alias%3D%3D%22%23fuzzing%3Amozilla.org%22)].num_joined_members&suffix=%20users&url=https%3A%2F%2Fmozilla.modular.im%2F_matrix%2Fclient%2Fr0%2FpublicRooms&style=flat&logo=matrix)](https://riot.im/app/#/room/#fuzzing:mozilla.org)
 [![PyPI](https://img.shields.io/pypi/v/grizzly-framework)](https://pypi.org/project/grizzly-framework)

From 495e5cd525faf84890cf3bd4705e1fa29edf2e18 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 19 Mar 2021 13:59:30 -0700
Subject: [PATCH 234/531] [ci] Add missing deps in tox

---
 setup.cfg | 5 ++---
 tox.ini   | 2 ++
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/setup.cfg b/setup.cfg
index a0eb7d35..9a61d72b 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -20,9 +20,11 @@ url = https://github.com/MozillaSecurity/grizzly
 [options]
 include_package_data = True
 install_requires =
+    cssbeautifier
     fasteners
     ffpuppet
     FuzzManager
+    jsbeautifier
     lithium-reducer >= 0.5
     prefpicker
     psutil >= 4.4.0
@@ -60,8 +62,5 @@ grizzly_reduce_strategies =
 dev =
     pre-commit
     tox
-reduce =
-    cssbeautifier
-    jsbeautifier
 s3 =
     boto3
diff --git a/tox.ini b/tox.ini
index 3557d1f7..fa4cb42e 100644
--- a/tox.ini
+++ b/tox.ini
@@ -9,6 +9,8 @@ deps =
     pytest
     pytest-cov
     pytest-mock
+extras =
+    s3
 passenv =
     BUILD_CACHE
     CI

From 901966d1f4e62e5d5ac1af92b5cb89e24c37df62 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 22 Mar 2021 14:38:14 -0700
Subject: [PATCH 235/531] [tests] Add ServerMap test coverage

---
 sapphire/test_server_map.py | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/sapphire/test_server_map.py b/sapphire/test_server_map.py
index 5bb5fa9b..f7c9e517 100644
--- a/sapphire/test_server_map.py
+++ b/sapphire/test_server_map.py
@@ -2,7 +2,6 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-# pylint: disable=protected-access
 
 import pytest
 
@@ -19,21 +18,22 @@ def test_servermap_01():
 
 def test_servermap_02(tmp_path):
     """test ServerMap dynamic responses"""
-
-    def fake_cb():
-        pass
-
     srv_map = ServerMap()
-    srv_map.set_dynamic_response("url_01", fake_cb, mime_type="test/type")
+    srv_map.set_dynamic_response("url_01", lambda: 0, mime_type="test/type")
     assert len(srv_map.dynamic) == 1
     assert "url_01" in srv_map.dynamic
     assert srv_map.dynamic["url_01"].mime == "test/type"
     assert callable(srv_map.dynamic["url_01"].target)
     assert srv_map.dynamic["url_01"].type == Resource.URL_DYNAMIC
-    srv_map.set_dynamic_response("url_02", fake_cb, mime_type="foo")
+    srv_map.set_dynamic_response("url_02", lambda: 0, mime_type="foo")
     assert len(srv_map.dynamic) == 2
     assert not srv_map.include
     assert not srv_map.redirect
+    with pytest.raises(TypeError, match="callback must be callable"):
+        srv_map.set_dynamic_response("x", None)
+    with pytest.raises(TypeError, match="mime_type must be of type 'str'"):
+        srv_map.set_dynamic_response("x", lambda: 0, None)
+    # test detecting collisions
     with pytest.raises(MapCollisionError):
         srv_map.set_include("url_01", str(tmp_path))
     with pytest.raises(MapCollisionError):
@@ -62,6 +62,7 @@ def test_servermap_03(tmp_path):
     assert len(srv_map.include) == 2
     assert not srv_map.dynamic
     assert not srv_map.redirect
+    # test detecting collisions
     with pytest.raises(MapCollisionError, match="URL collision on 'url_01'"):
         srv_map.set_redirect("url_01", "test_file")
     with pytest.raises(MapCollisionError):
@@ -88,6 +89,11 @@ def test_servermap_04(tmp_path):
     assert not srv_map.redirect["url_02"].required
     assert not srv_map.dynamic
     assert not srv_map.include
+    with pytest.raises(TypeError, match="target must not be an empty string"):
+        srv_map.set_redirect("x", "")
+    with pytest.raises(TypeError, match="target must be of type 'str'"):
+        srv_map.set_redirect("x", None)
+    # test detecting collisions
     with pytest.raises(MapCollisionError):
         srv_map.set_include("url_01", str(tmp_path))
     with pytest.raises(MapCollisionError):
@@ -96,6 +102,7 @@ def test_servermap_04(tmp_path):
 
 def test_servermap_05():
     """test ServerMap._check_url()"""
+    # pylint: disable=protected-access
     assert ServerMap._check_url("test") == "test"
     assert ServerMap._check_url("") == ""
     # only alphanumeric is allowed

From ee41c0127a66961c2936f80658c923d011d17cac Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Sun, 28 Mar 2021 13:34:27 -0700
Subject: [PATCH 236/531] Use os.scandir() in status_reporter.py

---
 grizzly/common/status_reporter.py      | 13 ++++++-------
 grizzly/common/test_status_reporter.py |  2 +-
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index b986eb71..76f5128f 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -111,15 +111,13 @@ def _results(self, max_len=85):
 
     @staticmethod
     def _scan(path, fname_pattern):
-        abs_path = os.path.abspath(path)
-        for fname in os.listdir(abs_path):
-            if fname_pattern.match(fname) is None:
+        for entry in os.scandir(path):
+            if fname_pattern.match(entry.name) is None:
                 continue
-            full_path = os.path.join(abs_path, fname)
-            if not os.path.isfile(full_path):
+            if not entry.is_file():
                 continue
-            if os.path.getsize(full_path) > 0:
-                yield full_path
+            if entry.stat().st_size:
+                yield entry.path
 
     def _specific(self):
         """Merged and generate formatted output of status reports.
@@ -283,6 +281,7 @@ def _sys_info():
         try:
             txt.append(" %s\n" % (str(os.getloadavg()),))
         except AttributeError:
+            # os.getloadavg() is not available on all platforms
             txt.append("\n")
         mem_usage = psutil.virtual_memory()
         txt.append("    Memory : ")
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 3bd082ff..47e03259 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -94,7 +94,7 @@ def test_status_reporter_04(tmp_path):
     test_path.touch()
     assert not any(StatusReporter._scan(str(tmp_path), re_filter))
     test_path.write_bytes(b"test")
-    assert tuple(StatusReporter._scan(str(tmp_path), re_filter))
+    assert any(StatusReporter._scan(str(tmp_path), re_filter))
 
 
 def test_status_reporter_05(tmp_path):

From 3ae9b31e7ca6c27d2e0067c377c2ec3f4f7258ea Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Sun, 28 Mar 2021 17:45:27 -0700
Subject: [PATCH 237/531] Status reporter updates

* Update imports
* Increase test coverage
* Fix nits
---
 grizzly/common/status_reporter.py      | 73 ++++++++++++----------
 grizzly/common/test_status_reporter.py | 84 ++++++++++++++++++--------
 2 files changed, 98 insertions(+), 59 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 76f5128f..aec54429 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -4,16 +4,23 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Manage Grizzly status reports."""
-import argparse
-import logging
-import os
-import re
+from argparse import ArgumentParser
 from collections import defaultdict
 from datetime import timedelta
 from functools import partial
-from time import gmtime, localtime, strftime, time
+from logging import DEBUG, INFO, basicConfig
 
-import psutil
+try:
+    from os import getloadavg
+except ImportError:  # pragma: no cover
+    # os.getloadavg() is not available on all platforms
+    getloadavg = None
+from os import SEEK_CUR, getenv, scandir
+from os.path import isdir
+from re import match
+from time import gmtime, strftime, time
+
+from psutil import cpu_count, cpu_percent, disk_usage, virtual_memory
 
 from .status import Status
 
@@ -80,8 +87,6 @@ def load(cls, tb_path=None):
         Returns:
             StatusReporter: Contains available status reports and traceback reports.
         """
-        if tb_path is not None and not os.path.isdir(tb_path):
-            raise OSError("%r is not a directory" % (tb_path,))
         tracebacks = None if tb_path is None else cls._tracebacks(tb_path)
         return cls(list(Status.loadall()), tracebacks=tracebacks)
 
@@ -111,8 +116,8 @@ def _results(self, max_len=85):
 
     @staticmethod
     def _scan(path, fname_pattern):
-        for entry in os.scandir(path):
-            if fname_pattern.match(entry.name) is None:
+        for entry in scandir(path):
+            if match(fname_pattern, entry.name) is None:
                 continue
             if not entry.is_file():
                 continue
@@ -274,29 +279,28 @@ def _sys_info():
         txt.append(
             "CPU & Load : %d @ %0.1f%%"
             % (
-                psutil.cpu_count(),
-                psutil.cpu_percent(interval=StatusReporter.CPU_POLL_INTERVAL),
+                cpu_count(),
+                cpu_percent(interval=StatusReporter.CPU_POLL_INTERVAL),
             )
         )
-        try:
-            txt.append(" %s\n" % (str(os.getloadavg()),))
-        except AttributeError:
-            # os.getloadavg() is not available on all platforms
+        if getloadavg is not None:
+            txt.append(" %s\n" % (str(getloadavg()),))
+        else:
             txt.append("\n")
-        mem_usage = psutil.virtual_memory()
+        mem_usage = virtual_memory()
         txt.append("    Memory : ")
         if mem_usage.available < 1073741824:  # < 1GB
             txt.append("%dMB" % (mem_usage.available / 1048576,))
         else:
             txt.append("%0.1fGB" % (mem_usage.available / 1073741824.0,))
         txt.append(" of %0.1fGB free\n" % (mem_usage.total / 1073741824.0,))
-        disk_usage = psutil.disk_usage("/")
+        usage = disk_usage("/")
         txt.append("      Disk : ")
-        if disk_usage.free < 1073741824:  # < 1GB
-            txt.append("%dMB" % (disk_usage.free / 1048576,))
+        if usage.free < 1073741824:  # < 1GB
+            txt.append("%dMB" % (usage.free / 1048576,))
         else:
-            txt.append("%0.1fGB" % (disk_usage.free / 1073741824.0,))
-        txt.append(" of %0.1fGB free" % (disk_usage.total / 1073741824.0,))
+            txt.append("%0.1fGB" % (usage.free / 1073741824.0,))
+        txt.append(" of %0.1fGB free" % (usage.total / 1073741824.0,))
         return "".join(txt)
 
     @staticmethod
@@ -313,7 +317,7 @@ def _tracebacks(path, ignore_kbi=True, max_preceeding=5):
             list: A list of TracebackReports.
         """
         tracebacks = list()
-        for screen_log in StatusReporter._scan(path, re.compile(r"screenlog\.\d+")):
+        for screen_log in StatusReporter._scan(path, r"screenlog\.\d+"):
             tbr = TracebackReport.from_file(screen_log, max_preceeding=max_preceeding)
             if tbr is None:
                 continue
@@ -363,7 +367,7 @@ def from_file(cls, input_log, max_preceeding=5):
                         break
                     if len(chunk) == cls.READ_LIMIT:
                         # seek back to avoid missing beginning of token
-                        in_fp.seek(len(token) * -1, os.SEEK_CUR)
+                        in_fp.seek(len(token) * -1, SEEK_CUR)
                 else:
                     # no traceback here, move along
                     return None
@@ -390,7 +394,7 @@ def from_file(cls, input_log, max_preceeding=5):
                     # stop at first empty line
                     tb_end = min(line_num, line_count)
                     break
-                if re.match(r"^\w+(\.\w+)*\:\s|^\w+(Interrupt|Error)$", log_line):
+                if match(r"^\w+(\.\w+)*\:\s|^\w+(Interrupt|Error)$", log_line):
                     is_kbi = log_line.startswith("KeyboardInterrupt")
                     # stop after error message
                     tb_end = min(line_num + 1, line_count)
@@ -430,15 +434,16 @@ def main(args=None):
     Returns:
         None
     """
-    log_level = logging.INFO
-    log_fmt = "[%(asctime)s] %(message)s"
-    if bool(os.getenv("DEBUG")):  # pragma: no cover
-        log_level = logging.DEBUG
+    if bool(getenv("DEBUG")):  # pragma: no cover
+        log_level = DEBUG
         log_fmt = "%(levelname).1s %(name)s [%(asctime)s] %(message)s"
-    logging.basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
+    else:
+        log_level = INFO
+        log_fmt = "[%(asctime)s] %(message)s"
+    basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
 
     modes = ("status",)
-    parser = argparse.ArgumentParser(description="Grizzly status report generator")
+    parser = ArgumentParser(description="Grizzly status report generator")
     parser.add_argument("--dump", help="File to write report to")
     parser.add_argument(
         "--mode",
@@ -456,9 +461,11 @@ def main(args=None):
         help="Scan path for Python tracebacks found in screenlog.# files",
     )
     args = parser.parse_args(args)
-
     if args.mode not in modes:
         parser.error("Invalid mode %r" % args.mode)
+    if args.tracebacks and not isdir(args.tracebacks):
+        parser.error("--tracebacks must be a directory")
+
     reporter = StatusReporter.load(tb_path=args.tracebacks)
     if args.dump:
         reporter.dump_summary(args.dump)
@@ -468,7 +475,7 @@ def main(args=None):
         return 0
     print(
         "Grizzly Status - %s - Instance report frequency: %ds\n"
-        % (strftime("%Y/%m/%d %X", localtime()), Status.REPORT_FREQ)
+        % (strftime("%Y/%m/%d %X"), Status.REPORT_FREQ)
     )
     print("[Reports]")
     reporter.print_specific()
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 47e03259..62e985cd 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -5,13 +5,16 @@
 """test Grizzly status reporter"""
 # pylint: disable=protected-access
 
-import re
 from itertools import count
+from re import match
+from unittest.mock import Mock
 
-import pytest
+from pytest import mark, raises
 
 from .status_reporter import Status, StatusReporter, TracebackReport, main
 
+GBYTES = 1_073_741_824
+
 
 def _fake_sys_info():
     return (
@@ -44,10 +47,6 @@ def test_status_reporter_02(tmp_path):
     # missing reports path
     st_rpt = StatusReporter.load()
     assert not st_rpt.reports
-    # missing tb path
-    Status.PATH = str(tmp_path)
-    with pytest.raises(OSError):
-        StatusReporter.load(tb_path="no_dir")
     # empty reports and tb paths
     st_rpt = StatusReporter.load(tb_path=str(tmp_path))
     assert isinstance(st_rpt.reports, list)
@@ -56,25 +55,57 @@ def test_status_reporter_02(tmp_path):
     assert not st_rpt.tracebacks
 
 
-def test_status_reporter_03(mocker):
+@mark.parametrize(
+    "disk, memory, getloadavg",
+    [
+        (Mock(free=12, total=GBYTES), Mock(available=12, total=GBYTES), None),
+        (
+            Mock(free=10.23 * GBYTES, total=100 * GBYTES),
+            Mock(available=1.1 * GBYTES, total=2 * GBYTES),
+            None,
+        ),
+        (
+            Mock(free=12, total=GBYTES),
+            Mock(available=12, total=GBYTES),
+            lambda: "(0.12, 0.34, 0.56)",
+        ),
+    ],
+)
+def test_status_reporter_03(mocker, disk, memory, getloadavg):
     """test StatusReporter._sys_info()"""
-    gbs = 1024 * 1024 * 1024
-    fake_psutil = mocker.patch("grizzly.common.status_reporter.psutil", autospec=True)
-    fake_psutil.cpu_count.return_value = 4
-    fake_psutil.cpu_percent.return_value = 10.0
-    fake_psutil.virtual_memory.return_value = mocker.Mock(available=12, total=gbs)
-    fake_psutil.disk_usage.return_value = mocker.Mock(free=12, total=gbs)
-    sysinfo = StatusReporter._sys_info()
-    assert "MB" in sysinfo
-    fake_psutil.virtual_memory.return_value = mocker.Mock(
-        available=1.1 * gbs, total=2 * gbs
+    mocker.patch(
+        "grizzly.common.status_reporter.cpu_count", autospec=True, return_value=4
+    )
+    mocker.patch(
+        "grizzly.common.status_reporter.cpu_percent", autospec=True, return_value=10
+    )
+    mocker.patch(
+        "grizzly.common.status_reporter.disk_usage", autospec=True, return_value=disk
+    )
+    mocker.patch(
+        "grizzly.common.status_reporter.virtual_memory",
+        autospec=True,
+        return_value=memory,
     )
-    fake_psutil.disk_usage.return_value = mocker.Mock(free=10.23 * gbs, total=100 * gbs)
+    if getloadavg is None:
+        # simulate platform that does not have os.getloadavg()
+        mocker.patch("grizzly.common.status_reporter.getloadavg", None)
+    else:
+        mocker.patch(
+            "grizzly.common.status_reporter.getloadavg",
+            autospec=True,
+            side_effect=getloadavg,
+        )
     sysinfo = StatusReporter._sys_info()
-    assert "MB" not in sysinfo
+    if disk.free < GBYTES or memory.available < GBYTES:
+        assert "MB" in sysinfo
+    else:
+        assert "MB" not in sysinfo
     lines = sysinfo.split("\n")
     assert len(lines) == 3
     assert "CPU & Load : " in lines[0]
+    if getloadavg is not None:
+        assert lines[0].endswith("(0.12, 0.34, 0.56)")
     assert "Memory : " in lines[1]
     assert "Disk : " in lines[2]
     # verify alignment
@@ -85,16 +116,15 @@ def test_status_reporter_03(mocker):
 
 def test_status_reporter_04(tmp_path):
     """test StatusReporter._scan()"""
-    re_filter = re.compile("TEST_FILE")
     (tmp_path / "somefile.txt").touch()
     test_path = tmp_path / "TEST_FILE"
     test_path.mkdir()
-    assert not any(StatusReporter._scan(str(tmp_path), re_filter))
+    assert not any(StatusReporter._scan(str(tmp_path), "TEST_FILE"))
     test_path.rmdir()
     test_path.touch()
-    assert not any(StatusReporter._scan(str(tmp_path), re_filter))
+    assert not any(StatusReporter._scan(str(tmp_path), "TEST_FILE"))
     test_path.write_bytes(b"test")
-    assert any(StatusReporter._scan(str(tmp_path), re_filter))
+    assert any(StatusReporter._scan(str(tmp_path), "TEST_FILE"))
 
 
 def test_status_reporter_05(tmp_path):
@@ -142,7 +172,7 @@ def test_status_reporter_05(tmp_path):
     # verify alignment
     position = len(lines[0].split(":")[0])
     for line in lines:
-        assert re.match(r"\S\s:\s\S", line[position - 2 :])
+        assert match(r"\S\s:\s\S", line[position - 2 :])
 
 
 def test_status_reporter_06(mocker, tmp_path):
@@ -536,6 +566,8 @@ def test_main_03(tmp_path):
 
 
 def test_main_04():
-    """test main() with invalid mode"""
-    with pytest.raises(SystemExit):
+    """test main() with invalid args"""
+    with raises(SystemExit):
         main(["--mode", "invalid"])
+    with raises(SystemExit):
+        main(["--tracebacks", "missing"])

From 034e98f5028fbc6fe14e940eaa453ca4fcd8e219 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 29 Mar 2021 14:11:50 -0700
Subject: [PATCH 238/531] [tests] pre-commit deps

---
 .pre-commit-config.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 2489c387..56370125 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -12,7 +12,7 @@ repos:
     hooks:
       - id: black
   - repo: https://github.com/pycqa/pylint
-    rev: pylint-2.7.2
+    rev: pylint-2.7.3
     hooks:
       - id: pylint
   - repo: https://gitlab.com/pycqa/flake8

From f1a8936383d7cad86916b085ad7e2d1ade461913 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 29 Mar 2021 14:12:05 -0700
Subject: [PATCH 239/531] [tests] Update coverage exclusion list

---
 pyproject.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/pyproject.toml b/pyproject.toml
index e8c92190..d467d9d6 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -16,6 +16,9 @@ omit = [
 
 [tool.coverage.report]
 exclude_lines = [
+    "@(abc.)?abstract*",
+    "except ImportError:",
+    "if __name__ == .__main__.:",
     "pragma: no cover",
 ]
 

From 2ad2fb708b90a5e568dd6a4e060a7cd7950a85de Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 30 Mar 2021 13:25:15 -0700
Subject: [PATCH 240/531] Make Adapters plug-ins

* Use plug-in code for both Adapters and Targets
* Update 'no-op' Adapter
---
 grizzly/__main__.py                           |  14 --
 grizzly/adapter/__init__.py                   |  10 +
 grizzly/{common => adapter}/adapter.py        |  15 +-
 .../no_op_adapter}/__init__.py                |   3 +-
 grizzly/{common => adapter}/test_adapter.py   |  29 +--
 grizzly/adapters/__init__.py                  |  73 --------
 grizzly/args.py                               |  26 +--
 grizzly/common/__init__.py                    |   3 -
 grizzly/common/plugins.py                     |  57 ++++++
 grizzly/common/test_plugins.py                |  81 ++++++++
 grizzly/common/test_utils.py                  |   2 +-
 grizzly/main.py                               |  15 +-
 grizzly/reduce/core.py                        |   8 +-
 grizzly/reduce/test_main.py                   |  10 +-
 grizzly/replay/replay.py                      |   6 +-
 grizzly/replay/test_main.py                   |  12 +-
 grizzly/session.py                            |   2 +-
 grizzly/target/__init__.py                    |  56 ------
 grizzly/target/test_target_loader.py          | 131 -------------
 grizzly/test_args.py                          |  35 ++--
 grizzly/test_main.py                          | 177 +++++++++++-------
 grizzly/test_session.py                       |  19 +-
 setup.cfg                                     |   5 +-
 23 files changed, 349 insertions(+), 440 deletions(-)
 create mode 100644 grizzly/adapter/__init__.py
 rename grizzly/{common => adapter}/adapter.py (93%)
 rename grizzly/{adapters/NoOpAdapter => adapter/no_op_adapter}/__init__.py (96%)
 rename grizzly/{common => adapter}/test_adapter.py (78%)
 delete mode 100644 grizzly/adapters/__init__.py
 create mode 100644 grizzly/common/plugins.py
 create mode 100644 grizzly/common/test_plugins.py
 delete mode 100644 grizzly/target/test_target_loader.py

diff --git a/grizzly/__main__.py b/grizzly/__main__.py
index 2b437d58..54151d3d 100644
--- a/grizzly/__main__.py
+++ b/grizzly/__main__.py
@@ -2,10 +2,6 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from logging import DEBUG, basicConfig
-from os import getenv
-
-from .adapters import load
 from .args import GrizzlyArgs
 from .main import main
 
@@ -13,14 +9,4 @@
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
 
-# TODO: This can go away once Adapters are loaded using
-# setuptools entrypoints. It is only needed to get log output from
-# load() because it is called before parse arguments (which
-# is where basicConfig should be called).
-if getenv("DEBUG"):
-    basicConfig(
-        format="%(asctime)s %(levelname).1s %(name)s | %(message)s", level=DEBUG
-    )
-# load Adapters
-load()
 raise SystemExit(main(GrizzlyArgs().parse_args()))
diff --git a/grizzly/adapter/__init__.py b/grizzly/adapter/__init__.py
new file mode 100644
index 00000000..68e44031
--- /dev/null
+++ b/grizzly/adapter/__init__.py
@@ -0,0 +1,10 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from .adapter import Adapter, AdapterError
+
+__all__ = (
+    "Adapter",
+    "AdapterError",
+)
diff --git a/grizzly/common/adapter.py b/grizzly/adapter/adapter.py
similarity index 93%
rename from grizzly/common/adapter.py
rename to grizzly/adapter/adapter.py
index 663403dc..0d88bc4d 100644
--- a/grizzly/common/adapter.py
+++ b/grizzly/adapter/adapter.py
@@ -31,15 +31,14 @@ class Adapter(metaclass=ABCMeta):
         fuzz (dict): Available as a safe scratch pad for the end-user.
         monitor (TargetMonitor): Used to provide Target status information to
                                  the adapter.
+        name (str): Name of the adapter.
         remaining (int): Can be used to indicate the number of TestCases
                          remaining to process.
     """
 
-    HARNESS_FILE = pathjoin(dirname(__file__), "harness.html")
+    HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
     # Only report test cases with served content.
     IGNORE_UNSERVED = True
-    # This is used as the identifier when launching Grizzly. Must be a unique string.
-    NAME = None
     # Maximum iterations between Target relaunches (<1 use default)
     RELAUNCH = 0
     # Maximum execution time per test (used as minimum timeout). The iteration is
@@ -47,14 +46,16 @@ class Adapter(metaclass=ABCMeta):
     # close it.
     TIME_LIMIT = 30
 
-    __slots__ = ("_harness", "fuzz", "monitor", "remaining")
+    __slots__ = ("_harness", "fuzz", "monitor", "name", "remaining")
 
-    def __init__(self):
-        if not isinstance(self.NAME, str):
-            raise AdapterError("%s.NAME must be a string" % (type(self).__name__,))
+    def __init__(self, name):
+        assert isinstance(name, str)
+        if not name:
+            raise AdapterError("name must not be empty")
         self._harness = None
         self.fuzz = dict()
         self.monitor = None
+        self.name = name
         self.remaining = None
 
     def cleanup(self):
diff --git a/grizzly/adapters/NoOpAdapter/__init__.py b/grizzly/adapter/no_op_adapter/__init__.py
similarity index 96%
rename from grizzly/adapters/NoOpAdapter/__init__.py
rename to grizzly/adapter/no_op_adapter/__init__.py
index 21d9049a..698ac5b8 100644
--- a/grizzly/adapters/NoOpAdapter/__init__.py
+++ b/grizzly/adapter/no_op_adapter/__init__.py
@@ -1,9 +1,8 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-# pylint: disable=invalid-name
 
-from grizzly.common import Adapter
+from grizzly.adapter import Adapter
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
diff --git a/grizzly/common/test_adapter.py b/grizzly/adapter/test_adapter.py
similarity index 78%
rename from grizzly/common/test_adapter.py
rename to grizzly/adapter/test_adapter.py
index 46e78814..cc6b6473 100644
--- a/grizzly/common/test_adapter.py
+++ b/grizzly/adapter/test_adapter.py
@@ -8,28 +8,19 @@
 
 
 class SimpleAdapter(Adapter):
-    NAME = "simple"
-
     def generate(self, testcase, server_map):
         pass
 
 
 def test_adapter_01():
-    """test a bad Adapter"""
-
-    class BadAdapter(SimpleAdapter):
-        NAME = None
-
-    with pytest.raises(AdapterError, match="BadAdapter.NAME must be a string"):
-        BadAdapter()
-
-
-def test_adapter_02():
     """test a simple Adapter"""
-    adpt = SimpleAdapter()
+    with pytest.raises(AdapterError, match="name must not be empty"):
+        SimpleAdapter("")
+    adpt = SimpleAdapter("simple")
     assert isinstance(adpt.fuzz, dict)
     assert not adpt.fuzz
     assert adpt.monitor is None
+    assert adpt.name == "simple"
     assert adpt.remaining is None
     assert adpt.get_harness() is None
     adpt.setup(None, None)
@@ -40,16 +31,12 @@ def test_adapter_02():
     adpt.cleanup()
 
 
-def test_adapter_03(tmp_path):
+def test_adapter_02(tmp_path):
     """test Adapter.enable_harness()"""
-    adpt = SimpleAdapter()
+    adpt = SimpleAdapter("a")
     # built-in harness
-    harness_file = tmp_path / "harness.html"
-    test_data = b"default_harness_data"
-    harness_file.write_bytes(test_data)
-    adpt.HARNESS_FILE = str(harness_file)  # pylint: disable=invalid-name
     adpt.enable_harness()
-    assert adpt.get_harness() == test_data
+    assert adpt.get_harness()
     # external harness
     ext_harness_file = tmp_path / "ext_harness.html"
     test_data = b"external_harness_data"
@@ -58,7 +45,7 @@ def test_adapter_03(tmp_path):
     assert adpt.get_harness() == test_data
 
 
-def test_adapter_04(tmp_path):
+def test_adapter_03(tmp_path):
     """test Adapter.scan_path()"""
     # empty path
     assert not any(SimpleAdapter.scan_path(str(tmp_path)))
diff --git a/grizzly/adapters/__init__.py b/grizzly/adapters/__init__.py
deleted file mode 100644
index 248f3226..00000000
--- a/grizzly/adapters/__init__.py
+++ /dev/null
@@ -1,73 +0,0 @@
-from importlib import import_module
-from logging import getLogger
-from os import listdir
-from os.path import abspath, dirname, isfile
-from os.path import join as pathjoin
-from sys import exc_info
-from sys import path as syspath
-from traceback import extract_tb
-
-from grizzly.common import Adapter
-
-LOG = getLogger(__name__)
-
-__all__ = ("get", "load", "names")
-__adapters__ = dict()
-
-
-def get(name):
-    return __adapters__.get(name.lower(), None)
-
-
-def load(path=None, skip_failures=True):
-    assert not __adapters__, "adapters have already been loaded"
-    if path is None:
-        path = dirname(__file__)
-    path = abspath(path)
-    LOG.debug("loading adapters from %r", path)
-    syspath.append(path)
-    for sub in listdir(path):
-        if not isfile(pathjoin(path, sub, "__init__.py")):
-            continue
-        LOG.debug("scanning %r", sub)
-        try:
-            lib = import_module(sub)
-        except Exception:  # pylint: disable=broad-except
-            if not skip_failures:
-                raise
-            exc_type, exc_obj, exc_tb = exc_info()
-            tbinfo = extract_tb(exc_tb)[-1]
-            LOG.debug(
-                "raised %s: %s (%s:%d)",
-                exc_type.__name__,
-                exc_obj,
-                tbinfo[0],
-                tbinfo[1],
-            )
-            continue
-        for clsname in dir(lib):
-            cls = getattr(lib, clsname)
-            if isinstance(cls, type) and issubclass(cls, Adapter):
-                if clsname == "Adapter":
-                    continue
-                LOG.debug("sanity checking %r", clsname)
-                if not isinstance(cls.NAME, str):
-                    raise RuntimeError(
-                        "%s.NAME must be 'str' not %r"
-                        % (cls.__name__, type(cls.NAME).__name__)
-                    )
-                if cls.NAME.lower() != cls.NAME:
-                    raise RuntimeError(
-                        "%s.NAME %r must be lowercase" % (cls.__name__, cls.NAME)
-                    )
-                if cls.NAME in __adapters__:
-                    raise RuntimeError(
-                        "Name collision! %r is used by %r and %r"
-                        % (cls.NAME, __adapters__[cls.NAME].__name__, cls.__name__)
-                    )
-                __adapters__[cls.NAME] = cls
-    LOG.debug("%d adapters loaded", len(__adapters__))
-
-
-def names():
-    return __adapters__.keys()
diff --git a/grizzly/args.py b/grizzly/args.py
index b53830a7..52826251 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -7,9 +7,8 @@
 from os import listdir
 from os.path import exists, isdir, isfile
 
-from .adapters import names as adapter_names
+from .common.plugins import scan as scan_plugins
 from .common.utils import TIMEOUT_DELAY
-from .target import available as available_targets
 
 
 # ref: https://stackoverflow.com/questions/12268602/sort-argparse-help-alphabetically
@@ -94,7 +93,7 @@ def __init__(self):
             "--platform",
             default="ffpuppet",
             help="Platforms available: %s (default: %%(default)s)"
-            % ", ".join(available_targets()),
+            % ", ".join(scan_plugins("grizzly_targets")),
         )
         self.launcher_grp.add_argument("-p", "--prefs", help="prefs.js file to use")
         self.launcher_grp.add_argument(
@@ -160,6 +159,9 @@ def parse_args(self, argv=None):
     def sanity_check(self, args):
         if hasattr(super(), "sanity_check"):
             super().sanity_check(args)  # pylint: disable=no-member
+        targets = scan_plugins("grizzly_targets")
+        if not targets:
+            self.parser.error("No Target platforms are installed")
 
         if "binary" not in self._sanity_skip and not isfile(args.binary):
             self.parser.error("file not found: %r" % args.binary)
@@ -200,7 +202,7 @@ def sanity_check(self, args):
                 if not isdir(ext) or (isfile(ext) and ext.endswith(".xpi")):
                     self.parser.error("Extension must be a folder or .xpi")
 
-        if args.platform.lower() not in set(available_targets()):
+        if args.platform not in targets:
             self.parser.error("Unsupported platform %r" % args.platform)
 
         if args.prefs and not isfile(args.prefs):
@@ -220,10 +222,10 @@ def sanity_check(self, args):
 class GrizzlyArgs(CommonArgs):
     def __init__(self):
         super().__init__()
-        self._adapters = sorted(adapter_names())
         self._sanity_skip.add("tool")
         self.parser.add_argument(
-            "adapter", help="Available adapters: %s" % ", ".join(self._adapters)
+            "adapter",
+            help="Available adapters: %s" % ", ".join(scan_plugins("grizzly_adapters")),
         )
         self.parser.add_argument(
             "--enable-profiling",
@@ -274,14 +276,12 @@ def __init__(self):
 
     def sanity_check(self, args):
         super().sanity_check(args)
+        adapters = scan_plugins("grizzly_adapters")
+        if not adapters:
+            self.parser.error("No Adapters are installed")
 
-        if args.adapter.lower() not in self._adapters:
-            msg = ["Adapter %r does not exist." % args.adapter.lower()]
-            if self._adapters:
-                msg.append("Available adapters: %s" % ", ".join(self._adapters))
-            else:
-                msg.append("No adapters available.")
-            self.parser.error(" ".join(msg))
+        if args.adapter not in adapters:
+            self.parser.error("Adapter %r is not installed" % (args.adapter,))
 
         if args.collect < 1:
             self.parser.error("--collect must be greater than 0")
diff --git a/grizzly/common/__init__.py b/grizzly/common/__init__.py
index f88daeb6..edde63bd 100644
--- a/grizzly/common/__init__.py
+++ b/grizzly/common/__init__.py
@@ -3,7 +3,6 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-from .adapter import Adapter, AdapterError
 from .iomanager import IOManager, ServerMap
 from .reporter import (
     FilesystemReporter,
@@ -18,8 +17,6 @@
 from .utils import grz_tmp
 
 __all__ = (
-    "Adapter",
-    "AdapterError",
     "FilesystemReporter",
     "FuzzManagerReporter",
     "grz_tmp",
diff --git a/grizzly/common/plugins.py b/grizzly/common/plugins.py
new file mode 100644
index 00000000..e17ca9f0
--- /dev/null
+++ b/grizzly/common/plugins.py
@@ -0,0 +1,57 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from logging import getLogger
+
+from pkg_resources import iter_entry_points
+
+__all__ = ("load", "scan", "PluginLoadError")
+
+
+LOG = getLogger(__name__)
+
+
+class PluginLoadError(Exception):
+    """Raised if loading a plug-in fails"""
+
+
+def load(name, group, base_type):
+    """Load a plug-in.
+
+    Args:
+        name (str):
+        group (str):
+        base_type (*): Used to validate loaded objects.
+    Returns:
+        *: Python object.
+    """
+    for entry in iter_entry_points(group):
+        if entry.name == name:
+            LOG.debug("loading %r (%s)", name, base_type.__name__)
+            plugin = entry.load()
+            break
+    else:
+        raise PluginLoadError("%r not found in %r" % (name, group))
+    if not issubclass(plugin, base_type):
+        raise PluginLoadError("%r doesn't inherit from %s" % (name, base_type.__name__))
+    return plugin
+
+
+def scan(group):
+    """Scan for available plug-ins.
+
+    Args:
+        group (str): Entry point group to scan.
+
+    Returns:
+        list: Names of available entry points.
+    """
+    found = list()
+    LOG.debug("scanning %r", group)
+    for entry in iter_entry_points(group):
+        if entry.name in found:
+            # not sure if this can even happen
+            raise PluginLoadError("Duplicate entry %r in %r" % (entry.name, group))
+        found.append(entry.name)
+    return found
diff --git a/grizzly/common/test_plugins.py b/grizzly/common/test_plugins.py
new file mode 100644
index 00000000..e660d125
--- /dev/null
+++ b/grizzly/common/test_plugins.py
@@ -0,0 +1,81 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from pkg_resources import EntryPoint
+from pytest import raises
+
+from .plugins import PluginLoadError, load, scan
+
+
+class FakeType1:
+    pass
+
+
+class FakeType2:
+    pass
+
+
+def test_load_01(mocker):
+    """test load() - nothing to load"""
+    mocker.patch(
+        "grizzly.common.plugins.iter_entry_points", autospec=True, return_value=[]
+    )
+    with raises(PluginLoadError, match="'test-name' not found in 'test-group'"):
+        load("test-name", "test-group", FakeType1)
+
+
+def test_load_02(mocker):
+    """test load() - successful load"""
+    entry = mocker.Mock(set_spec=EntryPoint)
+    entry.name = "test-name"
+    entry.load.return_value = FakeType1
+    mocker.patch(
+        "grizzly.common.plugins.iter_entry_points", autospec=True, return_value=[entry]
+    )
+    assert load("test-name", "test-group", FakeType1)
+
+
+def test_load_03(mocker):
+    """test load() - invalid type"""
+    entry = mocker.Mock(set_spec=EntryPoint)
+    entry.name = "test-name"
+    entry.load.return_value = FakeType1
+    mocker.patch(
+        "grizzly.common.plugins.iter_entry_points", autospec=True, return_value=[entry]
+    )
+    with raises(PluginLoadError, match="'test-name' doesn't inherit from FakeType2"):
+        load("test-name", "test-group", FakeType2)
+
+
+def test_scan_01(mocker):
+    """test scan() - no entries found"""
+    mocker.patch(
+        "grizzly.common.plugins.iter_entry_points", autospec=True, return_value=[]
+    )
+    assert not scan("test_group")
+
+
+def test_scan_02(mocker):
+    """test scan() - duplicate entry"""
+    entry = mocker.Mock(set_spec=EntryPoint)
+    entry.name = "test_entry"
+    mocker.patch(
+        "grizzly.common.plugins.iter_entry_points",
+        autospec=True,
+        return_value=[entry, entry],
+    )
+    with raises(PluginLoadError, match="Duplicate entry 'test_entry' in 'test_group'"):
+        scan("test_group")
+
+
+def test_scan_03(mocker):
+    """test scan() - success"""
+    entry = mocker.Mock(set_spec=EntryPoint)
+    entry.name = "test-name"
+    mocker.patch(
+        "grizzly.common.plugins.iter_entry_points",
+        autospec=True,
+        return_value=[entry],
+    )
+    assert "test-name" in scan("test_group")
diff --git a/grizzly/common/test_utils.py b/grizzly/common/test_utils.py
index 594a65a7..ec823ef7 100644
--- a/grizzly/common/test_utils.py
+++ b/grizzly/common/test_utils.py
@@ -6,7 +6,7 @@
 from .utils import grz_tmp
 
 
-def test_testcase_01(mocker, tmp_path):
+def test_grz_tmp_01(mocker, tmp_path):
     """test grz_tmp()"""
     mocker.patch(
         "grizzly.common.utils.gettempdir", autospec=True, return_value=str(tmp_path)
diff --git a/grizzly/main.py b/grizzly/main.py
index 3eea11b0..e9403840 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -8,7 +8,8 @@
 
 from sapphire import Sapphire
 
-from .adapters import get as get_adapter
+from .adapter import Adapter
+from .common.plugins import load as load_plugin
 from .common.reporter import (
     FilesystemReporter,
     FuzzManagerReporter,
@@ -16,8 +17,7 @@
 )
 from .common.utils import TIMEOUT_DELAY
 from .session import Session
-from .target import TargetLaunchError, TargetLaunchTimeout
-from .target import load as load_target
+from .target import Target, TargetLaunchError, TargetLaunchTimeout
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
@@ -27,6 +27,7 @@
 
 
 def configure_logging(log_level):
+    # TODO: move this to grizzly.common.utils
     if getenv("DEBUG") == "1":
         log_level = DEBUG
     if log_level == DEBUG:
@@ -52,7 +53,7 @@ def main(args):
         LOG.info("Running with Xvfb")
     if args.rr:
         LOG.info("Running with RR")
-    elif args.valgrind:
+    if args.valgrind:
         LOG.info("Running with Valgrind. This will be SLOW!")
 
     adapter = None
@@ -60,7 +61,7 @@ def main(args):
     target = None
     try:
         LOG.debug("initializing Adapter %r", args.adapter)
-        adapter = get_adapter(args.adapter)()
+        adapter = load_plugin(args.adapter, "grizzly_adapters", Adapter)(args.adapter)
 
         # test time limit and timeout sanity checking
         if args.time_limit:
@@ -88,8 +89,8 @@ def main(args):
         else:
             relaunch = args.relaunch
 
-        LOG.debug("initializing the Target")
-        target = load_target(args.platform)(
+        LOG.debug("initializing the Target %r", args.platform)
+        target = load_plugin(args.platform, "grizzly_targets", Target)(
             args.binary,
             args.extension,
             args.launch_timeout,
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 6e83da7d..51dbeaef 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -19,14 +19,14 @@
 from sapphire import Sapphire
 
 from ..common.fuzzmanager import CrashEntry
+from ..common.plugins import load as load_plugin
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter
 from ..common.storage import TestCaseLoadFailure, TestFile
 from ..common.utils import ConfigError, grz_tmp
 from ..main import configure_logging
 from ..replay import ReplayManager
 from ..session import Session
-from ..target import TargetLaunchError, TargetLaunchTimeout
-from ..target import load as load_target
+from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from .exceptions import GrizzlyReduceBaseException, NotReproducible
 from .stats import ReductionStats
 from .strategies import STRATEGIES
@@ -767,7 +767,7 @@ def main(cls, args):
             args.repeat = max(args.min_crashes, args.repeat)
             relaunch = min(args.relaunch, args.repeat)
             LOG.debug("initializing the Target")
-            target = load_target(args.platform)(
+            target = load_plugin(args.platform, "grizzly_targets", Target)(
                 args.binary,
                 args.extension,
                 args.launch_timeout,
@@ -844,7 +844,7 @@ def main(cls, args):
             LOG.error(exc.msg)
             return exc.code
 
-        except Exception:  # noqa pylint: disable=broad-except
+        except Exception:  # pylint: disable=broad-except
             LOG.exception("Exception during reduction!")
             return Session.EXIT_ERROR
 
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index d97f7363..e83ab372 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -76,9 +76,9 @@ def test_args_02(tmp_path):
             1,
         ),
         ("grizzly.reduce.core.ReduceManager.run", TargetLaunchTimeout, None, {}, 1),
-        ("grizzly.reduce.core.load_target", KeyboardInterrupt, None, {}, 1),
+        ("grizzly.reduce.core.load_plugin", KeyboardInterrupt, None, {}, 1),
         (
-            "grizzly.reduce.core.load_target",
+            "grizzly.reduce.core.load_plugin",
             GrizzlyReduceBaseException(""),
             None,
             {},
@@ -109,7 +109,7 @@ def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, result
         QUAL_NO_TESTCASE=7,
         QUAL_REDUCER_ERROR=9,
     )
-    mocker.patch("grizzly.reduce.core.load_target", autospec=True)
+    mocker.patch("grizzly.reduce.core.load_plugin", autospec=True)
     mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
     # setup args
     args = mocker.Mock(
@@ -137,7 +137,7 @@ def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, result
 def test_main_launch_error(mocker, exc_type):
     mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
     reporter = mocker.patch("grizzly.reduce.core.FilesystemReporter", autospec=True)
-    mocker.patch("grizzly.reduce.core.load_target", autospec=True)
+    mocker.patch("grizzly.reduce.core.load_plugin", autospec=True)
     mocker.patch("grizzly.reduce.core.ReplayManager.load_testcases")
     mocker.patch(
         "grizzly.reduce.core.ReplayManager.time_limits", return_value=(None, 10)
@@ -173,7 +173,7 @@ def test_main_launch_error(mocker, exc_type):
 def test_testcase_prefs(mocker, tmp_path, result):
     """test that prefs from testcase are used if --prefs not specified and --prefs
     overrides"""
-    load_target = mocker.patch("grizzly.reduce.core.load_target")
+    load_target = mocker.patch("grizzly.reduce.core.load_plugin")
     mocker.patch("grizzly.reduce.core.ReduceManager.run", autospec=True)
     mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
     rmtree_mock = mocker.patch("grizzly.reduce.core.rmtree", autospec=True)
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 9a45b462..200736f5 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -13,6 +13,7 @@
 
 from sapphire import Sapphire, ServerMap
 
+from ..common.plugins import load as load_plugin
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter, Report
 from ..common.runner import Runner, RunResult
 from ..common.status import Status
@@ -20,8 +21,7 @@
 from ..common.utils import TIMEOUT_DELAY, ConfigError, grz_tmp
 from ..main import configure_logging
 from ..session import Session
-from ..target import TargetLaunchError, TargetLaunchTimeout
-from ..target import load as load_target
+from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
@@ -596,7 +596,7 @@ def main(cls, args):
                 relaunch,
             )
             LOG.debug("initializing the Target")
-            target = load_target(args.platform)(
+            target = load_plugin(args.platform, "grizzly_targets", Target)(
                 args.binary,
                 args.extension,
                 args.launch_timeout,
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index a5770f8e..0532778f 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -91,7 +91,7 @@ def test_main_01(mocker, tmp_path):
         ["test.html"],
     )  # passed to mocked Target.detect_failure
     # setup Target
-    load_target = mocker.patch("grizzly.replay.replay.load_target")
+    load_target = mocker.patch("grizzly.replay.replay.load_plugin")
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
@@ -155,7 +155,7 @@ def test_main_02(mocker, tmp_path):
         ["test.html"],
     )  # passed to mocked Target.detect_failure
     # setup Target
-    load_target = mocker.patch("grizzly.replay.replay.load_target")
+    load_target = mocker.patch("grizzly.replay.replay.load_plugin")
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
@@ -191,7 +191,7 @@ def test_main_03(mocker):
     """test ReplayManager.main() error cases"""
     fake_sig = mocker.patch("grizzly.replay.replay.CrashSignature", autospec=True)
     mocker.patch("grizzly.replay.replay.FuzzManagerReporter", autospec=True)
-    fake_load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
+    fake_load_target = mocker.patch("grizzly.replay.replay.load_plugin", autospec=True)
     mocker.patch("grizzly.replay.replay.Sapphire", autospec=True)
     fake_tc = mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
     # setup args
@@ -255,7 +255,7 @@ def test_main_04(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.Sapphire", autospec=True)
     mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
     target = mocker.Mock(spec=Target, launch_timeout=30)
-    load_target = mocker.patch("grizzly.replay.replay.load_target", autospec=True)
+    load_target = mocker.patch("grizzly.replay.replay.load_plugin", autospec=True)
     load_target.return_value.return_value = target
     fake_tmp = tmp_path / "grz_tmp"
     fake_tmp.mkdir()
@@ -309,7 +309,7 @@ def test_main_05(mocker, tmp_path):
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
-    load_target = mocker.patch("grizzly.replay.replay.load_target")
+    load_target = mocker.patch("grizzly.replay.replay.load_plugin")
     load_target.return_value.return_value = target
     # setup args
     args = mocker.Mock(
@@ -409,7 +409,7 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
-    load_target = mocker.patch("grizzly.replay.replay.load_target")
+    load_target = mocker.patch("grizzly.replay.replay.load_plugin")
     load_target.return_value.return_value = target
     # create test to load
     test = TestCase("test.html", None, None)
diff --git a/grizzly/session.py b/grizzly/session.py
index 15df2ec8..d27b352c 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -131,7 +131,7 @@ def display_status(self, log_limiter):
 
     def generate_testcase(self, time_limit):
         LOG.debug("calling iomanager.create_testcase()")
-        test = self.iomanager.create_testcase(self.adapter.NAME, time_limit)
+        test = self.iomanager.create_testcase(self.adapter.name, time_limit)
         LOG.debug("calling self.adapter.generate()")
         with self.status.measure("generate"):
             self.adapter.generate(test, self.iomanager.server_map)
diff --git a/grizzly/target/__init__.py b/grizzly/target/__init__.py
index 1b65654f..97cd4fd4 100644
--- a/grizzly/target/__init__.py
+++ b/grizzly/target/__init__.py
@@ -2,12 +2,6 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from logging import getLogger
-from sys import exc_info
-from traceback import extract_tb
-
-from pkg_resources import iter_entry_points
-
 from .target import (
     Target,
     TargetError,
@@ -21,57 +15,7 @@
     "TargetError",
     "TargetLaunchError",
     "TargetLaunchTimeout",
-    "available",
-    "load",
     "sanitizer_opts",
 )
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
-
-LOG = getLogger(__name__)
-TARGETS = dict()
-
-
-def _load_targets():
-    global TARGETS  # pylint: disable=global-statement
-    TARGETS = {}
-    for entry_point in iter_entry_points("grizzly_targets"):
-        LOG.debug("scanning target %r", entry_point.name)
-        try:
-            target = entry_point.load()
-        except Exception:  # pylint: disable=broad-except
-            exc_type, exc_obj, exc_tb = exc_info()
-            tbinfo = extract_tb(exc_tb)[-1]
-            LOG.warning(
-                "Target %r raised an exception %s: %s (%s:%d)",
-                entry_point.name,
-                exc_type.__name__,
-                exc_obj,
-                tbinfo[0],
-                tbinfo[1],
-            )
-            continue
-        if not issubclass(target, Target):
-            LOG.warning(
-                "Target %r doesn't inherit from grizzly.target.Target, skipping.",
-                entry_point.name,
-            )
-        elif entry_point.name in TARGETS:
-            raise RuntimeError(
-                "Target %r already exists as %r. (duplicate: %r)"
-                % (entry_point.name, TARGETS[entry_point.name], target)
-            )
-        else:
-            TARGETS[entry_point.name] = target
-
-
-def available():
-    if not TARGETS:
-        _load_targets()
-    return TARGETS.keys()
-
-
-def load(name):
-    if not TARGETS:
-        _load_targets()
-    return TARGETS[name]
diff --git a/grizzly/target/test_target_loader.py b/grizzly/target/test_target_loader.py
deleted file mode 100644
index 2d82663a..00000000
--- a/grizzly/target/test_target_loader.py
+++ /dev/null
@@ -1,131 +0,0 @@
-# coding=utf-8
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-"""
-unittests for target plugin loading
-"""
-
-import pytest
-
-from grizzly.target import Target, available, load
-
-
-class _FakeTarget1(Target):  # pylint: disable=abstract-method
-    pass
-
-
-class _FakeTarget2(Target):  # pylint: disable=abstract-method
-    pass
-
-
-def test_target_load_01(mocker):
-    """If no targets are available, available() should return nothing."""
-    mocker.patch("grizzly.target.TARGETS", None)
-    mocker.patch("grizzly.target.iter_entry_points", lambda _: [])
-    assert not available()
-
-
-def test_target_load_02(mocker):
-    """Loading targets works."""
-    mocker.patch("grizzly.target.TARGETS", None)
-
-    class _FakeEntryPoint1:
-        name = "test1"
-
-        @staticmethod
-        def load():
-            return _FakeTarget1
-
-    class _FakeEntryPoint2:
-        name = "test2"
-
-        @staticmethod
-        def load():
-            return _FakeTarget2
-
-    mocker.patch(
-        "grizzly.target.iter_entry_points",
-        lambda _: [_FakeEntryPoint1, _FakeEntryPoint2],
-    )
-    assert set(available()) == {"test1", "test2"}
-    assert load("test1") is _FakeTarget1
-    assert load("test2") is _FakeTarget2
-
-
-def test_target_load_03(mocker):
-    """Non-Target will be skipped."""
-    mocker.patch("grizzly.target.TARGETS", None)
-
-    class _FakeEntryPoint1:
-        name = "test1"
-
-        @staticmethod
-        def load():
-            return Target
-
-    class _FakeEntryPoint2:
-        name = "test2"
-
-        @staticmethod
-        def load():
-            return object
-
-    mocker.patch(
-        "grizzly.target.iter_entry_points",
-        lambda _: [_FakeEntryPoint1, _FakeEntryPoint2],
-    )
-    assert set(available()) == {"test1"}
-    assert load("test1") is Target
-
-
-def test_target_load_04(mocker):
-    """test load() with name collision"""
-    mocker.patch("grizzly.target.TARGETS", None)
-
-    class _FakeEntryPoint1:
-        name = "test"
-
-        @staticmethod
-        def load():
-            return _FakeTarget1
-
-    class _FakeEntryPoint2:
-        name = "test"
-
-        @staticmethod
-        def load():
-            return _FakeTarget2
-
-    mocker.patch(
-        "grizzly.target.iter_entry_points",
-        lambda _: [_FakeEntryPoint1, _FakeEntryPoint2],
-    )
-    with pytest.raises(RuntimeError, match=r"Target (.)test\1 already exists"):
-        available()
-
-
-def test_target_load_05(mocker):
-    """test load() with broken Target"""
-    mocker.patch("grizzly.target.TARGETS", None)
-
-    class _FakeEntryPoint1:
-        name = "test1"
-
-        @staticmethod
-        def load():
-            return Target
-
-    class _FakeEntryPoint2:
-        name = "test2"
-
-        @staticmethod
-        def load():
-            raise Exception("boo!")
-
-    mocker.patch(
-        "grizzly.target.iter_entry_points",
-        lambda _: [_FakeEntryPoint1, _FakeEntryPoint2],
-    )
-    assert set(available()) == {"test1"}
-    assert load("test1") is Target
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index e91ce4ec..d85c0b6f 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -8,7 +8,7 @@
 from .args import GrizzlyArgs
 
 
-def test_grizzly_args_01(capsys, tmp_path):
+def test_grizzly_args_01(capsys, mocker, tmp_path):
     """test GrizzlyArgs.parse_args()"""
     # test help
     with raises(SystemExit):
@@ -18,13 +18,19 @@ def test_grizzly_args_01(capsys, tmp_path):
     # test success
     fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
-    argp = GrizzlyArgs()
-    argp._adapters = ["test_adapter"]
-    assert argp.parse_args(argv=[str(fake_bin), "test_adapter"])
+    mocker.patch(
+        "grizzly.args.scan_plugins",
+        autospec=True,
+        side_effect=(["targ1"], ["adpt1"], ["targ1"], ["adpt1"]),
+    )
+    assert GrizzlyArgs().parse_args(
+        argv=[str(fake_bin), "adpt1", "--platform", "targ1"]
+    )
 
 
-def test_grizzly_args_03(capsys):
+def test_grizzly_args_02(capsys, mocker):
     """test GrizzlyArgs.parse_args() handling binary"""
+    mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=["blah"])
     # test missing required args
     with raises(SystemExit):
         GrizzlyArgs().parse_args(argv=[])
@@ -37,22 +43,23 @@ def test_grizzly_args_03(capsys):
     assert "error: file not found: 'missing_bin'" in err
 
 
-def test_grizzly_args_04(capsys, tmp_path):
-    """test GrizzlyArgs.parse_args() handling adapter"""
+def test_grizzly_args_03(capsys, mocker, tmp_path):
+    """test GrizzlyArgs.parse_args() handling Adapter"""
+    scan_plugins = mocker.patch("grizzly.args.scan_plugins", autospec=True)
     fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
-    # no adapters
+    # no adapters installed
+    scan_plugins.side_effect = (["targ1"], [], ["targ1"], [])
     with raises(SystemExit):
-        GrizzlyArgs().parse_args(argv=[str(fake_bin), "missing"])
+        GrizzlyArgs().parse_args(argv=[str(fake_bin), "adpt", "--platform", "targ1"])
     _, err = capsys.readouterr()
-    assert "error: Adapter 'missing' does not exist. No adapters available." in err
+    assert "error: No Adapters are installed" in err
     # invalid adapter name
-    argp = GrizzlyArgs()
-    argp._adapters = ["a1", "b2"]
+    scan_plugins.side_effect = (["targ1"], ["a1", "a2"], ["targ1"], ["a1", "a2"])
     with raises(SystemExit):
-        argp.parse_args(argv=[str(fake_bin), "missing"])
+        GrizzlyArgs().parse_args(argv=[str(fake_bin), "missing", "--platform", "targ1"])
     _, err = capsys.readouterr()
-    assert "error: Adapter 'missing' does not exist. Available adapters: a1, b2" in err
+    assert "error: Adapter 'missing' is not installed" in err
 
 
 # TODO: Add CommonArgs tests
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 70de6665..06627883 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -7,7 +7,7 @@
 
 from sapphire import Sapphire
 
-from .common import Adapter
+from .adapter import Adapter
 from .main import main
 from .session import Session
 from .target import Target, TargetLaunchError
@@ -42,91 +42,135 @@ def __init__(self):
         self.xvfb = False
 
 
-# TODO: these could use call_count checks
-
-
-def test_main_01(mocker):
+@mark.parametrize(
+    "cov, adpt_relaunch, limit, verbose",
+    [
+        # successful run
+        (False, 0, 0, True),
+        # successful run (with limit)
+        (False, 0, 10, True),
+        # successful run (with coverage)
+        (True, 0, 0, False),
+        # relaunch 1
+        (False, 1, 0, False),
+        # relaunch 10
+        (False, 10, 0, False),
+    ],
+)
+def test_main_01(mocker, cov, adpt_relaunch, limit, verbose):
     """test main()"""
-    fake_adapter = mocker.Mock(spec=Adapter)
-    fake_adapter.NAME = "fake"
+    fake_adapter = mocker.NonCallableMock(spec_set=Adapter)
+    fake_adapter.RELAUNCH = adpt_relaunch
     fake_adapter.TIME_LIMIT = 10
-    mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
-    mocker.patch.dict(
-        "grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)}
+    fake_target = mocker.NonCallableMock(spec_set=Target)
+    plugin_loader = mocker.patch("grizzly.main.load_plugin", autospec=True)
+    plugin_loader.side_effect = (
+        mocker.Mock(spec_set=Adapter, return_value=fake_adapter),
+        mocker.Mock(spec_set=Target, return_value=fake_target),
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
-    fake_session.return_value.server = mocker.Mock(spec=Sapphire)
+    fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     args = FakeArgs()
     args.adapter = "fake"
-    args.input = "fake"
     args.ignore = ["fake", "fake"]
+    args.limit = limit
     args.prefs = "fake"
+    args.rr = True
     args.valgrind = True
     args.xvfb = True
-    # successful run (with coverage)
-    fake_adapter.RELAUNCH = 10
-    args.coverage = True
+    args.verbose = verbose
+    if not verbose:
+        args.log_level = 20
+    args.coverage = cov
     assert main(args) == Session.EXIT_SUCCESS
-    assert fake_session.mock_calls[0][-1]["coverage"]
-    assert fake_session.mock_calls[0][-1]["relaunch"] == 10
-    fake_session.reset_mock()
-    # successful run (without coverage)
-    fake_adapter.RELAUNCH = 1
-    args.coverage = False
-    assert main(args) == Session.EXIT_SUCCESS
-    assert not fake_session.mock_calls[0][-1]["coverage"]
-    assert fake_session.mock_calls[0][-1]["relaunch"] == 1
-    fake_session.reset_mock()
-    # with FM
+    assert fake_session.mock_calls[0][-1]["coverage"] == cov
+    if adpt_relaunch:
+        assert fake_session.mock_calls[0][-1]["relaunch"] == adpt_relaunch
+    else:
+        # check default
+        assert fake_session.mock_calls[0][-1]["relaunch"] == 1000
+    assert fake_session.return_value.run.call_count == 1
+    assert fake_target.cleanup.call_count == 1
+
+
+@mark.parametrize(
+    "reporter",
+    [
+        # Default reporter
+        None,
+        # FuzzManager Reporter
+        "FuzzManager",
+        # S3FuzzManager Reporter
+        "S3FuzzManager",
+    ],
+)
+def test_main_02(mocker, reporter):
+    """test main() - test reporters"""
+    fake_adapter = mocker.NonCallableMock(spec_set=Adapter)
     fake_adapter.RELAUNCH = 0
-    fake_reporter = mocker.patch("grizzly.main.FuzzManagerReporter", autospec=True)
-    fake_reporter.sanity_check.return_value = True
-    args.coverage = True
-    args.input = None
-    args.log_level = None
-    args.fuzzmanager = True
-    args.rr = True
-    assert main(args) == Session.EXIT_SUCCESS
-    assert fake_session.mock_calls[0][-1]["coverage"]
-    assert fake_session.mock_calls[0][-1]["relaunch"] == 1000
-    fake_session.reset_mock()
-    # with S3FM (with iteration limit)
-    fake_reporter = mocker.patch("grizzly.main.S3FuzzManagerReporter", autospec=True)
-    fake_reporter.sanity_check.return_value = True
-    args.fuzzmanager = False
-    args.limit = 10
-    args.s3_fuzzmanager = True
+    fake_adapter.TIME_LIMIT = 10
+    fake_target = mocker.NonCallableMock(spec_set=Target)
+    plugin_loader = mocker.patch("grizzly.main.load_plugin", autospec=True)
+    plugin_loader.side_effect = (
+        mocker.Mock(spec_set=Adapter, return_value=fake_adapter),
+        mocker.Mock(spec_set=Target, return_value=fake_target),
+    )
+    fake_session = mocker.patch("grizzly.main.Session", autospec=True)
+    fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
+    fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
+    args = FakeArgs()
+    args.adapter = "fake"
+    if reporter == "FuzzManager":
+        fake_reporter = mocker.patch("grizzly.main.FuzzManagerReporter", autospec=True)
+        fake_reporter.sanity_check.return_value = True
+        args.fuzzmanager = True
+    elif reporter == "S3FuzzManager":
+        fake_reporter = mocker.patch(
+            "grizzly.main.S3FuzzManagerReporter", autospec=True
+        )
+        fake_reporter.sanity_check.return_value = True
+        args.s3_fuzzmanager = True
     assert main(args) == Session.EXIT_SUCCESS
+    assert fake_target.cleanup.call_count == 1
 
 
-def test_main_02(mocker):
-    """test main() exit codes"""
-    fake_adapter = mocker.Mock(spec=Adapter)
-    fake_adapter.TIME_LIMIT = 10
+@mark.parametrize(
+    "exit_code, to_raise",
+    [
+        # test user abort
+        (Session.EXIT_ABORT, KeyboardInterrupt()),
+        # test launch failure
+        (Session.EXIT_LAUNCH_FAILURE, TargetLaunchError("test", None)),
+    ],
+)
+def test_main_03(mocker, exit_code, to_raise):
+    """test main() - exit codes"""
+    fake_adapter = mocker.NonCallableMock(spec_set=Adapter, name="fake")
     fake_adapter.RELAUNCH = 0
-    mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
-    mocker.patch.dict(
-        "grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)}
+    fake_adapter.TIME_LIMIT = 10
+    fake_target = mocker.NonCallableMock(spec_set=Target)
+    plugin_loader = mocker.patch("grizzly.main.load_plugin", autospec=True)
+    plugin_loader.side_effect = (
+        mocker.Mock(spec_set=Adapter, return_value=fake_adapter),
+        mocker.Mock(spec_set=Target, return_value=fake_target),
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     fake_session.EXIT_ABORT = Session.EXIT_ABORT
     fake_session.EXIT_ARGS = fake_session.EXIT_ARGS = Session.EXIT_ARGS
     fake_session.EXIT_LAUNCH_FAILURE = Session.EXIT_LAUNCH_FAILURE
-    fake_session.return_value.server = mocker.Mock(spec=Sapphire)
+    fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
     args = FakeArgs()
     args.adapter = "fake"
     args.input = "fake"
-    fake_session.return_value.run.side_effect = KeyboardInterrupt
-    assert main(args) == Session.EXIT_ABORT
-    # test TargetLaunchError
-    fake_session.return_value.run.side_effect = TargetLaunchError("test", None)
-    assert main(args) == Session.EXIT_LAUNCH_FAILURE
+    fake_session.return_value.run.side_effect = to_raise
+    assert main(args) == exit_code
+    assert fake_target.cleanup.call_count == 1
 
 
 @mark.parametrize(
-    "arg_testlimit, arg_timeout, result",
+    "arg_testlimit, arg_timeout, exit_code",
     [
         # use default test time limit and timeout values
         (None, None, Session.EXIT_SUCCESS),
@@ -140,22 +184,23 @@ def test_main_02(mocker):
         (11, 10, Session.EXIT_ARGS),
     ],
 )
-def test_main_03(mocker, arg_testlimit, arg_timeout, result):
-    """test main() time-limit and timeout"""
-    fake_adapter = mocker.Mock(spec=Adapter)
-    fake_adapter.NAME = "fake"
+def test_main_04(mocker, arg_testlimit, arg_timeout, exit_code):
+    """test main() - time-limit and timeout"""
+    fake_adapter = mocker.NonCallableMock(spec_set=Adapter, name="fake")
     fake_adapter.RELAUNCH = 1
     fake_adapter.TIME_LIMIT = 10
-    mocker.patch("grizzly.main.get_adapter", return_value=lambda: fake_adapter)
-    mocker.patch.dict(
-        "grizzly.target.TARGETS", values={"fake-target": mocker.Mock(spec=Target)}
+    fake_target = mocker.NonCallableMock(spec_set=Target)
+    plugin_loader = mocker.patch("grizzly.main.load_plugin", autospec=True)
+    plugin_loader.side_effect = (
+        mocker.Mock(spec_set=Adapter, return_value=fake_adapter),
+        mocker.Mock(spec_set=Target, return_value=fake_target),
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
-    fake_session.return_value.server = mocker.Mock(spec=Sapphire)
+    fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
     fake_session.EXIT_ARGS = Session.EXIT_ARGS
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     args = FakeArgs()
     args.adapter = "fake"
     args.time_limit = arg_testlimit
     args.timeout = arg_timeout
-    assert main(args) == result
+    assert main(args) == exit_code
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 6ab65908..01818c56 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -10,26 +10,25 @@
 
 from sapphire import SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT, Sapphire
 
-from .common import Adapter, Report, Reporter, RunResult, Status
+from .adapter import Adapter
+from .common import Report, Reporter, RunResult, Status
 from .session import LogOutputLimiter, Session, SessionError
 from .target import Target, TargetLaunchError
 
 
 class SimpleAdapter(Adapter):
-    NAME = "simple"
-
     def __init__(self, use_harness, remaining=None):
-        super().__init__()
+        super().__init__("simple")
         self.remaining = remaining
         self._use_harness = use_harness
 
-    def setup(self, input_path, server_map):
+    def setup(self, input_path, _server_map):
         if self._use_harness:
             self.enable_harness()
         self.fuzz["input"] = input_path
 
-    def generate(self, testcase, server_map):
-        assert testcase.adapter_name == self.NAME
+    def generate(self, testcase, _server_map):
+        assert testcase.adapter_name == self.name
         testcase.input_fname = self.fuzz["input"]
         testcase.add_from_data("test", testcase.landing_page)
         if self.remaining is not None:
@@ -206,9 +205,7 @@ def test_session_04(mocker, tmp_path):
     """test Adapter creating invalid test case"""
 
     class FuzzAdapter(Adapter):
-        NAME = "fuzz"
-
-        def generate(self, testcase, server_map):
+        def generate(self, _testcase, _server_map):
             pass
 
     Status.PATH = str(tmp_path)
@@ -216,7 +213,7 @@ def generate(self, testcase, server_map):
     server.serve_path.return_value = (SERVED_NONE, [])
     target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
     target.monitor.launches = 1
-    with Session(FuzzAdapter(), None, server, target) as session:
+    with Session(FuzzAdapter("fuzz"), None, server, target) as session:
         with raises(SessionError, match="Test case is missing landing page"):
             session.run([], 10)
 
diff --git a/setup.cfg b/setup.cfg
index 9a61d72b..d7ea5725 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -30,8 +30,7 @@ install_requires =
     psutil >= 4.4.0
 packages =
     grizzly
-    grizzly.adapters
-    grizzly.adapters.NoOpAdapter
+    grizzly.adapter
     grizzly.common
     grizzly.reduce
     grizzly.reduce.strategies
@@ -45,6 +44,8 @@ zip_safe = False
 [options.entry_points]
 console_scripts =
     grizzly.status = grizzly.common.status_reporter:main
+grizzly_adapters =
+    no-op = grizzly.adapter.no_op_adapter:NoOpAdapter
 grizzly_targets =
     ffpuppet = grizzly.target.puppet_target:PuppetTarget
 grizzly_reduce_strategies =

From bfa8a42001afe51868a75321b0ad2ba3b17dcf82 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 30 Mar 2021 13:27:12 -0700
Subject: [PATCH 241/531] [tests] Update coverage exclusion list

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index d467d9d6..785c7467 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -17,7 +17,7 @@ omit = [
 [tool.coverage.report]
 exclude_lines = [
     "@(abc.)?abstract*",
-    "except ImportError:",
+    "except ImportError(.*):",
     "if __name__ == .__main__.:",
     "pragma: no cover",
 ]

From b12ff6a833ed226c3df681982d02c90e153bf71c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 30 Mar 2021 13:48:36 -0700
Subject: [PATCH 242/531] [tests] Add no-op Adapter test

---
 grizzly/adapter/no_op_adapter/test_no_op.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 grizzly/adapter/no_op_adapter/test_no_op.py

diff --git a/grizzly/adapter/no_op_adapter/test_no_op.py b/grizzly/adapter/no_op_adapter/test_no_op.py
new file mode 100644
index 00000000..cb40661d
--- /dev/null
+++ b/grizzly/adapter/no_op_adapter/test_no_op.py
@@ -0,0 +1,19 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+from grizzly.common import TestCase
+
+from . import NoOpAdapter
+
+
+def test_no_op_01():
+    """test a simple Adapter"""
+    adapter = NoOpAdapter("no-op")
+    adapter.setup(None, None)
+    test = TestCase("a", "b", adapter.name)
+    assert not test.data_size
+    assert not test.contains("a")
+    adapter.generate(test, None)
+    assert test.contains("a")

From 08fa611a43ae4f2ee397a67ad814d41addbe0f4f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 30 Mar 2021 15:59:02 -0700
Subject: [PATCH 243/531] Move configure_logging() to common.utils

---
 grizzly/common/__init__.py   |  3 ++-
 grizzly/common/test_utils.py | 27 ++++++++++++++++++++++++++-
 grizzly/common/utils.py      | 27 ++++++++++++++++++++++++---
 grizzly/main.py              | 19 +++----------------
 grizzly/reduce/core.py       |  3 +--
 grizzly/replay/replay.py     |  3 +--
 6 files changed, 57 insertions(+), 25 deletions(-)

diff --git a/grizzly/common/__init__.py b/grizzly/common/__init__.py
index edde63bd..bb15f8ce 100644
--- a/grizzly/common/__init__.py
+++ b/grizzly/common/__init__.py
@@ -14,11 +14,12 @@
 from .runner import Runner, RunResult
 from .status import Status
 from .storage import TestCase, TestCaseLoadFailure, TestFile, TestFileExists
-from .utils import grz_tmp
+from .utils import configure_logging, grz_tmp
 
 __all__ = (
     "FilesystemReporter",
     "FuzzManagerReporter",
+    "configure_logging",
     "grz_tmp",
     "IOManager",
     "Report",
diff --git a/grizzly/common/test_utils.py b/grizzly/common/test_utils.py
index ec823ef7..afa617ed 100644
--- a/grizzly/common/test_utils.py
+++ b/grizzly/common/test_utils.py
@@ -2,8 +2,11 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from logging import DEBUG, INFO
 
-from .utils import grz_tmp
+from pytest import mark
+
+from .utils import configure_logging, grz_tmp
 
 
 def test_grz_tmp_01(mocker, tmp_path):
@@ -22,3 +25,25 @@ def test_grz_tmp_01(mocker, tmp_path):
     path = grz_tmp("test1", "test2")
     assert path == str(tmp_path / "grizzly" / "test1" / "test2")
     assert (tmp_path / "grizzly" / "test1" / "test2").is_dir()
+
+
+@mark.parametrize(
+    "env, log_level",
+    [
+        # default log level
+        ("0", INFO),
+        # debug log level
+        ("0", DEBUG),
+        # enable debug log level via env
+        ("1", INFO),
+        # enable debug log level via env
+        ("TRUE", INFO),
+    ],
+)
+def test_configure_logging_01(mocker, env, log_level):
+    """test configure_logging()"""
+    config = mocker.patch("grizzly.common.utils.basicConfig", autospec=True)
+    mocker.patch("grizzly.common.utils.getenv", autospec=True, return_value=env)
+    configure_logging(log_level)
+    assert config.call_count == 1
+    assert config.call_args.kwargs["level"] == (DEBUG if env != "0" else log_level)
diff --git a/grizzly/common/utils.py b/grizzly/common/utils.py
index cea57c09..e0fbf9cf 100644
--- a/grizzly/common/utils.py
+++ b/grizzly/common/utils.py
@@ -2,12 +2,12 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-from os import makedirs
+from logging import DEBUG, basicConfig
+from os import getenv, makedirs
 from os.path import join as pathjoin
 from tempfile import gettempdir
 
-__all__ = ("ConfigError", "grz_tmp", "TIMEOUT_DELAY")
+__all__ = ("ConfigError", "configure_logging", "grz_tmp", "TIMEOUT_DELAY")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
@@ -24,6 +24,27 @@ def __init__(self, message, exit_code):
         self.exit_code = exit_code
 
 
+def configure_logging(log_level):
+    """Configure log output level and formatting.
+
+    Args:
+        log_level (int): Set log level.
+
+    Returns:
+        None
+    """
+    # allow force enabling log_level via environment
+    if getenv("DEBUG", "0").lower() in ("1", "true"):
+        log_level = DEBUG
+    if log_level == DEBUG:
+        date_fmt = None
+        log_fmt = "%(asctime)s %(levelname).1s %(name)s | %(message)s"
+    else:
+        date_fmt = "%Y-%m-%d %H:%M:%S"
+        log_fmt = "[%(asctime)s] %(message)s"
+    basicConfig(format=log_fmt, datefmt=date_fmt, level=log_level)
+
+
 def grz_tmp(*subdir):
     path = pathjoin(gettempdir(), "grizzly", *subdir)
     makedirs(path, exist_ok=True)
diff --git a/grizzly/main.py b/grizzly/main.py
index e9403840..50e98118 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -2,8 +2,8 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from logging import DEBUG, basicConfig, getLogger
-from os import getcwd, getenv, getpid
+from logging import DEBUG, getLogger
+from os import getcwd, getpid
 from os.path import join as pathjoin
 
 from sapphire import Sapphire
@@ -15,7 +15,7 @@
     FuzzManagerReporter,
     S3FuzzManagerReporter,
 )
-from .common.utils import TIMEOUT_DELAY
+from .common.utils import TIMEOUT_DELAY, configure_logging
 from .session import Session
 from .target import Target, TargetLaunchError, TargetLaunchTimeout
 
@@ -26,19 +26,6 @@
 LOG = getLogger(__name__)
 
 
-def configure_logging(log_level):
-    # TODO: move this to grizzly.common.utils
-    if getenv("DEBUG") == "1":
-        log_level = DEBUG
-    if log_level == DEBUG:
-        date_fmt = None
-        log_fmt = "%(asctime)s %(levelname).1s %(name)s | %(message)s"
-    else:
-        date_fmt = "%Y-%m-%d %H:%M:%S"
-        log_fmt = "[%(asctime)s] %(message)s"
-    basicConfig(format=log_fmt, datefmt=date_fmt, level=log_level)
-
-
 def main(args):
     configure_logging(args.log_level)
     LOG.info("Starting Grizzly (%d)", getpid())
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 51dbeaef..c6d96004 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -22,8 +22,7 @@
 from ..common.plugins import load as load_plugin
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter
 from ..common.storage import TestCaseLoadFailure, TestFile
-from ..common.utils import ConfigError, grz_tmp
-from ..main import configure_logging
+from ..common.utils import ConfigError, configure_logging, grz_tmp
 from ..replay import ReplayManager
 from ..session import Session
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 200736f5..5341c19f 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -18,8 +18,7 @@
 from ..common.runner import Runner, RunResult
 from ..common.status import Status
 from ..common.storage import TestCase, TestCaseLoadFailure, TestFile
-from ..common.utils import TIMEOUT_DELAY, ConfigError, grz_tmp
-from ..main import configure_logging
+from ..common.utils import TIMEOUT_DELAY, ConfigError, configure_logging, grz_tmp
 from ..session import Session
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 

From acbf445d72ef852aaac7bd77e6dd51e09824830b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 30 Mar 2021 16:04:04 -0700
Subject: [PATCH 244/531] Update plug-in comments and help

---
 grizzly/args.py           |  9 +++++----
 grizzly/common/plugins.py | 11 ++++++-----
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 52826251..683d83a2 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -92,8 +92,8 @@ def __init__(self):
         self.launcher_grp.add_argument(
             "--platform",
             default="ffpuppet",
-            help="Platforms available: %s (default: %%(default)s)"
-            % ", ".join(scan_plugins("grizzly_targets")),
+            help="Installed Platforms (Targets): %s (default: %%(default)s)"
+            % ", ".join(sorted(scan_plugins("grizzly_targets"))),
         )
         self.launcher_grp.add_argument("-p", "--prefs", help="prefs.js file to use")
         self.launcher_grp.add_argument(
@@ -161,7 +161,7 @@ def sanity_check(self, args):
             super().sanity_check(args)  # pylint: disable=no-member
         targets = scan_plugins("grizzly_targets")
         if not targets:
-            self.parser.error("No Target platforms are installed")
+            self.parser.error("No Platforms (Targets) are installed")
 
         if "binary" not in self._sanity_skip and not isfile(args.binary):
             self.parser.error("file not found: %r" % args.binary)
@@ -225,7 +225,8 @@ def __init__(self):
         self._sanity_skip.add("tool")
         self.parser.add_argument(
             "adapter",
-            help="Available adapters: %s" % ", ".join(scan_plugins("grizzly_adapters")),
+            help="Installed Adapters: %s"
+            % ", ".join(sorted(scan_plugins("grizzly_adapters"))),
         )
         self.parser.add_argument(
             "--enable-profiling",
diff --git a/grizzly/common/plugins.py b/grizzly/common/plugins.py
index e17ca9f0..ba1cde90 100644
--- a/grizzly/common/plugins.py
+++ b/grizzly/common/plugins.py
@@ -20,12 +20,13 @@ def load(name, group, base_type):
     """Load a plug-in.
 
     Args:
-        name (str):
-        group (str):
-        base_type (*): Used to validate loaded objects.
+        name (str): Name of entry point to load.
+        group (str): Group containing entry point.
+        base_type (type): Used to validate loaded objects.
     Returns:
         *: Python object.
     """
+    assert isinstance(base_type, type)
     for entry in iter_entry_points(group):
         if entry.name == name:
             LOG.debug("loading %r (%s)", name, base_type.__name__)
@@ -39,13 +40,13 @@ def load(name, group, base_type):
 
 
 def scan(group):
-    """Scan for available plug-ins.
+    """Scan for installed plug-ins.
 
     Args:
         group (str): Entry point group to scan.
 
     Returns:
-        list: Names of available entry points.
+        list: Names of installed entry points.
     """
     found = list()
     LOG.debug("scanning %r", group)

From 7099e1c8aa48ddf5220e099fff682e9e3527f91a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 31 Mar 2021 16:27:55 -0700
Subject: [PATCH 245/531] Update and add tests for CommonArgs and GrizzlyArgs

* This also includes some refactoring
---
 grizzly/args.py             |  47 +++++------
 grizzly/reduce/test_main.py |   6 +-
 grizzly/replay/args.py      |  23 ++----
 grizzly/replay/replay.py    |   6 +-
 grizzly/replay/test_args.py |  61 +++++++++++++++
 grizzly/replay/test_main.py |  61 +--------------
 grizzly/test_args.py        | 150 ++++++++++++++++++++++++++++++++----
 7 files changed, 232 insertions(+), 122 deletions(-)
 create mode 100644 grizzly/replay/test_args.py

diff --git a/grizzly/args.py b/grizzly/args.py
index 683d83a2..faf5ea62 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -4,7 +4,6 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from argparse import ArgumentParser, HelpFormatter
 from logging import CRITICAL, DEBUG, ERROR, INFO, WARNING
-from os import listdir
 from os.path import exists, isdir, isfile
 
 from .common.plugins import scan as scan_plugins
@@ -34,7 +33,6 @@ class CommonArgs:
     IGNORE = ("log-limit", "timeout")
 
     def __init__(self):
-        super().__init__()
         # log levels for console logging
         self._level_map = {
             "CRIT": CRITICAL,
@@ -103,6 +101,9 @@ def __init__(self):
             help="Number of iterations performed before relaunching the browser"
             " (default: %(default)s)",
         )
+        self.launcher_grp.add_argument(
+            "--rr", action="store_true", help="Use rr (Linux only)"
+        )
         self.launcher_grp.add_argument(
             "--time-limit",
             type=int,
@@ -157,40 +158,32 @@ def parse_args(self, argv=None):
         return args
 
     def sanity_check(self, args):
-        if hasattr(super(), "sanity_check"):
-            super().sanity_check(args)  # pylint: disable=no-member
         targets = scan_plugins("grizzly_targets")
         if not targets:
             self.parser.error("No Platforms (Targets) are installed")
 
         if "binary" not in self._sanity_skip and not isfile(args.binary):
-            self.parser.error("file not found: %r" % args.binary)
+            self.parser.error("file not found: %r" % (args.binary,))
 
         # sanitize ignore list
         args.ignore = {arg.lower() for arg in args.ignore}
         for ignore in args.ignore:
             if ignore not in self.IGNORABLE:
-                self.parser.error("Unrecognized ignore value: %s" % ignore)
-
-        if "input" not in self._sanity_skip and args.input:
-            if not exists(args.input):
-                self.parser.error("%r does not exist" % args.input)
-            elif isdir(args.input) and not listdir(args.input):
-                self.parser.error("%r is empty" % args.input)
+                self.parser.error("Unrecognized ignore value %r" % (ignore,))
 
         # check log level
         log_level = self._level_map.get(args.log_level.upper(), None)
         if log_level is None:
-            self.parser.error("Invalid log-level %r" % args.log_level)
+            self.parser.error("Invalid log-level %r" % (args.log_level,))
         args.log_level = log_level
 
         if args.log_limit < 0:
             self.parser.error("--log-limit must be >= 0")
-        args.log_limit *= 1048576
+        args.log_limit *= 1_048_576
 
         if args.memory < 0:
-            self.parser.error("-m/--memory must be >= 0")
-        args.memory *= 1048576
+            self.parser.error("--memory must be >= 0")
+        args.memory *= 1_048_576
 
         if args.relaunch < 1:
             self.parser.error("--relaunch must be >= 1")
@@ -198,21 +191,24 @@ def sanity_check(self, args):
         if args.extension:
             for ext in args.extension:
                 if not exists(ext):
-                    self.parser.error("%r does not exist" % ext)
+                    self.parser.error("%r does not exist" % (ext,))
                 if not isdir(ext) or (isfile(ext) and ext.endswith(".xpi")):
                     self.parser.error("Extension must be a folder or .xpi")
 
         if args.platform not in targets:
-            self.parser.error("Unsupported platform %r" % args.platform)
+            self.parser.error("Platform %r not installed" % (args.platform,))
 
         if args.prefs and not isfile(args.prefs):
-            self.parser.error("-p/--prefs not found %r" % args.prefs)
+            self.parser.error("--prefs file not found")
+
+        if args.rr and args.valgrind:
+            self.parser.error("--rr and --valgrind are mutually exclusive")
 
         if args.time_limit is not None and args.time_limit < 1:
-            self.parser.error("--time-limit must be at least 1")
+            self.parser.error("--time-limit must be >= 1")
 
         if args.timeout is not None and args.timeout < 1:
-            self.parser.error("--timeout must be at least 1")
+            self.parser.error("--timeout must be >= 1")
 
         if "tool" not in self._sanity_skip:
             if args.tool is not None and not args.fuzzmanager:
@@ -256,9 +252,6 @@ def __init__(self):
         self.launcher_grp.add_argument(
             "--coverage", action="store_true", help="Enable coverage collection"
         )
-        self.launcher_grp.add_argument(
-            "--rr", action="store_true", help="Use RR (Linux only)"
-        )
 
         self.reporter_grp.add_argument(
             "-c",
@@ -292,6 +285,9 @@ def sanity_check(self, args):
                 "--fuzzmanager and --s3-fuzzmanager are mutually exclusive"
             )
 
+        if args.input and not exists(args.input):
+            self.parser.error("%r does not exist" % (args.input,))
+
         if args.limit < 0:
             self.parser.error("--limit must be >= 0 (0 = no limit)")
 
@@ -299,6 +295,3 @@ def sanity_check(self, args):
             self.parser.error(
                 "--tool can only be given with --fuzzmanager/--s3-fuzzmanager"
             )
-
-        if args.rr and args.valgrind:
-            self.parser.error("'--rr' and '--valgrind' cannot be used together")
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index e83ab372..c558ea87 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -24,10 +24,10 @@
 def test_args_01(capsys, tmp_path, mocker):
     """test args in common with grizzly.replay"""
     # pylint: disable=import-outside-toplevel
-    from ..replay.test_main import test_args_01 as real_test
+    from ..replay.test_args import test_replay_args_01 as real_test
 
-    mocker.patch("grizzly.replay.test_main.ReplayArgs", new=ReduceArgs)
-    real_test(capsys, tmp_path)
+    mocker.patch("grizzly.replay.test_args.ReplayArgs", new=ReduceArgs)
+    real_test(capsys, mocker, tmp_path)
 
 
 def test_args_02(tmp_path):
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index 6757ae11..9a110c2e 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -2,7 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from os.path import isfile
+from os.path import exists, isfile
 
 from ..args import CommonArgs
 
@@ -76,10 +76,6 @@ def __init__(self):
             "0 == Oldest, n-1 == Newest (default: run all testcases)",
         )
 
-        self.launcher_grp.add_argument(
-            "--rr", action="store_true", help="Use RR (Linux only)"
-        )
-
         self.reporter_grp.add_argument(
             "--include-test",
             action="store_true",
@@ -90,22 +86,19 @@ def sanity_check(self, args):
         super().sanity_check(args)
 
         if args.any_crash and args.sig is not None:
-            self.parser.error("signature is ignored when running with '--any-crash'")
+            self.parser.error("signature is ignored when running with --any-crash")
 
         if args.idle_threshold and args.idle_delay <= 0:
-            self.parser.error("'--idle-delay' value must be positive")
+            self.parser.error("--idle-delay value must be positive")
 
-        if args.min_crashes < 1:
-            self.parser.error("'--min-crashes' value must be positive")
+        if "input" not in self._sanity_skip and not exists(args.input):
+            self.parser.error("%r does not exist" % (args.input,))
 
-        if args.no_harness:
-            args.relaunch = 1
+        if args.min_crashes < 1:
+            self.parser.error("--min-crashes value must be positive")
 
         if args.repeat < 1:
-            self.parser.error("'--repeat' value must be positive")
-
-        if args.rr and args.valgrind:
-            self.parser.error("'--rr' and '--valgrind' cannot be used together")
+            self.parser.error("--repeat value must be positive")
 
         if args.sig is not None and not isfile(args.sig):
             self.parser.error("signature file not found: %r" % (args.sig,))
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 5341c19f..71807200 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -587,7 +587,11 @@ def main(cls, args):
             )
             LOG.info("Using time limit: %ds, timeout: %ds", time_limit, timeout)
             repeat = max(args.min_crashes, args.repeat)
-            relaunch = min(args.relaunch, repeat)
+            if args.no_harness:
+                LOG.debug("no-harness enabled, forcing relaunch=1")
+                relaunch = 1
+            else:
+                relaunch = min(args.relaunch, repeat)
             LOG.info(
                 "Repeat: %d, Minimum crashes: %d, Relaunch %d",
                 repeat,
diff --git a/grizzly/replay/test_args.py b/grizzly/replay/test_args.py
new file mode 100644
index 00000000..8935faf0
--- /dev/null
+++ b/grizzly/replay/test_args.py
@@ -0,0 +1,61 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""
+unit tests for grizzly.replay.args
+"""
+from pytest import mark, raises
+
+from .args import ReplayArgs
+
+
+def test_replay_args_01(capsys, mocker, tmp_path):
+    """test parsing args"""
+    mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=["targ1"])
+    # missing args tests
+    with raises(SystemExit):
+        ReplayArgs().parse_args([])
+    # specified prefs.js missing
+    exe = tmp_path / "binary"
+    exe.touch()
+    # test success
+    ReplayArgs().parse_args([str(exe), str(exe), "--platform", "targ1"])
+    # test missing input
+    with raises(SystemExit):
+        ReplayArgs().parse_args(argv=[str(exe), "missing", "--platform", "targ1"])
+    assert "error: 'missing' does not exist" in capsys.readouterr()[-1]
+
+
+@mark.parametrize(
+    "args, msg",
+    [
+        # test any-crash with signature
+        (
+            ["--any-crash", "--sig", "x"],
+            "error: signature is ignored when running with --any-crash",
+        ),
+        # test in valid idle_delay
+        (
+            ["--idle-threshold", "1", "--idle-delay", "-1"],
+            "error: --idle-delay value must be positive",
+        ),
+        # test invalid min-crashes value
+        (["--min-crashes", "0"], "error: --min-crashes value must be positive"),
+        # test invalid repeat value
+        (["--repeat", "-1"], "error: --repeat value must be positive"),
+        # test missing signature file
+        (["--sig", "missing"], "error: signature file not found"),
+    ],
+)
+def test_replay_args_02(capsys, mocker, tmp_path, args, msg):
+    """test CommonArgs.parse_args() - sanity checks"""
+    target = "target1"
+    mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=[target])
+    fake_bin = tmp_path / "fake.bin"
+    fake_bin.touch()
+    with raises(SystemExit):
+        ReplayArgs().parse_args(
+            argv=[str(fake_bin), str(fake_bin), "--platform", target] + args
+        )
+    assert msg in capsys.readouterr()[-1]
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 0532778f..25b3610b 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -8,74 +8,17 @@
 """
 from shutil import rmtree
 
-from pytest import mark, raises
+from pytest import mark
 
 from sapphire import SERVED_ALL
 
 from ..common import Report, TestCase, TestCaseLoadFailure
-from ..replay import ReplayManager
-from ..replay.args import ReplayArgs
 from ..session import Session
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
+from .replay import ReplayManager
 from .test_replay import _fake_save_logs
 
 
-def test_args_01(capsys, tmp_path):
-    """test parsing args"""
-    # missing args tests
-    with raises(SystemExit):
-        ReplayArgs().parse_args([])
-    # specified prefs.js missing
-    exe = tmp_path / "binary"
-    exe.touch()
-    inp = tmp_path / "input"
-    inp.mkdir()
-    (inp / "somefile").touch()
-    (inp / "test_info.json").touch()
-    with raises(SystemExit):
-        ReplayArgs().parse_args([str(exe), str(inp / "somefile"), "--prefs", "missing"])
-    assert "error: -p/--prefs not found 'missing'" in capsys.readouterr()[-1]
-    # test case directory
-    (inp / "prefs.js").touch()
-    ReplayArgs().parse_args([str(exe), str(inp)])
-    # test case file
-    ReplayArgs().parse_args(
-        [str(exe), str(inp / "somefile"), "--prefs", str(inp / "prefs.js")]
-    )
-    # test negative min-crashes value
-    with raises(SystemExit):
-        ReplayArgs().parse_args([str(exe), str(inp), "--min-crashes", "-1"])
-    assert "error: '--min-crashes' value must be positive" in capsys.readouterr()[-1]
-    # test negative repeat value
-    with raises(SystemExit):
-        ReplayArgs().parse_args([str(exe), str(inp), "--repeat", "-1"])
-    assert "error: '--repeat' value must be positive" in capsys.readouterr()[-1]
-    # test missing signature file
-    with raises(SystemExit):
-        ReplayArgs().parse_args([str(exe), str(inp), "--sig", "missing"])
-    assert "error: signature file not found" in capsys.readouterr()[-1]
-    # test any crash and signature
-    with raises(SystemExit):
-        ReplayArgs().parse_args([str(exe), str(inp), "--any-crash", "--sig", "x"])
-    assert (
-        "error: signature is ignored when running with '--any-crash'"
-        in capsys.readouterr()[-1]
-    )
-    # test multiple debuggers
-    with raises(SystemExit):
-        ReplayArgs().parse_args([str(exe), str(inp), "--rr", "--valgrind"])
-    assert "'--rr' and '--valgrind' cannot be used together" in capsys.readouterr()[-1]
-    # test idle args
-    with raises(SystemExit):
-        ReplayArgs().parse_args(
-            [str(exe), str(inp), "--idle-threshold", "1", "--idle-delay", "0"]
-        )
-    assert "'--idle-delay' value must be positive" in capsys.readouterr()[-1]
-    # force relaunch == 1 with --no-harness
-    args = ReplayArgs().parse_args([str(exe), str(inp), "--no-harness"])
-    assert args.relaunch == 1
-
-
 def test_main_01(mocker, tmp_path):
     """test ReplayManager.main()"""
     # This is a typical scenario - a test that reproduces results ~50% of the time.
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index d85c0b6f..7dfed9f4 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -3,19 +3,104 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
-from pytest import raises
+from pytest import mark, raises
 
-from .args import GrizzlyArgs
+from .args import CommonArgs, GrizzlyArgs
 
 
-def test_grizzly_args_01(capsys, mocker, tmp_path):
-    """test GrizzlyArgs.parse_args()"""
+def test_common_args_01(capsys, mocker):
+    """test CommonArgs.parse_args()"""
+    mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=[])
     # test help
     with raises(SystemExit):
-        GrizzlyArgs().parse_args(argv=["-h"])
-    out, _ = capsys.readouterr()
-    assert "For addition help check out the wiki" in out
+        CommonArgs().parse_args(argv=["-h"])
+    assert "For addition help check out the wiki" in capsys.readouterr()[0]
+    # test empty args
+    with raises(SystemExit):
+        CommonArgs().parse_args(argv=[])
+    assert "the following arguments are required: binary" in capsys.readouterr()[-1]
+
+
+def test_common_args_01a(capsys, mocker, tmp_path):
+    """test CommonArgs.parse_args()"""
+    mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=["targ1"])
+    fake_bin = tmp_path / "fake.bin"
+    fake_bin.touch()
+    # test with missing bin
+    with raises(SystemExit):
+        CommonArgs().parse_args(argv=["missing-bin"])
+    assert "error: file not found: 'missing-bin'" in capsys.readouterr()[-1]
     # test success
+    CommonArgs().parse_args(argv=[str(fake_bin), "--platform", "targ1"])
+    # test invalid extension
+    with raises(SystemExit):
+        CommonArgs().parse_args(argv=[str(fake_bin), "--extension", str(fake_bin)])
+    assert "error: Extension must be a folder or .xpi" in capsys.readouterr()[-1]
+
+
+@mark.parametrize(
+    "args, msg, targets",
+    [
+        # test no installed platforms
+        ([], "error: No Platforms (Targets) are installed", []),
+        # test invalid ignore value
+        (["--ignore", "bad"], "error: Unrecognized ignore value 'bad'", ["targ1"]),
+        # test invalid log level
+        (["--log-level", "bad"], "error: Invalid log-level 'bad'", ["targ1"]),
+        # test invalid log limit
+        (["--log-limit", "-1"], "error: --log-limit must be >= 0", ["targ1"]),
+        # test invalid memory limit
+        (["--memory", "-1"], "error: --memory must be >= 0", ["targ1"]),
+        # test invalid relaunch value
+        (["--relaunch", "0"], "error: --relaunch must be >= 1", ["targ1"]),
+        # test missing extension
+        (["--extension", "missing"], "error: 'missing' does not exist", ["targ1"]),
+        # test invalid platform/target
+        (["--platform", "bad"], "error: Platform 'bad' not installed", ["targ1"]),
+        # test invalid prefs file
+        (
+            ["--platform", "targ1", "--prefs", "bad"],
+            "error: --prefs file not found",
+            ["targ1"],
+        ),
+        # test invalid time-limit
+        (
+            ["--platform", "targ1", "--time-limit", "-1"],
+            "error: --time-limit must be >= 1",
+            ["targ1"],
+        ),
+        # test invalid timeout
+        (
+            ["--platform", "targ1", "--timeout", "-1"],
+            "error: --timeout must be >= 1",
+            ["targ1"],
+        ),
+        # test invalid tool usage
+        (
+            ["--platform", "targ1", "--tool", "x"],
+            "error: --tool can only be given with --fuzzmanager",
+            ["targ1"],
+        ),
+        # test enabling both rr and Valgrind
+        (
+            ["--platform", "targ1", "--rr", "--valgrind"],
+            "error: --rr and --valgrind are mutually exclusive",
+            ["targ1"],
+        ),
+    ],
+)
+def test_common_args_02(capsys, mocker, tmp_path, args, msg, targets):
+    """test CommonArgs.parse_args()"""
+    mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=targets)
+    fake_bin = tmp_path / "fake.bin"
+    fake_bin.touch()
+    with raises(SystemExit):
+        CommonArgs().parse_args(argv=[str(fake_bin)] + args)
+    assert msg in capsys.readouterr()[-1]
+
+
+def test_grizzly_args_01(mocker, tmp_path):
+    """test GrizzlyArgs.parse_args() - success"""
     fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
     mocker.patch(
@@ -29,22 +114,21 @@ def test_grizzly_args_01(capsys, mocker, tmp_path):
 
 
 def test_grizzly_args_02(capsys, mocker):
-    """test GrizzlyArgs.parse_args() handling binary"""
+    """test GrizzlyArgs.parse_args() - handling binary"""
     mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=["blah"])
     # test missing required args
     with raises(SystemExit):
         GrizzlyArgs().parse_args(argv=[])
-    _, err = capsys.readouterr()
+    err = capsys.readouterr()[-1]
     assert "the following arguments are required: binary, adapter" in err
     # test missing binary
     with raises(SystemExit):
         GrizzlyArgs().parse_args(argv=["missing_bin", "adapter"])
-    _, err = capsys.readouterr()
-    assert "error: file not found: 'missing_bin'" in err
+    assert "error: file not found: 'missing_bin'" in capsys.readouterr()[-1]
 
 
 def test_grizzly_args_03(capsys, mocker, tmp_path):
-    """test GrizzlyArgs.parse_args() handling Adapter"""
+    """test GrizzlyArgs.parse_args() - handling Adapter"""
     scan_plugins = mocker.patch("grizzly.args.scan_plugins", autospec=True)
     fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
@@ -52,14 +136,46 @@ def test_grizzly_args_03(capsys, mocker, tmp_path):
     scan_plugins.side_effect = (["targ1"], [], ["targ1"], [])
     with raises(SystemExit):
         GrizzlyArgs().parse_args(argv=[str(fake_bin), "adpt", "--platform", "targ1"])
-    _, err = capsys.readouterr()
-    assert "error: No Adapters are installed" in err
+    assert "error: No Adapters are installed" in capsys.readouterr()[-1]
     # invalid adapter name
     scan_plugins.side_effect = (["targ1"], ["a1", "a2"], ["targ1"], ["a1", "a2"])
     with raises(SystemExit):
         GrizzlyArgs().parse_args(argv=[str(fake_bin), "missing", "--platform", "targ1"])
-    _, err = capsys.readouterr()
-    assert "error: Adapter 'missing' is not installed" in err
+    assert "error: Adapter 'missing' is not installed" in capsys.readouterr()[-1]
 
 
-# TODO: Add CommonArgs tests
+@mark.parametrize(
+    "args, msg",
+    [
+        # test invalid collect value
+        (["--collect", "0"], "error: --collect must be greater than 0"),
+        # test enabling both fuzzmanager and s3-fuzzmanager reporters
+        (
+            ["--fuzzmanager", "--s3-fuzzmanager"],
+            "error: --fuzzmanager and --s3-fuzzmanager are mutually exclusive",
+        ),
+        # test missing input
+        (["--input", "missing"], "error: 'missing' does not exist"),
+        # test invalid limit value
+        (["--limit", "-1"], "error: --limit must be >= 0 (0 = no limit)"),
+        # test tool
+        (
+            ["--tool", "x"],
+            "error: --tool can only be given with --fuzzmanager/--s3-fuzzmanager",
+        ),
+    ],
+)
+def test_grizzly_args_04(capsys, mocker, tmp_path, args, msg):
+    """test CommonArgs.parse_args()"""
+    mocker.patch(
+        "grizzly.args.scan_plugins",
+        autospec=True,
+        side_effect=["targ1", "adpt", "targ1", "adpt"],
+    )
+    fake_bin = tmp_path / "fake.bin"
+    fake_bin.touch()
+    with raises(SystemExit):
+        GrizzlyArgs().parse_args(
+            argv=[str(fake_bin), "adpt", "--platform", "targ1"] + args
+        )
+    assert msg in capsys.readouterr()[-1]

From 7963df30d148af12907c0bf3c00f41c7db15c761 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 31 Mar 2021 19:39:28 -0700
Subject: [PATCH 246/531] [tests] Fix tests on Python version < 3.8

---
 grizzly/common/test_utils.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/grizzly/common/test_utils.py b/grizzly/common/test_utils.py
index afa617ed..46d2491b 100644
--- a/grizzly/common/test_utils.py
+++ b/grizzly/common/test_utils.py
@@ -46,4 +46,7 @@ def test_configure_logging_01(mocker, env, log_level):
     mocker.patch("grizzly.common.utils.getenv", autospec=True, return_value=env)
     configure_logging(log_level)
     assert config.call_count == 1
-    assert config.call_args.kwargs["level"] == (DEBUG if env != "0" else log_level)
+    if env != "0":
+        assert config.call_args[-1]["level"] == DEBUG
+    else:
+        assert config.call_args[-1]["level"] == log_level

From 685650487226f88e6a4e444a4bfa4953de8d38b9 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Apr 2021 10:40:42 -0700
Subject: [PATCH 247/531] Move sanitizer_opts() to common.utils

---
 grizzly/common/iomanager.py   |  2 +-
 grizzly/common/storage.py     |  3 +--
 grizzly/common/test_utils.py  | 37 ++++++++++++++++++++++++++++++++++-
 grizzly/common/utils.py       | 29 ++++++++++++++++++++++++++-
 grizzly/target/__init__.py    |  9 +--------
 grizzly/target/target.py      | 23 +---------------------
 grizzly/target/test_target.py | 30 +---------------------------
 7 files changed, 69 insertions(+), 64 deletions(-)

diff --git a/grizzly/common/iomanager.py b/grizzly/common/iomanager.py
index 7abb14a7..2e2d67e0 100644
--- a/grizzly/common/iomanager.py
+++ b/grizzly/common/iomanager.py
@@ -8,8 +8,8 @@
 
 from sapphire.server_map import ServerMap
 
-from ..target import sanitizer_opts
 from .storage import TestCase, TestFile
+from .utils import sanitizer_opts
 
 __all__ = ("IOManager",)
 __author__ = "Tyson Smith"
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 8549bee7..88074915 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -16,8 +16,7 @@
 from zipfile import BadZipfile, ZipFile
 from zlib import error as zlib_error
 
-from ..target import sanitizer_opts
-from .utils import grz_tmp
+from .utils import grz_tmp, sanitizer_opts
 
 __all__ = ("TestCase", "TestFile", "TestCaseLoadFailure", "TestFileExists")
 __author__ = "Tyson Smith"
diff --git a/grizzly/common/test_utils.py b/grizzly/common/test_utils.py
index 46d2491b..53d088e5 100644
--- a/grizzly/common/test_utils.py
+++ b/grizzly/common/test_utils.py
@@ -6,7 +6,7 @@
 
 from pytest import mark
 
-from .utils import configure_logging, grz_tmp
+from .utils import configure_logging, grz_tmp, sanitizer_opts
 
 
 def test_grz_tmp_01(mocker, tmp_path):
@@ -50,3 +50,38 @@ def test_configure_logging_01(mocker, env, log_level):
         assert config.call_args[-1]["level"] == DEBUG
     else:
         assert config.call_args[-1]["level"] == log_level
+
+
+@mark.parametrize(
+    "to_parse, expected",
+    [
+        # test empty string
+        ("", {}),
+        # test single value
+        ("test_value=true", {"test_value": "true"}),
+        # test multiple values
+        ("a=1:b=-2:C=3", {"a": "1", "b": "-2", "C": "3"}),
+        # path parsing
+        (
+            "p1='z:/a':p2='x:\\a.1':p3='/test/path/':p4='':p5=\"x:/a.a\"",
+            {
+                "p1": "'z:/a'",
+                "p2": "'x:\\a.1'",
+                "p3": "'/test/path/'",
+                "p4": "''",
+                "p5": '"x:/a.a"',
+            },
+        ),
+        # test platform specific parsing
+        (
+            "bar=1:file='%s':foo=2" % (__file__,),
+            {"bar": "1", "file": "'%s'" % (__file__,), "foo": "2"},
+        ),
+    ],
+)
+def test_sanitizer_opts_01(to_parse, expected):
+    """test sanitizer_opts()"""
+    parsed = sanitizer_opts(to_parse)
+    assert len(parsed) == len(expected)
+    for key in expected:
+        assert expected[key] == parsed[key]
diff --git a/grizzly/common/utils.py b/grizzly/common/utils.py
index e0fbf9cf..0ab362e1 100644
--- a/grizzly/common/utils.py
+++ b/grizzly/common/utils.py
@@ -5,9 +5,16 @@
 from logging import DEBUG, basicConfig
 from os import getenv, makedirs
 from os.path import join as pathjoin
+from re import split as resplit
 from tempfile import gettempdir
 
-__all__ = ("ConfigError", "configure_logging", "grz_tmp", "TIMEOUT_DELAY")
+__all__ = (
+    "ConfigError",
+    "configure_logging",
+    "grz_tmp",
+    "sanitizer_opts",
+    "TIMEOUT_DELAY",
+)
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
@@ -49,3 +56,23 @@ def grz_tmp(*subdir):
     path = pathjoin(gettempdir(), "grizzly", *subdir)
     makedirs(path, exist_ok=True)
     return path
+
+
+def sanitizer_opts(env_data):
+    """Parse the values defined in given *SAN_OPTIONS environment variable.
+    For example "ASAN_OPTIONS=debug=false:log_path='/test/file.log'"
+    would return {"debug": "false", "log_path": "'/test/file.log'"}
+
+    Args:
+        env_var (str): *SAN_OPTIONS environment variable to parse.
+
+    Returns:
+        dict: Sanitized values from environment.
+    """
+    opts = dict()
+    for opt in resplit(r":(?![\\|/])", env_data):
+        if not opt:
+            continue
+        key, val = opt.split("=")
+        opts[key] = val
+    return opts
diff --git a/grizzly/target/__init__.py b/grizzly/target/__init__.py
index 97cd4fd4..c879bdc4 100644
--- a/grizzly/target/__init__.py
+++ b/grizzly/target/__init__.py
@@ -2,20 +2,13 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from .target import (
-    Target,
-    TargetError,
-    TargetLaunchError,
-    TargetLaunchTimeout,
-    sanitizer_opts,
-)
+from .target import Target, TargetError, TargetLaunchError, TargetLaunchTimeout
 
 __all__ = (
     "Target",
     "TargetError",
     "TargetLaunchError",
     "TargetLaunchTimeout",
-    "sanitizer_opts",
 )
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index e1d20107..d3f263b5 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -5,36 +5,15 @@
 from abc import ABCMeta, abstractmethod, abstractproperty
 from logging import getLogger
 from os.path import isfile
-from re import split as resplit
 from threading import Lock
 
-__all__ = ("Target", "sanitizer_opts")
+__all__ = ("Target", "TargetError", "TargetLaunchError")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
 LOG = getLogger(__name__)
 
 
-def sanitizer_opts(env_data):
-    """Parse the values defined in given *SAN_OPTIONS environment variable.
-    For example "ASAN_OPTIONS=debug=false:log_path='/test/file.log'"
-    would return {"debug": "false", "log_path": "'/test/file.log'"}
-
-    Args:
-        env_var (str): *SAN_OPTIONS environment variable to parse.
-
-    Returns:
-        dict: Sanitized values from environment.
-    """
-    opts = dict()
-    for opt in resplit(r":(?![\\|/])", env_data):
-        if not opt:
-            continue
-        key, val = opt.split("=")
-        opts[key] = val
-    return opts
-
-
 class TargetError(Exception):
     """Raised by Target"""
 
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index 572b78da..2a6ec935 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -3,7 +3,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
 
-from .target import Target, sanitizer_opts
+from .target import Target
 
 
 class SimpleTarget(Target):
@@ -58,31 +58,3 @@ def test_target_01(tmp_path):
     target.add_abort_token("none!")
     target.dump_coverage()
     target.reverse(1, 2)
-
-
-def test_sanitizer_opts_01(tmp_path):
-    """test sanitizer_opts()"""
-    # test empty string
-    assert not sanitizer_opts("")
-    # test single value
-    opts = sanitizer_opts("test_value=true")
-    assert len(opts) == 1
-    assert opts["test_value"] == "true"
-    # test multiple values
-    opts = sanitizer_opts("a=1:b=-2:C=3")
-    assert len(opts) == 3
-    assert opts["a"] == "1"
-    assert opts["b"] == "-2"
-    assert opts["C"] == "3"
-    # path parsing
-    opts = sanitizer_opts("p1='z:/a':p2='x:\\a.1':p3='/test/path/':p4='':p5=\"x:/a.a\"")
-    assert opts["p1"] == "'z:/a'"
-    assert opts["p2"] == "'x:\\a.1'"
-    assert opts["p3"] == "'/test/path/'"
-    assert opts["p4"] == "''"
-    assert opts["p5"] == '"x:/a.a"'
-    # platform specific parsing
-    fake_file = tmp_path / "fake.log"
-    opts = sanitizer_opts("bar=1:file='%s':foo=2" % (str(fake_file),))
-    assert len(opts) == 3
-    assert opts["file"] == "'%s'" % (str(fake_file),)

From 3d29c8462b13c856b332fd741c740b01647df8b3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Apr 2021 10:51:08 -0700
Subject: [PATCH 248/531] [tests] Add tests for ReduceFuzzManagerIDArgs and
 ReduceFuzzManagerIDQualityArgs

---
 grizzly/reduce/test_main.py | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index c558ea87..c679f14b 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -14,7 +14,7 @@
 from ..common import TestCaseLoadFailure
 from ..target import TargetLaunchError, TargetLaunchTimeout
 from . import ReduceManager
-from .args import ReduceArgs
+from .args import ReduceArgs, ReduceFuzzManagerIDArgs, ReduceFuzzManagerIDQualityArgs
 from .exceptions import GrizzlyReduceBaseException
 
 LOG = getLogger(__name__)
@@ -65,6 +65,24 @@ def test_args_02(tmp_path):
         ReduceArgs().parse_args([str(exe), str(inp), "--report-period", "15"])
 
 
+def test_args_03(tmp_path):
+    """test ReduceFuzzManagerIDArgs"""
+    exe = tmp_path / "binary"
+    exe.touch()
+    ReduceFuzzManagerIDArgs().parse_args([str(exe), "123"])
+
+
+def test_args_04(capsys, tmp_path):
+    """test ReduceFuzzManagerIDQualityArgs"""
+    exe = tmp_path / "binary"
+    exe.touch()
+    with raises(SystemExit):
+        ReduceFuzzManagerIDQualityArgs().parse_args(
+            [str(exe), "123", "--quality", "-1"]
+        )
+    assert "error: '--quality' value cannot be negative" in capsys.readouterr()[-1]
+
+
 @pytest.mark.parametrize(
     "patch_func, side_effect, return_value, kwargs, result",
     [

From a725b20e76a970cc2535960fec89d49f513892f3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 6 Apr 2021 12:32:25 -0700
Subject: [PATCH 249/531] [tests] Fix test_status_reporter_03 on Windows

---
 grizzly/common/test_status_reporter.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 62e985cd..8ad1ac7e 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -92,9 +92,7 @@ def test_status_reporter_03(mocker, disk, memory, getloadavg):
         mocker.patch("grizzly.common.status_reporter.getloadavg", None)
     else:
         mocker.patch(
-            "grizzly.common.status_reporter.getloadavg",
-            autospec=True,
-            side_effect=getloadavg,
+            "grizzly.common.status_reporter.getloadavg", side_effect=getloadavg
         )
     sysinfo = StatusReporter._sys_info()
     if disk.free < GBYTES or memory.available < GBYTES:

From f4971e1ad101921f0a4ad599ee1404dee92eb7ce Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 15 Apr 2021 14:48:19 -0700
Subject: [PATCH 250/531] [ci] Use matrix formatting and enable Windows

---
 .pre-commit-config.yaml |  33 +++---
 .taskcluster.yml        | 231 +++++++++++++++++-----------------------
 CODE_OF_CONDUCT.md      |   4 +-
 tox.ini                 |  13 ++-
 4 files changed, 122 insertions(+), 159 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 56370125..03c61681 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,24 +1,8 @@
 repos:
-  - repo: https://github.com/pycqa/isort
-    rev: 5.7.0
-    hooks:
-      - id: isort
   - repo: https://github.com/asottile/yesqa
     rev: v1.2.2
     hooks:
       - id: yesqa
-  - repo: https://github.com/ambv/black
-    rev: 20.8b1
-    hooks:
-      - id: black
-  - repo: https://github.com/pycqa/pylint
-    rev: pylint-2.7.3
-    hooks:
-      - id: pylint
-  - repo: https://gitlab.com/pycqa/flake8
-    rev: 3.9.0
-    hooks:
-      - id: flake8
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v3.4.0
     hooks:
@@ -35,18 +19,25 @@ repos:
         args: ['--django']
       - id: check-json
       - id: requirements-txt-fixer
-  - repo: https://github.com/codespell-project/codespell
-    rev: v2.0.0
-    hooks:
-      - id: codespell
-        exclude_types: [json]
   - repo: https://github.com/marco-c/taskcluster_yml_validator
     rev: v0.0.7
     hooks:
       - id: taskcluster_yml
+  - repo: https://github.com/MozillaSecurity/orion
+    rev: v0.0.2
+    hooks:
+      - id: orion_ci
   - repo: meta
     hooks:
       - id: check-useless-excludes
+  - repo: local
+    hooks:
+      - id: lint
+        name: Run linters
+        entry: tox -e lint
+        language: system
+        pass_filenames: false
+        types: [python]
 
 default_language_version:
   python: python3
diff --git a/.taskcluster.yml b/.taskcluster.yml
index aa953a56..b0676a1e 100644
--- a/.taskcluster.yml
+++ b/.taskcluster.yml
@@ -35,140 +35,103 @@ tasks:
     project_name:
       Grizzly
 
+    matrix:
+      language: python
+      secrets:
+        - type: env
+          secret: project/fuzzing/codecov-grizzly
+          name: CODECOV_TOKEN
+          key: token
+      script:
+        - bash
+        - '-xec'
+        - tox; tox -e codecov
+      jobs:
+        include:
+          - name: tests python 3.6
+            version: "3.6"
+            env:
+              TOXENV: py36
+          - name: tests python 3.7
+            version: "3.7"
+            env:
+              TOXENV: py37
+          - name: tests python 3.8
+            version: "3.8"
+            env:
+              TOXENV: py38
+          - name: test python 3.8 (windows)
+            version: "3.8"
+            platform: windows
+            env:
+              TOXENV: py38
+          - name: tests python 3.9
+            version: "3.9"
+            env:
+              TOXENV: py39
+          - name: lint
+            version: "3.9"
+            env:
+              TOXENV: lint
+            script:
+              - tox
+          - name: precommit
+            version: "3.9"
+            env:
+              TOXENV: precommit
+            script:
+              - tox
+          - name: PyPI upload
+            version: "3.8"
+            env:
+              TOXENV: pypi
+            script:
+              - tox
+            when:
+              release: true
+              all_passed: true
+            secrets:
+              - type: env
+                secret: project/fuzzing/pypi-grizzly
+                name: TWINE_USERNAME
+                key: username
+              - type: env
+                secret: project/fuzzing/pypi-grizzly
+                name: TWINE_PASSWORD
+                key: password
+
   in:
     $if: 'tasks_for in ["github-push", "github-release"] || (tasks_for == "github-pull-request" && event["action"] in ["opened", "reopened", "synchronize"])'
     then:
-      $flatten:
-        - $map: []
-          #- {msys: 'NmOU83KwRJGjk-btMbOOPA', toxenv: 'py38', name: 'tests python 3.8'}
-          each(build):
-            taskId: {$eval: as_slugid(build.toxenv + '-win')}
-            provisionerId: proj-fuzzing
-            workerType: ci-windows
-            created: {$fromNow: ''}
-            deadline: {$fromNow: '1 hour'}
-            scopes:
-              - secrets:get:project/fuzzing/${codecov_secret}
-            dependencies:
-              - ${build.msys}
-            payload:
-              env:
-                MSYSTEM: MINGW64
-                TOXENV: ${build.toxenv}
-                CODECOV_SECRET: ${codecov_secret}
-                FETCH_REF: ${fetch_ref}
-                FETCH_REV: ${fetch_rev}
-                CLONE_REPO: ${http_repo}
-              mounts:
-                - format: tar.bz2
-                  content:
-                    taskId: ${build.msys}
-                    artifact: public/msys2.tar.bz2
-                  directory: .
-              command:
-                - "set HOME=%CD%"
-                - "set ARTIFACTS=%CD%"
-                - "set PATH=%CD%\\msys64\\MINGW64\\bin;%PATH%"
-                - "set PATH=%CD%\\msys64\\usr\\bin;%PATH%"
-                - >-
-                  bash -x -e -c "
-                  . py-ci.sh;
-                  clone;
-                  tox;
-                  tox_codecov;"
-              features:
-                taskclusterProxy: true
-              maxRunTime: 900
-            metadata:
-              name: ${project_name} ${build.name} (windows)
-              description: ${project_name} ${build.name} (windows)
-              owner: '${user}@users.noreply.github.com'
-              source: ${http_repo}/raw/${fetch_rev}/.taskcluster.yml
-        - $map:
-          - {image: ci-py-36, toxenv: 'py36', name: 'tests python 3.6'}
-          - {image: ci-py-37, toxenv: 'py37', name: 'tests python 3.7'}
-          - {image: ci-py-38, toxenv: 'py38', name: 'tests python 3.8'}
-          - {image: ci-py-39, toxenv: 'py39', name: 'tests python 3.9'}
-          - {image: ci-py-39, toxenv: 'lint', name: 'lint'}
-          each(build):
-            taskId: {$eval: as_slugid(build.toxenv)}
-            provisionerId: proj-fuzzing
-            workerType: ci
-            created: {$fromNow: ''}
-            deadline: {$fromNow: '1 hour'}
-            scopes:
-              - secrets:get:project/fuzzing/${codecov_secret}
-            payload:
-              maxRunTime: 900
-              image:
-                type: indexed-image
-                path: public/${build.image}.tar.zst
-                namespace: project.fuzzing.orion.${build.image}.master
-              env:
-                TOXENV: ${build.toxenv}
-                CODECOV_SECRET: ${codecov_secret}
-                FETCH_REF: ${fetch_ref}
-                FETCH_REV: ${fetch_rev}
-                CLONE_REPO: ${http_repo}
-              features:
-                taskclusterProxy: true
-              command:
-                - /bin/bash
-                - '--login'
-                - '-x'
-                - '-e'
-                - '-c'
-                - >-
-                  . py-ci.sh;
-                  clone;
-                  tox;
-                  if [[ "${build.toxenv}" != "lint" ]]; then tox_codecov; fi;
-            metadata:
-              name: ${project_name} ${build.name}
-              description: ${project_name} ${build.name}
-              owner: '${user}@users.noreply.github.com'
-              source: ${http_repo}/raw/${fetch_rev}/.taskcluster.yml
-        - $if: 'tasks_for in ["github-release"]'
-          then:
-            - provisionerId: proj-fuzzing
-              workerType: ci
-              dependencies:
-                - {$eval: as_slugid("py36")}
-                - {$eval: as_slugid("py37")}
-                - {$eval: as_slugid("py38")}
-                #- {$eval: as_slugid("py38-win")}
-                - {$eval: as_slugid("py39")}
-                - {$eval: as_slugid("lint")}
-              created: {$fromNow: ''}
-              deadline: {$fromNow: '1 hour'}
-              scopes:
-                - secrets:get:project/fuzzing/${pypi_secret}
-              payload:
-                maxRunTime: 900
-                image:
-                  type: indexed-image
-                  path: public/ci-py-38.tar.zst
-                  namespace: project.fuzzing.orion.ci-py-38.master
-                features:
-                  taskclusterProxy: true
-                env:
-                  TOXENV: pypi
-                  FETCH_REF: ${fetch_ref}
-                  FETCH_REV: ${fetch_rev}
-                  CLONE_REPO: ${http_repo}
-                  PYPI_SECRET: ${pypi_secret}
-                command:
-                  - /bin/bash
-                  - '--login'
-                  - '-x'
-                  - '-e'
-                  - '-c'
-                  - >-
-                    . py-ci.sh;
-                    clone;
-                    tox_pypi;
-              metadata:
-                name: ${project_name} PyPI upload
-                description: ${project_name} PyPI upload
-                owner: '${user}@users.noreply.github.com'
-                source: ${http_repo}/raw/${fetch_rev}/.taskcluster.yml
+      - created: {$fromNow: ''}
+        deadline: {$fromNow: '1 hour'}
+        provisionerId: proj-fuzzing
+        workerType: ci
+        payload:
+          features:
+            taskclusterProxy: true
+          maxRunTime: 3600
+          image:
+            type: indexed-image
+            path: public/orion-decision.tar.zst
+            namespace: project.fuzzing.orion.orion-decision.master
+          env:
+            PROJECT_NAME: ${project_name}
+            CI_MATRIX: {$json: {$eval: matrix}}
+            GITHUB_EVENT: {$json: {$eval: event}}
+            GITHUB_ACTION: ${tasks_for}
+            TASKCLUSTER_NOW: ${now}
+          command:
+            - ci-decision
+            - -v
+        scopes:
+          - queue:create-task:highest:proj-fuzzing/ci
+          - queue:create-task:highest:proj-fuzzing/ci-*
+          - queue:scheduler-id:taskcluster-github
+          - secrets:get:project/fuzzing/codecov-grizzly
+          - secrets:get:project/fuzzing/pypi-grizzly
+        metadata:
+          name: ${project_name} CI decision
+          description: Schedule CI tasks for ${project_name}
+          owner: twsmith@mozilla.com
+          source: https://github.com/MozillaSecurity/grizzly
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 498baa3f..041fbb69 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -1,8 +1,8 @@
 # Community Participation Guidelines
 
-This repository is governed by Mozilla's code of conduct and etiquette guidelines. 
+This repository is governed by Mozilla's code of conduct and etiquette guidelines.
 For more details, please read the
-[Mozilla Community Participation Guidelines](https://www.mozilla.org/about/governance/policies/participation/). 
+[Mozilla Community Participation Guidelines](https://www.mozilla.org/about/governance/policies/participation/).
 
 ## How to Report
 For more information on how to report violations of the Community Participation Guidelines, please read our '[How to Report](https://www.mozilla.org/about/governance/policies/participation/reporting/)' page.
diff --git a/tox.ini b/tox.ini
index fa4cb42e..8f91ecce 100644
--- a/tox.ini
+++ b/tox.ini
@@ -14,11 +14,13 @@ extras =
 passenv =
     BUILD_CACHE
     CI
+    CI_*
     CODECOV_*
     TOXENV
     TRAVIS
     TRAVIS_*
     TWINE_*
+    VCS_*
 usedevelop = true
 
 [testenv:codecov]
@@ -29,12 +31,19 @@ deps =
     coverage[toml]
 skip_install = true
 
+[testenv:precommit]
+commands =
+    pre-commit run -a
+deps =
+    pre-commit
+skip_install = true
+
 [testenv:lint]
 allowlist_externals =
     bash
 commands =
-    isort {toxinidir}
-    black {toxinidir}
+    isort --check-only {toxinidir}
+    black --check {toxinidir}
     # codespell trips over the regex in 'sapphire/worker.py' saying 'sHTTP ==> https'
     # https://github.com/codespell-project/codespell/issues/1774
     # ignoring it is broken so we need to ignore the file

From 311c3c1e1768c5e219eaa8fad567e76927f81fd9 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tysmith@users.noreply.github.com>
Date: Tue, 27 Apr 2021 12:22:15 -0700
Subject: [PATCH 251/531] Update README.md

---
 README.md | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/README.md b/README.md
index c6c74dbe..06e55028 100644
--- a/README.md
+++ b/README.md
@@ -5,22 +5,29 @@ Grizzly
 [![Matrix](https://img.shields.io/badge/dynamic/json?color=green&label=chat&query=%24.chunk[%3F(%40.canonical_alias%3D%3D%22%23fuzzing%3Amozilla.org%22)].num_joined_members&suffix=%20users&url=https%3A%2F%2Fmozilla.modular.im%2F_matrix%2Fclient%2Fr0%2FpublicRooms&style=flat&logo=matrix)](https://riot.im/app/#/room/#fuzzing:mozilla.org)
 [![PyPI](https://img.shields.io/pypi/v/grizzly-framework)](https://pypi.org/project/grizzly-framework)
 
-Grizzly is a general purpose browser fuzzing framework made up of multiple modules.
-The intention is to create a platform that can be extended by the creation of adapters
-and targets to support different fuzzers that target browsers.
-An adapter is used to wrap an existing fuzzer to allow it to be run via Grizzly.
-Adapters take the content output by fuzzers and transform it (if needed) into a format that can
-be served to and processed by the browser.
+Grizzly is a modular general purpose browser fuzzing framework. The goal is to create a platform that can be extended via the creation of plug-ins to support multiple combinations of browsers and fuzzers. An Adapter is used to add support for a fuzzer and a Target to add support for a browser.
+
 Cross platform compatibility is available for Windows, Linux and MacOS.
 However not all features may be available.
 
 For additional information please check out the [wiki](https://github.com/MozillaSecurity/grizzly/wiki) or the [announcement](https://blog.mozilla.org/security/2019/07/10/grizzly/).
 
-Installation
+Quick Start
 ------------
-To install the latest version from PyPI run `python3 -m pip install grizzly-framework`. See [getting started](https://github.com/MozillaSecurity/grizzly/wiki/Getting-Started) on the wiki for more details.
+Install the latest version from PyPI. For more details see [getting started](https://github.com/MozillaSecurity/grizzly/wiki/Getting-Started) on the wiki for more details.
+
+```python3 -m pip install grizzly-framework```
+
+**Fuzz** - Run the `no-op` test adapter to check everything is working.
+
+```python3 -m grizzly <browser-binary> no-op```
+
+**Reduce** - [Grizzly Reduce](https://github.com/MozillaSecurity/grizzly/wiki/Grizzly-Reduce) can reduce a test case.
+
+```python3 -m grizzly.reduce <browser-binary> <testcase>```
+
+**Replay** - [Grizzly Replay](https://github.com/MozillaSecurity/grizzly/wiki/Grizzly-Replay) can replay a test case with different builds and debuggers.
+
+```python3 -m grizzly.replay <browser-binary> <testcase>```
+
 
-Target platforms
--------
-Other target platforms can be defined as [setuptools entry-points](https://setuptools.readthedocs.io/en/latest/setuptools.html#dynamic-discovery-of-services-and-plugins),
-using the name "grizzly_targets".  Targets must implement `grizzly.target.Target`.

From 85812f087a1b3d227d16949d94a9178cf185e6f4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tysmith@users.noreply.github.com>
Date: Tue, 27 Apr 2021 12:24:09 -0700
Subject: [PATCH 252/531] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 06e55028..2f2c3691 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@ For additional information please check out the [wiki](https://github.com/Mozill
 
 Quick Start
 ------------
-Install the latest version from PyPI. For more details see [getting started](https://github.com/MozillaSecurity/grizzly/wiki/Getting-Started) on the wiki for more details.
+Install the latest version from PyPI. For more details see [getting started](https://github.com/MozillaSecurity/grizzly/wiki/Getting-Started) on the wiki.
 
 ```python3 -m pip install grizzly-framework```
 

From 4361751264037926de24bda6ff2f03613fc56b1a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 27 Apr 2021 17:11:09 -0700
Subject: [PATCH 253/531] [tests] Address pylint 'consider-using-with'

---
 grizzly/common/storage.py |  1 +
 sapphire/conftest.py      | 38 +++++++++++++++++---------------------
 2 files changed, 18 insertions(+), 21 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 88074915..709d579e 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -539,6 +539,7 @@ def __init__(self, file_name):
             raise TypeError("file_name is invalid %r" % (file_name,))
         # name including path relative to wwwroot
         self._file_name = normpath(file_name)
+        # pylint: disable=consider-using-with
         self._fp = SpooledTemporaryFile(
             dir=grz_tmp("storage"), max_size=self.CACHE_LIMIT, prefix="testfile_"
         )
diff --git a/sapphire/conftest.py b/sapphire/conftest.py
index a30993a4..071661e0 100644
--- a/sapphire/conftest.py
+++ b/sapphire/conftest.py
@@ -98,28 +98,27 @@ def _handle_request(
                     # will calculate the md5 hash
                     data_hash = hashlib.md5() if t_file.md5_org is not None else None
                     target_url = quote(t_file.url)
-                cli = None
                 try:
                     if t_file.custom_request is None:
-                        cli = urlopen(
+                        with urlopen(
                             "http://%s:%d/%s" % (addr, port, target_url), timeout=10
-                        )
-                        resp_code = cli.getcode()
-                        content_type = cli.info().get("Content-Type")
-                        if resp_code == 200:
-                            data_length = 0
-                            while True:
-                                data = cli.read(self.rx_size)
-                                data_length += len(data)
+                        ) as cli:
+                            resp_code = cli.getcode()
+                            content_type = cli.info().get("Content-Type")
+                            if resp_code == 200:
+                                data_length = 0
+                                while True:
+                                    data = cli.read(self.rx_size)
+                                    data_length += len(data)
+                                    if data_hash is not None:
+                                        data_hash.update(data)
+                                    if len(data) < self.rx_size:
+                                        break
+                                    if throttle > 0:
+                                        # try to simulate a slow connection
+                                        time.sleep(throttle)
                                 if data_hash is not None:
-                                    data_hash.update(data)
-                                if len(data) < self.rx_size:
-                                    break
-                                if throttle > 0:
-                                    # try to simulate a slow connection
-                                    time.sleep(throttle)
-                            if data_hash is not None:
-                                data_hash = data_hash.hexdigest()
+                                    data_hash = data_hash.hexdigest()
                     else:  # custom request
                         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                         try:
@@ -177,9 +176,6 @@ def _handle_request(
                             if not skip_served or t_file.code is None:
                                 t_file.code = 0
                                 break
-                finally:
-                    if cli is not None:
-                        cli.close()
             self._idle.set()
 
         def wait(self, timeout=None):

From a56e41096fb989bb6a84e231719cded85f929b8a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 30 Apr 2021 13:34:17 -0700
Subject: [PATCH 254/531] [sapphire] Add more debug output in
 ConnectionManager.listener()

---
 sapphire/connection_manager.py | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/sapphire/connection_manager.py b/sapphire/connection_manager.py
index daf6dbf1..a0f9a7cd 100644
--- a/sapphire/connection_manager.py
+++ b/sapphire/connection_manager.py
@@ -113,8 +113,7 @@ def listener(serv_sock, serv_job, max_workers, shutdown_delay=0):
                     )
                     serv_job.worker_complete.wait()
                     serv_job.worker_complete.clear()
-                    # remove complete workers
-                    LOG.debug("trimming worker pool")
+                    LOG.debug("removing completed workers from worker pool")
                     # sometimes the thread that triggered the event doesn't quite
                     # cleanup in time, so retry (10x with 0.5 second sleep on failure)
                     for _ in range(10):
@@ -132,16 +131,20 @@ def listener(serv_sock, serv_job, max_workers, shutdown_delay=0):
                 serv_job.exceptions.put(exc_info())
             serv_job.finish()
         finally:
-            LOG.debug("listener cleaning up workers")
+            LOG.debug(
+                "shutting down listener, waiting %0.2fs for %d worker(s)...",
+                shutdown_delay,
+                len(worker_pool),
+            )
+            # use shutdown_delay to avoid cutting off connections
             deadline = time() + shutdown_delay
             while time() < deadline:
-                worker_pool = list(w for w in worker_pool if not w.done)
-                if not worker_pool:
+                # wait for all running workers to exit
+                if all(w.done for w in worker_pool):
                     break
-                # avoid cutting off connections
-                LOG.debug("waiting for %d worker(s)...", len(worker_pool))
                 sleep(0.1)
             else:  # pragma: no cover
-                LOG.debug("closing remaining workers")
-                for worker in (w for w in worker_pool if not w.done):
+                worker_pool = list(w for w in worker_pool if not w.done)
+                LOG.debug("closing remaining %d worker(s)", len(worker_pool))
+                for worker in worker_pool:
                     worker.close()

From 0735640ac84c30bcd617778d2d058b6128b0628e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 4 May 2021 10:03:06 -0700
Subject: [PATCH 255/531] Sanity check platform specific args

---
 grizzly/args.py      | 10 ++++++++++
 grizzly/test_args.py | 19 +++++++++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/grizzly/args.py b/grizzly/args.py
index faf5ea62..6e97181c 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -5,6 +5,7 @@
 from argparse import ArgumentParser, HelpFormatter
 from logging import CRITICAL, DEBUG, ERROR, INFO, WARNING
 from os.path import exists, isdir, isfile
+from platform import system
 
 from .common.plugins import scan as scan_plugins
 from .common.utils import TIMEOUT_DELAY
@@ -214,6 +215,15 @@ def sanity_check(self, args):
             if args.tool is not None and not args.fuzzmanager:
                 self.parser.error("--tool can only be given with --fuzzmanager")
 
+        # check platform specific args
+        os_name = system()
+        if args.rr and os_name != "Linux":
+            self.parser.error("--rr is only supported on Linux")
+        if args.valgrind and os_name != "Linux":
+            self.parser.error("--valgrind is only supported on Linux")
+        if args.xvfb and os_name != "Linux":
+            self.parser.error("--xvfb is only supported on Linux")
+
 
 class GrizzlyArgs(CommonArgs):
     def __init__(self):
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index 7dfed9f4..64f87737 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -87,11 +87,30 @@ def test_common_args_01a(capsys, mocker, tmp_path):
             "error: --rr and --valgrind are mutually exclusive",
             ["targ1"],
         ),
+        # test rr on unsupported platform
+        (
+            ["--platform", "targ1", "--rr"],
+            "error: --rr is only supported on Linux",
+            ["targ1"],
+        ),
+        # test Valgrind on unsupported platform
+        (
+            ["--platform", "targ1", "--valgrind"],
+            "error: --valgrind is only supported on Linux",
+            ["targ1"],
+        ),
+        # test Xvfb on unsupported platform
+        (
+            ["--platform", "targ1", "--xvfb"],
+            "error: --xvfb is only supported on Linux",
+            ["targ1"],
+        ),
     ],
 )
 def test_common_args_02(capsys, mocker, tmp_path, args, msg, targets):
     """test CommonArgs.parse_args()"""
     mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=targets)
+    mocker.patch("grizzly.args.system", autospec=True, return_value="foo")
     fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
     with raises(SystemExit):

From 3dcb0d53268a33595311c0be034c0e77752b4441 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 12 May 2021 15:03:59 -0700
Subject: [PATCH 256/531] Add to stackless OOM ignore list

---
 grizzly/common/reporter.py      | 18 ++++++++++++------
 grizzly/common/test_reporter.py |  7 ++++++-
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index e90fe91b..aa91e80e 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -62,7 +62,7 @@ class Report:
     DEFAULT_MAJOR = "NO_STACK"
     DEFAULT_MINOR = "0"
     HANG_STACK_HEIGHT = 10
-    MAX_LOG_SIZE = 1048576  # 1MB
+    MAX_LOG_SIZE = 1_048_576  # 1MB
 
     __slots__ = (
         "_crash_info",
@@ -596,14 +596,20 @@ def _process_rr_trace(self, report):
     @staticmethod
     def _ignored(report):
         # This is here to prevent reporting stack-less crashes
-        # that were caused by system OOM or bogus other crashes
+        # that were caused by system OOM
         with open(report.preferred, "rb") as log_fp:
             log_data = log_fp.read().decode("utf-8", errors="ignore")
-        mem_errs = ("ERROR: Failed to mmap", ": AddressSanitizer failed to allocate")
         # ignore sanitizer OOMs missing stack
-        for msg in mem_errs:
-            if msg in log_data and "#0 " not in log_data:
-                return True
+        if report.stack is None:
+            mem_errs = (
+                "ERROR: Failed to mmap",
+                # NOTE: max_allocation_size_mb can trigger a similar message
+                ": AddressSanitizer failed to allocate",
+                "Sanitizer: internal allocator is out of memory trying to allocate",
+            )
+            for msg in mem_errs:
+                if msg in log_data:
+                    return True
         # ignore Valgrind crashes
         if log_data.startswith("VEX temporary storage exhausted."):
             return True
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 58a4ad22..cab07313 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -576,7 +576,12 @@ def test_fuzzmanager_reporter_09(mocker, tmp_path):
     """test FuzzManagerReporter._ignored()"""
     log_file = tmp_path / "test.log"
     log_file.touch()
-    report = mocker.Mock(spec=Report, path=str(tmp_path), preferred=str(log_file))
+    report = mocker.Mock(
+        spec_set=Report,
+        path=str(tmp_path),
+        preferred=str(log_file),
+        stack=None,
+    )
     # not ignored
     assert not FuzzManagerReporter._ignored(report)
     # ignored - sanitizer OOM missing stack

From 81291e45a531f52c22319a957f1057b86d2d5016 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 18 May 2021 17:12:53 -0700
Subject: [PATCH 257/531] Better detection of TSan reports

---
 grizzly/common/reporter.py      |  8 +++++---
 grizzly/common/test_reporter.py | 16 ++++++++++++++++
 2 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index aa91e80e..ea207b95 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -283,18 +283,20 @@ def _find_sanitizer(logs):
         prioritize_tokens = (
             "use-after-",
             "-buffer-overflow on",
+            ": data race ",
             ": SEGV on ",
             "access-violation on ",
             "attempting free on ",
             "negative-size-param",
             "-param-overlap",
         )
+        fallback = None
         found = None
         for fname in (x for x in logs if "asan" in x):
             with open(fname, "r") as log_fp:
                 data = log_fp.read(65536)
             # look for interesting crash info in the log
-            if "==ERROR:" in data:
+            if "==ERROR:" in data or "WARNING:" in data:
                 # check for e10s forced crash
                 if re_e10s_forced.search(data) is not None:
                     continue
@@ -310,8 +312,8 @@ def _find_sanitizer(logs):
                     found = fname
                 # catch all (choose the one with info for now)
                 elif data:
-                    found = fname
-        return found
+                    fallback = fname
+        return found or fallback
 
     @staticmethod
     def _find_valgrind(logs):
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index cab07313..ef1f17ac 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -241,6 +241,22 @@ def test_report_09(tmp_path):
     selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
     assert selected is not None
     assert "heap-use-after-free" in Path(selected).read_text()
+    # test selecting TSan reports
+    tsan_path = tmp_path / "tsan"
+    tsan_path.mkdir()
+    (tsan_path / "log_asan_benign.txt").write_text(
+        "==27531==WARNING: Symbolizer buffer too small\n"
+        "==27531==WARNING: Symbolizer buffer too small"
+    )
+    tsan_report = tsan_path / "log_asan_report.txt"
+    tsan_report.write_text(
+        "WARNING: ThreadSanitizer: data race (pid=26919)\n"
+        "  Write of size 8 at 0x7f0ca2fc3400 by thread T51:\n"
+        "    #0 memcpy /sanitizer_common_interceptors.inc:810:5 (lib+0x6656e)\n"
+    )
+    selected = Report._find_sanitizer([str(x) for x in tsan_path.iterdir()])
+    assert selected is not None
+    assert selected == str(tsan_report)
 
 
 def test_report_10(tmp_path):

From f81d9248f644e8c2e1895802bbbb4e9c81c5351b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 18 May 2021 18:20:54 -0700
Subject: [PATCH 258/531] Create FM report zip in a temporary directory

---
 grizzly/common/reporter.py | 57 +++++++++++++++++---------------------
 1 file changed, 26 insertions(+), 31 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index ea207b95..29314f1d 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -17,7 +17,7 @@
 from re import compile as re_compile
 from shutil import copyfile, copyfileobj, move, rmtree
 from tarfile import open as tar_open
-from tempfile import mkstemp
+from tempfile import TemporaryDirectory, mkstemp
 from time import strftime
 from zipfile import ZIP_DEFLATED, ZipFile
 
@@ -702,38 +702,33 @@ def _submit_report(self, report, test_cases):
                 copyfile(screen_log, target_log)
                 Report.tail(target_log, 10240)  # limit to last 10K
 
-        # add results to a zip file
-        zip_name = "%s.zip" % (report.prefix,)
-        with ZipFile(zip_name, mode="w", compression=ZIP_DEFLATED) as zip_fp:
-            # add test files
-            for dir_name, _, dir_files in walk(report.path):
-                arc_path = relpath(dir_name, report.path)
-                for file_name in dir_files:
-                    zip_fp.write(
-                        pathjoin(dir_name, file_name),
-                        arcname=pathjoin(arc_path, file_name),
-                    )
-
-        # override tool name if specified
-        if self.tool is not None:
-            collector.tool = self.tool
-
-        # announce shortDescription if crash is not in a bucket
-        if (
-            cache_metadata["_grizzly_seen_count"] == 1
-            and not cache_metadata["frequent"]
-        ):
-            LOG.info("Submitting new crash %r", cache_metadata["shortDescription"])
-        # submit results to the FuzzManager server
-        new_entry = collector.submit(
-            report.crash_info, testCase=zip_name, testCaseQuality=self.quality
-        )
+        with TemporaryDirectory(prefix="fm-zip", dir=grz_tmp()) as tmp_dir:
+            # add results to a zip file
+            zip_name = pathjoin(tmp_dir, "%s.zip" % (report.prefix,))
+            with ZipFile(zip_name, mode="w", compression=ZIP_DEFLATED) as zip_fp:
+                # add test files
+                for dir_name, _, dir_files in walk(report.path):
+                    arc_path = relpath(dir_name, report.path)
+                    for file_name in dir_files:
+                        zip_fp.write(
+                            pathjoin(dir_name, file_name),
+                            arcname=pathjoin(arc_path, file_name),
+                        )
+            # override tool name if specified
+            if self.tool is not None:
+                collector.tool = self.tool
+            # announce shortDescription if crash is not in a bucket
+            if (
+                cache_metadata["_grizzly_seen_count"] == 1
+                and not cache_metadata["frequent"]
+            ):
+                LOG.info("Submitting new crash %r", cache_metadata["shortDescription"])
+            # submit results to the FuzzManager server
+            new_entry = collector.submit(
+                report.crash_info, testCase=zip_name, testCaseQuality=self.quality
+            )
         LOG.info("Logged %d with quality %d", new_entry["id"], self.quality)
 
-        # remove zipfile
-        if isfile(zip_name):
-            unlink(zip_name)
-
         return new_entry["id"]
 
 

From e32f3b3af4c1f5d54c9035567d7c9bfc9a2dbdde Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 18 May 2021 18:30:21 -0700
Subject: [PATCH 259/531] Fix nits in reporter

---
 grizzly/common/reporter.py | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 29314f1d..6f6cc9e1 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -89,10 +89,9 @@ def __init__(self, log_path, target_binary, is_hang=False, size_limit=MAX_LOG_SI
         if size_limit < 1:
             LOG.warning("No limit set on report log size!")
         else:
-            with scandir(path=log_path) as contents:
-                for log in contents:
-                    if log.is_file() and log.stat().st_size > size_limit:
-                        Report.tail(log.path, size_limit)
+            for log in scandir(path=log_path):
+                if log.is_file() and log.stat().st_size > size_limit:
+                    Report.tail(log.path, size_limit)
         # look through logs one by one until we find a stack
         for log_file in (x for x in self._logs if x is not None):
             with open(log_file, "rb") as log_fp:
@@ -383,11 +382,9 @@ def select_logs(cls, path):
         Returns:
             LogMap: A LogMap pointing to log files or None if path is empty.
         """
-        to_scan = None
-        with scandir(path=path) as contents:
-            files = (x for x in contents if x.is_file())
-            # order by date hopefully the oldest log is the cause of the issue
-            to_scan = [x.path for x in sorted(files, key=lambda x: x.stat().st_mtime)]
+        files = (x for x in scandir(path=path) if x.is_file())
+        # order by date hopefully the oldest log is the cause of the issue
+        to_scan = [x.path for x in sorted(files, key=lambda x: x.stat().st_mtime)]
         if not to_scan:
             LOG.warning("No files found in %r", path)
             return None
@@ -495,8 +492,7 @@ def _submit_report(self, report, test_cases):
             dest_path = pathjoin(self.report_path, report.major[:16])
         else:
             dest_path = self.report_path
-        if not isdir(dest_path):
-            makedirs(dest_path)
+        makedirs(dest_path, exist_ok=True)
         # dump test cases and the contained files to working directory
         for test_number, test_case in enumerate(test_cases):
             dump_path = pathjoin(dest_path, "%s-%d" % (report.prefix, test_number))

From 2255c14ae8ff0a7ab269460c1aed3e36723913d3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 28 May 2021 13:48:32 -0700
Subject: [PATCH 260/531] Add force_close kwarg to Target.close()

---
 grizzly/target/puppet_target.py | 4 ++--
 grizzly/target/target.py        | 2 +-
 grizzly/target/test_target.py   | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index c9ed4e06..9070ebdb 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -62,10 +62,10 @@ def cleanup(self):
         if self._remove_prefs and self._prefs and isfile(self._prefs):
             unlink(self._prefs)
 
-    def close(self):
+    def close(self, force_close=False):
         # prevent parallel calls to FFPuppet.close() and/or FFPuppet.clean_up()
         with self._lock:
-            self._puppet.close()
+            self._puppet.close(force_close=force_close)
 
     @property
     def closed(self):
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index d3f263b5..fa4c9511 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -73,7 +73,7 @@ def cleanup(self):
         pass
 
     @abstractmethod
-    def close(self):
+    def close(self, force_close=False):
         pass
 
     @abstractproperty
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index 2a6ec935..c9b0fb32 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -10,7 +10,7 @@ class SimpleTarget(Target):
     def cleanup(self):
         pass
 
-    def close(self):
+    def close(self, force_close=False):
         pass
 
     @property

From 569a31840b8aeef1f0a8f6860f4da89c80b84daf Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 28 May 2021 13:51:38 -0700
Subject: [PATCH 261/531] [replay] Use Target.close(force_close=True) when not
 checking results

---
 grizzly/replay/replay.py      | 3 ++-
 grizzly/replay/test_replay.py | 2 ++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 71807200..9a6e459c 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -504,7 +504,8 @@ def run(
             # remove unpacked testcase data
             for tc_path in unpacked:
                 rmtree(tc_path)
-            self.target.close()
+            # we don't want to clean up but we are not checking results
+            self.target.close(force_close=True)
             # remove unprocessed reports
             for report in reports.values():
                 report.report.cleanup()
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 3a1ec9ce..73f86b97 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -59,6 +59,8 @@ def test_replay_02(mocker, tmp_path):
             assert replay.status.results == 0
             assert target.monitor.is_healthy.call_count == 1
             assert target.close.call_count == 2
+            assert target.close.mock_calls[0] == mocker.call()
+            assert target.close.mock_calls[1] == mocker.call(force_close=True)
         assert not any(tmp_path.iterdir())
 
 

From 137069f17856eea997f6259196440ac97178c4fc Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 14 Jun 2021 16:30:37 -0700
Subject: [PATCH 262/531] Update FFPuppet support

---
 grizzly/args.py                      | 37 ++++++++++++----------------
 grizzly/main.py                      |  1 +
 grizzly/target/puppet_target.py      | 30 ++++++++++++++--------
 grizzly/target/test_puppet_target.py | 21 +++++++---------
 grizzly/test_args.py                 | 24 ------------------
 grizzly/test_main.py                 |  1 +
 setup.cfg                            |  2 +-
 7 files changed, 48 insertions(+), 68 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 6e97181c..795ca941 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -102,9 +102,6 @@ def __init__(self):
             help="Number of iterations performed before relaunching the browser"
             " (default: %(default)s)",
         )
-        self.launcher_grp.add_argument(
-            "--rr", action="store_true", help="Use rr (Linux only)"
-        )
         self.launcher_grp.add_argument(
             "--time-limit",
             type=int,
@@ -125,12 +122,10 @@ def __init__(self):
             " and will be closed. Typically this should be a few seconds greater"
             " than the value used for `test-duration`." % (TIMEOUT_DELAY,),
         )
-        self.launcher_grp.add_argument(
-            "--valgrind", action="store_true", help="Use Valgrind (Linux only)"
-        )
-        self.launcher_grp.add_argument(
-            "--xvfb", action="store_true", help="Use Xvfb (Linux only)"
-        )
+        if system().startswith("Linux"):
+            self.launcher_grp.add_argument(
+                "--xvfb", action="store_true", help="Use Xvfb."
+            )
 
         self.reporter_grp = self.parser.add_argument_group("Reporter Arguments")
         self.reporter_grp.add_argument(
@@ -148,6 +143,18 @@ def __init__(self):
             help="Override tool name used when reporting issues to FuzzManager",
         )
 
+        if system().startswith("Linux"):
+            dbg_group = self.launcher_grp.add_mutually_exclusive_group()
+            dbg_group.add_argument(
+                "--pernosco",
+                action="store_true",
+                help="Use rr. Trace intended to be used with Pernosco.",
+            )
+            dbg_group.add_argument("--rr", action="store_true", help="Use rr.")
+            dbg_group.add_argument(
+                "--valgrind", action="store_true", help="Use Valgrind."
+            )
+
         self.parser.epilog = (
             "For addition help check out the wiki:"
             " https://github.com/MozillaSecurity/grizzly/wiki"
@@ -202,9 +209,6 @@ def sanity_check(self, args):
         if args.prefs and not isfile(args.prefs):
             self.parser.error("--prefs file not found")
 
-        if args.rr and args.valgrind:
-            self.parser.error("--rr and --valgrind are mutually exclusive")
-
         if args.time_limit is not None and args.time_limit < 1:
             self.parser.error("--time-limit must be >= 1")
 
@@ -215,15 +219,6 @@ def sanity_check(self, args):
             if args.tool is not None and not args.fuzzmanager:
                 self.parser.error("--tool can only be given with --fuzzmanager")
 
-        # check platform specific args
-        os_name = system()
-        if args.rr and os_name != "Linux":
-            self.parser.error("--rr is only supported on Linux")
-        if args.valgrind and os_name != "Linux":
-            self.parser.error("--valgrind is only supported on Linux")
-        if args.xvfb and os_name != "Linux":
-            self.parser.error("--xvfb is only supported on Linux")
-
 
 class GrizzlyArgs(CommonArgs):
     def __init__(self):
diff --git a/grizzly/main.py b/grizzly/main.py
index 50e98118..e556fd53 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -83,6 +83,7 @@ def main(args):
             args.launch_timeout,
             args.log_limit,
             args.memory,
+            pernosco=args.pernosco,
             rr=args.rr,
             valgrind=args.valgrind,
             xvfb=args.xvfb,
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 9070ebdb..e02bdc8d 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -16,6 +16,7 @@
 from time import sleep, time
 
 from ffpuppet import BrowserTimeoutError, FFPuppet, LaunchError
+from ffpuppet.core import Debugger, Reason
 from prefpicker import PrefPicker
 from psutil import AccessDenied, NoSuchProcess, Process, process_iter
 
@@ -32,20 +33,29 @@
 
 
 class PuppetTarget(Target):
-    __slots__ = ("use_rr", "use_valgrind", "_puppet", "_remove_prefs")
+    __slots__ = ("use_valgrind", "_puppet", "_remove_prefs")
 
     def __init__(
         self, binary, extension, launch_timeout, log_limit, memory_limit, **kwds
     ):
         super().__init__(binary, extension, launch_timeout, log_limit, memory_limit)
-        self.use_rr = kwds.pop("rr", False)
-        self.use_valgrind = kwds.pop("valgrind", False)
+        # TODO: clean up handling debuggers
+        if kwds.pop("pernosco", False):
+            debugger = Debugger.PERNOSCO
+        elif kwds.pop("rr", False):
+            debugger = Debugger.RR
+        elif kwds.pop("valgrind", False):
+            self.use_valgrind = True
+            debugger = Debugger.VALGRIND
+        else:
+            debugger = Debugger.NONE
         self._remove_prefs = False
+
         # create Puppet object
         self._puppet = FFPuppet(
-            use_rr=self.use_rr,
-            use_valgrind=self.use_valgrind,
+            debugger=debugger,
             use_xvfb=kwds.pop("xvfb", False),
+            working_path=grz_tmp("target_ffpuppet"),
         )
         if kwds:
             LOG.warning(
@@ -113,19 +123,19 @@ def detect_failure(self, ignored):
         if not self._puppet.is_healthy():
             self.close()
             # something has happened figure out what
-            if self._puppet.reason == FFPuppet.RC_CLOSED:
+            if self._puppet.reason == Reason.CLOSED:
                 LOG.debug("target.close() was called")
-            elif self._puppet.reason == FFPuppet.RC_EXITED:
+            elif self._puppet.reason == Reason.EXITED:
                 LOG.debug("target closed itself")
             elif (
-                self._puppet.reason == FFPuppet.RC_WORKER
+                self._puppet.reason == Reason.WORKER
                 and "memory" in ignored
                 and "ffp_worker_memory_usage" in self._puppet.available_logs()
             ):
                 status = self.RESULT_IGNORED
                 LOG.debug("memory limit exceeded")
             elif (
-                self._puppet.reason == FFPuppet.RC_WORKER
+                self._puppet.reason == Reason.WORKER
                 and "log-limit" in ignored
                 and "ffp_worker_log_size" in self._puppet.available_logs()
             ):
@@ -133,7 +143,7 @@ def detect_failure(self, ignored):
                 LOG.debug("log size limit exceeded")
             else:
                 # crash or hang (forced SIGABRT) has been detected
-                LOG.debug("failure detected, ffpuppet reason %r", self._puppet.reason)
+                LOG.debug("failure detected, ffpuppet %s", self._puppet.reason)
                 status = self.RESULT_FAILURE
         return status
 
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index b12957c1..9ddf2206 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -6,7 +6,8 @@
 from os.path import isfile
 from platform import system
 
-from ffpuppet import BrowserTerminatedError, BrowserTimeoutError, FFPuppet
+from ffpuppet import BrowserTerminatedError, BrowserTimeoutError
+from ffpuppet.core import Reason
 from pytest import mark, raises
 
 from .puppet_target import PuppetTarget
@@ -16,7 +17,7 @@
 def test_puppet_target_01(mocker, tmp_path):
     """test creating a PuppetTarget"""
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
-    fake_ffp.return_value.reason = FFPuppet.RC_CLOSED
+    fake_ffp.return_value.reason = Reason.CLOSED
     fake_ffp.return_value.log_length.return_value = 562
     fake_file = tmp_path / "fake"
     fake_file.touch()
@@ -83,26 +84,22 @@ def test_puppet_target_02(mocker, tmp_path):
         # running as expected - no failures
         (True, None, [], Target.RESULT_NONE, 0),
         # browser process closed
-        (False, FFPuppet.RC_CLOSED, [], Target.RESULT_NONE, 1),
+        (False, Reason.CLOSED, [], Target.RESULT_NONE, 1),
         # browser process crashed
-        (False, FFPuppet.RC_ALERT, [], Target.RESULT_FAILURE, 1),
+        (False, Reason.ALERT, [], Target.RESULT_FAILURE, 1),
         # browser exit with no crash logs
-        (False, FFPuppet.RC_EXITED, [], Target.RESULT_NONE, 1),
+        (False, Reason.EXITED, [], Target.RESULT_NONE, 1),
         # ffpuppet check failed
-        (False, FFPuppet.RC_WORKER, [], Target.RESULT_FAILURE, 1),
+        (False, Reason.WORKER, [], Target.RESULT_FAILURE, 1),
         # ffpuppet check ignored (memory)
-        (False, FFPuppet.RC_WORKER, ["memory"], Target.RESULT_IGNORED, 1),
+        (False, Reason.WORKER, ["memory"], Target.RESULT_IGNORED, 1),
         # ffpuppet check ignored (log-limit)
-        (False, FFPuppet.RC_WORKER, ["log-limit"], Target.RESULT_IGNORED, 1),
+        (False, Reason.WORKER, ["log-limit"], Target.RESULT_IGNORED, 1),
     ],
 )
 def test_puppet_target_03(mocker, tmp_path, healthy, reason, ignore, result, closes):
     """test PuppetTarget.detect_failure()"""
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
-    fake_ffp.RC_ALERT = FFPuppet.RC_ALERT
-    fake_ffp.RC_CLOSED = FFPuppet.RC_CLOSED
-    fake_ffp.RC_EXITED = FFPuppet.RC_EXITED
-    fake_ffp.RC_WORKER = FFPuppet.RC_WORKER
     fake_file = tmp_path / "fake"
     fake_file.touch()
     target = PuppetTarget(str(fake_file), None, 300, 25, 5000)
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index 64f87737..d275ac8a 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -81,30 +81,6 @@ def test_common_args_01a(capsys, mocker, tmp_path):
             "error: --tool can only be given with --fuzzmanager",
             ["targ1"],
         ),
-        # test enabling both rr and Valgrind
-        (
-            ["--platform", "targ1", "--rr", "--valgrind"],
-            "error: --rr and --valgrind are mutually exclusive",
-            ["targ1"],
-        ),
-        # test rr on unsupported platform
-        (
-            ["--platform", "targ1", "--rr"],
-            "error: --rr is only supported on Linux",
-            ["targ1"],
-        ),
-        # test Valgrind on unsupported platform
-        (
-            ["--platform", "targ1", "--valgrind"],
-            "error: --valgrind is only supported on Linux",
-            ["targ1"],
-        ),
-        # test Xvfb on unsupported platform
-        (
-            ["--platform", "targ1", "--xvfb"],
-            "error: --xvfb is only supported on Linux",
-            ["targ1"],
-        ),
     ],
 )
 def test_common_args_02(capsys, mocker, tmp_path, args, msg, targets):
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 06627883..ec9980ed 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -29,6 +29,7 @@ def __init__(self):
         self.log_level = 10  # 10 = DEBUG, 20 = INFO
         self.log_limit = 0
         self.memory = 0
+        self.pernosco = False
         self.platform = "fake-target"
         self.prefs = None
         self.rr = False  # pylint: disable=invalid-name
diff --git a/setup.cfg b/setup.cfg
index d7ea5725..03d8f110 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -22,7 +22,7 @@ include_package_data = True
 install_requires =
     cssbeautifier
     fasteners
-    ffpuppet
+    ffpuppet >= 0.8.0
     FuzzManager
     jsbeautifier
     lithium-reducer >= 0.5

From 9a07fc347062b65edd0d52368ffd9156b6fbd4eb Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 15 Jun 2021 11:11:31 -0700
Subject: [PATCH 263/531] Pass pernosco args to target in all cases

---
 grizzly/main.py          | 6 ++++--
 grizzly/reduce/core.py   | 9 ++++++---
 grizzly/replay/replay.py | 5 ++++-
 3 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/grizzly/main.py b/grizzly/main.py
index e556fd53..a4d1d5a3 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -38,9 +38,11 @@ def main(args):
         LOG.info("Ignoring: %s", ", ".join(args.ignore))
     if args.xvfb:
         LOG.info("Running with Xvfb")
-    if args.rr:
+    if args.pernosco:
+        LOG.info("Running with RR (Pernosco mode)")
+    elif args.rr:
         LOG.info("Running with RR")
-    if args.valgrind:
+    elif args.valgrind:
         LOG.info("Running with Valgrind. This will be SLOW!")
 
     adapter = None
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index c6d96004..fc4503a5 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -712,10 +712,12 @@ def main(cls, args):
             LOG.info("Ignoring: %s", ", ".join(args.ignore))
         if args.xvfb:
             LOG.info("Running with Xvfb")
-        if args.valgrind:
-            LOG.info("Running with Valgrind. This will be SLOW!")
-        if args.rr:
+        if args.pernosco:
+            LOG.info("Running with RR (Pernosco mode)")
+        elif args.rr:
             LOG.info("Running with RR")
+        elif args.valgrind:
+            LOG.info("Running with Valgrind. This will be SLOW!")
 
         signature = None
         signature_desc = None
@@ -772,6 +774,7 @@ def main(cls, args):
                 args.launch_timeout,
                 args.log_limit,
                 args.memory,
+                pernosco=args.pernosco,
                 rr=args.rr,
                 valgrind=args.valgrind,
                 xvfb=args.xvfb,
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 9a6e459c..1b8873a6 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -552,7 +552,9 @@ def main(cls, args):
             LOG.info("Ignoring: %s", ", ".join(args.ignore))
         if args.xvfb:
             LOG.info("Running with Xvfb")
-        if args.rr:
+        if args.pernosco:
+            LOG.info("Running with RR (Pernosco mode)")
+        elif args.rr:
             LOG.info("Running with RR")
         elif args.valgrind:
             LOG.info("Running with Valgrind. This will be SLOW!")
@@ -606,6 +608,7 @@ def main(cls, args):
                 args.launch_timeout,
                 args.log_limit,
                 args.memory,
+                pernosco=args.pernosco,
                 rr=args.rr,
                 valgrind=args.valgrind,
                 xvfb=args.xvfb,

From ff0f527afebdd8ba9dfe41326ecffba3cd95eb79 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 15 Jun 2021 11:14:33 -0700
Subject: [PATCH 264/531] [tests] Test processing debugger args in PuppetTarget

---
 grizzly/target/puppet_target.py      |  7 +++---
 grizzly/target/test_puppet_target.py | 34 +++++++++++++++++++++++++++-
 2 files changed, 36 insertions(+), 5 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index e02bdc8d..e03e9851 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -40,15 +40,14 @@ def __init__(
     ):
         super().__init__(binary, extension, launch_timeout, log_limit, memory_limit)
         # TODO: clean up handling debuggers
+        debugger = Debugger.NONE
         if kwds.pop("pernosco", False):
             debugger = Debugger.PERNOSCO
-        elif kwds.pop("rr", False):
+        if kwds.pop("rr", False):
             debugger = Debugger.RR
-        elif kwds.pop("valgrind", False):
+        if kwds.pop("valgrind", False):
             self.use_valgrind = True
             debugger = Debugger.VALGRIND
-        else:
-            debugger = Debugger.NONE
         self._remove_prefs = False
 
         # create Puppet object
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 9ddf2206..9aaedaf7 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -7,7 +7,7 @@
 from platform import system
 
 from ffpuppet import BrowserTerminatedError, BrowserTimeoutError
-from ffpuppet.core import Reason
+from ffpuppet.core import Debugger, Reason
 from pytest import mark, raises
 
 from .puppet_target import PuppetTarget
@@ -328,3 +328,35 @@ def test_puppet_target_08(mocker, tmp_path):
         with raises(TargetError, match="Missing prefs.js file 'missing'"):
             target.prefs = "missing"
         assert not isfile(prefs_file)
+
+
+@mark.parametrize(
+    "pernosco, rr, valgrind",
+    [
+        # No debugger selected
+        (False, False, False),
+        # Pernosco selected
+        (True, False, False),
+        # rr selected
+        (False, True, False),
+        # Valgrind selected
+        (False, False, True),
+    ],  # pylint: disable=invalid-name
+)
+def test_puppet_target_09(mocker, tmp_path, pernosco, rr, valgrind):
+    """test PuppetTarget debugger args"""
+    fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
+    fake_file = tmp_path / "fake"
+    fake_file.touch()
+    with PuppetTarget(
+        str(fake_file), None, 30, 25, 500, pernosco=pernosco, rr=rr, valgrind=valgrind
+    ) as _:
+        pass
+    if pernosco:
+        assert fake_ffp.call_args[-1]["debugger"] == Debugger.PERNOSCO
+    elif rr:
+        assert fake_ffp.call_args[-1]["debugger"] == Debugger.RR
+    elif valgrind:
+        assert fake_ffp.call_args[-1]["debugger"] == Debugger.VALGRIND
+    else:
+        assert fake_ffp.call_args[-1]["debugger"] == Debugger.NONE

From 41331fd0950b525084b8b3c6fcb6474fbe27ee0f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 15 Jun 2021 11:31:04 -0700
Subject: [PATCH 265/531] Update minimum FFPuppet version to 0.8.1

---
 grizzly/target/puppet_target.py      | 3 +--
 grizzly/target/test_puppet_target.py | 3 +--
 setup.cfg                            | 2 +-
 3 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index e03e9851..bcf80545 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -15,8 +15,7 @@
 from tempfile import mkdtemp, mkstemp
 from time import sleep, time
 
-from ffpuppet import BrowserTimeoutError, FFPuppet, LaunchError
-from ffpuppet.core import Debugger, Reason
+from ffpuppet import BrowserTimeoutError, Debugger, FFPuppet, LaunchError, Reason
 from prefpicker import PrefPicker
 from psutil import AccessDenied, NoSuchProcess, Process, process_iter
 
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 9aaedaf7..68ce1688 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -6,8 +6,7 @@
 from os.path import isfile
 from platform import system
 
-from ffpuppet import BrowserTerminatedError, BrowserTimeoutError
-from ffpuppet.core import Debugger, Reason
+from ffpuppet import BrowserTerminatedError, BrowserTimeoutError, Debugger, Reason
 from pytest import mark, raises
 
 from .puppet_target import PuppetTarget
diff --git a/setup.cfg b/setup.cfg
index 03d8f110..49d13f5f 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -22,7 +22,7 @@ include_package_data = True
 install_requires =
     cssbeautifier
     fasteners
-    ffpuppet >= 0.8.0
+    ffpuppet >= 0.8.1
     FuzzManager
     jsbeautifier
     lithium-reducer >= 0.5

From 41e227fc70adcaaa263922900616081ab42fbcc4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 17 Jun 2021 12:10:56 -0700
Subject: [PATCH 266/531] Replace Status.duration with Status.runtime

Calculations are now based on read-only status
---
 grizzly/common/status.py               | 32 ++++++++++++--------
 grizzly/common/status_reporter.py      | 11 +++----
 grizzly/common/test_status.py          | 42 ++++++++++++++++++--------
 grizzly/common/test_status_reporter.py |  5 +--
 4 files changed, 56 insertions(+), 34 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 7aa7b5dc..5a18c8f1 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -113,18 +113,6 @@ def _data(self):
             "timestamp": self.timestamp,
         }
 
-    @property
-    def duration(self):
-        """Calculate the number of seconds since start() was called.
-
-        Args:
-            None
-
-        Returns:
-            int: Total runtime in seconds since start() was called
-        """
-        return max(self.timestamp - self.start_time, 0)
-
     @classmethod
     def load(cls, data_file):
         """Load status report. Loading a status report from disk will create a
@@ -162,6 +150,7 @@ def load(cls, data_file):
             return None
         for attr, value in data.items():
             setattr(status, attr, value)
+        assert status.start_time <= status.timestamp
         # set read only
         status.data_file = None
         return status
@@ -231,7 +220,8 @@ def rate(self):
         Returns:
             float: Number of iterations performed per second.
         """
-        return self.iteration / float(self.duration) if self.duration > 0 else 0
+        runtime = self.runtime
+        return self.iteration / float(runtime) if runtime else 0
 
     def record(self, name, duration):
         """Used to add profiling data. This is intended to be used to make rough
@@ -278,6 +268,7 @@ def report(self, force=False, report_freq=REPORT_FREQ):
         now = time()
         if not force and now < (self.timestamp + report_freq):
             return False
+        assert self.start_time <= now
         self.timestamp = now
         with self._lock:
             with open(self.data_file, "w") as out_fp:
@@ -296,6 +287,21 @@ def results(self):
         """
         return sum(self._results.values())
 
+    @property
+    def runtime(self):
+        """Calculate the number of seconds since start() was called. Value is
+        calculated relative to 'timestamp' if status object is read-only.
+
+        Args:
+            None
+
+        Returns:
+            int: Total runtime in seconds.
+        """
+        if self.data_file is None:
+            return self.timestamp - self.start_time
+        return max(time() - self.start_time, 0)
+
     def signatures(self):
         """Provide the signature and the number of times it has been found for
         each result.
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index aec54429..4fc8bf33 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -41,6 +41,7 @@ class StatusReporter:
     SUMMARY_LIMIT = 4095  # summary output must be no more than 4KB
 
     def __init__(self, reports, tracebacks=None):
+        assert all(x.data_file is None for x in reports)
         self.reports = reports
         self.tracebacks = tracebacks
 
@@ -136,7 +137,7 @@ def _specific(self):
         if not self.reports:
             return "No status reports available"
         exp = int(time()) - self.EXP_LIMIT
-        self.reports.sort(key=lambda x: x.duration, reverse=True)
+        self.reports.sort(key=lambda x: x.runtime, reverse=True)
         self.reports.sort(key=lambda x: x.timestamp < exp)
         txt = list()
         for num, report in enumerate(self.reports, start=1):
@@ -144,7 +145,7 @@ def _specific(self):
             if report.timestamp < exp:
                 txt.append(" (EXPIRED)\n")
                 continue
-            txt.append(" Runtime %s\n" % (timedelta(seconds=int(report.duration)),))
+            txt.append(" Runtime %s\n" % (timedelta(seconds=int(report.runtime)),))
             txt.append(" * Iterations: %d" % (report.iteration,))
             txt.append(" @ %0.2f," % (round(report.rate, 2),))
             txt.append(" Ignored: %d," % (report.ignored,))
@@ -162,9 +163,7 @@ def _specific(self):
                     txt.append(str(timedelta(seconds=int(entry.total))))
                 else:
                     txt.append("%0.3fs" % (round(entry.total, 3),))
-                txt.append(
-                    " %0.2f%%" % (round(entry.total / report.duration * 100, 2),)
-                )
+                txt.append(" %0.2f%%" % (round(entry.total / report.runtime * 100, 2),))
                 txt.append(" (%0.3f avg," % (round(avg, 3),))
                 txt.append(" %0.3f max," % (round(entry.max, 3),))
                 txt.append(" %0.3f min)" % (round(entry.min, 3),))
@@ -218,7 +217,7 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
             # Runtime
             if runtime:
                 txt.append("\n")
-                total_runtime = sum(x.duration for x in reports)
+                total_runtime = sum(x.runtime for x in reports)
                 txt.append("   Runtime : %s" % (timedelta(seconds=int(total_runtime)),))
             # Log size
             log_usage = sum(log_sizes) / 1048576.0
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 0de9825e..fa321016 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -13,9 +13,10 @@
 from .status import Status
 
 
-def test_status_01(tmp_path):
+def test_status_01(mocker, tmp_path):
     """test Status.start()"""
     Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.common.status.time", return_value=1.0)
     status = Status.start()
     assert status is not None
     assert status.data_file is not None
@@ -23,12 +24,12 @@ def test_status_01(tmp_path):
     assert stat(status.data_file).st_size > 0
     assert status.start_time > 0
     assert status.timestamp >= status.start_time
-    assert int(status.duration) == 0
     assert status.ignored == 0
     assert status.iteration == 0
     assert status.log_size == 0
     assert status.rate == 0
     assert status.results == 0
+    assert int(status.runtime) == 0
     assert status.pid is not None
     assert not status._enable_profiling
     assert not status._profiles
@@ -83,9 +84,10 @@ def test_status_04(tmp_path):
     assert Status.load(str(bad)) is None
 
 
-def test_status_05(tmp_path):
+def test_status_05(mocker, tmp_path):
     """test Status.load()"""
     Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.common.status.time", return_value=1.0)
     # create simple entry
     status = Status.start(enable_profiling=True)
     status.count_result("sig1")
@@ -96,7 +98,7 @@ def test_status_05(tmp_path):
     assert loaded.data_file is None
     assert status.start_time == loaded.start_time
     assert status.timestamp == loaded.timestamp
-    assert status.duration == loaded.duration
+    assert status.runtime == loaded.runtime
     assert status.ignored == loaded.ignored
     assert status.iteration == loaded.iteration
     assert status.log_size == loaded.log_size
@@ -127,19 +129,33 @@ def test_status_06(tmp_path):
     assert len(tuple(Status.loadall())) == 5
 
 
-def test_status_07(tmp_path):
-    """test Status.duration and Status.rate calculations"""
+def test_status_07(mocker, tmp_path):
+    """test Status.runtime and Status.rate calculations"""
     Status.PATH = str(tmp_path)
+    mocker.patch(
+        "grizzly.common.status.time", side_effect=(1.0, 1.0, 3.0, 3.0, 5.0, 5.0, 5.0)
+    )
     status = Status.start()
-    status.start_time = 1
-    status.timestamp = 2
-    status.iteration = 0
-    assert status.duration == 1
+    assert status.data_file is not None
+    assert status.start_time == 1
+    # test no iterations
+    assert status.runtime == 2.0
     assert status.rate == 0
+    # test one iteration
     status.iteration = 1
-    assert status.rate == 1
-    status.timestamp += 1
-    assert status.rate == 0.5
+    # timestamp should be ignored when calculating rate and runtime on active object
+    status.timestamp = 100
+    assert status.runtime == 4.0
+    assert status.rate == 0.25
+    # test loaded
+    status.report(force=True)
+    loaded = Status.load(status.data_file)
+    assert loaded.runtime == 4.0
+    assert loaded.rate == 0.25
+    # timestamp should be used when calculating rate and runtime on loaded object
+    loaded.timestamp = 2.0
+    assert loaded.runtime == 1.0
+    assert loaded.rate == 1.0
 
 
 def _client_writer(done, reported, working_path):
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 8ad1ac7e..7deeab03 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -125,8 +125,10 @@ def test_status_reporter_04(tmp_path):
     assert any(StatusReporter._scan(str(tmp_path), "TEST_FILE"))
 
 
-def test_status_reporter_05(tmp_path):
+def test_status_reporter_05(mocker, tmp_path):
     """test StatusReporter._summary()"""
+    mocker.patch("grizzly.common.status.time", side_effect=count(start=1.0, step=1.0))
+    mocker.patch("grizzly.common.status_reporter.time", side_effect=(1.0, 2.0))
     Status.PATH = str(tmp_path)
     # single report
     status = Status.start()
@@ -149,7 +151,6 @@ def test_status_reporter_05(tmp_path):
     assert len(output.split("\n")) == 3
     # multiple reports
     status = Status.start()
-    status.start_time += 66.0
     status.ignored = 1
     status.iteration = 8
     status.log_size = 86900000

From 54f8d6a97e0d2b82bd0df416cd74932af496b29d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 17 Jun 2021 14:04:37 -0700
Subject: [PATCH 267/531] Add --runtime argument

---
 grizzly/args.py         | 22 +++++++++++++-----
 grizzly/main.py         |  7 ++++--
 grizzly/session.py      |  8 ++++++-
 grizzly/test_args.py    |  4 +++-
 grizzly/test_main.py    | 20 ++++++++++-------
 grizzly/test_session.py | 50 +++++++++++++++++++++++++++--------------
 6 files changed, 76 insertions(+), 35 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 795ca941..90ed6650 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -236,7 +236,7 @@ def __init__(self):
             " status reporter while running Grizzly.",
         )
         self.parser.add_argument(
-            "-i", "--input", help="Test case or directory containing test cases"
+            "-i", "--input", help="Test case or directory containing test cases."
         )
         self.parser.add_argument(
             "--limit",
@@ -255,7 +255,14 @@ def __init__(self):
         )
 
         self.launcher_grp.add_argument(
-            "--coverage", action="store_true", help="Enable coverage collection"
+            "--coverage", action="store_true", help="Enable coverage collection."
+        )
+        self.launcher_grp.add_argument(
+            "--runtime",
+            type=int,
+            default=0,
+            help="Maximum runtime in seconds. Checked after each iteration."
+            " (default: 'no limit')",
         )
 
         self.reporter_grp.add_argument(
@@ -263,14 +270,14 @@ def __init__(self):
             "--collect",
             type=int,
             default=1,
-            help="Maximum number of test cases to include in the report"
-            "(default: %(default)s)",
+            help="Maximum number of test cases to include in the report."
+            " (default: %(default)s)",
         )
         self.reporter_grp.add_argument(
             "--s3-fuzzmanager",
             action="store_true",
             help="Report large attachments (if any) to S3 and then the crash &"
-            " S3 link to FuzzManager",
+            " S3 link to FuzzManager.",
         )
 
     def sanity_check(self, args):
@@ -294,7 +301,10 @@ def sanity_check(self, args):
             self.parser.error("%r does not exist" % (args.input,))
 
         if args.limit < 0:
-            self.parser.error("--limit must be >= 0 (0 = no limit)")
+            self.parser.error("--limit must be >= 0")
+
+        if args.runtime < 0:
+            self.parser.error("--runtime must be >= 0")
 
         if args.tool is not None and not (args.fuzzmanager or args.s3_fuzzmanager):
             self.parser.error(
diff --git a/grizzly/main.py b/grizzly/main.py
index a4d1d5a3..f1891635 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -52,7 +52,7 @@ def main(args):
         LOG.debug("initializing Adapter %r", args.adapter)
         adapter = load_plugin(args.adapter, "grizzly_adapters", Adapter)(args.adapter)
 
-        # test time limit and timeout sanity checking
+        # test case time limit and timeout sanity checking
         if args.time_limit:
             time_limit = args.time_limit
         else:
@@ -108,8 +108,10 @@ def main(args):
             reporter = FilesystemReporter(pathjoin(getcwd(), "results"))
             LOG.info("Results will be stored in %r", reporter.report_path)
 
-        if args.limit > 0:
+        if args.limit:
             LOG.info("%r iteration(s) will be attempted", args.limit)
+        if args.runtime:
+            LOG.info("Runtime is limited to %rs", args.runtime)
 
         # set 'auto_close=1' so the client error pages (code 4XX) will
         # call 'window.close()' after a second.
@@ -137,6 +139,7 @@ def main(args):
                 time_limit,
                 input_path=args.input,
                 iteration_limit=args.limit,
+                runtime_limit=args.runtime,
                 display_mode=display_mode,
             )
 
diff --git a/grizzly/session.py b/grizzly/session.py
index d27b352c..cf82c03e 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -147,10 +147,12 @@ def run(
         time_limit,
         input_path=None,
         iteration_limit=0,
+        runtime_limit=0,
         display_mode=DISPLAY_NORMAL,
     ):
-        assert time_limit > 0
         assert iteration_limit >= 0
+        assert runtime_limit >= 0
+        assert time_limit > 0
 
         LOG.debug("calling adapter.setup()")
         self.adapter.setup(input_path, self.iomanager.server_map)
@@ -274,6 +276,10 @@ def run(
                 LOG.info("Hit iteration limit (%d)", iteration_limit)
                 break
 
+            if runtime_limit and self.status.runtime >= runtime_limit:
+                LOG.info("Hit runtime limit (%ds)", runtime_limit)
+                break
+
             # warn about large browser logs
             self.status.log_size = self.target.log_size()
             if self.status.log_size > self.TARGET_LOG_SIZE_WARN:
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index d275ac8a..83ff0470 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -152,7 +152,9 @@ def test_grizzly_args_03(capsys, mocker, tmp_path):
         # test missing input
         (["--input", "missing"], "error: 'missing' does not exist"),
         # test invalid limit value
-        (["--limit", "-1"], "error: --limit must be >= 0 (0 = no limit)"),
+        (["--limit", "-1"], "error: --limit must be >= 0"),
+        # test runtime limit value
+        (["--runtime", "-1"], "error: --runtime must be >= 0"),
         # test tool
         (
             ["--tool", "x"],
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index ec9980ed..8ec5a370 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -34,6 +34,7 @@ def __init__(self):
         self.prefs = None
         self.rr = False  # pylint: disable=invalid-name
         self.relaunch = 1000
+        self.runtime = 0
         self.s3_fuzzmanager = False
         self.time_limit = None
         self.timeout = None
@@ -44,21 +45,23 @@ def __init__(self):
 
 
 @mark.parametrize(
-    "cov, adpt_relaunch, limit, verbose",
+    "cov, adpt_relaunch, limit, runtime, verbose",
     [
         # successful run
-        (False, 0, 0, True),
-        # successful run (with limit)
-        (False, 0, 10, True),
+        (False, 0, 0, 0, True),
+        # successful run (with iteration limit)
+        (False, 0, 10, 0, True),
+        # successful run (with runtime limit)
+        (False, 0, 0, 10, True),
         # successful run (with coverage)
-        (True, 0, 0, False),
+        (True, 0, 0, 0, False),
         # relaunch 1
-        (False, 1, 0, False),
+        (False, 1, 0, 0, False),
         # relaunch 10
-        (False, 10, 0, False),
+        (False, 10, 0, 0, False),
     ],
 )
-def test_main_01(mocker, cov, adpt_relaunch, limit, verbose):
+def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, verbose):
     """test main()"""
     fake_adapter = mocker.NonCallableMock(spec_set=Adapter)
     fake_adapter.RELAUNCH = adpt_relaunch
@@ -76,6 +79,7 @@ def test_main_01(mocker, cov, adpt_relaunch, limit, verbose):
     args.adapter = "fake"
     args.ignore = ["fake", "fake"]
     args.limit = limit
+    args.runtime = runtime
     args.prefs = "fake"
     args.rr = True
     args.valgrind = True
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 01818c56..01027af5 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -6,6 +6,8 @@
 """
 unit tests for grizzly.Session
 """
+from itertools import count
+
 from pytest import mark, raises
 
 from sapphire import SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT, Sapphire
@@ -37,29 +39,34 @@ def generate(self, testcase, _server_map):
 
 
 @mark.parametrize(
-    "harness, profiling, coverage, relaunch, iters",
+    "harness, profiling, coverage, relaunch, iters, runtime",
     [
         # with harness, single iteration
-        (True, False, False, 1, 1),
+        (True, False, False, 1, 1, 0),
         # with harness, 10 iterations relaunch every iteration
-        (True, False, False, 1, 10),
+        (True, False, False, 1, 10, 0),
         # with harness, 10 iterations relaunch every other iteration
-        (True, False, False, 2, 10),
+        (True, False, False, 2, 10, 0),
         # with harness, 10 iterations no relaunches
-        (True, False, False, 10, 10),
+        (True, False, False, 10, 10, 0),
         # no harness, single iteration
-        (False, False, False, 1, 1),
+        (False, False, False, 1, 1, 0),
         # no harness, 10 iterations
-        (False, False, False, 1, 10),
+        (False, False, False, 1, 10, 0),
         # test enable profiling
-        (True, True, False, 10, 10),
+        (True, True, False, 10, 10, 0),
         # test Session.dump_coverage()
-        (True, True, True, 2, 2),
+        (True, True, True, 2, 2, 0),
+        # with harness, runtime limit
+        (True, False, False, 1, 0, 1),
     ],
 )
-def test_session_01(mocker, tmp_path, harness, profiling, coverage, relaunch, iters):
+def test_session_01(
+    mocker, tmp_path, harness, profiling, coverage, relaunch, iters, runtime
+):
     """test Session with typical fuzzer Adapter"""
     Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.common.status.time", side_effect=count(start=1.0, step=1.0))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     prefs = tmp_path / "prefs.js"
     prefs.touch()
@@ -68,9 +75,12 @@ def test_session_01(mocker, tmp_path, harness, profiling, coverage, relaunch, it
     target.monitor.launches = 1
     # avoid shutdown delay
     target.monitor.is_healthy.return_value = False
+    # we can only test iter limit OR runtime limit not both
+    assert bool(iters) != bool(runtime), "test is broken!"
+    max_iters = iters or 1
     # calculate if the target is 'closed' based on relaunch
     type(target).closed = mocker.PropertyMock(
-        side_effect=((x % relaunch == 0) for x in range(iters))
+        side_effect=((x % relaunch == 0) for x in range(max_iters))
     )
     with Session(
         SimpleAdapter(harness),
@@ -85,18 +95,24 @@ def test_session_01(mocker, tmp_path, harness, profiling, coverage, relaunch, it
             SERVED_ALL,
             [session.iomanager.page_name(offset=-1)],
         )
-        session.run([], 10, input_path="file.bin", iteration_limit=iters)
-        assert session.status.iteration == iters
+        session.run(
+            [],
+            10,
+            input_path="file.bin",
+            iteration_limit=iters,
+            runtime_limit=runtime,
+        )
+        assert session.status.iteration == max_iters
         assert session.status.test_name == "file.bin"
-        assert target.close.call_count == iters / relaunch
-        assert target.detect_failure.call_count == iters
+        assert target.close.call_count == max_iters / relaunch
+        assert target.detect_failure.call_count == max_iters
         assert target.handle_hang.call_count == 0
         if profiling:
-            assert any(session.status.profile_entries())
+            assert any(session.status.profile_entries()) == profiling
         else:
             assert not any(session.status.profile_entries())
         if coverage:
-            assert target.dump_coverage.call_count == iters
+            assert target.dump_coverage.call_count == max_iters
         else:
             assert target.dump_coverage.call_count == 0
 

From 5dc334a0d7100338db10bd28202df0d5f937e750 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 21 Jun 2021 11:00:52 -0700
Subject: [PATCH 268/531] [tests] Add debugger selection tests

---
 grizzly/replay/test_main.py | 147 +++++++++++++++++++++++++-----------
 grizzly/test_main.py        |  40 ++++++++++
 2 files changed, 142 insertions(+), 45 deletions(-)

diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 25b3610b..1c92cccb 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -24,15 +24,13 @@ def test_main_01(mocker, tmp_path):
     # This is a typical scenario - a test that reproduces results ~50% of the time.
     # Of the four attempts only the first and third will 'reproduce' the result
     # and the forth attempt should be skipped.
-    # mock Sapphire.serve_path only
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
+    # mock Sapphire.serve_path only
     serve_path = mocker.patch(
-        "grizzly.replay.replay.Sapphire.serve_path", autospec=True
+        "grizzly.replay.replay.Sapphire.serve_path",
+        autospec=True,
+        return_value=(SERVED_ALL, ["test.html"]),  # passed to Target.detect_failure
     )
-    serve_path.return_value = (
-        SERVED_ALL,
-        ["test.html"],
-    )  # passed to mocked Target.detect_failure
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_plugin")
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
@@ -61,7 +59,8 @@ def test_main_01(mocker, tmp_path):
         input=str(tmp_path / "test.html"),
         logs=str(log_path),
         min_crashes=2,
-        no_harness=True,
+        no_harness=False,
+        pernosco=False,
         prefs=str(tmp_path / "prefs.js"),
         relaunch=1,
         repeat=4,
@@ -88,15 +87,13 @@ def test_main_01(mocker, tmp_path):
 
 def test_main_02(mocker, tmp_path):
     """test ReplayManager.main() - no repro"""
-    # mock Sapphire.serve_path only
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    serve_path = mocker.patch(
-        "grizzly.replay.replay.Sapphire.serve_path", autospec=True
+    # mock Sapphire.serve_path only
+    mocker.patch(
+        "grizzly.replay.replay.Sapphire.serve_path",
+        autospec=True,
+        return_value=(SERVED_ALL, ["test.html"]),  # passed to Target.detect_failure
     )
-    serve_path.return_value = (
-        SERVED_ALL,
-        ["test.html"],
-    )  # passed to mocked Target.detect_failure
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_plugin")
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
@@ -105,7 +102,6 @@ def test_main_02(mocker, tmp_path):
     load_target.return_value.return_value = target
     # setup args
     (tmp_path / "test.html").touch()
-    (tmp_path / "prefs.js").touch()
     args = mocker.Mock(
         fuzzmanager=False,
         idle_delay=0,
@@ -114,6 +110,7 @@ def test_main_02(mocker, tmp_path):
         input=str(tmp_path / "test.html"),
         min_crashes=2,
         no_harness=True,
+        pernosco=False,
         prefs=None,
         relaunch=1,
         repeat=1,
@@ -142,31 +139,27 @@ def test_main_03(mocker):
         ignore=list(),
         input="test",
         min_crashes=1,
-        no_harenss=True,
+        no_harness=True,
+        pernosco=False,
         prefs=None,
         relaunch=1,
         repeat=1,
+        rr=False,
         sig=None,
         test_index=None,
         time_limit=10,
         timeout=None,
+        valgrind=False,
     )
     # user abort
     fake_load_target.side_effect = KeyboardInterrupt
-    # coverage
-    args.rr = True
-    args.valgrind = False
     assert ReplayManager.main(args) == Session.EXIT_ABORT
     fake_load_target.reset_mock()
     # invalid test case
     fake_tc.load.side_effect = TestCaseLoadFailure
-    # coverage
-    args.rr = False
-    args.valgrind = True
     assert ReplayManager.main(args) == Session.EXIT_ERROR
     assert fake_load_target.call_count == 0
     # no test cases
-    args.valgrind = False
     fake_tc.load.side_effect = None
     fake_tc.load.return_value = list()
     assert ReplayManager.main(args) == Session.EXIT_ERROR
@@ -210,14 +203,17 @@ def test_main_04(mocker, tmp_path):
         ignore=list(),
         input="test",
         min_crashes=1,
-        no_harenss=True,
+        no_harness=True,
+        pernosco=False,
         prefs=None,
         relaunch=1,
         repeat=1,
+        rr=False,
         sig=None,
         test_index=None,
         time_limit=10,
         timeout=None,
+        valgrind=False,
     )
     # target launch error
     fake_logs = tmp_path / "fake_report"
@@ -240,12 +236,10 @@ def test_main_04(mocker, tmp_path):
 def test_main_05(mocker, tmp_path):
     """test ReplayManager.main() loading/generating prefs.js"""
     serve_path = mocker.patch(
-        "grizzly.replay.replay.Sapphire.serve_path", autospec=True
+        "grizzly.replay.replay.Sapphire.serve_path",
+        autospec=True,
+        return_value=(None, ["test.html"]),  # passed to Target.detect_failure
     )
-    serve_path.return_value = (
-        None,
-        ["test.html"],
-    )  # passed to mocked Target.detect_failure
     # setup Target
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
@@ -262,12 +256,15 @@ def test_main_05(mocker, tmp_path):
         ignore=list(),
         min_crashes=1,
         no_harness=True,
+        pernosco=False,
         relaunch=1,
         repeat=1,
+        rr=False,
         sig=None,
         test_index=None,
         time_limit=1,
         timeout=None,
+        valgrind=False,
     )
     log_path = tmp_path / "logs"
     args.logs = str(log_path)
@@ -339,15 +336,13 @@ def test_main_05(mocker, tmp_path):
 )
 def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, result):
     """test ReplayManager.main() - test time limit and timeout"""
-    # mock Sapphire.serve_path only
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    serve_path = mocker.patch(
-        "grizzly.replay.replay.Sapphire.serve_path", autospec=True
+    # mock Sapphire.serve_path only
+    mocker.patch(
+        "grizzly.replay.replay.Sapphire.serve_path",
+        autospec=True,
+        return_value=(SERVED_ALL, ["test.html"]),  # passed to Target.detect_failure
     )
-    serve_path.return_value = (
-        SERVED_ALL,
-        ["test.html"],
-    )  # passed to mocked Target.detect_failure
     # setup Target
     target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
@@ -355,16 +350,15 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
     load_target = mocker.patch("grizzly.replay.replay.load_plugin")
     load_target.return_value.return_value = target
     # create test to load
-    test = TestCase("test.html", None, None)
-    test_file = tmp_path / "test.html"
-    test_file.write_text("test")
-    test.add_from_file(str(test_file))
-    replay_path = tmp_path / "test"
-    replay_path.mkdir()
-    test.time_limit = test_timelimit
-    test.dump(str(replay_path), include_details=True)
+    with TestCase("test.html", None, None) as test:
+        test_file = tmp_path / "test.html"
+        test_file.write_text("test")
+        test.add_from_file(str(test_file))
+        replay_path = tmp_path / "test"
+        replay_path.mkdir()
+        test.time_limit = test_timelimit
+        test.dump(str(replay_path), include_details=True)
     # setup args
-    (tmp_path / "prefs.js").touch()
     args = mocker.Mock(
         fuzzmanager=False,
         idle_delay=0,
@@ -373,6 +367,7 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
         input=str(replay_path),
         min_crashes=2,
         no_harness=True,
+        pernosco=False,
         prefs=None,
         relaunch=1,
         repeat=1,
@@ -384,3 +379,65 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
         valgrind=False,
     )
     assert ReplayManager.main(args) == result
+
+
+@mark.parametrize(
+    "pernosco, rr, valgrind, no_harness",
+    [
+        # No debugger enabled and no harness
+        (False, False, False, False),
+        # No debugger enabled and with harness
+        (False, False, False, True),
+        # Pernosco enabled
+        (True, False, False, False),
+        # rr enabled
+        (False, True, False, False),
+        # Valgrind enabled
+        (False, False, True, False),
+    ],  # pylint: disable=invalid-name
+)
+def test_main_07(mocker, tmp_path, pernosco, rr, valgrind, no_harness):
+    """test ReplayManager.main() enable debuggers"""
+    mocker.patch("grizzly.common.runner.sleep", autospec=True)
+    # mock Sapphire.serve_path only
+    mocker.patch(
+        "grizzly.replay.replay.Sapphire.serve_path",
+        autospec=True,
+        return_value=(SERVED_ALL, ["test.html"]),  # passed to Target.detect_failure
+    )
+    # setup Target
+    load_target = mocker.patch("grizzly.replay.replay.load_plugin")
+    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
+    target.RESULT_NONE = Target.RESULT_NONE
+    target.detect_failure.return_value = Target.RESULT_NONE
+    load_target.return_value.return_value = target
+    # setup args
+    (tmp_path / "test.html").touch()
+    args = mocker.Mock(
+        fuzzmanager=False,
+        idle_delay=0,
+        idle_threshold=0,
+        ignore=["fake", "timeout"],
+        input=str(tmp_path / "test.html"),
+        min_crashes=2,
+        no_harness=no_harness,
+        pernosco=pernosco,
+        prefs=None,
+        relaunch=1,
+        repeat=1,
+        rr=rr,
+        sig=None,
+        test_index=None,
+        time_limit=10,
+        timeout=None,
+        valgrind=valgrind,
+    )
+    # maximum one debugger allowed at a time
+    assert sum((pernosco, rr, valgrind)) < 2, "test broken!"
+    assert ReplayManager.main(args) == Session.EXIT_FAILURE
+    assert target.detect_failure.call_count == 1
+    assert target.close.call_count == 2
+    assert target.cleanup.call_count == 1
+    assert load_target.return_value.call_args[-1]["pernosco"] == pernosco
+    assert load_target.return_value.call_args[-1]["rr"] == rr
+    assert load_target.return_value.call_args[-1]["valgrind"] == valgrind
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 8ec5a370..ff7b589c 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -209,3 +209,43 @@ def test_main_04(mocker, arg_testlimit, arg_timeout, exit_code):
     args.time_limit = arg_testlimit
     args.timeout = arg_timeout
     assert main(args) == exit_code
+
+
+@mark.parametrize(
+    "pernosco, rr, valgrind",
+    [
+        # No debugger enabled
+        (False, False, False),
+        # Pernosco enabled
+        (True, False, False),
+        # rr enabled
+        (False, True, False),
+        # Valgrind enabled
+        (False, False, True),
+    ],  # pylint: disable=invalid-name
+)
+def test_main_05(mocker, pernosco, rr, valgrind):
+    """test enabling debuggers"""
+    fake_adapter = mocker.NonCallableMock(spec_set=Adapter)
+    fake_adapter.RELAUNCH = 1
+    fake_adapter.TIME_LIMIT = 10
+    fake_target = mocker.Mock(spec_set=Target)
+    plugin_loader = mocker.patch("grizzly.main.load_plugin", autospec=True)
+    plugin_loader.side_effect = (
+        mocker.Mock(spec_set=Adapter, return_value=fake_adapter),
+        fake_target,
+    )
+    fake_session = mocker.patch("grizzly.main.Session", autospec=True)
+    fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
+    fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
+    args = FakeArgs()
+    args.adapter = "fake"
+    # maximum one debugger allowed at a time
+    assert sum((pernosco, rr, valgrind)) < 2, "test broken!"
+    args.pernosco = pernosco
+    args.rr = rr
+    args.valgrind = valgrind
+    assert main(args) == Session.EXIT_SUCCESS
+    assert fake_target.call_args[-1]["pernosco"] == pernosco
+    assert fake_target.call_args[-1]["rr"] == rr
+    assert fake_target.call_args[-1]["valgrind"] == valgrind

From e9512c3227e4af7981481bc6fe85dc667448abbe Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Tue, 22 Jun 2021 15:12:16 -0400
Subject: [PATCH 269/531] Fix platform specific argument availability in main.

---
 grizzly/args.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/grizzly/args.py b/grizzly/args.py
index 90ed6650..05e138f9 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -126,6 +126,8 @@ def __init__(self):
             self.launcher_grp.add_argument(
                 "--xvfb", action="store_true", help="Use Xvfb."
             )
+        else:
+            self.parser.set_defaults(xvfb=False)
 
         self.reporter_grp = self.parser.add_argument_group("Reporter Arguments")
         self.reporter_grp.add_argument(
@@ -154,6 +156,12 @@ def __init__(self):
             dbg_group.add_argument(
                 "--valgrind", action="store_true", help="Use Valgrind."
             )
+        else:
+            self.parser.set_defaults(
+                pernosco=False,
+                rr=False,
+                valgrind=False,
+            )
 
         self.parser.epilog = (
             "For addition help check out the wiki:"

From b832ac987325544f3d3e89e8e1e45fa8b64fea55 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 10 Jun 2021 17:21:35 -0400
Subject: [PATCH 270/531] Add tool logging for `grizzly.reduce.crash` main.

---
 grizzly/reduce/crash.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index 41ef0124..8b8e62c2 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -34,6 +34,10 @@ def main(args):
             bucket = Bucket(crash.bucket)
             args.sig = str(bucket.signature_path())
         if args.tool is None:
+            LOG.info(
+                "Setting default --tool=%s from CrashEntry",
+                crash.tool,
+            )
             args.tool = crash.tool
 
         # call grizzly.reduce

From c500cd3897dd87e1819eb31c66d2f4f558eb9aa2 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Tue, 15 Jun 2021 15:56:18 -0400
Subject: [PATCH 271/531] [reduce] Don't alter testcase newlines in beautify.

---
 grizzly/reduce/strategies/beautify.py | 40 +++++++++++++++++++--------
 grizzly/reduce/test_strategies.py     | 15 ++++++++--
 setup.cfg                             |  2 +-
 3 files changed, 41 insertions(+), 16 deletions(-)

diff --git a/grizzly/reduce/strategies/beautify.py b/grizzly/reduce/strategies/beautify.py
index c68e397a..2243146f 100644
--- a/grizzly/reduce/strategies/beautify.py
+++ b/grizzly/reduce/strategies/beautify.py
@@ -8,6 +8,7 @@
     HAVE_CSSBEAUTIFIER (bool): True if `cssbeautifier` module is available.
     HAVE_JSBEAUTIFIER (bool): True if `jsbeautifier` module is available.
 """
+import os
 import re
 from abc import ABC, abstractmethod
 from logging import getLogger
@@ -118,11 +119,12 @@ def update(self, success, served=None):
 
     @classmethod
     @abstractmethod
-    def beautify_bytes(cls, data):
+    def beautify_bytes(cls, data, linesep=b"\n"):
         """Perform beautification on a code buffer.
 
         Arguments:
             data (bytes): The code data to be beautified.
+            linesep (bytes): Newline sequence used in this testcase.
 
         Returns:
             bytes: The beautified result.
@@ -212,6 +214,14 @@ def __iter__(self):
             lith_tc.load(file)
             raw = b"".join(lith_tc.parts)
 
+            # try to determine line-endings from testcase before resorting to os.linesep
+            if b"\r\n" in lith_tc.before or b"\r\n" in lith_tc.after or b"\r\n" in raw:
+                linesep = b"\r\n"
+            elif b"\n" in lith_tc.before or b"\n" in lith_tc.after or b"\n" in raw:
+                linesep = b"\n"
+            else:
+                linesep = os.linesep.encode("utf-8")
+
             with file.open("wb") as testcase_fp:
                 last = 0
                 any_beautified = False
@@ -221,13 +231,13 @@ def __iter__(self):
                     testcase_fp.write(before)
                     to_beautify = raw[start:end]
                     LOG.debug("before: %r", to_beautify)
-                    beautified = self.beautify_bytes(to_beautify)
+                    beautified = self.beautify_bytes(to_beautify, linesep)
                     LOG.debug("after: %r", beautified)
                     if beautified:
-                        if before and not before.endswith(b"\n"):
-                            beautified = b"\n" + beautified
-                        if not beautified.endswith(b"\n"):
-                            beautified = beautified + b"\n"
+                        if before and not before.endswith(linesep):
+                            beautified = linesep + beautified
+                        if not beautified.endswith(linesep):
+                            beautified = beautified + linesep
 
                         testcase_fp.write(beautified)
                         if beautified == to_beautify:
@@ -293,18 +303,21 @@ class CSSBeautify(_BeautifyStrategy):
     tag_name = "style"
 
     @classmethod
-    def beautify_bytes(cls, data):
+    def beautify_bytes(cls, data, linesep=b"\n"):
         """Perform CSS beautification on a code buffer.
 
         Arguments:
             data (bytes): The code data to be beautified.
+            linesep (bytes): Newline sequence used in this testcase.
 
         Returns:
             bytes: The beautified result.
         """
         assert cls.import_available
+        linesep_u = linesep.decode("utf-8")
         data = data.decode("utf-8", errors="surrogateescape")
-        return cssbeautifier.beautify(data, cls.opts).encode(
+        beautified = cssbeautifier.beautify(data, cls.opts)
+        return linesep_u.join(beautified.splitlines()).encode(
             "utf-8", errors="surrogateescape"
         )
 
@@ -323,23 +336,26 @@ class JSBeautify(_BeautifyStrategy):
     native_extension = ".js"
     opts = None
     tag_name = "script"
-    try_catch_re = re.compile(r"(\s*try {)\n\s*(.*)\n\s*(}\s*catch.*)")
+    try_catch_re = re.compile(r"(\s*try {)\r?\n\s*(.*)\r?\n\s*(}\s*catch.*)")
 
     @classmethod
-    def beautify_bytes(cls, data):
+    def beautify_bytes(cls, data, linesep=b"\n"):
         """Perform JS beautification on a code buffer.
 
         Arguments:
             data (bytes): The code data to be beautified.
+            linesep (bytes): Newline sequence used in this testcase.
 
         Returns:
             bytes: The beautified result.
         """
         assert HAVE_JSBEAUTIFIER
+        linesep_u = linesep.decode("utf-8")
         data = data.decode("utf-8", errors="surrogateescape")
-
         beautified = jsbeautifier.beautify(data, cls.opts)
         # All try/catch pairs will be expanded on their own lines
         # Collapse these pairs when only a single instruction is contained within
         beautified = cls.try_catch_re.sub(r"\1 \2 \3", beautified)
-        return beautified.encode("utf-8", errors="surrogateescape")
+        return linesep_u.join(beautified.splitlines()).encode(
+            "utf-8", errors="surrogateescape"
+        )
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 142e3163..bc7835f8 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -295,11 +295,15 @@ def replay_run(testcases, _time_limit, **_):
         # test DDBEGIN/END respected in .js file
         pytest.param(
             *BeautifyStrategyParams(
-                test_data="try{\n//DDBEGIN\n'fluff';'required'\n//DDEND\n}catch(e){}\n",
+                test_data=(
+                    "try{\r\n//DDBEGIN\r\n'fluff';'required'\r\n//DDEND\r\n"
+                    "}catch(e){}\r\n\r\n"
+                ),
                 test_name="test.js",
                 expected_run_calls=1,
                 expected_results={
-                    "try{\n//DDBEGIN\n'fluff';\n'required'\n//DDEND\n}catch(e){}\n"
+                    "try{\r\n//DDBEGIN\r\n'fluff';\r\n'required'\r\n//DDEND\r\n"
+                    "}catch(e){}\r\n"
                 },
                 expected_num_reports=2,
                 strategies=["jsbeautify"],
@@ -612,7 +616,12 @@ def replay_run(testcases, _time_limit, **_):
 
     assert replayer.run.call_count == expected_run_calls
     assert set(log_path.iterdir()) == {log_path / "reports"}
-    tests = {test.read_text() for test in log_path.glob("reports/*-*/" + test_name)}
+    # don't use test.read_text() because that converts newlines, and some tests need
+    # unaltered newlines
+    tests = {
+        test.read_bytes().decode("utf-8")
+        for test in log_path.glob("reports/*-*/" + test_name)
+    }
     assert tests == expected_results
     assert (
         sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports
diff --git a/setup.cfg b/setup.cfg
index 49d13f5f..0d88ed05 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -25,7 +25,7 @@ install_requires =
     ffpuppet >= 0.8.1
     FuzzManager
     jsbeautifier
-    lithium-reducer >= 0.5
+    lithium-reducer >= 0.5.3
     prefpicker
     psutil >= 4.4.0
 packages =

From a8e3a66266472a7c8faf5a2f463c49295c6288b2 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Tue, 22 Jun 2021 23:50:24 -0400
Subject: [PATCH 272/531] Update beautify tests

---
 grizzly/reduce/test_strategies.py          | 427 +--------------------
 grizzly/reduce/test_strategies_beautify.py | 261 +++++++++++++
 2 files changed, 262 insertions(+), 426 deletions(-)
 create mode 100644 grizzly/reduce/test_strategies_beautify.py

diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index bc7835f8..8562d804 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -3,8 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
-"""Unit tests for `grizzly.reduce.strategies`.
-"""
+"""Unit tests for `grizzly.reduce.strategies`."""
 from collections import namedtuple
 from logging import getLogger
 
@@ -18,12 +17,6 @@
 from ..target import Target
 from . import ReduceManager
 from .strategies import Strategy, _load_strategies
-from .strategies.beautify import (
-    HAVE_CSSBEAUTIFIER,
-    HAVE_JSBEAUTIFIER,
-    CSSBeautify,
-    JSBeautify,
-)
 
 LOG = getLogger(__name__)
 pytestmark = pytest.mark.usefixtures(
@@ -210,424 +203,6 @@ def replay_run(testcases, _time_limit, **_):
     ), list((log_path / "reports").iterdir())
 
 
-BeautifyStrategyParams = namedtuple(
-    "BeautifyStrategyParams",
-    "test_data, test_name, expected_run_calls, expected_results, expected_num_reports,"
-    "strategies, have_beautifiers",
-)
-
-
-@pytest.mark.parametrize(
-    BeautifyStrategyParams._fields,
-    [
-        # test beautify a .js file
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="try{'fluff';'required'}catch(e){}\n",
-                test_name="test.js",
-                expected_run_calls=1,
-                expected_results={
-                    "try {\n    'fluff';\n    'required'\n} catch (e) {}\n"
-                },
-                expected_num_reports=2,
-                strategies=["jsbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
-            ),
-        ),
-        # test beautify js embedded in html
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="<script>try{'fluff';'required'}catch(e){}</script>\n",
-                test_name="test.html",
-                expected_run_calls=1,
-                expected_results={
-                    "<script>\ntry {\n    'fluff';\n    'required'\n} "
-                    "catch (e) {}\n</script>\n"
-                },
-                expected_num_reports=2,
-                strategies=["jsbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
-            ),
-        ),
-        # test beautify multiple js embedded in html
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="<script>try{'fluff';'required'}catch(e){}</script>"
-                "<script>'fluff';'requisite'</script>\n",
-                test_name="test.html",
-                expected_run_calls=1,
-                expected_results={
-                    "<script>\ntry {\n    'fluff';\n    'required'\n} "
-                    "catch (e) {}\n</script><script>\n'fluff';\n'"
-                    "requisite'\n</script>\n"
-                },
-                expected_num_reports=2,
-                strategies=["jsbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
-            ),
-        ),
-        # test beautify js embedded in html with no end
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="<script>try{'fluff';'required'}catch(e){}\n",
-                test_name="test.html",
-                expected_run_calls=1,
-                expected_results={
-                    "<script>\ntry {\n    'fluff';\n    'required'\n} catch (e) {}\n"
-                },
-                expected_num_reports=2,
-                strategies=["jsbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
-            ),
-        ),
-        # test DDBEGIN/END respected in .js file
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data=(
-                    "try{\r\n//DDBEGIN\r\n'fluff';'required'\r\n//DDEND\r\n"
-                    "}catch(e){}\r\n\r\n"
-                ),
-                test_name="test.js",
-                expected_run_calls=1,
-                expected_results={
-                    "try{\r\n//DDBEGIN\r\n'fluff';\r\n'required'\r\n//DDEND\r\n"
-                    "}catch(e){}\r\n"
-                },
-                expected_num_reports=2,
-                strategies=["jsbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
-            ),
-        ),
-        # test DDBEGIN/END respected for js embedded in html, DD outside <script>
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="<!--DDBEGIN-->\n<script>\ntry{'fluff';'required'}"
-                "catch(e){}\n</script><!--DDEND-->\n",
-                test_name="test.html",
-                expected_run_calls=1,
-                expected_results={
-                    "<!--DDBEGIN-->\n<script>\ntry {\n    'fluff';\n    'required'\n} "
-                    "catch (e) {}\n</script><!--DDEND-->\n"
-                },
-                expected_num_reports=2,
-                strategies=["jsbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
-            ),
-        ),
-        # test DDBEGIN/END respected for js embedded in html, DD inside <script>
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="<script>try{\n//DDBEGIN\n'fluff';'required'\n//DDEND\n}"
-                "catch(e){}</script>\n",
-                test_name="test.html",
-                expected_run_calls=1,
-                expected_results={
-                    "<script>try{\n//DDBEGIN\n'fluff';\n'required'\n//DDEND\n}"
-                    "catch(e){}</script>\n"
-                },
-                expected_num_reports=2,
-                strategies=["jsbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
-            ),
-        ),
-        # test DDBEGIN/END respected for js embedded in html, DD straddle before
-        # <script>
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="<!--DDBEGIN-->\n<script>\ntry{'fluff';'required'}catch(e){}"
-                "\n//DDEND\n",
-                test_name="test.html",
-                expected_run_calls=1,
-                expected_results={
-                    "<!--DDBEGIN-->\n<script>\ntry {\n    'fluff';\n    'required'\n} "
-                    "catch (e) {}\n//DDEND\n"
-                },
-                expected_num_reports=2,
-                strategies=["jsbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
-            ),
-        ),
-        # test DDBEGIN/END respected for js embedded in html, DD straddle after <script>
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="<script>\n//DDBEGIN\ntry{'fluff';'required'}catch(e){}\n"
-                "//DDEND\n",
-                test_name="test.html",
-                expected_run_calls=1,
-                expected_results={
-                    "<script>\n//DDBEGIN\ntry {\n    'fluff';\n    'required'\n} "
-                    "catch (e) {}\n//DDEND\n"
-                },
-                expected_num_reports=2,
-                strategies=["jsbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
-            ),
-        ),
-        # test DDBEGIN/END respected for js embedded in html, DD straddle after
-        # </script>
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="<script>\n//DDBEGIN\ntry{'fluff';'required'}catch(e){}\n"
-                "</script>\n<!--DDEND-->\n",
-                test_name="test.html",
-                expected_run_calls=1,
-                expected_results={
-                    "<script>\n//DDBEGIN\ntry {\n    'fluff';\n    'required'\n} "
-                    "catch (e) {}\n</script>\n<!--DDEND-->\n"
-                },
-                expected_num_reports=2,
-                strategies=["jsbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
-            ),
-        ),
-        # test beautify js embedded in html (no <script>)
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="try{'fluff';'required'}catch(e){}\n",
-                test_name="test.html",
-                expected_run_calls=1,
-                expected_results={"try{'fluff';'required'}catch(e){}\n"},
-                expected_num_reports=2,
-                # no beautify performed, add check so the run succeeds
-                strategies=["jsbeautify", "check"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
-            ),
-        ),
-        # test beautify js where beautification breaks
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="try{'fluff';'requi'+'red'}catch(e){}\n",
-                test_name="test.js",
-                expected_run_calls=2,
-                expected_results={"try{'fluff';'requi'+'red'}catch(e){}\n"},
-                expected_num_reports=2,
-                # no beautify performed, add check so the run succeeds
-                strategies=["jsbeautify", "check"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_JSBEAUTIFIER, reason="jsbeautifier required"
-            ),
-        ),
-        # test beautify a .css file
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="*,#a{fluff:0;required:1}\n",
-                test_name="test.css",
-                expected_run_calls=1,
-                expected_results={"*,\n#a {\n  fluff: 0;\n  required: 1\n}\n"},
-                expected_num_reports=2,
-                strategies=["cssbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"
-            ),
-        ),
-        # test beautify css embedded in html
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="<style>*,#a{fluff:0;required:1}</style>\n",
-                test_name="test.html",
-                expected_run_calls=1,
-                expected_results={
-                    "<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n</style>\n"
-                },
-                expected_num_reports=2,
-                strategies=["cssbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"
-            ),
-        ),
-        # test beautify css embedded in html with no end
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data="<style>*,#a{fluff:0;required:1}\n",
-                test_name="test.html",
-                expected_run_calls=1,
-                expected_results={"<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n"},
-                expected_num_reports=2,
-                strategies=["cssbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"
-            ),
-        ),
-        # test already beautified css (beautify does nothing)
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data=(
-                    "<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n</style>\n"
-                ),
-                test_name="test.html",
-                expected_run_calls=1,
-                expected_results={
-                    "<style>\n*,\n#a {\n  fluff: 0;\n  required: 1\n}\n</style>\n"
-                },
-                expected_num_reports=2,
-                strategies=["check", "cssbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"
-            ),
-        ),
-        # test almost beautified css (any change breaks test, beautify only removes an
-        # extra blank line so `lines` will have already tried it, and this will hit the
-        # cache)
-        pytest.param(
-            *BeautifyStrategyParams(
-                test_data=(
-                    "<style nochange=true>\n/*DDBEGIN*/\n\nrequisite {\n"
-                    "  required: 1\n}\n/*DDEND*/\n</style>\n"
-                ),
-                test_name="test.html",
-                expected_run_calls=8,
-                expected_results={
-                    "<style nochange=true>\n/*DDBEGIN*/\n\nrequisite {\n"
-                    "  required: 1\n}\n/*DDEND*/\n</style>\n"
-                },
-                expected_num_reports=2,
-                strategies=["check", "lines", "cssbeautify"],
-                have_beautifiers=True,
-            ),
-            marks=pytest.mark.skipif(
-                not HAVE_CSSBEAUTIFIER, reason="cssbeautifier required"
-            ),
-        ),
-        # test that when beautifiers are not available, the strategies have no effect
-        BeautifyStrategyParams(
-            test_data="<style>*,#a{fluff:0;required:1}\n",
-            test_name="test.html",
-            expected_run_calls=1,
-            expected_results={"<style>*,#a{fluff:0;required:1}\n"},
-            expected_num_reports=2,
-            strategies=["check", "cssbeautify"],
-            have_beautifiers=False,
-        ),
-    ],
-)
-def test_beautifier(
-    mocker,
-    tmp_path,
-    test_data,
-    test_name,
-    expected_run_calls,
-    expected_results,
-    expected_num_reports,
-    strategies,
-    have_beautifiers,
-):
-    """test for the "beautify" strategies"""
-    if not have_beautifiers:
-        mocker.patch.object(CSSBeautify, "import_available", False)
-        mocker.patch.object(JSBeautify, "import_available", False)
-    mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
-    mocker.patch("grizzly.reduce.strategies.beautify._contains_dd", return_value=True)
-    replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
-    replayer = replayer.return_value
-    replayer.status.iteration = 1
-
-    def replay_run(testcases, _time_limit, **_):
-        for test in testcases:
-            contents = test.get_file(test_name).data.decode("ascii")
-            if "nochange" in test_data:
-                LOG.debug("interesting if test unchanged")
-                interesting = test_data == contents
-            elif "requisite" in test_data:
-                LOG.debug(
-                    "interesting if ('requisite' and 'required') or "
-                    "'requi'+'red' in %r",
-                    contents,
-                )
-                interesting = (
-                    "required" in contents and "requisite" in contents
-                ) or "'requi'+'red'" in contents
-            else:
-                LOG.debug("interesting if 'required' or 'requi'+'red' in %r", contents)
-                interesting = "required" in contents or "'requi'+'red'" in contents
-            if interesting:
-                log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
-                log_path.mkdir()
-                _fake_save_logs_foo(log_path)
-                report = Report(str(log_path), "bin")
-                return [ReplayResult(report, [[test_name]], [], True)]
-        return []
-
-    replayer.run.side_effect = replay_run
-
-    test = TestCase(test_name, None, "test-adapter")
-    test.add_from_data(test_data, test_name)
-    tests = [test]
-    log_path = tmp_path / "logs"
-
-    target = mocker.Mock(spec=Target)
-    target.relaunch = 1
-    try:
-        mgr = ReduceManager(
-            [],
-            mocker.Mock(spec=Sapphire, timeout=30),
-            target,
-            tests,
-            strategies,
-            log_path,
-            use_analysis=False,
-        )
-        assert mgr.run() == 0
-    finally:
-        for test in tests:
-            test.cleanup()
-
-    assert replayer.run.call_count == expected_run_calls
-    assert set(log_path.iterdir()) == {log_path / "reports"}
-    # don't use test.read_text() because that converts newlines, and some tests need
-    # unaltered newlines
-    tests = {
-        test.read_bytes().decode("utf-8")
-        for test in log_path.glob("reports/*-*/" + test_name)
-    }
-    assert tests == expected_results
-    assert (
-        sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports
-    ), list((log_path / "reports").iterdir())
-
-
 PurgeUnservedTestParams = namedtuple(
     "PurgeUnservedTestParams",
     "strategies, test_data, served, expected_results, expected_run_calls,"
diff --git a/grizzly/reduce/test_strategies_beautify.py b/grizzly/reduce/test_strategies_beautify.py
new file mode 100644
index 00000000..c59e7a6f
--- /dev/null
+++ b/grizzly/reduce/test_strategies_beautify.py
@@ -0,0 +1,261 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# pylint: disable=protected-access
+"""Unit tests for `grizzly.reduce.strategies.beautify`."""
+from logging import getLogger
+from os import linesep
+
+import pytest
+
+from ..common import TestCase
+from .strategies.beautify import CSSBeautify, JSBeautify
+
+LOG = getLogger(__name__)
+
+
+def _test_beautify(cls, interesting, test_name, test_data, reduced, mocker):
+    mocker.patch("grizzly.reduce.strategies.beautify._contains_dd", return_value=True)
+
+    best_test = TestCase(test_name, None, "test-adapter")
+    best_test.add_from_data(test_data, test_name)
+    best_tests = [best_test]
+
+    def _interesting(testcases):
+        for test in testcases:
+            contents = test.get_file(test_name).data.decode("ascii")
+            if interesting(contents):
+                return True
+        return False
+
+    try:
+        with cls(best_tests) as sgy:
+            for tests in sgy:
+                try:
+                    result = _interesting(tests)
+                    sgy.update(result)
+                    if result:
+                        for test in best_tests:
+                            test.cleanup()
+                        best_tests = tests
+                        tests = []
+                finally:
+                    for test in tests:
+                        test.cleanup()
+        assert len(best_tests) == 1
+        contents = best_tests[0].get_file(test_name).data.decode("ascii")
+        assert contents == reduced
+    finally:
+        for test in best_tests:
+            test.cleanup()
+
+
+@pytest.mark.parametrize(
+    "test_data, reduced",
+    [
+        pytest.param(
+            "try{'a';'R'}catch(e){}\n",
+            "try {\n    'a';\n    'R'\n} catch (e) {}\n",
+            id="#0: test beautify a .js file",
+        ),
+        pytest.param(
+            "try{\n//DDBEGIN\n'a';'R'\n//DDEND\n}catch(e){}\n",
+            "try{\n//DDBEGIN\n'a';\n'R'\n//DDEND\n}catch(e){}\n",
+            id="#1: test DDBEGIN/END respected in .js file",
+        ),
+        pytest.param(
+            "try{\r\n'a';'R'}catch(e){}\n",
+            "try {\r\n    'a';\r\n    'R'\r\n} catch (e) {}\r\n",
+            id="#2: test that mixed crlf/lf gets converted to crlf",
+        ),
+        pytest.param(
+            "try{\r'a';'R'}catch(e){}\n",
+            "try {\n    'a';\n    'R'\n} catch (e) {}\n",
+            id="#3: test that mixed cr/lf gets converted to lf",
+        ),
+        pytest.param(
+            "try{'a';'R'}catch(e){}\x1e",
+            linesep.join(("try {", "    'a';", "    'R'", "} catch (e) {}", "")),
+            id="#4: test that other line-ending gets converted to lf",
+        ),
+    ],
+)
+def test_beautify_js_1(test_data, reduced, mocker):
+    _test_beautify(
+        JSBeautify, lambda x: "R" in x, "test.js", test_data, reduced, mocker
+    )
+
+
+@pytest.mark.parametrize(
+    "test_data, reduced",
+    [
+        pytest.param(
+            "try{'a';'R'+'R'}catch(e){}\n",
+            "try{'a';'R'+'R'}catch(e){}\n",
+            id="#5: test beautify js where beautification breaks",
+        ),
+    ],
+)
+def test_beautify_js_2(test_data, reduced, mocker):
+    _test_beautify(
+        JSBeautify, lambda x: "'R'+'R'" in x, "test.js", test_data, reduced, mocker
+    )
+
+
+@pytest.mark.parametrize(
+    "test_data, reduced",
+    [
+        pytest.param(
+            "<script>try{'a';'R'}catch(e){}</script>\n",
+            "<script>\ntry {\n    'a';\n    'R'\n} catch (e) {}\n</script>\n",
+            id="#6: test beautify js embedded in html",
+        ),
+        pytest.param(
+            "<script>try{'a';'R'}catch(e){}\n",
+            "<script>\ntry {\n    'a';\n    'R'\n} catch (e) {}\n",
+            id="#7: test beautify js embedded in html with no end",
+        ),
+        pytest.param(
+            "<!--DDBEGIN-->\n<script>\ntry{'a';'R'}catch(e){}\n</script><!--DDEND-->\n",
+            "<!--DDBEGIN-->\n<script>\ntry {\n    'a';\n    'R'\n"
+            "} catch (e) {}\n</script><!--DDEND-->\n",
+            id="#8: test DDBEGIN/END respected for js embedded in html, "
+            "DD outside <script>",
+        ),
+        pytest.param(
+            "<script>try{\n//DDBEGIN\n'a';'R'\n//DDEND\n}catch(e){}</script>\n",
+            "<script>try{\n//DDBEGIN\n'a';\n'R'\n//DDEND\n}catch(e){}</script>\n",
+            id="#9: test DDBEGIN/END respected for js embedded in html, "
+            "DD inside <script>",
+        ),
+        pytest.param(
+            "<!--DDBEGIN-->\n<script>\ntry{'a';'R'}catch(e){}\n//DDEND\n",
+            "<!--DDBEGIN-->\n<script>\ntry {\n    'a';\n    'R'\n"
+            "} catch (e) {}\n//DDEND\n",
+            id="#10: test DDBEGIN/END respected for js embedded in html, "
+            "DD straddle before <script>",
+        ),
+        pytest.param(
+            "<script>\n//DDBEGIN\ntry{'a';'R'}catch(e){}\n//DDEND\n",
+            "<script>\n//DDBEGIN\ntry {\n    'a';\n    'R'\n} catch (e) {}\n//DDEND\n",
+            id="#11: test DDBEGIN/END respected for js embedded in html, "
+            "DD straddle after <script>",
+        ),
+        pytest.param(
+            "<script>\n//DDBEGIN\ntry{'a';'R'}catch(e){}\n</script>\n<!--DDEND-->\n",
+            "<script>\n//DDBEGIN\ntry {\n    'a';\n    'R'\n"
+            "} catch (e) {}\n</script>\n<!--DDEND-->\n",
+            id="#12: test DDBEGIN/END respected for js embedded in html, "
+            "DD straddle after </script>",
+        ),
+        pytest.param(
+            "try{'a';'R'}catch(e){}\n",
+            "try{'a';'R'}catch(e){}\n",
+            id="#13: test beautify js embedded in html (no <script>)",
+        ),
+    ],
+)
+def test_beautify_js_3(test_data, reduced, mocker):
+    _test_beautify(
+        JSBeautify, lambda x: "R" in x, "test.html", test_data, reduced, mocker
+    )
+
+
+@pytest.mark.parametrize(
+    "test_data, reduced",
+    [
+        pytest.param(
+            "<script>try{'a';'R'}catch(e){}</script><script>'a';'Q'</script>\n",
+            "<script>\ntry {\n    'a';\n    'R'\n} catch (e) {}\n</script>"
+            "<script>\n'a';\n'Q'\n</script>\n",
+            id="#14: test beautify multiple js embedded in html",
+        ),
+    ],
+)
+def test_beautify_js_4(test_data, reduced, mocker):
+    _test_beautify(
+        JSBeautify,
+        lambda x: "Q" in x and "R" in x,
+        "test.html",
+        test_data,
+        reduced,
+        mocker,
+    )
+
+
+@pytest.mark.parametrize(
+    "test_data, reduced",
+    [
+        pytest.param(
+            "*,#a{a:0;R:1}\n",
+            "*,\n#a {\n  a: 0;\n  R: 1\n}\n",
+            id="#0: test beautify a .css file",
+        ),
+        pytest.param(
+            "*,\r\n#a{a:0;R:1}\n",
+            "*,\r\n#a {\r\n  a: 0;\r\n  R: 1\r\n}\r\n",
+            id="#1: test that mixed crlf/lf gets converted to crlf",
+        ),
+        pytest.param(
+            "*,\r#a{a:0;R:1}\n",
+            "*,\n#a {\n  a: 0;\n  R: 1\n}\n",
+            id="#2: test that mixed cr/lf gets converted to lf",
+        ),
+        pytest.param(
+            "*,\x1e#a{a:0;R:1}\x1e",
+            linesep.join(("*,", "#a {", "  a: 0;", "  R: 1", "}", "")),
+            id="#3: test that other line-ending gets converted to lf",
+        ),
+    ],
+)
+def test_beautify_css_1(test_data, reduced, mocker):
+    _test_beautify(
+        CSSBeautify, lambda x: "R" in x, "test.css", test_data, reduced, mocker
+    )
+
+
+@pytest.mark.parametrize(
+    "test_data, reduced",
+    [
+        pytest.param(
+            "<style>*,#a{a:0;R:1}</style>\n",
+            "<style>\n*,\n#a {\n  a: 0;\n  R: 1\n}\n</style>\n",
+            id="#4: test beautify css embedded in html",
+        ),
+        pytest.param(
+            "<style>*,#a{a:0;R:1}\n",
+            "<style>\n*,\n#a {\n  a: 0;\n  R: 1\n}\n",
+            id="#5: test beautify css embedded in html with no end",
+        ),
+        pytest.param(
+            "<style>\n*,\n#a {\n  a: 0;\n  R: 1\n}\n</style>\n",
+            "<style>\n*,\n#a {\n  a: 0;\n  R: 1\n}\n</style>\n",
+            id="#6: test already beautified css (beautify does nothing)",
+        ),
+        pytest.param(
+            "*,#a{a:0;R:1}\n",
+            "*,#a{a:0;R:1}\n",
+            id="#7: test beautify css embedded in html (no <style>)",
+        ),
+    ],
+)
+def test_beautify_css_2(test_data, reduced, mocker):
+    _test_beautify(
+        CSSBeautify, lambda x: "R" in x, "test.html", test_data, reduced, mocker
+    )
+
+
+@pytest.mark.parametrize(
+    "beautify, test_data",
+    [
+        (JSBeautify, "<script>try{'a';'R'}catch(e){}\n"),
+        (CSSBeautify, "<style>*,#a{a:0;R:1}\n"),
+    ],
+)
+def test_no_beautify(beautify, test_data, mocker):
+    """test that when beautifiers are not available, the strategies have no effect"""
+    mocker.patch.object(beautify, "import_available", False)
+    _test_beautify(
+        beautify, lambda x: "R" in x, "test.html", test_data, test_data, mocker
+    )

From 7314461f7a9a27ac8ca720c9208684ca811c996b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 5 Jul 2021 13:08:08 -0700
Subject: [PATCH 273/531] [ci] Pin pylint version

---
 tox.ini | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tox.ini b/tox.ini
index 8f91ecce..192a865e 100644
--- a/tox.ini
+++ b/tox.ini
@@ -57,7 +57,7 @@ deps =
     codespell
     flake8
     isort
-    pylint
+    pylint==2.8.3
 usedevelop = true
 
 [testenv:pypi]

From dbdeee5e3ec3fcdaa9b3f439e2df364c14d9f6fc Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 5 Jul 2021 17:06:09 -0400
Subject: [PATCH 274/531] Reconfigure linters.

Allow pre-commit to control all versions except pylint, which is
configured in a toxenv to allow dependencies to be installed.
---
 .pre-commit-config.yaml | 29 +++++++++++++++++++++++------
 .taskcluster.yml        |  6 ------
 setup.cfg               |  3 +++
 tox.ini                 | 23 ++++-------------------
 4 files changed, 30 insertions(+), 31 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 03c61681..75b28584 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,10 +1,22 @@
 repos:
+  - repo: https://github.com/pycqa/isort
+    rev: 5.9.1
+    hooks:
+      - id: isort
   - repo: https://github.com/asottile/yesqa
-    rev: v1.2.2
+    rev: v1.2.3
     hooks:
       - id: yesqa
+  - repo: https://github.com/ambv/black
+    rev: 21.6b0
+    hooks:
+      - id: black
+  - repo: https://gitlab.com/pycqa/flake8
+    rev: 3.9.2
+    hooks:
+      - id: flake8
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v3.4.0
+    rev: v4.0.1
     hooks:
       - id: check-ast
       - id: check-docstring-first
@@ -19,6 +31,11 @@ repos:
         args: ['--django']
       - id: check-json
       - id: requirements-txt-fixer
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.1.0
+    hooks:
+      - id: codespell
+        exclude_types: [json]
   - repo: https://github.com/marco-c/taskcluster_yml_validator
     rev: v0.0.7
     hooks:
@@ -32,11 +49,11 @@ repos:
       - id: check-useless-excludes
   - repo: local
     hooks:
-      - id: lint
-        name: Run linters
-        entry: tox -e lint
+      - id: pylint
+        name: pylint
+        entry: tox -e pylint --
         language: system
-        pass_filenames: false
+        require_serial: true
         types: [python]
 
 default_language_version:
diff --git a/.taskcluster.yml b/.taskcluster.yml
index b0676a1e..f2b207c1 100644
--- a/.taskcluster.yml
+++ b/.taskcluster.yml
@@ -75,12 +75,6 @@ tasks:
               TOXENV: lint
             script:
               - tox
-          - name: precommit
-            version: "3.9"
-            env:
-              TOXENV: precommit
-            script:
-              - tox
           - name: PyPI upload
             version: "3.8"
             env:
diff --git a/setup.cfg b/setup.cfg
index 0d88ed05..a248b0d1 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -65,3 +65,6 @@ dev =
     tox
 s3 =
     boto3
+
+[codespell]
+ignore-regex = \\[fnrstv]
diff --git a/tox.ini b/tox.ini
index 192a865e..8e89a5bb 100644
--- a/tox.ini
+++ b/tox.ini
@@ -31,32 +31,17 @@ deps =
     coverage[toml]
 skip_install = true
 
-[testenv:precommit]
+[testenv:lint]
 commands =
-    pre-commit run -a
+    pre-commit run -a {posargs}
 deps =
     pre-commit
 skip_install = true
 
-[testenv:lint]
-allowlist_externals =
-    bash
+[testenv:pylint]
 commands =
-    isort --check-only {toxinidir}
-    black --check {toxinidir}
-    # codespell trips over the regex in 'sapphire/worker.py' saying 'sHTTP ==> https'
-    # https://github.com/codespell-project/codespell/issues/1774
-    # ignoring it is broken so we need to ignore the file
-    codespell --skip=".git,.tox,htmlcov,results,./sapphire/worker.py" {toxinidir}
-    pylint {toxinidir}/grizzly
-    pylint {toxinidir}/loki
-    pylint {toxinidir}/sapphire
-    flake8 {toxinidir}
+    pylint {posargs}
 deps =
-    black
-    codespell
-    flake8
-    isort
     pylint==2.8.3
 usedevelop = true
 

From b208f8dafa8877304c7f43ed1997b609bc3cb259 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Jun 2021 13:00:33 -0700
Subject: [PATCH 275/531] Add Status.lock_file()

---
 grizzly/common/status.py | 64 +++++++++++++++++++++++++---------------
 1 file changed, 40 insertions(+), 24 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 5a18c8f1..94d26328 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -50,13 +50,18 @@ class Status:
     )
 
     def __init__(self, data_file, enable_profiling=False, start_time=None):
-        assert data_file.endswith(".json")
-        assert start_time is None or isinstance(start_time, float)
-        self._lock = InterProcessLock("%s.lock" % (data_file,))
-        self._enable_profiling = enable_profiling
+        if data_file is None:
+            # read-only mode
+            assert start_time is None
+            self._lock = None
+            self._enable_profiling = False
+        else:
+            assert data_file.endswith(".json")
+            assert isinstance(start_time, float)
+            self._lock = InterProcessLock(self.lock_file(data_file))
+            self._enable_profiling = enable_profiling
         self._profiles = dict()
         self._results = defaultdict(int)
-        # if data_file is None the status report is read only (no reporting)
         self.data_file = data_file
         self.ignored = 0
         self.iteration = 0
@@ -75,24 +80,23 @@ def cleanup(self):
         Returns:
             None
         """
-        if self.data_file is None:
-            return
-        try:
-            with self._lock:
-                unlink(self.data_file)
-        except OSError:  # pragma: no cover
-            LOG.warning("Failed to delete %r", self.data_file)
-        try:
-            unlink("%s.lock" % (self.data_file,))
-        except OSError:  # pragma: no cover
-            pass
-        self.data_file = None
+        if self.data_file is not None:
+            try:
+                with self._lock:
+                    unlink(self.data_file)
+            except OSError:  # pragma: no cover
+                LOG.warning("Failed to delete %r", self.data_file)
+            try:
+                unlink(self.lock_file(self.data_file))
+            except OSError:  # pragma: no cover
+                pass
+            self.data_file = None
 
     def count_result(self, signature):
         """Increment counter that matches `signature`.
 
         Args:
-            signature (str):
+            signature (str): Signature to increment.
 
         Returns:
             None
@@ -122,12 +126,13 @@ def load(cls, data_file):
             data_file (str): JSON file that contains status data.
 
         Returns:
-            Status: Loaded status object or None
+            Status: Loaded status object (read-only) or None
         """
-        status = cls(data_file)
+        assert data_file
+        status = cls(None)
         data = None
         try:
-            with status._lock:  # pylint: disable=protected-access
+            with InterProcessLock(cls.lock_file(data_file)):
                 with open(data_file, "r") as out_fp:
                     data = load(out_fp)
         except OSError:
@@ -136,7 +141,7 @@ def load(cls, data_file):
             if not isfile(data_file):
                 # attempt to remove potentially leaked lock file
                 try:
-                    unlink("%s.lock" % (data_file,))
+                    unlink(cls.lock_file(data_file))
                 except OSError:  # pragma: no cover
                     pass
         except ValueError:
@@ -151,8 +156,7 @@ def load(cls, data_file):
         for attr, value in data.items():
             setattr(status, attr, value)
         assert status.start_time <= status.timestamp
-        # set read only
-        status.data_file = None
+        assert status.data_file is None
         return status
 
     @classmethod
@@ -174,6 +178,18 @@ def loadall(cls):
                     continue
                 yield status
 
+    @staticmethod
+    def lock_file(data_file):
+        """Name of lock file to use with data_file.
+
+        Args:
+            data_file (str): Name of data file.
+
+        Returns:
+            str: Lock file name.
+        """
+        return "%s.lock" % (data_file,)
+
     @contextmanager
     def measure(self, name):
         """Used to simplify collecting profiling data.

From 0a1286aedaf042def758127b385e528e1860207f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Jun 2021 13:13:03 -0700
Subject: [PATCH 276/531] Only attempt to update profiles when enable_profiling
 is True

---
 grizzly/common/status.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 94d26328..74ac7d18 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -250,16 +250,16 @@ def record(self, name, duration):
         Returns:
             None
         """
-        assert isinstance(duration, (float, int))
-        try:
-            self._profiles[name]["count"] += 1
-            if self._profiles[name]["max"] < duration:
-                self._profiles[name]["max"] = duration
-            elif self._profiles[name]["min"] > duration:
-                self._profiles[name]["min"] = duration
-            self._profiles[name]["total"] += duration
-        except KeyError:
-            if self._enable_profiling:
+        if self._enable_profiling:
+            assert isinstance(duration, (float, int))
+            try:
+                self._profiles[name]["count"] += 1
+                if self._profiles[name]["max"] < duration:
+                    self._profiles[name]["max"] = duration
+                elif self._profiles[name]["min"] > duration:
+                    self._profiles[name]["min"] = duration
+                self._profiles[name]["total"] += duration
+            except KeyError:
                 # add profile entry
                 self._profiles[name] = {
                     "count": 1,

From e12f24d8e91f7d48a1e090cefde43a0647c364b7 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Jun 2021 19:07:24 -0700
Subject: [PATCH 277/531] Add path argument to Status load(), loadall() and
 start()

Also update StatusReporter to make use of these changes
---
 grizzly/common/status.py               | 32 +++++------
 grizzly/common/status_reporter.py      | 12 +++-
 grizzly/common/test_status.py          | 49 ++++++----------
 grizzly/common/test_status_reporter.py | 77 ++++++++++++--------------
 4 files changed, 76 insertions(+), 94 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 74ac7d18..20d93d62 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -7,9 +7,8 @@
 from contextlib import contextmanager
 from json import dump, load
 from logging import getLogger
-from os import close, getpid, listdir, unlink
+from os import close, getpid, scandir, unlink
 from os.path import isdir, isfile
-from os.path import join as pathjoin
 from tempfile import mkstemp
 from time import time
 
@@ -160,23 +159,21 @@ def load(cls, data_file):
         return status
 
     @classmethod
-    def loadall(cls):
-        """Load all status reports found in cls.PATH.
+    def loadall(cls, path):
+        """Load all status reports found in `path`.
 
         Args:
-            None
+            path (str): Path to scan for files containing status data.
 
-        Returns:
-            Generator: Status objects stored in cls.PATH.
+        Yields:
+            Status: Objects contain status data from files found in `path`.
         """
-        if isdir(cls.PATH):
-            for data_file in listdir(cls.PATH):
-                if not data_file.endswith(".json"):
-                    continue
-                status = cls.load(pathjoin(cls.PATH, data_file))
-                if status is None:
-                    continue
-                yield status
+        if isdir(path):
+            for entry in scandir(path):
+                if entry.is_file() and entry.name.endswith(".json"):
+                    status = cls.load(entry.path)
+                    if status is not None:
+                        yield status
 
     @staticmethod
     def lock_file(data_file):
@@ -332,16 +329,17 @@ def signatures(self):
             yield (sig, count)
 
     @classmethod
-    def start(cls, enable_profiling=False):
+    def start(cls, path=PATH, enable_profiling=False):
         """Create a unique Status object.
 
         Args:
+            path (str): Location to save files containing status data.
             enable_profiling (bool): Record profiling data.
 
         Returns:
             Status: Active status report.
         """
-        tfd, filepath = mkstemp(dir=cls.PATH, prefix="grzstatus_", suffix=".json")
+        tfd, filepath = mkstemp(dir=path, prefix="grzstatus_", suffix=".json")
         close(tfd)
         status = cls(filepath, enable_profiling=enable_profiling, start_time=time())
         status.pid = getpid()
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 4fc8bf33..760dd8c5 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -79,17 +79,18 @@ def has_results(self):
         return any(x.results for x in self.reports)
 
     @classmethod
-    def load(cls, tb_path=None):
+    def load(cls, path, tb_path=None):
         """Read Grizzly status reports and create a StatusReporter object.
 
         Args:
+            path (str): Path to scan for status data files.
             tb_path (str): Directory to scan for files containing Python tracebacks.
 
         Returns:
             StatusReporter: Contains available status reports and traceback reports.
         """
         tracebacks = None if tb_path is None else cls._tracebacks(tb_path)
-        return cls(list(Status.loadall()), tracebacks=tracebacks)
+        return cls(list(Status.loadall(path)), tracebacks=tracebacks)
 
     def print_results(self):
         print(self._results())
@@ -450,6 +451,11 @@ def main(args=None):
         help="Status loading mode. Available modes: %s (default: 'status')"
         % (", ".join(modes),),
     )
+    parser.add_argument(
+        "--reports",
+        default=Status.PATH,
+        help="Scan path for status report json files (default: %(default)s)",
+    )
     parser.add_argument(
         "--system-report",
         action="store_true",
@@ -465,7 +471,7 @@ def main(args=None):
     if args.tracebacks and not isdir(args.tracebacks):
         parser.error("--tracebacks must be a directory")
 
-    reporter = StatusReporter.load(tb_path=args.tracebacks)
+    reporter = StatusReporter.load(args.reports, tb_path=args.tracebacks)
     if args.dump:
         reporter.dump_summary(args.dump)
         return 0
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index fa321016..02c66b50 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -15,9 +15,8 @@
 
 def test_status_01(mocker, tmp_path):
     """test Status.start()"""
-    Status.PATH = str(tmp_path)
     mocker.patch("grizzly.common.status.time", return_value=1.0)
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     assert status is not None
     assert status.data_file is not None
     assert isfile(status.data_file)
@@ -37,8 +36,7 @@ def test_status_01(mocker, tmp_path):
 
 def test_status_02(tmp_path):
     """test Status.cleanup()"""
-    Status.PATH = str(tmp_path)
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     dfile = status.data_file
     status.cleanup()
     assert status.data_file is None
@@ -46,15 +44,14 @@ def test_status_02(tmp_path):
     # call 2nd time
     status.cleanup()
     # missing data file
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     remove(status.data_file)
     status.cleanup()
 
 
 def test_status_03(tmp_path):
     """test Status.report()"""
-    Status.PATH = str(tmp_path)
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     status.count_result("sig1")
     # try to report before REPORT_FREQ elapses
     assert not status.report()
@@ -72,7 +69,6 @@ def test_status_03(tmp_path):
 
 def test_status_04(tmp_path):
     """test Status.load() failure paths"""
-    Status.PATH = str(tmp_path)
     # load no db
     assert Status.load(str(tmp_path / "missing.json")) is None
     # load empty
@@ -86,10 +82,9 @@ def test_status_04(tmp_path):
 
 def test_status_05(mocker, tmp_path):
     """test Status.load()"""
-    Status.PATH = str(tmp_path)
     mocker.patch("grizzly.common.status.time", return_value=1.0)
     # create simple entry
-    status = Status.start(enable_profiling=True)
+    status = Status.start(path=str(tmp_path), enable_profiling=True)
     status.count_result("sig1")
     status.record("test", 123.45)
     status.report(force=True)
@@ -115,27 +110,23 @@ def test_status_05(mocker, tmp_path):
 
 def test_status_06(tmp_path):
     """test Status.loadall()"""
-    working_path = tmp_path / "status"
-    Status.PATH = str(working_path)
     # missing path
-    assert not any(Status.loadall())
+    assert not any(Status.loadall("missing"))
     # no status data
-    working_path.mkdir()
-    assert not any(Status.loadall())
+    assert not any(Status.loadall(str(tmp_path)))
     # add more entries
     for _ in range(5):
-        Status.start()
-    (working_path / "empty.json").touch()
-    assert len(tuple(Status.loadall())) == 5
+        Status.start(path=str(tmp_path))
+    (tmp_path / "empty.json").touch()
+    assert len(tuple(Status.loadall(str(tmp_path)))) == 5
 
 
 def test_status_07(mocker, tmp_path):
     """test Status.runtime and Status.rate calculations"""
-    Status.PATH = str(tmp_path)
     mocker.patch(
         "grizzly.common.status.time", side_effect=(1.0, 1.0, 3.0, 3.0, 5.0, 5.0, 5.0)
     )
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     assert status.data_file is not None
     assert status.start_time == 1
     # test no iterations
@@ -161,8 +152,7 @@ def test_status_07(mocker, tmp_path):
 def _client_writer(done, reported, working_path):
     """Used by test_status_08"""
     # NOTE: this must be at the top level to work on Windows
-    Status.PATH = working_path
-    status = Status.start()
+    status = Status.start(path=working_path)
     try:
         while not done.is_set():
             status.iteration += 1
@@ -177,7 +167,6 @@ def _client_writer(done, reported, working_path):
 
 def test_status_08(tmp_path):
     """test Status.loadall() with multiple active reporters"""
-    Status.PATH = str(tmp_path)
     done = Event()
     procs = list()
     report_events = list()
@@ -187,7 +176,7 @@ def test_status_08(tmp_path):
             report_events.append(Event())
             procs.append(
                 Process(
-                    target=_client_writer, args=(done, report_events[-1], Status.PATH)
+                    target=_client_writer, args=(done, report_events[-1], str(tmp_path))
                 )
             )
             procs[-1].start()
@@ -195,7 +184,7 @@ def test_status_08(tmp_path):
         for has_reported in report_events:
             assert has_reported.wait(timeout=60)
         # collect reports
-        reports = tuple(Status.loadall())
+        reports = tuple(Status.loadall(str(tmp_path)))
         assert len(reports) == len(procs)
         assert max(x.rate for x in reports) > 0
     finally:
@@ -204,13 +193,12 @@ def test_status_08(tmp_path):
             if proc.pid is not None:
                 proc.join()
     # verify cleanup
-    assert not any(Status.loadall())
+    assert not any(Status.loadall(str(tmp_path)))
 
 
 def test_status_09(tmp_path):
     """test Status.count_result() and Status.signatures()"""
-    Status.PATH = str(tmp_path)
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     status.count_result("sig1")
     status.count_result("sig2")
     status.count_result("sig1")
@@ -229,9 +217,8 @@ def test_status_09(tmp_path):
 
 def test_status_10(tmp_path):
     """test Status.measure() and Status.record() - profiling support"""
-    Status.PATH = str(tmp_path)
     # profiling disabled
-    status = Status.start(enable_profiling=False)
+    status = Status.start(path=str(tmp_path), enable_profiling=False)
     status.record("x", 10.1)
     assert not status._profiles
     with status.measure("x"):
@@ -239,7 +226,7 @@ def test_status_10(tmp_path):
     assert not status._profiles
     status.cleanup()
     # profiling enabled
-    status = Status.start(enable_profiling=True)
+    status = Status.start(path=str(tmp_path), enable_profiling=True)
     assert not status._profiles
     # initial entry
     status.record("test1", 10.1)
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 7deeab03..fe348ab3 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -43,12 +43,11 @@ def test_status_reporter_01(tmp_path):
 
 def test_status_reporter_02(tmp_path):
     """test StatusReporter.load()"""
-    Status.PATH = str(tmp_path / "missing")
     # missing reports path
-    st_rpt = StatusReporter.load()
+    st_rpt = StatusReporter.load(str(tmp_path / "missing"))
     assert not st_rpt.reports
     # empty reports and tb paths
-    st_rpt = StatusReporter.load(tb_path=str(tmp_path))
+    st_rpt = StatusReporter.load(str(tmp_path), tb_path=str(tmp_path))
     assert isinstance(st_rpt.reports, list)
     assert not st_rpt.reports
     assert isinstance(st_rpt.tracebacks, list)
@@ -129,14 +128,13 @@ def test_status_reporter_05(mocker, tmp_path):
     """test StatusReporter._summary()"""
     mocker.patch("grizzly.common.status.time", side_effect=count(start=1.0, step=1.0))
     mocker.patch("grizzly.common.status_reporter.time", side_effect=(1.0, 2.0))
-    Status.PATH = str(tmp_path)
     # single report
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     status.ignored = 0
     status.iteration = 1
     status.log_size = 0
     status.report(force=True)
-    rptr = StatusReporter.load()
+    rptr = StatusReporter.load(str(tmp_path))
     rptr._sys_info = _fake_sys_info
     assert rptr.reports is not None
     assert len(rptr.reports) == 1
@@ -150,12 +148,12 @@ def test_status_reporter_05(mocker, tmp_path):
     assert "Timestamp" not in output
     assert len(output.split("\n")) == 3
     # multiple reports
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     status.ignored = 1
     status.iteration = 8
     status.log_size = 86900000
     status.report(force=True)
-    rptr = StatusReporter.load()
+    rptr = StatusReporter.load(str(tmp_path))
     rptr._sys_info = _fake_sys_info
     assert len(rptr.reports) == 2
     output = rptr._summary(sysinfo=True, timestamp=True)
@@ -176,18 +174,17 @@ def test_status_reporter_05(mocker, tmp_path):
 
 def test_status_reporter_06(mocker, tmp_path):
     """test StatusReporter._specific()"""
-    Status.PATH = str(tmp_path)
     mocker.patch("grizzly.common.status_reporter.time", return_value=3661.0)
     # single report
     mocker.patch(
         "grizzly.common.status.time", side_effect=count(start=0.0, step=3600.0)
     )
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     status.ignored = 0
     status.iteration = 1
     status.log_size = 0
     status.report(force=True)
-    rptr = StatusReporter.load()
+    rptr = StatusReporter.load(str(tmp_path))
     assert rptr.reports is not None
     output = rptr._specific()
     assert len(output.split("\n")[:-1]) == 2
@@ -199,7 +196,7 @@ def test_status_reporter_06(mocker, tmp_path):
     mocker.patch(
         "grizzly.common.status.time", side_effect=count(start=0.0, step=3661.0)
     )
-    status = Status.start(enable_profiling=True)
+    status = Status.start(path=str(tmp_path), enable_profiling=True)
     status.ignored = 1
     status.iteration = 432422
     status._results = {"sig": 123}
@@ -208,7 +205,7 @@ def test_status_reporter_06(mocker, tmp_path):
     status.record("test1", 1.23456)
     status.record("test2", 1201.1)
     status.report(force=True)
-    rptr = StatusReporter.load()
+    rptr = StatusReporter.load(str(tmp_path))
     assert len(rptr.reports) == 2
     output = rptr._specific()
     assert len(output.split("\n")[:-1]) == 7
@@ -221,11 +218,11 @@ def test_status_reporter_06(mocker, tmp_path):
     assert "EXPIRED" not in output
     # expired report
     mocker.patch("grizzly.common.status.time", return_value=1.0)
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     status.ignored = 1
     status.iteration = 1
     status.report(force=True)
-    rptr = StatusReporter.load()
+    rptr = StatusReporter.load(str(tmp_path))
     assert len(rptr.reports) == 3
     output = rptr._specific()
     assert len(output.split("\n")[:-1]) == 8
@@ -234,31 +231,30 @@ def test_status_reporter_06(mocker, tmp_path):
 
 def test_status_reporter_07(tmp_path):
     """test StatusReporter._results()"""
-    Status.PATH = str(tmp_path)
     # single report without results
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     status.ignored = 0
     status.iteration = 1
     status.log_size = 0
     status.report(force=True)
-    rptr = StatusReporter.load()
+    rptr = StatusReporter.load(str(tmp_path))
     assert rptr.reports is not None
     assert len(rptr.reports) == 1
     assert not rptr.has_results
     assert not rptr._results()
     # multiple reports with results
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     status.iteration = 1
     status.count_result("[@ test1]")
     status.count_result("[@ test2]")
     status.count_result("[@ test1]")
     status.report(force=True)
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     status.iteration = 1
     status.count_result("[@ test1]")
     status.count_result("[@ longsignature123]")
     status.report(force=True)
-    rptr = StatusReporter.load()
+    rptr = StatusReporter.load(str(tmp_path))
     assert rptr.has_results
     assert len(rptr.reports) == 3
     output = rptr._results(max_len=16)
@@ -270,9 +266,9 @@ def test_status_reporter_07(tmp_path):
 
 def test_status_reporter_08(tmp_path):
     """test StatusReporter.load() with traceback"""
-    (tmp_path / "status").mkdir()
-    Status.PATH = str(tmp_path / "status")
-    status = Status.start()
+    status_path = tmp_path / "status"
+    status_path.mkdir()
+    status = Status.start(path=str(status_path))
     status.ignored = 0
     status.iteration = 1
     status.log_size = 0
@@ -284,21 +280,21 @@ def test_status_reporter_08(tmp_path):
         test_fp.write(b"Traceback (most recent call last):\n")
         test_fp.write(b"  blah\n")
         test_fp.write(b"IndexError: list index out of range\n")
-    rptr = StatusReporter.load(tb_path=str(tmp_path))
+    rptr = StatusReporter.load(str(status_path), tb_path=str(tmp_path))
     assert len(rptr.tracebacks) == 1
     # create second screenlog
     with (tmp_path / "screenlog.1234").open("wb") as test_fp:
         test_fp.write(b"Traceback (most recent call last):\n")
         test_fp.write(b"  blah\n")
         test_fp.write(b"foo.bar.error: blah\n")
-    rptr = StatusReporter.load(tb_path=str(tmp_path))
+    rptr = StatusReporter.load(str(status_path), tb_path=str(tmp_path))
     assert len(rptr.tracebacks) == 2
     # create third screenlog
     with (tmp_path / "screenlog.3").open("wb") as test_fp:
         test_fp.write(b"Traceback (most recent call last):\n")
         test_fp.write(b"  blah\n")
         test_fp.write(b"KeyboardInterrupt\n")
-    rptr = StatusReporter.load(tb_path=str(tmp_path))
+    rptr = StatusReporter.load(str(status_path), tb_path=str(tmp_path))
     assert len(rptr.tracebacks) == 2
     merged_log = rptr._summary()
     assert len(merged_log.splitlines()) == 14
@@ -311,14 +307,12 @@ def test_status_reporter_08(tmp_path):
 
 def test_status_reporter_09(tmp_path):
     """test StatusReporter.load() no reports with traceback"""
-    (tmp_path / "status").mkdir()
-    Status.PATH = str(tmp_path / "status")
     # create screenlog with tb
     with (tmp_path / "screenlog.1").open("wb") as test_fp:
         test_fp.write(b"Traceback (most recent call last):\n")
         test_fp.write(b"  blah\n")
         test_fp.write(b"IndexError: list index out of range\n")
-    rptr = StatusReporter.load(tb_path=str(tmp_path))
+    rptr = StatusReporter.load(str(tmp_path), tb_path=str(tmp_path))
     rptr._sys_info = _fake_sys_info
     assert len(rptr.tracebacks) == 1
     output = rptr._summary()
@@ -329,16 +323,16 @@ def test_status_reporter_09(tmp_path):
 
 def test_status_reporter_10(tmp_path):
     """test StatusReporter.summary() limit with traceback"""
-    (tmp_path / "status").mkdir()
-    Status.PATH = str(tmp_path / "status")
+    status_path = tmp_path / "status"
+    status_path.mkdir()
     # create reports
-    status = Status.start()
+    status = Status.start(path=str(status_path))
     status.ignored = 100
     status.iteration = 1000
     status.log_size = 9999999999
     status._results = {"sig": 123}
     status.report(force=True)
-    status = Status.start()
+    status = Status.start(path=str(status_path))
     status.ignored = 9
     status.iteration = 192938
     status.log_size = 0
@@ -354,7 +348,7 @@ def test_status_reporter_10(tmp_path):
                 )
                 test_fp.write(b"    some_long_name_for_a_func_%04d()\n" % (j,))
             test_fp.write(b"IndexError: list index out of range\n")
-    rptr = StatusReporter.load(tb_path=str(tmp_path))
+    rptr = StatusReporter.load(str(status_path), tb_path=str(tmp_path))
     rptr._sys_info = _fake_sys_info
     assert len(rptr.tracebacks) == 10
     merged_log = rptr._summary(runtime=True, sysinfo=True, timestamp=True)
@@ -534,31 +528,28 @@ def test_traceback_report_08(tmp_path):
 
 def test_main_01(tmp_path):
     """test main() with no reports"""
-    Status.PATH = str(tmp_path)
     StatusReporter.CPU_POLL_INTERVAL = 0.01
-    assert main([]) == 0
+    assert main(["--reports", str(tmp_path)]) == 0
 
 
 def test_main_02(tmp_path):
     """test main() with a report"""
-    Status.PATH = str(tmp_path)
     StatusReporter.CPU_POLL_INTERVAL = 0.01
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     status.iteration = 1
     status.count_result("[@ test]")
     status.report(force=True)
-    assert main([]) == 0
+    assert main(["--reports", str(tmp_path)]) == 0
 
 
 def test_main_03(tmp_path):
     """test main() --dump"""
-    Status.PATH = str(tmp_path)
     StatusReporter.CPU_POLL_INTERVAL = 0.01
-    status = Status.start()
+    status = Status.start(path=str(tmp_path))
     status.iteration = 1
     status.report(force=True)
     dump_file = tmp_path / "output.txt"
-    assert main(["--dump", str(dump_file)]) == 0
+    assert main(["--dump", str(dump_file), "--reports", str(tmp_path)]) == 0
     assert dump_file.is_file()
     assert b"Runtime" not in dump_file.read_bytes()
     # assert False, dump_file.read_bytes()

From e0dfe79ba72659098f46305d5ef5a803e8273599 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Jun 2021 19:27:33 -0700
Subject: [PATCH 278/531] [tests] Update use of Status.PATH

---
 grizzly/test_session.py | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 01027af5..55ff598e 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -13,7 +13,7 @@
 from sapphire import SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT, Sapphire
 
 from .adapter import Adapter
-from .common import Report, Reporter, RunResult, Status
+from .common import Report, Reporter, RunResult
 from .session import LogOutputLimiter, Session, SessionError
 from .target import Target, TargetLaunchError
 
@@ -65,7 +65,7 @@ def test_session_01(
     mocker, tmp_path, harness, profiling, coverage, relaunch, iters, runtime
 ):
     """test Session with typical fuzzer Adapter"""
-    Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     mocker.patch("grizzly.common.status.time", side_effect=count(start=1.0, step=1.0))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     prefs = tmp_path / "prefs.js"
@@ -134,7 +134,7 @@ def test_session_01(
 )
 def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
     """test Session with playback Adapter"""
-    Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
     # calculate if the target is 'closed' based on relaunch
@@ -182,7 +182,7 @@ def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
 )
 def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
     """test Session - detecting failure"""
-    Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     adapter = SimpleAdapter(harness)
     reporter = mocker.Mock(spec=Reporter)
     report = mocker.Mock(spec=Report, major="major123", minor="minor456")
@@ -224,7 +224,7 @@ class FuzzAdapter(Adapter):
         def generate(self, _testcase, _server_map):
             pass
 
-    Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_NONE, [])
     target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
@@ -236,7 +236,7 @@ def generate(self, _testcase, _server_map):
 
 def test_session_05(mocker, tmp_path):
     """test Target not requesting landing page"""
-    Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_TIMEOUT, [])
     target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
@@ -259,7 +259,7 @@ def test_session_05(mocker, tmp_path):
 )
 def test_session_06(mocker, tmp_path, harness, report_size):
     """test Session - handle Target delayed failures"""
-    Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     reporter = mocker.Mock(spec=Reporter)
     report = mocker.Mock(spec=Report, major="major123", minor="minor456")
     report.crash_info.createShortSignature.return_value = "[@ sig]"
@@ -301,7 +301,7 @@ def test_session_06(mocker, tmp_path, harness, report_size):
 )
 def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, results):
     """test Session.run() - initial test case was not served"""
-    Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     report = mocker.Mock(spec=Report, major="major123", minor="minor456")
     report.crash_info.createShortSignature.return_value = "[@ sig]"
     reporter = mocker.Mock(spec=Reporter)
@@ -326,7 +326,7 @@ def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, resul
 
 def test_session_08(tmp_path, mocker):
     """test Session.run() ignoring failures"""
-    Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     result = RunResult([], 0.1, status=RunResult.IGNORED)
     result.attempted = True
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
@@ -350,7 +350,7 @@ def test_session_08(tmp_path, mocker):
 
 def test_session_09(tmp_path, mocker):
     """test Session.run() handle TargetLaunchError"""
-    Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     report = mocker.Mock(spec=Report, major="major123", minor="minor456")
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.launch.side_effect = TargetLaunchError("test", report)
@@ -369,7 +369,7 @@ def test_session_09(tmp_path, mocker):
 
 def test_session_10(tmp_path, mocker):
     """test Session.run() report hang"""
-    Status.PATH = str(tmp_path)
+    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     result = RunResult([], 60.0, status=RunResult.FAILED, timeout=True)
     result.attempted = True
     runner = mocker.patch("grizzly.session.Runner", autospec=True)

From f1d709caf098acbff954cd06a47b52454c644112 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Jun 2021 19:28:46 -0700
Subject: [PATCH 279/531] Update Status docs

---
 grizzly/common/status.py | 26 ++++++++++++++++++++------
 1 file changed, 20 insertions(+), 6 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 20d93d62..9837868b 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -27,7 +27,22 @@
 
 class Status:
     """Status holds status information for the Grizzly session.
-    There can be multiple readers of the data but only a single writer.
+    There can be multiple readers (read-only) but only a single writer of data.
+    Read-only mode is implied if `data_file` is None.
+
+    Attributes:
+        _enable_profiling (bool): Profiling support status.
+        _lock (InterProcessLock): Lock used with data_file.
+        _profiles (dict): Profiling data.
+        _results (dict): Results data. Used to count occurrences of a signature.
+        data_file (str): File to save data to. None in read-only mode.
+        ignored (int): Ignored result count.
+        iteration (int): Iteration count.
+        log_size (int): Log size in bytes.
+        pid (int): Python process ID.
+        start_time (float): Start time of session.
+        test_name (str): Current test name.
+        timestamp (float): Last time data was saved to data_file. Set by report().
     """
 
     PATH = grz_tmp("status")
@@ -118,8 +133,7 @@ def _data(self):
 
     @classmethod
     def load(cls, data_file):
-        """Load status report. Loading a status report from disk will create a
-        read only status report.
+        """Load status report from a file. This will create a read-only status report.
 
         Args:
             data_file (str): JSON file that contains status data.
@@ -166,7 +180,7 @@ def loadall(cls, path):
             path (str): Path to scan for files containing status data.
 
         Yields:
-            Status: Objects contain status data from files found in `path`.
+            Status: Successfully loaded read-only status objects.
         """
         if isdir(path):
             for entry in scandir(path):
@@ -194,7 +208,7 @@ def measure(self, name):
         Args:
             name (str): Used to group the entries.
 
-        Returns:
+        Yields:
             None
         """
         if self._enable_profiling:
@@ -323,7 +337,7 @@ def signatures(self):
             None
 
         Yields:
-            tuples: Containing signature and count.
+            tuple: Signature and count.
         """
         for sig, count in self._results.items():
             yield (sig, count)

From bbbf68654c5c20485ad26c9282dda0ddd380211a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 24 Jun 2021 09:01:36 -0700
Subject: [PATCH 280/531] Include PID in Status file name

---
 grizzly/common/status.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 9837868b..bab8f7f2 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -353,9 +353,14 @@ def start(cls, path=PATH, enable_profiling=False):
         Returns:
             Status: Active status report.
         """
-        tfd, filepath = mkstemp(dir=path, prefix="grzstatus_", suffix=".json")
+        pid = getpid()
+        tfd, filepath = mkstemp(
+            dir=path,
+            prefix="grzstatus_%d_" % (pid,),
+            suffix=".json",
+        )
         close(tfd)
         status = cls(filepath, enable_profiling=enable_profiling, start_time=time())
-        status.pid = getpid()
+        status.pid = pid
         status.report(force=True)
         return status

From d5363bf475fca42d233ddb64e070c62d90d66716 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 24 Jun 2021 09:03:26 -0700
Subject: [PATCH 281/531] Ignore results in expired reports

---
 grizzly/common/status_reporter.py      | 32 +++++++++++++++-----------
 grizzly/common/test_status_reporter.py |  2 +-
 2 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 760dd8c5..e6800a0f 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -103,10 +103,14 @@ def print_summary(self, runtime=True, sysinfo=False, timestamp=False):
 
     def _results(self, max_len=85):
         signatures = defaultdict(int)
+        exp = int(time()) - self.EXP_LIMIT
         # calculate totals
-        for result in self.reports:
-            for sig, count in result.signatures():
-                signatures[sig] += count
+        for report in self.reports:
+            # filter expired reports
+            if report.timestamp > exp:
+                # count results in report
+                for sig, count in report.signatures():
+                    signatures[sig] += count
         # generate output
         txt = list()
         for sig, count in sorted(signatures.items(), key=lambda x: x[1], reverse=True):
@@ -114,6 +118,8 @@ def _results(self, max_len=85):
                 txt.append("%d: '%s...'\n" % (count, sig[:max_len]))
             else:
                 txt.append("%d: %r\n" % (count, sig))
+        if not txt:
+            txt.append("No results available\n")
         return "".join(txt)
 
     @staticmethod
@@ -221,14 +227,14 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
                 total_runtime = sum(x.runtime for x in reports)
                 txt.append("   Runtime : %s" % (timedelta(seconds=int(total_runtime)),))
             # Log size
-            log_usage = sum(log_sizes) / 1048576.0
+            log_usage = sum(log_sizes) / 1_048_576.0
             if log_usage > self.DISPLAY_LIMIT_LOG:
                 txt.append("\n")
                 txt.append("      Logs : %0.1fMB" % (log_usage,))
                 if count > 1:
                     txt.append(
                         " (%0.2fMB, %0.2fMB)"
-                        % (max(log_sizes) / 1048576.0, min(log_sizes) / 1048576.0)
+                        % (max(log_sizes) / 1_048_576.0, min(log_sizes) / 1_048_576.0)
                     )
         else:
             txt.append("No status reports available")
@@ -289,18 +295,18 @@ def _sys_info():
             txt.append("\n")
         mem_usage = virtual_memory()
         txt.append("    Memory : ")
-        if mem_usage.available < 1073741824:  # < 1GB
-            txt.append("%dMB" % (mem_usage.available / 1048576,))
+        if mem_usage.available < 1_073_741_824:  # < 1GB
+            txt.append("%dMB" % (mem_usage.available / 1_048_576,))
         else:
-            txt.append("%0.1fGB" % (mem_usage.available / 1073741824.0,))
-        txt.append(" of %0.1fGB free\n" % (mem_usage.total / 1073741824.0,))
+            txt.append("%0.1fGB" % (mem_usage.available / 1_073_741_824.0,))
+        txt.append(" of %0.1fGB free\n" % (mem_usage.total / 1_073_741_824.0,))
         usage = disk_usage("/")
         txt.append("      Disk : ")
-        if usage.free < 1073741824:  # < 1GB
-            txt.append("%dMB" % (usage.free / 1048576,))
+        if usage.free < 1_073_741_824:  # < 1GB
+            txt.append("%dMB" % (usage.free / 1_048_576,))
         else:
-            txt.append("%0.1fGB" % (usage.free / 1073741824.0,))
-        txt.append(" of %0.1fGB free" % (usage.total / 1073741824.0,))
+            txt.append("%0.1fGB" % (usage.free / 1_073_741_824.0,))
+        txt.append(" of %0.1fGB free" % (usage.total / 1_073_741_824.0,))
         return "".join(txt)
 
     @staticmethod
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index fe348ab3..87a431bd 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -241,7 +241,7 @@ def test_status_reporter_07(tmp_path):
     assert rptr.reports is not None
     assert len(rptr.reports) == 1
     assert not rptr.has_results
-    assert not rptr._results()
+    assert rptr._results() == "No results available\n"
     # multiple reports with results
     status = Status.start(path=str(tmp_path))
     status.iteration = 1

From 82bf44ad5b5c3d1898768b777d70ddd23422e6b0 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 24 Jun 2021 10:10:52 -0700
Subject: [PATCH 282/531] Add ability to remove expired status reports

---
 grizzly/common/status_reporter.py      | 42 ++++++++++++++++++++++++--
 grizzly/common/test_status_reporter.py | 22 ++++++++++++++
 2 files changed, 61 insertions(+), 3 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index e6800a0f..617872d7 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -15,7 +15,7 @@
 except ImportError:  # pragma: no cover
     # os.getloadavg() is not available on all platforms
     getloadavg = None
-from os import SEEK_CUR, getenv, scandir
+from os import SEEK_CUR, getenv, remove, scandir
 from os.path import isdir
 from re import match
 from time import gmtime, strftime, time
@@ -45,6 +45,37 @@ def __init__(self, reports, tracebacks=None):
         self.reports = reports
         self.tracebacks = tracebacks
 
+    @staticmethod
+    def delete_expired(path, exp_limit=EXP_LIMIT):
+        """Remove expired reports from the filesystem.
+
+        Args:
+            path (str): Path to scan for status report files.
+            exp_limit (int): Age limit of report in seconds before it is considered
+                             expired.
+
+        Returns:
+            None
+        """
+        exp = int(time()) - exp_limit
+        expired = 0
+        for entry in scandir(path):
+            if entry.name.endswith(".json") and entry.is_file():
+                report = Status.load(entry.path)
+                if report and report.timestamp <= exp:
+                    # remove lock file
+                    try:
+                        remove(Status.lock_file(entry.path))
+                    except OSError:  # pragma: no cover
+                        pass
+                    # remove data file
+                    try:
+                        remove(entry.path)
+                        expired += 1
+                    except OSError:  # pragma: no cover
+                        pass
+        print("%d expired report(s) removed" % (expired,))
+
     def dump_specific(self, filename):
         """Write out merged reports.
 
@@ -448,13 +479,13 @@ def main(args=None):
         log_fmt = "[%(asctime)s] %(message)s"
     basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
 
-    modes = ("status",)
+    modes = ("status", "cleanup")
     parser = ArgumentParser(description="Grizzly status report generator")
     parser.add_argument("--dump", help="File to write report to")
     parser.add_argument(
         "--mode",
         default="status",
-        help="Status loading mode. Available modes: %s (default: 'status')"
+        help="Report mode. Available modes: %s (default: 'status')"
         % (", ".join(modes),),
     )
     parser.add_argument(
@@ -477,6 +508,11 @@ def main(args=None):
     if args.tracebacks and not isdir(args.tracebacks):
         parser.error("--tracebacks must be a directory")
 
+    if args.mode == "cleanup":
+        print("Removing expired reports from disk...")
+        StatusReporter.delete_expired(args.reports)
+        return 0
+
     reporter = StatusReporter.load(args.reports, tb_path=args.tracebacks)
     if args.dump:
         reporter.dump_summary(args.dump)
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 87a431bd..48c17b78 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -6,6 +6,7 @@
 # pylint: disable=protected-access
 
 from itertools import count
+from os.path import isfile
 from re import match
 from unittest.mock import Mock
 
@@ -355,6 +356,22 @@ def test_status_reporter_10(tmp_path):
     assert len(merged_log) < StatusReporter.SUMMARY_LIMIT
 
 
+def test_status_reporter_11(mocker, tmp_path):
+    """test StatusReporter.delete_expired()"""
+    # test not expired
+    mocker.patch("grizzly.common.status.time", return_value=1.0)
+    mocker.patch("grizzly.common.status_reporter.time", return_value=1.0)
+    status = Status.start(path=str(tmp_path))
+    status.report(force=True)
+    StatusReporter.delete_expired(str(tmp_path))
+    assert isfile(status.data_file)
+    # test expired
+    mocker.patch("grizzly.common.status_reporter.time", return_value=2.0)
+    status.report(force=True)
+    StatusReporter.delete_expired(str(tmp_path), exp_limit=1)
+    assert not isfile(status.data_file)
+
+
 def test_traceback_report_01():
     """test simple TracebackReport"""
     tbr = TracebackReport("log.txt", ["0", "1", "2"], prev_lines=["-2", "-1"])
@@ -561,3 +578,8 @@ def test_main_04():
         main(["--mode", "invalid"])
     with raises(SystemExit):
         main(["--tracebacks", "missing"])
+
+
+def test_main_05(tmp_path):
+    """test main() cleanup mode"""
+    assert main(["--mode", "cleanup", "--reports", str(tmp_path)]) == 0

From fbb82977df1c311d544d77f4951e568c1a393280 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 7 Jul 2021 12:25:26 -0700
Subject: [PATCH 283/531] Remove imports in common/__init__.py to avoid
 circular import issues

---
 grizzly/adapter/no_op_adapter/test_no_op.py |  2 +-
 grizzly/common/__init__.py                  | 31 ---------------------
 grizzly/reduce/test_main.py                 |  2 +-
 grizzly/reduce/test_reduce.py               |  3 +-
 grizzly/reduce/test_strategies.py           |  3 +-
 grizzly/reduce/test_strategies_beautify.py  |  2 +-
 grizzly/replay/test_main.py                 |  3 +-
 grizzly/replay/test_replay.py               |  4 ++-
 grizzly/session.py                          |  5 +++-
 grizzly/test_session.py                     |  3 +-
 10 files changed, 18 insertions(+), 40 deletions(-)

diff --git a/grizzly/adapter/no_op_adapter/test_no_op.py b/grizzly/adapter/no_op_adapter/test_no_op.py
index cb40661d..f732fb80 100644
--- a/grizzly/adapter/no_op_adapter/test_no_op.py
+++ b/grizzly/adapter/no_op_adapter/test_no_op.py
@@ -3,7 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-from grizzly.common import TestCase
+from grizzly.common.storage import TestCase
 
 from . import NoOpAdapter
 
diff --git a/grizzly/common/__init__.py b/grizzly/common/__init__.py
index bb15f8ce..ce790c19 100644
--- a/grizzly/common/__init__.py
+++ b/grizzly/common/__init__.py
@@ -3,36 +3,5 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-from .iomanager import IOManager, ServerMap
-from .reporter import (
-    FilesystemReporter,
-    FuzzManagerReporter,
-    Report,
-    Reporter,
-    S3FuzzManagerReporter,
-)
-from .runner import Runner, RunResult
-from .status import Status
-from .storage import TestCase, TestCaseLoadFailure, TestFile, TestFileExists
-from .utils import configure_logging, grz_tmp
-
-__all__ = (
-    "FilesystemReporter",
-    "FuzzManagerReporter",
-    "configure_logging",
-    "grz_tmp",
-    "IOManager",
-    "Report",
-    "Reporter",
-    "Runner",
-    "RunResult",
-    "S3FuzzManagerReporter",
-    "ServerMap",
-    "Status",
-    "TestCase",
-    "TestCaseLoadFailure",
-    "TestFile",
-    "TestFileExists",
-)
 __author__ = "Jesse Schwartzentruber"
 __credits__ = ["Jesse Schwartzentruber", "Tyson Smith"]
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index c679f14b..d76414e3 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -11,7 +11,7 @@
 import pytest
 from pytest import raises
 
-from ..common import TestCaseLoadFailure
+from ..common.storage import TestCaseLoadFailure
 from ..target import TargetLaunchError, TargetLaunchTimeout
 from . import ReduceManager
 from .args import ReduceArgs, ReduceFuzzManagerIDArgs, ReduceFuzzManagerIDQualityArgs
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index dd9928eb..e89229df 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -15,7 +15,8 @@
 
 from sapphire import Sapphire
 
-from ..common import Report, TestCase
+from ..common.reporter import Report
+from ..common.storage import TestCase
 from ..replay import ReplayResult
 from ..target import Target
 from . import ReduceManager
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 8562d804..382c5d5c 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -12,7 +12,8 @@
 
 from sapphire import Sapphire
 
-from ..common import Report, TestCase, TestFile
+from ..common.reporter import Report
+from ..common.storage import TestCase, TestFile
 from ..replay import ReplayResult
 from ..target import Target
 from . import ReduceManager
diff --git a/grizzly/reduce/test_strategies_beautify.py b/grizzly/reduce/test_strategies_beautify.py
index c59e7a6f..384d3689 100644
--- a/grizzly/reduce/test_strategies_beautify.py
+++ b/grizzly/reduce/test_strategies_beautify.py
@@ -9,7 +9,7 @@
 
 import pytest
 
-from ..common import TestCase
+from ..common.storage import TestCase
 from .strategies.beautify import CSSBeautify, JSBeautify
 
 LOG = getLogger(__name__)
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 1c92cccb..44bfe5ab 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -12,7 +12,8 @@
 
 from sapphire import SERVED_ALL
 
-from ..common import Report, TestCase, TestCaseLoadFailure
+from ..common.reporter import Report
+from ..common.storage import TestCase, TestCaseLoadFailure
 from ..session import Session
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from .replay import ReplayManager
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 73f86b97..45a61db9 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -13,7 +13,9 @@
 
 from sapphire import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT, Sapphire
 
-from ..common import Report, Status, TestCase, TestCaseLoadFailure
+from ..common.reporter import Report
+from ..common.status import Status
+from ..common.storage import TestCase, TestCaseLoadFailure
 from ..target import Target
 from .replay import ReplayManager, ReplayResult
 
diff --git a/grizzly/session.py b/grizzly/session.py
index cf82c03e..4d03c909 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -5,7 +5,10 @@
 from logging import getLogger
 from time import time
 
-from .common import IOManager, Runner, RunResult, Status, TestFile
+from .common.iomanager import IOManager
+from .common.runner import Runner, RunResult
+from .common.status import Status
+from .common.storage import TestFile
 from .target import TargetLaunchError
 
 __all__ = ("SessionError", "LogOutputLimiter", "Session")
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 55ff598e..3b7485c4 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -13,7 +13,8 @@
 from sapphire import SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT, Sapphire
 
 from .adapter import Adapter
-from .common import Report, Reporter, RunResult
+from .common.reporter import Report, Reporter
+from .common.runner import RunResult
 from .session import LogOutputLimiter, Session, SessionError
 from .target import Target, TargetLaunchError
 

From 3ec3d36973f8f26115f85507ce8edeaaab0304d5 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 8 Jul 2021 13:33:51 -0700
Subject: [PATCH 284/531] Add Target assets

AssetManager helps track target assets in a generic way
---
 grizzly/args.py                      | 38 +++++++++--
 grizzly/common/plugins.py            | 16 +++++
 grizzly/common/test_plugins.py       | 23 ++++++-
 grizzly/main.py                      |  6 +-
 grizzly/reduce/core.py               |  4 +-
 grizzly/replay/replay.py             | 20 +++---
 grizzly/replay/test_main.py          | 10 ++-
 grizzly/session.py                   |  8 ++-
 grizzly/target/__init__.py           |  9 ++-
 grizzly/target/puppet_target.py      | 72 +++++++++-----------
 grizzly/target/target.py             | 80 ++++++++++++++++++++---
 grizzly/target/test_puppet_target.py | 63 +++++++-----------
 grizzly/target/test_target.py        | 98 +++++++++++++++++++++++-----
 grizzly/test_args.py                 | 17 +++++
 grizzly/test_main.py                 |  1 +
 grizzly/test_session.py              | 18 ++---
 16 files changed, 344 insertions(+), 139 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 05e138f9..86d53738 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -8,6 +8,7 @@
 from platform import system
 
 from .common.plugins import scan as scan_plugins
+from .common.plugins import scan_target_assets
 from .common.utils import TIMEOUT_DELAY
 
 
@@ -59,14 +60,30 @@ def __init__(self):
             ),
         )
 
+        # build 'asset' help string
+        assets = scan_target_assets()
+        asset_msg = list()
+        for target in sorted(assets):
+            if assets[target]:
+                asset_msg.append(
+                    "%s: %s. " % (target, ", ".join(sorted(assets[target])))
+                )
+
         self.launcher_grp = self.parser.add_argument_group("Launcher Arguments")
+        self.launcher_grp.add_argument(
+            "--asset",
+            action="append",
+            metavar=("ASSET", "PATH"),
+            nargs=2,
+            help="Specify target specific asset files. %s" % ("".join(asset_msg),),
+        )
         self.launcher_grp.add_argument(
             "-e",
             "--extension",
             action="append",
-            help="Install an extension. Specify the path to the xpi or the directory"
-            " containing the unpacked extension. To install multiple extensions"
-            " specify multiple times",
+            help="DEPRECATED. Install an extension. Specify the path to the xpi or the"
+            " directory containing the unpacked extension. To install multiple"
+            " extensions specify multiple times",
         )
         self.launcher_grp.add_argument(
             "--launch-timeout",
@@ -94,7 +111,9 @@ def __init__(self):
             help="Installed Platforms (Targets): %s (default: %%(default)s)"
             % ", ".join(sorted(scan_plugins("grizzly_targets"))),
         )
-        self.launcher_grp.add_argument("-p", "--prefs", help="prefs.js file to use")
+        self.launcher_grp.add_argument(
+            "-p", "--prefs", help="DEPRECATED. prefs.js file to use"
+        )
         self.launcher_grp.add_argument(
             "--relaunch",
             type=int,
@@ -214,6 +233,17 @@ def sanity_check(self, args):
         if args.platform not in targets:
             self.parser.error("Platform %r not installed" % (args.platform,))
 
+        # check args.platform before args.asset since it is used
+        if args.asset:
+            supported_assets = scan_target_assets()[args.platform]
+            for asset, path in args.asset:
+                if not supported_assets or asset not in supported_assets:
+                    self.parser.error(
+                        "Asset %r not supported by target %r" % (asset, args.platform)
+                    )
+                if not exists(path):
+                    self.parser.error("%r does not exist %r" % (asset, path))
+
         if args.prefs and not isfile(args.prefs):
             self.parser.error("--prefs file not found")
 
diff --git a/grizzly/common/plugins.py b/grizzly/common/plugins.py
index ba1cde90..68a8f00e 100644
--- a/grizzly/common/plugins.py
+++ b/grizzly/common/plugins.py
@@ -23,6 +23,7 @@ def load(name, group, base_type):
         name (str): Name of entry point to load.
         group (str): Group containing entry point.
         base_type (type): Used to validate loaded objects.
+
     Returns:
         *: Python object.
     """
@@ -56,3 +57,18 @@ def scan(group):
             raise PluginLoadError("Duplicate entry %r in %r" % (entry.name, group))
         found.append(entry.name)
     return found
+
+
+def scan_target_assets():
+    """Scan targets and load list of supported assets (minimal sanity checking).
+
+    Args:
+        None
+
+    Returns:
+        dict: Name of target and list of supported assets.
+    """
+    assets = dict()
+    for entry in iter_entry_points("grizzly_targets"):
+        assets[entry.name] = entry.load().SUPPORTED_ASSETS
+    return assets
diff --git a/grizzly/common/test_plugins.py b/grizzly/common/test_plugins.py
index e660d125..f2e2e366 100644
--- a/grizzly/common/test_plugins.py
+++ b/grizzly/common/test_plugins.py
@@ -5,7 +5,8 @@
 from pkg_resources import EntryPoint
 from pytest import raises
 
-from .plugins import PluginLoadError, load, scan
+from ..target import Target
+from .plugins import PluginLoadError, load, scan, scan_target_assets
 
 
 class FakeType1:
@@ -79,3 +80,23 @@ def test_scan_03(mocker):
         return_value=[entry],
     )
     assert "test-name" in scan("test_group")
+
+
+def test_scan_target_assets_01(mocker):
+    """test scan_target_assets() - success"""
+    targ1 = mocker.Mock(set_spec=EntryPoint)
+    targ1.name = "t1"
+    targ1.load.return_value = mocker.Mock(set_spec=Target, SUPPORTED_ASSETS=None)
+    targ2 = mocker.Mock(set_spec=EntryPoint)
+    targ2.name = "t2"
+    targ2.load.return_value = mocker.Mock(set_spec=Target, SUPPORTED_ASSETS=("a", "B"))
+    mocker.patch(
+        "grizzly.common.plugins.iter_entry_points",
+        autospec=True,
+        return_value=[targ1, targ2],
+    )
+    assets = scan_target_assets()
+    assert "t1" in assets
+    assert assets["t1"] is None
+    assert "t2" in assets
+    assert "B" in assets["t2"]
diff --git a/grizzly/main.py b/grizzly/main.py
index f1891635..723d9b95 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -81,7 +81,6 @@ def main(args):
         LOG.debug("initializing the Target %r", args.platform)
         target = load_plugin(args.platform, "grizzly_targets", Target)(
             args.binary,
-            args.extension,
             args.launch_timeout,
             args.log_limit,
             args.memory,
@@ -91,9 +90,12 @@ def main(args):
             xvfb=args.xvfb,
         )
         if args.prefs:
-            target.prefs = args.prefs
             LOG.info("Using prefs %r", args.prefs)
+            target.assets.add("prefs", args.prefs)
+        if args.extension:
+            target.assets.add("extension", args.extension)
         adapter.monitor = target.monitor
+        target.process_assets()
 
         LOG.debug("initializing the Reporter")
         if args.fuzzmanager:
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index fc4503a5..1535407e 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -779,6 +779,8 @@ def main(cls, args):
                 valgrind=args.valgrind,
                 xvfb=args.xvfb,
             )
+            if args.extension:
+                target.assets.add("extension", args.extension)
             # prioritize specified prefs.js file over included file
             if args.prefs is not None:
                 for testcase in testcases:
@@ -796,7 +798,7 @@ def main(cls, args):
                         LOG.info("Using prefs.js from testcase")
                         target.prefs = str(tmp_prefs / "prefs.js")
                         break
-
+            target.process_assets()
             LOG.debug("starting sapphire server")
             # launch HTTP server used to serve test cases
             with Sapphire(auto_close=1, timeout=timeout) as server:
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 1b8873a6..96f3478a 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -574,7 +574,6 @@ def main(cls, args):
 
         results = None
         target = None
-        tmp_prefs = None
         try:
             if args.no_harness and len(testcases) > 1:
                 LOG.error(
@@ -604,7 +603,6 @@ def main(cls, args):
             LOG.debug("initializing the Target")
             target = load_plugin(args.platform, "grizzly_targets", Target)(
                 args.binary,
-                args.extension,
                 args.launch_timeout,
                 args.log_limit,
                 args.memory,
@@ -613,21 +611,27 @@ def main(cls, args):
                 valgrind=args.valgrind,
                 xvfb=args.xvfb,
             )
+            if args.extension:
+                target.assets.add("extension", args.extension)
             # prioritize specified prefs.js file over included file
-            if args.prefs is not None:
+            if args.prefs:
                 for testcase in testcases:
                     testcase.add_meta(TestFile.from_file(args.prefs, "prefs.js"))
                 LOG.info("Using specified prefs.js")
-                target.prefs = args.prefs
+                target.assets.add("prefs", args.prefs)
             else:
                 for testcase in testcases:
                     prefs_tf = testcase.get_file("prefs.js")
                     if prefs_tf:
-                        tmp_prefs = mkdtemp(prefix="prefs_", dir=grz_tmp("replay"))
-                        prefs_tf.dump(tmp_prefs)
                         LOG.info("Using prefs.js from testcase")
-                        target.prefs = pathjoin(tmp_prefs, "prefs.js")
+                        prefs_tf.dump(target.assets.path)
+                        target.assets.add(
+                            "prefs",
+                            pathjoin(target.assets.path, "prefs.js"),
+                        )
                         break
+            target.process_assets()
+
             LOG.debug("starting sapphire server")
             # launch HTTP server used to serve test cases
             with Sapphire(auto_close=1, timeout=timeout) as server:
@@ -689,6 +693,4 @@ def main(cls, args):
                 target.cleanup()
             for testcase in testcases:
                 testcase.cleanup()
-            if tmp_prefs is not None:
-                rmtree(tmp_prefs, ignore_errors=True)
             LOG.info("Done.")
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 44bfe5ab..82a5f19a 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -15,7 +15,7 @@
 from ..common.reporter import Report
 from ..common.storage import TestCase, TestCaseLoadFailure
 from ..session import Session
-from ..target import Target, TargetLaunchError, TargetLaunchTimeout
+from ..target import AssetManager, Target, TargetLaunchError, TargetLaunchTimeout
 from .replay import ReplayManager
 from .test_replay import _fake_save_logs
 
@@ -242,7 +242,13 @@ def test_main_05(mocker, tmp_path):
         return_value=(None, ["test.html"]),  # passed to Target.detect_failure
     )
     # setup Target
-    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
+    assets = mocker.Mock(spec_set=AssetManager, path=str(tmp_path))
+    target = mocker.Mock(
+        spec_set=Target,
+        assets=assets,
+        binary="bin",
+        launch_timeout=30,
+    )
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
diff --git a/grizzly/session.py b/grizzly/session.py
index 4d03c909..d2c07629 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -139,9 +139,11 @@ def generate_testcase(self, time_limit):
         with self.status.measure("generate"):
             self.adapter.generate(test, self.iomanager.server_map)
         self.status.test_name = test.input_fname
-        if self.target.prefs is not None:
-            # TODO: this can likely be improved
-            test.add_meta(TestFile.from_file(self.target.prefs, "prefs.js"))
+        # TODO: update TestCase to better handle assets
+        if self.target.assets.get("prefs"):
+            test.add_meta(
+                TestFile.from_file(self.target.assets.get("prefs"), "prefs.js")
+            )
         return test
 
     def run(
diff --git a/grizzly/target/__init__.py b/grizzly/target/__init__.py
index c879bdc4..705d7b5b 100644
--- a/grizzly/target/__init__.py
+++ b/grizzly/target/__init__.py
@@ -2,9 +2,16 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from .target import Target, TargetError, TargetLaunchError, TargetLaunchTimeout
+from .target import (
+    AssetManager,
+    Target,
+    TargetError,
+    TargetLaunchError,
+    TargetLaunchTimeout,
+)
 
 __all__ = (
+    "AssetManager",
     "Target",
     "TargetError",
     "TargetLaunchError",
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index bcf80545..bc412865 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -3,8 +3,8 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
-from os import close, kill, unlink
-from os.path import abspath, isfile
+from os import kill
+from os.path import join as pathjoin
 from platform import system
 from signal import SIGABRT
 
@@ -12,7 +12,7 @@
     from signal import SIGUSR1
 except ImportError:
     SIGUSR1 = None
-from tempfile import mkdtemp, mkstemp
+from tempfile import mkdtemp
 from time import sleep, time
 
 from ffpuppet import BrowserTimeoutError, Debugger, FFPuppet, LaunchError, Reason
@@ -32,12 +32,17 @@
 
 
 class PuppetTarget(Target):
-    __slots__ = ("use_valgrind", "_puppet", "_remove_prefs")
+    SUPPORTED_ASSETS = (
+        # xpi or directory containing the unpacked extension
+        "extension",
+        # prefs.js file to use
+        "prefs",
+    )
 
-    def __init__(
-        self, binary, extension, launch_timeout, log_limit, memory_limit, **kwds
-    ):
-        super().__init__(binary, extension, launch_timeout, log_limit, memory_limit)
+    __slots__ = ("use_valgrind", "_extension", "_prefs", "_puppet")
+
+    def __init__(self, binary, launch_timeout, log_limit, memory_limit, **kwds):
+        super().__init__(binary, launch_timeout, log_limit, memory_limit)
         # TODO: clean up handling debuggers
         debugger = Debugger.NONE
         if kwds.pop("pernosco", False):
@@ -47,13 +52,14 @@ def __init__(
         if kwds.pop("valgrind", False):
             self.use_valgrind = True
             debugger = Debugger.VALGRIND
-        self._remove_prefs = False
+        self._extension = None
+        self._prefs = None
 
         # create Puppet object
         self._puppet = FFPuppet(
             debugger=debugger,
             use_xvfb=kwds.pop("xvfb", False),
-            working_path=grz_tmp("target_ffpuppet"),
+            working_path=grz_tmp("target"),
         )
         if kwds:
             LOG.warning(
@@ -63,12 +69,10 @@ def __init__(
     def add_abort_token(self, token):
         self._puppet.add_abort_token(token)
 
-    def cleanup(self):
+    def _cleanup(self):
         # prevent parallel calls to FFPuppet.close() and/or FFPuppet.clean_up()
         with self._lock:
             self._puppet.clean_up()
-        if self._remove_prefs and self._prefs and isfile(self._prefs):
-            unlink(self._prefs)
 
     def close(self, force_close=False):
         # prevent parallel calls to FFPuppet.close() and/or FFPuppet.clean_up()
@@ -252,8 +256,8 @@ def launch(self, location, env_mod=None):
                 location=location,
                 log_limit=self.log_limit,
                 memory_limit=self.memory_limit,
-                prefs_js=self.prefs,
-                extension=self.extension,
+                prefs_js=self._prefs,
+                extension=self._extension,
                 env_mod=env_mod,
             )
         except LaunchError as exc:
@@ -266,37 +270,21 @@ def launch(self, location, env_mod=None):
     def log_size(self):
         return self._puppet.log_length("stderr") + self._puppet.log_length("stdout")
 
-    @property
-    def prefs(self):
+    def process_assets(self):
+        self._extension = self.assets.get("extension")
+        self._prefs = self.assets.get("prefs")
+        # generate temporary prefs.js with prefpicker
         if self._prefs is None:
-            # generate temporary prefs.js
-            for prefs_template in PrefPicker.templates():
-                if prefs_template.endswith("browser-fuzzing.yml"):
-                    LOG.debug("using prefpicker template %r", prefs_template)
-                    tmp_fd, self._prefs = mkstemp(
-                        prefix="prefs_", suffix=".js", dir=grz_tmp()
-                    )
-                    close(tmp_fd)
-                    PrefPicker.load_template(prefs_template).create_prefsjs(self._prefs)
-                    LOG.debug("generated prefs.js %r", self._prefs)
-                    self._remove_prefs = True
+            for template in PrefPicker.templates():
+                if template.endswith("browser-fuzzing.yml"):
+                    LOG.debug("using prefpicker template %r", template)
+                    self._prefs = pathjoin(self.assets.path, "prefs.js")
+                    PrefPicker.load_template(template).create_prefsjs(self._prefs)
+                    LOG.debug("generated %r", self._prefs)
+                    self.assets.add("prefs", self._prefs)
                     break
             else:  # pragma: no cover
                 raise TargetError("Failed to generate prefs.js")
-        return self._prefs
-
-    @prefs.setter
-    def prefs(self, prefs_file):
-        if self._remove_prefs and self._prefs and isfile(self._prefs):
-            unlink(self._prefs)
-        if prefs_file is None:
-            self._prefs = None
-            self._remove_prefs = True
-        elif isfile(prefs_file):
-            self._prefs = abspath(prefs_file)
-            self._remove_prefs = False
-        else:
-            raise TargetError("Missing prefs.js file %r" % (prefs_file,))
 
     def save_logs(self, *args, **kwargs):
         self._puppet.save_logs(*args, **kwargs)
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index fa4c9511..e3c30ee1 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -4,9 +4,15 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from abc import ABCMeta, abstractmethod, abstractproperty
 from logging import getLogger
-from os.path import isfile
+from os import unlink
+from os.path import basename, dirname, exists, isfile
+from os.path import join as pathjoin
+from shutil import copyfile, copytree, rmtree
+from tempfile import mkdtemp
 from threading import Lock
 
+from ..common.utils import grz_tmp
+
 __all__ = ("Target", "TargetError", "TargetLaunchError")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
@@ -14,6 +20,57 @@
 LOG = getLogger(__name__)
 
 
+class AssetManager:
+    __slots__ = ("assets", "path")
+
+    def __init__(self, base_path=None):
+        self.assets = dict()
+        self.path = mkdtemp(prefix="assets_", dir=base_path)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.cleanup()
+
+    def add(self, asset, path):
+        assert isinstance(asset, str)
+        if not path or not exists(path):
+            raise OSError("Asset %r not found %r" % (asset, path))
+        assert asset not in self.assets
+        # only copy files from outside working path
+        if dirname(path) != self.path:
+            # check file name collision
+            dst_path = pathjoin(self.path, basename(path))
+            if exists(dst_path):
+                raise OSError("Name collision in asset path %r" % (basename(path),))
+            if isfile(path):
+                copyfile(path, dst_path)
+            else:
+                copytree(path, dst_path)
+            self.assets[asset] = dst_path
+        else:
+            self.assets[asset] = path
+        LOG.debug("added asset %r from %r", asset, path)
+
+    def cleanup(self):
+        if self.path:
+            rmtree(self.path, ignore_errors=True)
+            self.assets.clear()
+            self.path = None
+
+    def get(self, asset):
+        return self.assets.get(asset, None)
+
+    def remove(self, asset):
+        path = self.assets.pop(asset, None)
+        if path:
+            if isfile(path):
+                unlink(path)
+            else:
+                rmtree(path, ignore_errors=True)
+
+
 class TargetError(Exception):
     """Raised by Target"""
 
@@ -34,27 +91,26 @@ class Target(metaclass=ABCMeta):
     RESULT_NONE = 0
     RESULT_FAILURE = 1
     RESULT_IGNORED = 2
+    SUPPORTED_ASSETS = None
 
     __slots__ = (
         "_lock",
         "_monitor",
-        "_prefs",
+        "assets",
         "binary",
-        "extension",
         "launch_timeout",
         "log_limit",
         "memory_limit",
     )
 
-    def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit):
+    def __init__(self, binary, launch_timeout, log_limit, memory_limit):
         assert log_limit >= 0
         assert memory_limit >= 0
         assert binary is not None and isfile(binary)
         self._lock = Lock()
         self._monitor = None
-        self._prefs = None
+        self.assets = AssetManager(base_path=grz_tmp("target"))
         self.binary = binary
-        self.extension = extension
         self.launch_timeout = max(launch_timeout, 300)
         self.log_limit = log_limit
         self.memory_limit = memory_limit
@@ -69,9 +125,14 @@ def add_abort_token(self, _token):  # pylint: disable=no-self-use
         LOG.warning("add_abort_token() not implemented!")
 
     @abstractmethod
-    def cleanup(self):
+    def _cleanup(self):
         pass
 
+    def cleanup(self):
+        # call target specific _cleanup first
+        self._cleanup()
+        self.assets.cleanup()
+
     @abstractmethod
     def close(self, force_close=False):
         pass
@@ -112,9 +173,8 @@ def log_size(self):  # pylint: disable=no-self-use
     def monitor(self):
         pass
 
-    # TODO: better meta file handling
-    @abstractproperty
-    def prefs(self):
+    @abstractmethod
+    def process_assets(self):
         pass
 
     def reverse(self, remote, local):
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 68ce1688..e0cd8e72 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -10,7 +10,7 @@
 from pytest import mark, raises
 
 from .puppet_target import PuppetTarget
-from .target import Target, TargetError, TargetLaunchError, TargetLaunchTimeout
+from .target import Target, TargetLaunchError, TargetLaunchTimeout
 
 
 def test_puppet_target_01(mocker, tmp_path):
@@ -20,12 +20,8 @@ def test_puppet_target_01(mocker, tmp_path):
     fake_ffp.return_value.log_length.return_value = 562
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    with PuppetTarget(str(fake_file), None, 300, 25, 5000) as target:
+    with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
         assert target.closed
-        assert not target._remove_prefs
-        prefs_file = target.prefs
-        assert isfile(prefs_file)
-        assert target._remove_prefs
         assert target.detect_failure([]) == Target.RESULT_NONE
         assert target.log_size() == 1124
         fake_ffp.return_value.log_length.assert_any_call("stderr")
@@ -36,9 +32,8 @@ def test_puppet_target_01(mocker, tmp_path):
         target.save_logs("fake_dest")
         assert fake_ffp.return_value.save_logs.call_count == 1
     assert fake_ffp.return_value.clean_up.call_count == 1
-    assert not isfile(prefs_file)
     # with extra args
-    with PuppetTarget(str(fake_file), None, 1, 1, 1, rr=True, fake=1) as target:
+    with PuppetTarget(str(fake_file), 1, 1, 1, rr=True, fake=1) as target:
         pass
 
 
@@ -48,9 +43,8 @@ def test_puppet_target_02(mocker, tmp_path):
     fake_file = tmp_path / "fake"
     fake_file.touch()
     # test providing prefs.js
-    with PuppetTarget(str(fake_file), None, 300, 25, 5000) as target:
-        target.prefs = str(fake_file)
-        assert not target._remove_prefs
+    with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
+        target.assets.add("prefs", str(fake_file))
         # launch success
         target.launch("launch_target_page")
         assert fake_ffp.return_value.launch.call_count == 1
@@ -101,7 +95,7 @@ def test_puppet_target_03(mocker, tmp_path, healthy, reason, ignore, result, clo
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    target = PuppetTarget(str(fake_file), None, 300, 25, 5000)
+    target = PuppetTarget(str(fake_file), 300, 25, 5000)
     if "memory" in ignore:
         fake_ffp.return_value.available_logs.return_value = "ffp_worker_memory_usage"
     elif "log-limit" in ignore:
@@ -136,7 +130,7 @@ def test_puppet_target_04(mocker, tmp_path, healthy, usage, os_name, killed):
     fake_kill.side_effect = OSError
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    target = PuppetTarget(str(fake_file), None, 300, 25, 5000)
+    target = PuppetTarget(str(fake_file), 300, 25, 5000)
     fake_ffp.return_value.cpu_usage.return_value = usage
     fake_ffp.return_value.is_healthy.return_value = healthy
     target.handle_hang()
@@ -159,7 +153,7 @@ def test_puppet_target_05(mocker, tmp_path):
     fake_time = mocker.patch("grizzly.target.puppet_target.time", autospec=True)
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    target = PuppetTarget(str(fake_file), None, 300, 25, 5000)
+    target = PuppetTarget(str(fake_file), 300, 25, 5000)
     fake_kill = mocker.patch("grizzly.target.puppet_target.kill", autospec=True)
     # not running
     fake_ffp.return_value.get_pid.return_value = None
@@ -272,7 +266,7 @@ def test_puppet_target_06(mocker, tmp_path):
     fake_ffp.return_value.cpu_usage.return_value = [(999, 30), (998, 20), (997, 10)]
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    with PuppetTarget(str(fake_file), None, 300, 25, 5000) as target:
+    with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
         assert not target.is_idle(0)
         assert not target.is_idle(25)
         assert target.is_idle(50)
@@ -283,7 +277,7 @@ def test_puppet_target_07(mocker, tmp_path):
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    with PuppetTarget(str(fake_file), None, 300, 25, 5000) as target:
+    with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
         fake_ffp.return_value.is_running.return_value = False
         fake_ffp.return_value.is_healthy.return_value = False
         assert target.monitor is not None
@@ -302,31 +296,22 @@ def test_puppet_target_07(mocker, tmp_path):
 
 
 def test_puppet_target_08(mocker, tmp_path):
-    """test PuppetTarget.prefs"""
+    """test PuppetTarget.process_assets()"""
     mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    with PuppetTarget(str(fake_file), None, 300, 25, 5000) as target:
-        # default temp prefs
-        assert not target._remove_prefs
-        prefs_file = target.prefs
-        assert isfile(prefs_file)
-        assert target._remove_prefs
-        # set prefs, remove temp
-        target.prefs = str(fake_file)
-        assert not isfile(prefs_file)
-        assert not target._remove_prefs
-        prefs_file = target.prefs
-        assert isfile(prefs_file)
-        # unset prefs (revert to temp), don't remove previously specified file
-        target.prefs = None
-        assert target._remove_prefs
-        assert isfile(prefs_file)
-        prefs_file = target.prefs
-        # set missing file
-        with raises(TargetError, match="Missing prefs.js file 'missing'"):
-            target.prefs = "missing"
-        assert not isfile(prefs_file)
+    # no prefs file provided
+    with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
+        assert target.assets.get("prefs") is None
+        target.process_assets()
+        assert isfile(target.assets.get("prefs"))
+        assert target.assets.get("prefs").endswith("prefs.js")
+    # prefs file provided
+    with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
+        target.assets.add("prefs", str(fake_file))
+        target.process_assets()
+        assert isfile(target.assets.get("prefs"))
+        assert target.assets.get("prefs").endswith("fake")
 
 
 @mark.parametrize(
@@ -348,7 +333,7 @@ def test_puppet_target_09(mocker, tmp_path, pernosco, rr, valgrind):
     fake_file = tmp_path / "fake"
     fake_file.touch()
     with PuppetTarget(
-        str(fake_file), None, 30, 25, 500, pernosco=pernosco, rr=rr, valgrind=valgrind
+        str(fake_file), 30, 25, 500, pernosco=pernosco, rr=rr, valgrind=valgrind
     ) as _:
         pass
     if pernosco:
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index c9b0fb32..c2503a3e 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -1,13 +1,17 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-# pylint: disable=protected-access
 
-from .target import Target
+from pathlib import Path
+from shutil import rmtree
+
+from pytest import raises
+
+from .target import AssetManager, Target
 
 
 class SimpleTarget(Target):
-    def cleanup(self):
+    def _cleanup(self):
         pass
 
     def close(self, force_close=False):
@@ -37,6 +41,9 @@ def monitor(self):
     def prefs(self):
         pass
 
+    def process_assets(self):
+        pass
+
     def save_logs(self, *_args, **_kwargs):
         pass
 
@@ -45,16 +52,75 @@ def test_target_01(tmp_path):
     """test creating a simple Target"""
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    target = SimpleTarget(str(fake_file), str(fake_file), 321, 2, 3)
-    assert target.binary == str(fake_file)
-    assert target.extension == str(fake_file)
-    assert not target.is_idle(0)
-    assert target.launch_timeout == 321
-    assert target.log_size() == 0
-    assert target.log_limit == 2
-    assert target.memory_limit == 3
-    assert target.monitor is None
-    # test stubs
-    target.add_abort_token("none!")
-    target.dump_coverage()
-    target.reverse(1, 2)
+    with SimpleTarget(str(fake_file), 321, 2, 3) as target:
+        assert target.binary == str(fake_file)
+        assert target.assets
+        assert not target.is_idle(0)
+        assert target.launch_timeout == 321
+        assert target.log_size() == 0
+        assert target.log_limit == 2
+        assert target.memory_limit == 3
+        assert target.monitor is None
+        # test stubs
+        target.add_abort_token("none!")
+        target.dump_coverage()
+        target.reverse(1, 2)
+
+
+def test_assert_manager_01(tmp_path):
+    """test AssetManager()"""
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        assert not assets.assets
+        assert assets.path
+        # get missing
+        assert assets.get("missing") is None
+        # add missing file
+        with raises(OSError, match="Asset 'a' not found 'p'"):
+            assets.add("a", "p")
+        assert not assets.assets
+        # remove invalid asset
+        assets.remove("missing")
+        # add file
+        example = tmp_path / "example.txt"
+        example.write_text("example")
+        assets.add("example_file", str(example))
+        assert len(assets.assets) == 1
+        example.unlink()
+        assert any(tmp_path.glob("**/example.txt"))
+        # add directory
+        example = tmp_path / "example_path"
+        example.mkdir()
+        (example / "a").mkdir()
+        (example / "a" / "1.txt").write_text("1")
+        (example / "b").mkdir()
+        (example / "b" / "2.txt").write_text("2")
+        assets.add("example_path", str(example))
+        rmtree(str(example))
+        assert any(tmp_path.glob("**/example_path/a/1.txt"))
+        assert any(tmp_path.glob("**/example_path/b/2.txt"))
+        assert len(assets.assets) == 2
+        # get
+        assert "example.txt" in assets.get("example_file")
+        assert "example_path" in assets.get("example_path")
+        # remove directory
+        assets.remove("example_path")
+        assert len(assets.assets) == 1
+        assert not any(tmp_path.glob("**/example_path"))
+        # remove file
+        assets.remove("example_file")
+        assert len(assets.assets) == 0
+        assert not any(tmp_path.glob("**/example.txt"))
+        assert not any(Path(assets.path).iterdir())
+        # add in working path
+        example = Path(assets.path) / "example.txt"
+        example.write_text("test")
+        assets.add("direct", str(example))
+        # add existing
+        example = tmp_path / "example.txt"
+        example.write_text("example")
+        with raises(OSError, match="Name collision in asset path"):
+            assets.add("example_file", str(example))
+        # cleanup
+        assets.cleanup()
+        assert not assets.assets
+        assert assets.path is None
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index 83ff0470..f2a8a666 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -63,6 +63,18 @@ def test_common_args_01a(capsys, mocker, tmp_path):
             "error: --prefs file not found",
             ["targ1"],
         ),
+        # test invalid asset
+        (
+            ["--platform", "targ1", "--asset", "bad", "a"],
+            "error: Asset 'bad' not supported by target",
+            ["targ1"],
+        ),
+        # test invalid asset path
+        (
+            ["--platform", "targ1", "--asset", "a", "a"],
+            "error: 'a' does not exist",
+            ["targ1"],
+        ),
         # test invalid time-limit
         (
             ["--platform", "targ1", "--time-limit", "-1"],
@@ -86,6 +98,11 @@ def test_common_args_01a(capsys, mocker, tmp_path):
 def test_common_args_02(capsys, mocker, tmp_path, args, msg, targets):
     """test CommonArgs.parse_args()"""
     mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=targets)
+    mocker.patch(
+        "grizzly.args.scan_target_assets",
+        autospec=True,
+        return_value={"targ1": ["a", "b"]},
+    )
     mocker.patch("grizzly.args.system", autospec=True, return_value="foo")
     fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index ff7b589c..a13928cb 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -77,6 +77,7 @@ def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, verbose):
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     args = FakeArgs()
     args.adapter = "fake"
+    args.extension = "fake"
     args.ignore = ["fake", "fake"]
     args.limit = limit
     args.runtime = runtime
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 3b7485c4..4fb73949 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -71,7 +71,7 @@ def test_session_01(
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     prefs = tmp_path / "prefs.js"
     prefs.touch()
-    target = mocker.Mock(spec=Target, launch_timeout=30, prefs=str(prefs))
+    target = mocker.Mock(spec=Target, launch_timeout=30, assets={"prefs": str(prefs)})
     target.log_size.return_value = 1000
     target.monitor.launches = 1
     # avoid shutdown delay
@@ -137,7 +137,7 @@ def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
     """test Session with playback Adapter"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    target = mocker.Mock(spec=Target, launch_timeout=30, assets=dict())
     # calculate if the target is 'closed' based on relaunch
     type(target).closed = mocker.PropertyMock(
         side_effect=((x % relaunch == 0) for x in range(remaining))
@@ -189,7 +189,7 @@ def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
     report = mocker.Mock(spec=Report, major="major123", minor="minor456")
     report.crash_info.createShortSignature.return_value = "[@ sig]"
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    target = mocker.Mock(spec=Target, launch_timeout=30, assets=dict())
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     target.monitor.launches = 1
@@ -228,7 +228,7 @@ def generate(self, _testcase, _server_map):
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_NONE, [])
-    target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    target = mocker.Mock(spec=Target, launch_timeout=30, assets=dict())
     target.monitor.launches = 1
     with Session(FuzzAdapter("fuzz"), None, server, target) as session:
         with raises(SessionError, match="Test case is missing landing page"):
@@ -240,7 +240,7 @@ def test_session_05(mocker, tmp_path):
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_TIMEOUT, [])
-    target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    target = mocker.Mock(spec=Target, launch_timeout=30, assets=dict())
     target.monitor.launches = 1
     with Session(SimpleAdapter(False), None, server, target) as session:
         with raises(SessionError, match="Please check Adapter and Target"):
@@ -265,7 +265,7 @@ def test_session_06(mocker, tmp_path, harness, report_size):
     report = mocker.Mock(spec=Report, major="major123", minor="minor456")
     report.crash_info.createShortSignature.return_value = "[@ sig]"
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, launch_timeout=30, prefs=None)
+    target = mocker.Mock(spec=Target, launch_timeout=30, assets=dict())
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     target.monitor.launches = 1
@@ -307,7 +307,7 @@ def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, resul
     report.crash_info.createShortSignature.return_value = "[@ sig]"
     reporter = mocker.Mock(spec=Reporter)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, prefs=None)
+    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, assets=dict())
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     target.monitor.launches = 1
@@ -336,7 +336,7 @@ def test_session_08(tmp_path, mocker):
     adapter = mocker.Mock(spec=Adapter, remaining=None)
     adapter.IGNORE_UNSERVED = False
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, prefs=None)
+    target = mocker.Mock(spec=Target, assets=dict())
     target.monitor.launches = 1
     with Session(adapter, None, server, target) as session:
         session.run([], 10, iteration_limit=1)
@@ -380,7 +380,7 @@ def test_session_10(tmp_path, mocker):
     report = mocker.Mock(spec=Report, major="major123", minor="minor456")
     reporter = mocker.Mock(spec=Reporter)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, prefs=None)
+    target = mocker.Mock(spec=Target, assets=dict())
     target.monitor.launches = 1
     target.create_report.return_value = report
     with Session(adapter, reporter, server, target) as session:

From 4da33fd046c4932f587b2b71c866b64e30e6d96f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 14 Jul 2021 15:41:29 -0700
Subject: [PATCH 285/531] Increase support for assets - Remove TestCase meta
 file type - Add `--asset` command line argument - Add ability to save/load
 asset in TestCase - Remove `prefs.js` specific file handling

---
 grizzly/args.py                      |  29 ++--
 grizzly/common/iomanager.py          |   3 -
 grizzly/common/storage.py            | 101 +++++++------
 grizzly/common/test_storage.py       | 216 +++++++++++++++------------
 grizzly/main.py                      |   9 +-
 grizzly/reduce/core.py               |  38 ++---
 grizzly/reduce/test_main.py          |  62 ++------
 grizzly/reduce/test_strategies.py    |  26 +---
 grizzly/replay/replay.py             |  51 +++----
 grizzly/replay/test_main.py          |  81 ++++------
 grizzly/replay/test_replay.py        |  31 ++--
 grizzly/session.py                   |   7 +-
 grizzly/target/puppet_target.py      |   8 +-
 grizzly/target/target.py             |  57 ++++++-
 grizzly/target/test_puppet_target.py |  18 ++-
 grizzly/target/test_target.py        |  50 +++++++
 grizzly/test_args.py                 |  27 +---
 grizzly/test_main.py                 |  12 +-
 grizzly/test_session.py              |  54 +++++--
 19 files changed, 464 insertions(+), 416 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 86d53738..7da6bde1 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -4,7 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from argparse import ArgumentParser, HelpFormatter
 from logging import CRITICAL, DEBUG, ERROR, INFO, WARNING
-from os.path import exists, isdir, isfile
+from os.path import exists, isfile
 from platform import system
 
 from .common.plugins import scan as scan_plugins
@@ -73,6 +73,7 @@ def __init__(self):
         self.launcher_grp.add_argument(
             "--asset",
             action="append",
+            default=list(),
             metavar=("ASSET", "PATH"),
             nargs=2,
             help="Specify target specific asset files. %s" % ("".join(asset_msg),),
@@ -80,10 +81,8 @@ def __init__(self):
         self.launcher_grp.add_argument(
             "-e",
             "--extension",
-            action="append",
             help="DEPRECATED. Install an extension. Specify the path to the xpi or the"
-            " directory containing the unpacked extension. To install multiple"
-            " extensions specify multiple times",
+            " directory containing the unpacked extension.",
         )
         self.launcher_grp.add_argument(
             "--launch-timeout",
@@ -223,16 +222,17 @@ def sanity_check(self, args):
         if args.relaunch < 1:
             self.parser.error("--relaunch must be >= 1")
 
-        if args.extension:
-            for ext in args.extension:
-                if not exists(ext):
-                    self.parser.error("%r does not exist" % (ext,))
-                if not isdir(ext) or (isfile(ext) and ext.endswith(".xpi")):
-                    self.parser.error("Extension must be a folder or .xpi")
-
         if args.platform not in targets:
             self.parser.error("Platform %r not installed" % (args.platform,))
 
+        # TODO: remove deprecated 'extension' from args
+        if args.extension:  # pragma: no cover
+            args.asset.append(["extension", args.extension])
+
+        # TODO: remove deprecated 'prefs' from args
+        if args.prefs:  # pragma: no cover
+            args.asset.append(["prefs", args.extension])
+
         # check args.platform before args.asset since it is used
         if args.asset:
             supported_assets = scan_target_assets()[args.platform]
@@ -242,10 +242,9 @@ def sanity_check(self, args):
                         "Asset %r not supported by target %r" % (asset, args.platform)
                     )
                 if not exists(path):
-                    self.parser.error("%r does not exist %r" % (asset, path))
-
-        if args.prefs and not isfile(args.prefs):
-            self.parser.error("--prefs file not found")
+                    self.parser.error(
+                        "Failed to add asset %r cannot find %r" % (asset, path)
+                    )
 
         if args.time_limit is not None and args.time_limit < 1:
             self.parser.error("--time-limit must be >= 1")
diff --git a/grizzly/common/iomanager.py b/grizzly/common/iomanager.py
index 2e2d67e0..c1ee1d03 100644
--- a/grizzly/common/iomanager.py
+++ b/grizzly/common/iomanager.py
@@ -92,9 +92,6 @@ def create_testcase(self, adapter_name, time_limit):
         # add environment variable info to the test case
         for e_name, e_value in self._tracked_env.items():
             self._test.add_environ_var(e_name, e_value)
-        # add environment files to the test case
-        for e_file in self._environ_files:
-            self._test.add_meta(e_file.clone())
         # reset redirect map
         self.server_map.redirect.clear()
         self.server_map.set_redirect(
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 709d579e..c18139eb 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -16,6 +16,7 @@
 from zipfile import BadZipfile, ZipFile
 from zlib import error as zlib_error
 
+from ..target import AssetManager
 from .utils import grz_tmp, sanitizer_opts
 
 __all__ = ("TestCase", "TestFile", "TestCaseLoadFailure", "TestFileExists")
@@ -32,12 +33,13 @@ class TestFileExists(Exception):
     TestFile with the same name"""
 
 
-TestFileMap = namedtuple("TestFileMap", "meta optional required")
+TestFileMap = namedtuple("TestFileMap", "optional required")
 
 
 class TestCase:
     __slots__ = (
         "adapter_name",
+        "assets",
         "duration",
         "env_vars",
         "hang",
@@ -60,6 +62,7 @@ def __init__(
         timestamp=None,
     ):
         self.adapter_name = adapter_name
+        self.assets = None
         self.duration = None
         self.env_vars = dict()  # environment variables
         self.hang = False
@@ -69,11 +72,7 @@ def __init__(
         self.time_limit = time_limit
         self.timestamp = time() if timestamp is None else timestamp
         self._existing_paths = list()  # file paths in use
-        self._files = TestFileMap(
-            meta=list(),  # environment files such as prefs.js, etc...
-            optional=list(),
-            required=list(),
-        )
+        self._files = TestFileMap(optional=list(), required=list())
 
     def __enter__(self):
         return self
@@ -120,17 +119,6 @@ def add_batch(self, path, include_files, prefix=None):
                 test_path = "/".join((prefix, test_path))
             self.add_from_file(fname, file_name=test_path)
 
-    def add_meta(self, meta_file):
-        """Add a TestFile to TestCase as a meta file.
-
-        Args:
-            meta_file (TestFile): TestFile to add to TestCase.
-
-        Returns:
-            None
-        """
-        self._add(self._files.meta, meta_file)
-
     def add_environ_var(self, name, value):
         """Add environment variable to TestCase.
 
@@ -147,7 +135,7 @@ def add_file(self, test_file, required=True):
         """Add a TestFile to TestCase.
 
         Args:
-            meta_file (TestFile): TestFile to add to TestCase.
+            test_file (TestFile): TestFile to add to TestCase.
             required (bool): Indicates if test file must be served.
 
         Returns:
@@ -197,11 +185,11 @@ def add_from_file(self, input_file, file_name=None, required=True):
             tfile.close()
             raise
 
-    def cleanup(self):
+    def cleanup(self, skip_assets=True):
         """Close all the test files.
 
         Args:
-            None
+            skip_assets (bool): Skip calling cleanup() on assets.
 
         Returns:
             None
@@ -209,6 +197,8 @@ def cleanup(self):
         for file_group in self._files:
             for test_file in file_group:
                 test_file.close()
+        if not skip_assets and self.assets:
+            self.assets.cleanup()
 
     def clone(self):
         """Make a copy of the TestCase.
@@ -230,8 +220,6 @@ def clone(self):
         result.duration = self.duration
         result.hang = self.hang
         result.env_vars.update(self.env_vars)
-        for entry in self._files.meta:
-            result.add_meta(entry.clone())
         for entry in self._files.optional:
             result.add_file(entry.clone(), required=False)
         for entry in self._files.required:
@@ -265,19 +253,19 @@ def data_size(self):
             total += sum(x.size for x in group)
         return total
 
-    def dump(self, out_path, include_details=False):
+    def dump(self, dst_path, include_details=False):
         """Write all the test case data to the filesystem.
 
         Args:
-            out_path (str): Path to directory to output data.
+            dst_path (str): Path to directory to output data.
             include_details (bool): Output "test_info.json" file.
 
         Returns:
             None
         """
-        # save test files to out_path
+        # save test files to dst_path
         for test_file in chain(self._files.required, self._files.optional):
-            test_file.dump(out_path)
+            test_file.dump(dst_path)
         # save test case files and meta data including:
         # adapter used, input file, environment info and files
         if include_details:
@@ -292,11 +280,12 @@ def dump(self, out_path, include_details=False):
                 "time_limit": self.time_limit,
                 "timestamp": self.timestamp,
             }
-            with open(pathjoin(out_path, "test_info.json"), "w") as out_fp:
+            # save target assets and update meta data
+            if self.assets and not self.assets.is_empty():
+                info["assets_path"] = "_assets_"
+                info["assets"] = self.assets.dump(dst_path, subdir=info["assets_path"])
+            with open(pathjoin(dst_path, "test_info.json"), "w") as out_fp:
                 json.dump(info, out_fp, indent=2, sort_keys=True)
-            # save meta files
-            for meta_file in self._files.meta:
-                meta_file.dump(out_path)
 
     def get_file(self, file_name):
         """Lookup and return the TestFile with the specified file name.
@@ -307,15 +296,13 @@ def get_file(self, file_name):
         Returns:
             TestFile: TestFile with matching file name otherwise None.
         """
-        for tfile in chain(
-            self._files.meta, self._files.optional, self._files.required
-        ):
+        for tfile in chain(self._files.optional, self._files.required):
             if tfile.file_name == file_name:
                 return tfile
         return None
 
     @classmethod
-    def load(cls, path, load_prefs, adjacent=False):
+    def load(cls, path, adjacent=False):
         """Load TestCases from disk.
 
         Args:
@@ -325,7 +312,6 @@ def load(cls, path, load_prefs, adjacent=False):
                         3) A zip archive containing testcase data or
                            subdirectories containing testcase data.
                         4) A single file to be used as a test case.
-            load_prefs (bool): Load prefs.js file if available.
             adjacent (bool): Load adjacent files as part of the test case.
                              This is always the case when loading a directory.
                              WARNING: This should be used with caution!
@@ -348,11 +334,20 @@ def load(cls, path, load_prefs, adjacent=False):
         # load testcase data from disk
         try:
             if isfile(path):
-                tests = [cls.load_single(path, load_prefs, adjacent=adjacent)]
+                tests = [cls.load_single(path, adjacent=adjacent)]
             elif isdir(path):
                 tests = list()
+                assets = None
                 for tc_path in TestCase.scan_path(path):
-                    tests.append(cls.load_single(tc_path, load_prefs))
+                    tests.append(cls.load_single(tc_path, load_assets=assets is None))
+                    # only load assets once
+                    if not assets and tests[-1].assets:
+                        assets = tests[-1].assets
+                # reuse AssetManager on all tests
+                if assets:
+                    for test in tests:
+                        if test.assets is None:
+                            test.assets = assets
                 tests.sort(key=lambda tc: tc.timestamp)
             else:
                 raise TestCaseLoadFailure("Invalid TestCase path")
@@ -379,13 +374,12 @@ def load_environ(self, path, env_data):
                 )
 
     @classmethod
-    def load_single(cls, path, load_prefs, adjacent=False):
+    def load_single(cls, path, adjacent=False, load_assets=True):
         """Load contents of a TestCase from disk. If `path` is a directory it must
         contain a valid 'test_info.json' file.
 
         Args:
             path (str): Path to the directory or file to load.
-            load_prefs (bool): Load prefs.js file if available.
             adjacent (bool): Load adjacent files as part of the TestCase.
                              This is always true when loading a directory.
                              WARNING: This should be used with caution!
@@ -429,23 +423,34 @@ def load_single(cls, path, load_prefs, adjacent=False):
         )
         test.duration = info.get("duration", None)
         test.hang = info.get("hang", False)
-        if load_prefs and isfile(pathjoin(path, "prefs.js")):
-            test.add_meta(TestFile.from_file(pathjoin(path, "prefs.js")))
         test.add_from_file(pathjoin(path, entry_point))
         test.landing_page = entry_point
-        # load environment variables
         if info:
+            # load assets
+            try:
+                if load_assets and info.get("assets", None):
+                    test.assets = AssetManager.load(
+                        info.get("assets"),
+                        pathjoin(path, info.get("assets_path", "")),
+                    )
+            except OSError as exc:
+                raise TestCaseLoadFailure(str(exc)) from None
+            # load environment variables
             try:
                 test.load_environ(path, info.get("env", {}))
             except TestCaseLoadFailure:
-                test.cleanup()
+                test.cleanup(skip_assets=False)
                 raise
         # load all adjacent data from directory
         if adjacent:
+            asset_path = info.get("assets_path", None)
             for dpath, _, files in walk(path):
+                # ignore asset path
+                if asset_path and dpath == pathjoin(path, asset_path):
+                    continue
                 for fname in files:
                     # ignore files that have been previously loaded
-                    if fname in (entry_point, "prefs.js", "test_info.json"):
+                    if fname in (entry_point, "test_info.json"):
                         continue
                     location = "/".join((dpath.split(path, 1)[-1], fname))
                     test.add_from_file(
@@ -466,6 +471,14 @@ def optional(self):
         for test in self._files.optional:
             yield test.file_name
 
+    def pop_assets(self):
+        if self.assets is None:
+            assets = None
+        else:
+            assets = self.assets
+            self.assets = None
+        return assets
+
     def purge_optional(self, keep):
         """Remove optional files (by name) that are not in keep.
 
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 2868275d..a101d3ea 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -10,8 +10,9 @@
 import zipfile
 from itertools import chain
 
-import pytest
+from pytest import raises
 
+from ..target import AssetManager
 from .storage import TestCase, TestCaseLoadFailure, TestFile, TestFileExists
 
 
@@ -23,6 +24,7 @@ def test_testcase_01(tmp_path):
     with TestCase(l_page, r_page, adpt_name) as tcase:
         assert tcase.landing_page == l_page
         assert tcase.redirect_page == r_page
+        assert tcase.assets is None
         assert tcase.adapter_name == adpt_name
         assert tcase.duration is None
         assert tcase.data_size == 0
@@ -30,10 +32,10 @@ def test_testcase_01(tmp_path):
         assert tcase.timestamp > 0
         assert not tcase.env_vars
         assert not tcase._existing_paths
-        assert not tcase._files.meta
         assert not tcase._files.optional
         assert not tcase._files.required
         assert not tcase.contains("no_file")
+        assert tcase.pop_assets() is None
         assert not any(tcase.optional)
         tcase.dump(str(tmp_path))
         assert not any(tmp_path.iterdir())
@@ -51,9 +53,9 @@ def test_testcase_02(tmp_path):
         in_file.write_bytes(b"test_req")
         tcase.add_from_file(str(in_file))
         assert tcase.data_size == 8
-        with pytest.raises(TestFileExists, match="'testfile1.bin' exists in test"):
+        with raises(TestFileExists, match="'testfile1.bin' exists in test"):
             tcase.add_from_file(str(in_file), file_name="testfile1.bin")
-        with pytest.raises(TestFileExists, match="'testfile1.bin' exists in test"):
+        with raises(TestFileExists, match="'testfile1.bin' exists in test"):
             tcase.add_from_data("test", "testfile1.bin")
         tcase.add_from_data("test_nreq", "nested/testfile2.bin", required=False)
         tcase.add_from_data("test_blah", "/testfile3.bin")
@@ -78,20 +80,6 @@ def test_testcase_02(tmp_path):
 
 
 def test_testcase_03(tmp_path):
-    """test TestCase.add_meta()"""
-    with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
-        dmp_path = tmp_path / "dmp_test"
-        dmp_path.mkdir()
-        meta_file = dmp_path / "metafile.bin"
-        meta_data = b"foobar"
-        tcase.add_meta(TestFile.from_data(meta_data, meta_file.name))
-        tcase.dump(str(dmp_path), include_details=True)
-        assert tcase.data_size == 6
-        assert meta_file.is_file()
-        assert meta_file.read_bytes() == meta_data
-
-
-def test_testcase_04(tmp_path):
     """test TestCase.add_environ_var() and TestCase.env_vars"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
         tcase.add_environ_var("TEST_ENV_VAR", "1")
@@ -107,7 +95,7 @@ def test_testcase_04(tmp_path):
         assert data["env"]["TEST_NONE"] is None
 
 
-def test_testcase_05():
+def test_testcase_04():
     """test TestCase.purge_optional()"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
         tcase.add_from_data("foo", "testfile1.bin")
@@ -132,7 +120,7 @@ def test_testcase_05():
         assert not any(tcase.optional)
 
 
-def test_testcase_06():
+def test_testcase_05():
     """test TestCase.data_size"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
         assert tcase.data_size == 0
@@ -140,29 +128,26 @@ def test_testcase_06():
         assert tcase.data_size == 1
         tcase.add_from_data("12", "testfile2.bin", required=False)
         assert tcase.data_size == 3
-        tcase.add_meta(TestFile.from_data("123", "meta.bin"))
-        assert tcase.data_size == 6
 
 
-def test_testcase_07(tmp_path):
+def test_testcase_06(tmp_path):
     """test TestCase.load_single() using a directory - fail cases"""
     # missing test_info.json
-    with pytest.raises(TestCaseLoadFailure, match="Missing 'test_info.json'"):
-        TestCase.load_single(str(tmp_path), True)
+    with raises(TestCaseLoadFailure, match="Missing 'test_info.json'"):
+        TestCase.load_single(str(tmp_path))
     # invalid test_info.json
     (tmp_path / "test_info.json").write_bytes(b"X")
-    with pytest.raises(TestCaseLoadFailure, match="Invalid 'test_info.json'"):
-        TestCase.load_single(str(tmp_path), True)
+    with raises(TestCaseLoadFailure, match="Invalid 'test_info.json'"):
+        TestCase.load_single(str(tmp_path))
     # test_info.json missing 'target' entry
     (tmp_path / "test_info.json").write_bytes(b"{}")
-    with pytest.raises(
+    with raises(
         TestCaseLoadFailure, match="'test_info.json' has invalid 'target' entry"
     ):
-        TestCase.load_single(str(tmp_path), True)
+        TestCase.load_single(str(tmp_path))
     # build a test case
     src_dir = tmp_path / "src"
     src_dir.mkdir()
-    (src_dir / "prefs.js").touch()
     entry_point = src_dir / "target.bin"
     entry_point.touch()
     with TestCase("target.bin", None, "test-adapter") as src:
@@ -170,29 +155,26 @@ def test_testcase_07(tmp_path):
         src.dump(str(src_dir), include_details=True)
     # bad 'target' entry in test_info.json
     entry_point.unlink()
-    with pytest.raises(
-        TestCaseLoadFailure, match="Entry point 'target.bin' not found in"
-    ):
-        TestCase.load_single(str(src_dir), True)
+    with raises(TestCaseLoadFailure, match="Entry point 'target.bin' not found in"):
+        TestCase.load_single(str(src_dir))
     # bad 'env' entry in test_info.json
     entry_point.touch()
     with TestCase("target.bin", None, "test-adapter") as src:
         src.add_environ_var("TEST_ENV_VAR", 100)
         src.dump(str(src_dir), include_details=True)
-    with pytest.raises(
-        TestCaseLoadFailure, match="'env_data' contains invalid 'env' entries"
-    ):
-        TestCase.load_single(str(src_dir), True)
+    with raises(TestCaseLoadFailure, match="'env_data' contains invalid 'env' entries"):
+        TestCase.load_single(str(src_dir))
 
 
-def test_testcase_08(tmp_path):
+def test_testcase_07(mocker, tmp_path):
     """test TestCase.load_single() using a directory"""
     # build a valid test case
     src_dir = tmp_path / "src"
     src_dir.mkdir()
-    (src_dir / "prefs.js").touch()
     entry_point = src_dir / "target.bin"
     entry_point.touch()
+    asset_file = src_dir / "example_asset"
+    asset_file.touch()
     (src_dir / "optional.bin").touch()
     (src_dir / "x.bin").touch()
     nested = tmp_path / "src" / "nested"
@@ -200,14 +182,30 @@ def test_testcase_08(tmp_path):
     # overlap file name in different directories
     (nested / "x.bin").touch()
     (tmp_path / "src" / "nested" / "empty").mkdir()
-    with TestCase("target.bin", None, "test-adapter") as src:
-        src.add_environ_var("TEST_ENV_VAR", "100")
-        src.add_from_file(str(entry_point))
-        src.dump(str(src_dir), include_details=True)
-    # load test case from test_info.json
-    with TestCase.load_single(str(src_dir), True) as dst:
+    dst_dir = tmp_path / "dst"
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        assets.add("example", str(asset_file))
+        with TestCase("target.bin", None, "test-adapter") as src:
+            src.add_environ_var("TEST_ENV_VAR", "100")
+            src.add_from_file(str(entry_point))
+            src.add_from_file(str(src_dir / "optional.bin"), required=False)
+            src.add_from_file(str(src_dir / "x.bin"), required=False)
+            src.add_from_file(
+                str(nested / "x.bin"),
+                file_name=os.path.join("nested", "x.bin"),
+                required=False,
+            )
+            src.assets = assets
+            src.dump(str(dst_dir), include_details=True)
+    # test loading test case from test_info.json
+    with TestCase.load_single(str(dst_dir)) as dst:
+        asset = dst.pop_assets()
+        assert asset
+        try:
+            assert "example" in asset.assets
+        finally:
+            asset.cleanup()
         assert dst.landing_page == "target.bin"
-        assert "prefs.js" in (x.file_name for x in dst._files.meta)
         assert "target.bin" in (x.file_name for x in dst._files.required)
         assert "optional.bin" in (x.file_name for x in dst._files.optional)
         assert "x.bin" in (x.file_name for x in dst._files.optional)
@@ -216,37 +214,41 @@ def test_testcase_08(tmp_path):
         )
         assert dst.env_vars["TEST_ENV_VAR"] == "100"
         assert dst.timestamp > 0
+    # test load with missing asset
+    mocker.patch("grizzly.common.storage.AssetManager.load", side_effect=OSError)
+    with raises(TestCaseLoadFailure):
+        TestCase.load_single(str(dst_dir))
 
 
-def test_testcase_09(tmp_path):
+def test_testcase_08(tmp_path):
     """test TestCase.load_single() using a file"""
     # invalid entry_point specified
-    with pytest.raises(TestCaseLoadFailure, match="Missing or invalid TestCase"):
-        TestCase.load_single(str(tmp_path / "missing_file"), False)
+    with raises(TestCaseLoadFailure, match="Missing or invalid TestCase"):
+        TestCase.load_single(str(tmp_path / "missing_file"), adjacent=False)
     # valid test case
     src_dir = tmp_path / "src"
     src_dir.mkdir()
-    (src_dir / "prefs.js").touch()
     entry_point = src_dir / "target.bin"
     entry_point.touch()
     (src_dir / "optional.bin").touch()
     # load single file test case
-    with TestCase.load_single(str(entry_point), False) as tcase:
+    with TestCase.load_single(str(entry_point), adjacent=False) as tcase:
+        assert tcase.assets is None
         assert tcase.landing_page == "target.bin"
-        assert "prefs.js" not in (x.file_name for x in tcase._files.meta)
         assert "target.bin" in (x.file_name for x in tcase._files.required)
         assert "optional.bin" not in (x.file_name for x in tcase._files.optional)
         assert tcase.timestamp == 0
     # load full test case
-    with TestCase.load_single(str(entry_point), True, adjacent=True) as tcase:
+    with TestCase.load_single(str(entry_point), adjacent=True) as tcase:
         assert tcase.landing_page == "target.bin"
-        assert "prefs.js" in (x.file_name for x in tcase._files.meta)
         assert "target.bin" in (x.file_name for x in tcase._files.required)
         assert "optional.bin" in (x.file_name for x in tcase._files.optional)
 
 
-def test_testcase_10(tmp_path):
+def test_testcase_09(tmp_path):
     """test TestCase - dump, load and compare"""
+    working = tmp_path / "working"
+    working.mkdir()
     with TestCase("a.html", "b.html", "adpt") as org:
         # set non default values
         org.duration = 1.23
@@ -255,75 +257,94 @@ def test_testcase_10(tmp_path):
         org.input_fname = "infile"
         org.time_limit = 10
         org.add_from_data("a", "a.html")
-        org.dump(str(tmp_path), include_details=True)
-        loaded = TestCase.load_single(str(tmp_path), False)
+        with AssetManager(base_path=str(tmp_path)) as assets:
+            fake = tmp_path / "fake_asset"
+            fake.touch()
+            assets.add("fake", str(fake))
+            org.assets = assets
+            org.dump(str(working), include_details=True)
+        org.assets = None
+        loaded = TestCase.load_single(str(working), adjacent=False)
         try:
             for prop in TestCase.__slots__:
-                if prop.startswith("_") or prop == "redirect_page":
+                if prop.startswith("_") or prop in ("assets", "redirect_page"):
                     continue
                 assert getattr(loaded, prop) == getattr(org, prop)
             assert org._existing_paths == loaded._existing_paths
+            assert loaded.assets
+            assert "fake" in loaded.assets.assets
         finally:
-            loaded.cleanup()
+            loaded.cleanup(skip_assets=False)
 
 
-def test_testcase_11(tmp_path):
+def test_testcase_10(tmp_path):
     """test TestCase.load() - missing file and empty directory"""
     # missing file
-    with pytest.raises(TestCaseLoadFailure, match="Invalid TestCase path"):
-        TestCase.load("missing", False)
+    with raises(TestCaseLoadFailure, match="Invalid TestCase path"):
+        TestCase.load("missing")
     # empty path
-    assert not TestCase.load(str(tmp_path), True)
+    assert not TestCase.load(str(tmp_path), adjacent=True)
 
 
-def test_testcase_12(tmp_path):
+def test_testcase_11(tmp_path):
     """test TestCase.load() - single file"""
     tfile = tmp_path / "testcase.html"
     tfile.touch()
-    testcases = TestCase.load(str(tfile), False)
+    testcases = TestCase.load(str(tfile), adjacent=False)
     try:
         assert len(testcases) == 1
+        assert all(x.assets is None for x in testcases)
     finally:
         map(lambda x: x.cleanup, testcases)
 
 
-def test_testcase_13(tmp_path):
+def test_testcase_12(tmp_path):
     """test TestCase.load() - single directory"""
     with TestCase("target.bin", None, "test-adapter") as src:
         src.add_from_data("test", "target.bin")
         src.dump(str(tmp_path), include_details=True)
-    testcases = TestCase.load(str(tmp_path), False)
+    testcases = TestCase.load(str(tmp_path))
     try:
         assert len(testcases) == 1
+        assert all(x.assets is None for x in testcases)
     finally:
-        map(lambda x: x.cleanup, testcases)
+        map(lambda x: x.cleanup(), testcases)
 
 
-def test_testcase_14(tmp_path):
-    """test TestCase.load() - multiple directories"""
+def test_testcase_13(tmp_path):
+    """test TestCase.load() - multiple directories (with assets)"""
     nested = tmp_path / "nested"
     nested.mkdir()
-    with TestCase("target.bin", None, "test-adapter") as src:
-        src.add_from_data("test", "target.bin")
-        src.dump(str(nested / "test-1"), include_details=True)
-        src.dump(str(nested / "test-2"), include_details=True)
-        src.dump(str(nested / "test-3"), include_details=True)
-    testcases = TestCase.load(str(nested), False)
+    asset_file = tmp_path / "example_asset"
+    asset_file.touch()
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        assets.add("example", str(asset_file))
+        with TestCase("target.bin", None, "test-adapter") as src:
+            src.assets = assets
+            src.add_from_data("test", "target.bin")
+            src.dump(str(nested / "test-1"), include_details=True)
+            src.dump(str(nested / "test-2"), include_details=True)
+            src.dump(str(nested / "test-3"), include_details=True)
+    testcases = TestCase.load(str(nested))
     try:
         assert len(testcases) == 3
+        assert all(x.assets is not None for x in testcases)
+        asset = testcases[-1].pop_assets()
+        assert asset is not None
+        assert "example" in asset.assets
     finally:
-        map(lambda x: x.cleanup, testcases)
+        map(lambda x: x.cleanup(skip_assets=False), testcases)
     # try loading testcases that are nested too deep
-    assert not TestCase.load(str(tmp_path), False)
+    assert not TestCase.load(str(tmp_path))
 
 
-def test_testcase_15(tmp_path):
+def test_testcase_14(tmp_path):
     """test TestCase.load() - archive"""
     archive = tmp_path / "testcase.zip"
     # bad archive
     archive.write_bytes(b"x")
-    with pytest.raises(TestCaseLoadFailure, match="Testcase archive is corrupted"):
-        TestCase.load(str(archive), True)
+    with raises(TestCaseLoadFailure, match="Testcase archive is corrupted"):
+        TestCase.load(str(archive))
     # build archive containing multiple testcases
     with TestCase("target.bin", None, "test-adapter") as src:
         src.add_from_data("test", "target.bin")
@@ -344,14 +365,15 @@ def test_testcase_15(tmp_path):
                     os.path.join(dir_name, file_name),
                     arcname=os.path.join(arc_path, file_name),
                 )
-    testcases = TestCase.load(str(archive), True)
+    testcases = TestCase.load(str(archive))
     try:
-        assert len(tuple(testcases)) == 3
+        assert len(testcases) == 3
+        assert all(x.assets is None for x in testcases)
     finally:
         map(lambda x: x.cleanup, testcases)
 
 
-def test_testcase_16(tmp_path):
+def test_testcase_15(tmp_path):
     """test TestCase.load_environ()"""
     (tmp_path / "ubsan.supp").touch()
     (tmp_path / "other_file").touch()
@@ -369,7 +391,7 @@ def test_testcase_16(tmp_path):
         assert len(opts) == 3
 
 
-def test_testcase_17(tmp_path):
+def test_testcase_16(tmp_path):
     """test TestCase.add_batch()"""
     include = tmp_path / "inc_path"
     include.mkdir()
@@ -386,7 +408,7 @@ def test_testcase_17(tmp_path):
         tcase.add_batch("/missing/path/", tuple())
         assert not tcase._existing_paths
         # missing file
-        with pytest.raises(IOError):
+        with raises(IOError):
             tcase.add_batch(str(tmp_path), [str(tmp_path / "missing.bin")])
         assert not tcase._existing_paths
         # relative file name
@@ -405,11 +427,11 @@ def test_testcase_17(tmp_path):
         assert tcase.contains(os.path.join("test", "file.bin"))
         assert len(tcase._existing_paths) == 3
         # collision
-        with pytest.raises(TestFileExists, match="'file.bin' exists in test"):
+        with raises(TestFileExists, match="'file.bin' exists in test"):
             tcase.add_batch(str(include), [str(inc_1)])
 
 
-def test_testcase_18(tmp_path):
+def test_testcase_17(tmp_path):
     """test TestCase.scan_path()"""
     # empty path
     (tmp_path / "not-test").mkdir()
@@ -427,7 +449,7 @@ def test_testcase_18(tmp_path):
     assert len(tc_paths) == 1
 
 
-def test_testcase_19():
+def test_testcase_18():
     """test TestCase.get_file()"""
     with TestCase("test.htm", None, "test-adapter") as src:
         src.add_from_data("test", "test.htm")
@@ -435,14 +457,13 @@ def test_testcase_19():
         assert src.get_file("test.htm").data == b"test"
 
 
-def test_testcase_20():
+def test_testcase_19():
     """test TestCase.clone()"""
     with TestCase("a.htm", "b.htm", "adpt", input_fname="fn", time_limit=2) as src:
         src.duration = 1.2
         src.hang = True
         src.add_from_data("123", "test.htm")
         src.add_from_data("456", "opt.htm", required=False)
-        src.add_meta(TestFile.from_data("pref", "prefs.js"))
         src.add_environ_var("go", "away")
         with src.clone() as tgt:
             for prop in TestCase.__slots__:
@@ -453,7 +474,6 @@ def test_testcase_20():
             for file, data in (
                 ("test.htm", b"123"),
                 ("opt.htm", b"456"),
-                ("prefs.js", b"pref"),
             ):
                 src.get_file(file).write(b"src")
                 tgt.get_file(file).write(b"tgt")
@@ -478,19 +498,19 @@ def test_testfile_01():
 def test_testfile_02():
     """test TestFile file names"""
     # empty file name
-    with pytest.raises(TypeError, match="file_name is invalid"):
+    with raises(TypeError, match="file_name is invalid"):
         TestFile("")
     # path (root) with missing file name
-    with pytest.raises(TypeError, match="file_name is invalid"):
+    with raises(TypeError, match="file_name is invalid"):
         TestFile("/")
     # path (root) with missing file name
-    with pytest.raises(TypeError, match="file_name is invalid"):
+    with raises(TypeError, match="file_name is invalid"):
         TestFile("/.")
     # path with missing file name
-    with pytest.raises(TypeError, match="file_name is invalid"):
+    with raises(TypeError, match="file_name is invalid"):
         TestFile("path/")
     # invalid use of '..'
-    with pytest.raises(TypeError, match="file_name is invalid"):
+    with raises(TypeError, match="file_name is invalid"):
         TestFile("../test")
     # path (root) with file
     with TestFile("/valid.txt") as tfile:
diff --git a/grizzly/main.py b/grizzly/main.py
index 723d9b95..5860b373 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -89,13 +89,10 @@ def main(args):
             valgrind=args.valgrind,
             xvfb=args.xvfb,
         )
-        if args.prefs:
-            LOG.info("Using prefs %r", args.prefs)
-            target.assets.add("prefs", args.prefs)
-        if args.extension:
-            target.assets.add("extension", args.extension)
-        adapter.monitor = target.monitor
+        # add specified assets
+        target.assets.add_batch(args.asset)
         target.process_assets()
+        adapter.monitor = target.monitor
 
         LOG.debug("initializing the Reporter")
         if args.fuzzmanager:
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 1535407e..1edde1bb 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -10,8 +10,6 @@
 from logging import getLogger
 from math import ceil, log
 from pathlib import Path
-from shutil import rmtree
-from tempfile import mkdtemp
 from time import time
 
 from FTB.Signatures.CrashInfo import CrashSignature
@@ -21,7 +19,7 @@
 from ..common.fuzzmanager import CrashEntry
 from ..common.plugins import load as load_plugin
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter
-from ..common.storage import TestCaseLoadFailure, TestFile
+from ..common.storage import TestCaseLoadFailure
 from ..common.utils import ConfigError, configure_logging, grz_tmp
 from ..replay import ReplayManager
 from ..session import Session
@@ -719,11 +717,11 @@ def main(cls, args):
         elif args.valgrind:
             LOG.info("Running with Valgrind. This will be SLOW!")
 
+        assets = None
         signature = None
         signature_desc = None
         target = None
         testcases = []
-        tmp_prefs = None
         try:
             if args.sig:
                 signature = CrashSignature.fromFile(args.sig)
@@ -733,8 +731,8 @@ def main(cls, args):
                     signature_desc = meta["shortDescription"]
 
             try:
-                testcases = ReplayManager.load_testcases(
-                    args.input, args.prefs is None, subset=args.test_index
+                testcases, assets = ReplayManager.load_testcases(
+                    args.input, subset=args.test_index
                 )
             except TestCaseLoadFailure as exc:
                 LOG.error("Error: %s", str(exc))
@@ -770,34 +768,18 @@ def main(cls, args):
             LOG.debug("initializing the Target")
             target = load_plugin(args.platform, "grizzly_targets", Target)(
                 args.binary,
-                args.extension,
                 args.launch_timeout,
                 args.log_limit,
                 args.memory,
+                assets=assets,
                 pernosco=args.pernosco,
                 rr=args.rr,
                 valgrind=args.valgrind,
                 xvfb=args.xvfb,
             )
-            if args.extension:
-                target.assets.add("extension", args.extension)
-            # prioritize specified prefs.js file over included file
-            if args.prefs is not None:
-                for testcase in testcases:
-                    testcase.add_meta(TestFile.from_file(args.prefs, "prefs.js"))
-                LOG.info("Using specified prefs.js")
-                target.prefs = args.prefs
-            else:
-                for testcase in testcases:
-                    prefs_tf = testcase.get_file("prefs.js")
-                    if prefs_tf:
-                        tmp_prefs = Path(
-                            mkdtemp(prefix="prefs_", dir=grz_tmp("replay"))
-                        )
-                        prefs_tf.dump(str(tmp_prefs))
-                        LOG.info("Using prefs.js from testcase")
-                        target.prefs = str(tmp_prefs / "prefs.js")
-                        break
+            # TODO: support overriding existing assets
+            # prioritize specified assets over included
+            target.assets.add_batch(args.asset)
             target.process_assets()
             LOG.debug("starting sapphire server")
             # launch HTTP server used to serve test cases
@@ -858,6 +840,6 @@ def main(cls, args):
                 target.cleanup()
             for testcase in testcases:
                 testcase.cleanup()
-            if tmp_prefs is not None:
-                rmtree(str(tmp_prefs), ignore_errors=True)
+            if assets:
+                assets.cleanup()
             LOG.info("Done.")
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index d76414e3..dcdfe40b 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -4,21 +4,18 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Unit tests for `grizzly.reduce.main`."""
 from logging import getLogger
-from pathlib import Path
-from shutil import rmtree
 from unittest.mock import Mock
 
-import pytest
-from pytest import raises
+from pytest import mark, raises
 
-from ..common.storage import TestCaseLoadFailure
-from ..target import TargetLaunchError, TargetLaunchTimeout
+from ..common.storage import TestCase, TestCaseLoadFailure
+from ..target import AssetManager, TargetLaunchError, TargetLaunchTimeout
 from . import ReduceManager
 from .args import ReduceArgs, ReduceFuzzManagerIDArgs, ReduceFuzzManagerIDQualityArgs
 from .exceptions import GrizzlyReduceBaseException
 
 LOG = getLogger(__name__)
-pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")
+pytestmark = mark.usefixtures("tmp_path_fm_config")
 
 
 def test_args_01(capsys, tmp_path, mocker):
@@ -83,7 +80,7 @@ def test_args_04(capsys, tmp_path):
     assert "error: '--quality' value cannot be negative" in capsys.readouterr()[-1]
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     "patch_func, side_effect, return_value, kwargs, result",
     [
         (
@@ -113,7 +110,7 @@ def test_args_04(capsys, tmp_path):
         (
             "grizzly.reduce.core.ReplayManager.load_testcases",
             None,
-            [Mock(hang=False), Mock(hang=False)],
+            ([Mock(hang=False), Mock(hang=False)], Mock(spec_set=AssetManager)),
             {"no_harness": True},
             2,
         ),
@@ -134,7 +131,6 @@ def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, result
         ignore=["fake"],
         input="test",
         min_crashes=1,
-        prefs=None,
         relaunch=1,
         repeat=1,
         sig=None,
@@ -145,7 +141,7 @@ def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, result
     assert ReduceManager.main(args) == result
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     "exc_type",
     [
         TargetLaunchError,
@@ -156,7 +152,13 @@ def test_main_launch_error(mocker, exc_type):
     mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
     reporter = mocker.patch("grizzly.reduce.core.FilesystemReporter", autospec=True)
     mocker.patch("grizzly.reduce.core.load_plugin", autospec=True)
-    mocker.patch("grizzly.reduce.core.ReplayManager.load_testcases")
+    mocker.patch(
+        "grizzly.reduce.core.ReplayManager.load_testcases",
+        return_value=(
+            [mocker.Mock(spec_set=TestCase, hang=False, adapter_name="fake")],
+            None,
+        ),
+    )
     mocker.patch(
         "grizzly.reduce.core.ReplayManager.time_limits", return_value=(None, 10)
     )
@@ -167,10 +169,10 @@ def test_main_launch_error(mocker, exc_type):
         ignore=["fake"],
         input="test",
         min_crashes=1,
-        prefs=None,
         relaunch=1,
         repeat=1,
         sig=None,
+        tool=None,
     )
 
     exc_obj = exc_type(
@@ -185,37 +187,3 @@ def test_main_launch_error(mocker, exc_type):
         assert report is exc_obj.report
     else:
         assert reporter.return_value.submit.call_count == 0
-
-
-@pytest.mark.parametrize("result", ["testprefs", "argprefs"])
-def test_testcase_prefs(mocker, tmp_path, result):
-    """test that prefs from testcase are used if --prefs not specified and --prefs
-    overrides"""
-    load_target = mocker.patch("grizzly.reduce.core.load_plugin")
-    mocker.patch("grizzly.reduce.core.ReduceManager.run", autospec=True)
-    mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
-    rmtree_mock = mocker.patch("grizzly.reduce.core.rmtree", autospec=True)
-    (tmp_path / "test.html").touch()
-    (tmp_path / "prefs.js").write_text("testprefs")
-    args = mocker.Mock(
-        fuzzmanager=False,
-        ignore=[],
-        input=str(tmp_path / "test.html"),
-        min_crashes=1,
-        prefs=None,
-        repeat=1,
-        sig=None,
-        test_index=None,
-        time_limit=10,
-        timeout=10,
-    )
-    if result == "argprefs":
-        (tmp_path / "args.js").write_text("argprefs")
-        args.prefs = str(tmp_path / "args.js")
-
-    try:
-        ReduceManager.main(args)
-        assert Path(load_target.return_value.return_value.prefs).read_text() == result
-    finally:
-        for rm_args, rm_kwds in rmtree_mock.call_args_list:
-            rmtree(*rm_args, **rm_kwds)
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 382c5d5c..e09bb42b 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -7,25 +7,22 @@
 from collections import namedtuple
 from logging import getLogger
 
-import pytest
-from pytest import raises
+from pytest import mark, raises
 
 from sapphire import Sapphire
 
 from ..common.reporter import Report
-from ..common.storage import TestCase, TestFile
+from ..common.storage import TestCase
 from ..replay import ReplayResult
 from ..target import Target
 from . import ReduceManager
 from .strategies import Strategy, _load_strategies
 
 LOG = getLogger(__name__)
-pytestmark = pytest.mark.usefixtures(
-    "tmp_path_fm_config", "reporter_sequential_strftime"
-)
+pytestmark = mark.usefixtures("tmp_path_fm_config", "reporter_sequential_strftime")
 
 
-@pytest.mark.parametrize("is_hang", [True, False])
+@mark.parametrize("is_hang", [True, False])
 def test_strategy_tc_load(is_hang):
     """test that strategy base class dump and load doesn't change testcase metadata"""
 
@@ -104,7 +101,7 @@ def entries(_):
 )
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     ListStrategyParams._fields,
     [
         # "list" is a no-op with a single testcase
@@ -211,7 +208,7 @@ def replay_run(testcases, _time_limit, **_):
 )
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     PurgeUnservedTestParams._fields,
     [
         # single test, first reduction uses 2 files, second uses only target file.
@@ -355,7 +352,6 @@ def replay_run(testcases, _time_limit, **_):
         test = TestCase("test.html", None, "test-adapter")
         for filename, data in testcase.items():
             test.add_from_data(data, filename)
-        test.add_meta(TestFile.from_data("12345", "prefs.js"))
         tests.append(test)
     log_path = tmp_path / "logs"
 
@@ -389,16 +385,6 @@ def replay_run(testcases, _time_limit, **_):
     assert (
         sum(1 for _ in (log_path / "reports").iterdir()) == expected_num_reports
     ), list((log_path / "reports").iterdir())
-    # each input has 2 files, so if there are more than 2 reports, the result has 2
-    # testcases
-    assert (
-        sum(1 for _ in log_path.glob("reports/*-*/prefs.js"))
-        == (expected_num_reports + 1) // 2
-    ), "prefs.js missing in %r" % [
-        str(p.relative_to(log_path))
-        for p in log_path.glob("reports/**/*")
-        if p.is_file()
-    ]
 
 
 def test_dd_only(mocker, tmp_path):
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 96f3478a..aa538f7a 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -17,7 +17,7 @@
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter, Report
 from ..common.runner import Runner, RunResult
 from ..common.status import Status
-from ..common.storage import TestCase, TestCaseLoadFailure, TestFile
+from ..common.storage import TestCase, TestCaseLoadFailure
 from ..common.utils import TIMEOUT_DELAY, ConfigError, configure_logging, grz_tmp
 from ..session import Session
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
@@ -138,21 +138,27 @@ def expect_hang(ignore, signature, tests):
         return is_hang
 
     @classmethod
-    def load_testcases(cls, path, load_prefs, subset=None):
+    def load_testcases(cls, path, subset=None):
         """Load TestCases.
 
         Args:
             path (str): Path to load.
-            load_prefs (bool): Load prefs.js file if available.
             subset (list(int)): Indices of tests to load when loading multiple
                                 tests.
         Returns:
-            list(TestCase): Loaded TestCases.
+            tuple (list(TestCase), AssetManager): Loaded TestCases and AssetManager.
         """
         LOG.debug("loading the TestCases")
-        testcases = TestCase.load(path, load_prefs)
+        testcases = TestCase.load(path)
         if not testcases:
             raise TestCaseLoadFailure("Failed to load TestCases")
+        # remove loaded assets from test cases
+        assets = None
+        for test in testcases:
+            if assets is None:
+                assets = test.pop_assets()
+            else:
+                test.pop_assets()
         if subset:
             count = len(testcases)
             # deduplicate and limit requested indices to valid range
@@ -165,7 +171,7 @@ def load_testcases(cls, path, load_prefs, subset=None):
             for test in testcases:
                 test.cleanup()
             testcases = selected
-        return testcases
+        return testcases, assets
 
     @staticmethod
     def report_to_filesystem(path, results, tests=None):
@@ -565,9 +571,7 @@ def main(cls, args):
             signature = None
 
         try:
-            testcases = cls.load_testcases(
-                args.input, args.prefs is None, subset=args.test_index
-            )
+            testcases, assets = cls.load_testcases(args.input, subset=args.test_index)
         except TestCaseLoadFailure as exc:
             LOG.error("Error: %s", str(exc))
             return Session.EXIT_ERROR
@@ -606,30 +610,15 @@ def main(cls, args):
                 args.launch_timeout,
                 args.log_limit,
                 args.memory,
+                assets=assets,
                 pernosco=args.pernosco,
                 rr=args.rr,
                 valgrind=args.valgrind,
                 xvfb=args.xvfb,
             )
-            if args.extension:
-                target.assets.add("extension", args.extension)
-            # prioritize specified prefs.js file over included file
-            if args.prefs:
-                for testcase in testcases:
-                    testcase.add_meta(TestFile.from_file(args.prefs, "prefs.js"))
-                LOG.info("Using specified prefs.js")
-                target.assets.add("prefs", args.prefs)
-            else:
-                for testcase in testcases:
-                    prefs_tf = testcase.get_file("prefs.js")
-                    if prefs_tf:
-                        LOG.info("Using prefs.js from testcase")
-                        prefs_tf.dump(target.assets.path)
-                        target.assets.add(
-                            "prefs",
-                            pathjoin(target.assets.path, "prefs.js"),
-                        )
-                        break
+            # TODO: support overriding existing assets
+            # prioritize specified assets over included
+            target.assets.add_batch(args.asset)
             target.process_assets()
 
             LOG.debug("starting sapphire server")
@@ -661,6 +650,10 @@ def main(cls, args):
             else:
                 LOG.info("Failed to reproduce results")
             if args.logs and results:
+                # add target assets to test cases
+                if not target.assets.is_empty():
+                    for test in testcases:
+                        test.assets = target.assets
                 cls.report_to_filesystem(
                     args.logs, results, testcases if args.include_test else None
                 )
@@ -693,4 +686,6 @@ def main(cls, args):
                 target.cleanup()
             for testcase in testcases:
                 testcase.cleanup()
+            if assets:
+                assets.cleanup()
             LOG.info("Done.")
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 82a5f19a..66403af0 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -6,8 +6,6 @@
 """
 unit tests for grizzly.replay.main
 """
-from shutil import rmtree
-
 from pytest import mark
 
 from sapphire import SERVED_ALL
@@ -33,8 +31,9 @@ def test_main_01(mocker, tmp_path):
         return_value=(SERVED_ALL, ["test.html"]),  # passed to Target.detect_failure
     )
     # setup Target
-    load_target = mocker.patch("grizzly.replay.replay.load_plugin")
-    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
+    load_target = mocker.patch("grizzly.replay.replay.load_plugin", autospec=True)
+    target = mocker.Mock(spec_set=Target, binary="bin", launch_timeout=30)
+    target.assets = mocker.Mock(spec_set=AssetManager)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
@@ -48,11 +47,11 @@ def test_main_01(mocker, tmp_path):
     # setup args
     log_path = tmp_path / "logs"
     (tmp_path / "test.html").touch()
-    (tmp_path / "prefs.js").touch()
     (tmp_path / "sig.json").write_bytes(
         b'{"symptoms": [{"type": "crashAddress", "address": "0"}]}'
     )
     args = mocker.Mock(
+        asset=list(),
         fuzzmanager=False,
         idle_delay=0,
         idle_threshold=0,
@@ -62,7 +61,6 @@ def test_main_01(mocker, tmp_path):
         min_crashes=2,
         no_harness=False,
         pernosco=False,
-        prefs=str(tmp_path / "prefs.js"),
         relaunch=1,
         repeat=4,
         rr=False,
@@ -80,6 +78,8 @@ def test_main_01(mocker, tmp_path):
     assert load_target.call_count == 1
     assert target.close.call_count == 4
     assert target.cleanup.call_count == 1
+    assert target.assets.add.call_count == 0
+    assert target.assets.is_empty.call_count == 1
     assert log_path.is_dir()
     assert any(log_path.glob("reports/*/log_asan_blah.txt"))
     assert any(log_path.glob("reports/*/log_stderr.txt"))
@@ -104,6 +104,7 @@ def test_main_02(mocker, tmp_path):
     # setup args
     (tmp_path / "test.html").touch()
     args = mocker.Mock(
+        asset=list(),
         fuzzmanager=False,
         idle_delay=0,
         idle_threshold=0,
@@ -112,7 +113,6 @@ def test_main_02(mocker, tmp_path):
         min_crashes=2,
         no_harness=True,
         pernosco=False,
-        prefs=None,
         relaunch=1,
         repeat=1,
         rr=False,
@@ -137,12 +137,12 @@ def test_main_03(mocker):
     fake_tc = mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
     # setup args
     args = mocker.Mock(
+        asset=list(),
         ignore=list(),
         input="test",
         min_crashes=1,
         no_harness=True,
         pernosco=False,
-        prefs=None,
         relaunch=1,
         repeat=1,
         rr=False,
@@ -201,12 +201,12 @@ def test_main_04(mocker, tmp_path):
     )
     # setup args
     args = mocker.Mock(
+        asset=list(),
         ignore=list(),
         input="test",
         min_crashes=1,
         no_harness=True,
         pernosco=False,
-        prefs=None,
         relaunch=1,
         repeat=1,
         rr=False,
@@ -235,28 +235,28 @@ def test_main_04(mocker, tmp_path):
 
 
 def test_main_05(mocker, tmp_path):
-    """test ReplayManager.main() loading/generating prefs.js"""
+    """test ReplayManager.main() loading specified assets"""
     serve_path = mocker.patch(
         "grizzly.replay.replay.Sapphire.serve_path",
         autospec=True,
         return_value=(None, ["test.html"]),  # passed to Target.detect_failure
     )
     # setup Target
-    assets = mocker.Mock(spec_set=AssetManager, path=str(tmp_path))
-    target = mocker.Mock(
-        spec_set=Target,
-        assets=assets,
-        binary="bin",
-        launch_timeout=30,
-    )
+    target = mocker.NonCallableMock(spec_set=Target, binary="bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
-    load_target = mocker.patch("grizzly.replay.replay.load_plugin")
-    load_target.return_value.return_value = target
+    mocker.patch(
+        "grizzly.replay.replay.load_plugin",
+        autospec=True,
+        return_value=mocker.Mock(spec_set=Target, return_value=target),
+    )
+    asset = tmp_path / "sample_asset"
+    asset.touch()
     # setup args
     args = mocker.Mock(
+        asset=[["from_cmdline", str(asset)]],
         fuzzmanager=False,
         idle_delay=0,
         idle_threshold=0,
@@ -284,44 +284,15 @@ def test_main_05(mocker, tmp_path):
         src.add_from_file(str(entry_point))
         src.dump(str(input_path), include_details=True)
     args.input = str(input_path)
-
-    # test no specified prefs.js
-    args.prefs = None
-    assert ReplayManager.main(args) == Session.EXIT_SUCCESS
-    assert target.launch.call_count == 1
-    assert target.detect_failure.call_count == 1
-    assert serve_path.call_count == 1
-    assert log_path.is_dir()
-    assert not any(log_path.glob("**/prefs.js"))
-
-    target.reset_mock()
-    serve_path.reset_mock()
-    rmtree(str(log_path), ignore_errors=True)
-
-    # test included prefs.js
-    (input_path / "prefs.js").write_bytes(b"included")
-    assert ReplayManager.main(args) == Session.EXIT_SUCCESS
-    assert target.launch.call_count == 1
-    assert target.detect_failure.call_count == 1
-    assert serve_path.call_count == 1
-    assert log_path.is_dir()
-    prefs = next(log_path.glob("**/prefs.js"))
-    assert prefs.read_bytes() == b"included"
-
-    target.reset_mock()
-    serve_path.reset_mock()
-    rmtree(str(log_path), ignore_errors=True)
-
-    # test specified prefs.js
-    (tmp_path / "prefs.js").write_bytes(b"specified")
-    args.prefs = str(tmp_path / "prefs.js")
-    assert ReplayManager.main(args) == Session.EXIT_SUCCESS
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        target.assets = assets
+        assert ReplayManager.main(args) == Session.EXIT_SUCCESS
+        assert "from_cmdline" in target.assets.assets
     assert target.launch.call_count == 1
     assert target.detect_failure.call_count == 1
     assert serve_path.call_count == 1
     assert log_path.is_dir()
-    prefs = next(log_path.glob("**/prefs.js"))
-    assert prefs.read_bytes() == b"specified"
+    assert any(log_path.glob("**/sample_asset"))
 
 
 @mark.parametrize(
@@ -367,6 +338,7 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
         test.dump(str(replay_path), include_details=True)
     # setup args
     args = mocker.Mock(
+        asset=list(),
         fuzzmanager=False,
         idle_delay=0,
         idle_threshold=0,
@@ -375,7 +347,6 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
         min_crashes=2,
         no_harness=True,
         pernosco=False,
-        prefs=None,
         relaunch=1,
         repeat=1,
         rr=False,
@@ -421,6 +392,7 @@ def test_main_07(mocker, tmp_path, pernosco, rr, valgrind, no_harness):
     # setup args
     (tmp_path / "test.html").touch()
     args = mocker.Mock(
+        asset=list(),
         fuzzmanager=False,
         idle_delay=0,
         idle_threshold=0,
@@ -429,7 +401,6 @@ def test_main_07(mocker, tmp_path, pernosco, rr, valgrind, no_harness):
         min_crashes=2,
         no_harness=no_harness,
         pernosco=pernosco,
-        prefs=None,
         relaunch=1,
         repeat=1,
         rr=rr,
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 45a61db9..aaa952b1 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -16,7 +16,7 @@
 from ..common.reporter import Report
 from ..common.status import Status
 from ..common.storage import TestCase, TestCaseLoadFailure
-from ..target import Target
+from ..target import AssetManager, Target
 from .replay import ReplayManager, ReplayResult
 
 
@@ -723,33 +723,40 @@ def test_replay_20(mocker, tmp_path):
 
 def test_replay_21(mocker, tmp_path):
     """test ReplayManager.load_testcases()"""
-    fake_load = mocker.patch("grizzly.replay.replay.TestCase.load")
-    test0 = mocker.Mock(spec=TestCase)
-    test1 = mocker.Mock(spec=TestCase, landing_page="x.html")
-    test2 = mocker.Mock(spec=TestCase)
+    fake_load = mocker.patch("grizzly.replay.replay.TestCase.load", autospec=True)
+    test0 = mocker.Mock(spec_set=TestCase)
+    test0.pop_assets.return_value = None
+    test1 = mocker.Mock(spec_set=TestCase, landing_page="x.html")
+    test1.pop_assets.return_value = None
+    test2 = mocker.Mock(spec_set=TestCase)
+    test2.pop_assets.return_value = None
     # failure
     fake_load.return_value = ()
     with raises(TestCaseLoadFailure, match="Failed to load TestCases"):
-        ReplayManager.load_testcases(str(tmp_path), False)
+        ReplayManager.load_testcases(str(tmp_path))
     # success
     fake_load.return_value = [test0, test1]
-    tests = ReplayManager.load_testcases(str(tmp_path), False)
+    tests, assets = ReplayManager.load_testcases(str(tmp_path))
     assert len(tests) == 2
     assert tests[0].cleanup.call_count == 0
     assert tests[1].cleanup.call_count == 0
+    assert assets is None
     # success select
-    fake_load.return_value = [test0, test1, test2, mocker.Mock(spec=TestCase)]
-    tests = ReplayManager.load_testcases(str(tmp_path), False, subset=[1, 3])
+    test0.pop_assets.return_value = mocker.Mock(spec_set=AssetManager)
+    fake_load.return_value = [test0, test1, test2, mocker.Mock(spec_set=TestCase)]
+    tests, assets = ReplayManager.load_testcases(str(tmp_path), subset=[1, 3])
     assert len(tests) == 2
     assert tests[0].landing_page == "x.html"
     assert test0.cleanup.call_count == 1
     assert test1.cleanup.call_count == 0
     assert test2.cleanup.call_count == 1
+    assert assets is not None
     test0.reset_mock()
     test2.reset_mock()
     # select (first and last) with invalid input
+    test0.pop_assets.return_value = None
     fake_load.return_value = [test0, test1, test2]
-    tests = ReplayManager.load_testcases(str(tmp_path), False, subset=[0, 10, -10, -1])
+    tests, _ = ReplayManager.load_testcases(str(tmp_path), subset=[0, 10, -10, -1])
     assert len(tests) == 2
     assert test0.cleanup.call_count == 0
     assert test1.cleanup.call_count == 1
@@ -775,7 +782,7 @@ def test_replay_22(mocker, tmp_path, is_hang, use_sig, match_sig, ignored, resul
     """test ReplayManager.run() - detect hangs"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     served = ["index.html"]
-    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_TIMEOUT, served)
     if use_sig:
         signature = mocker.Mock()
@@ -783,7 +790,7 @@ def test_replay_22(mocker, tmp_path, is_hang, use_sig, match_sig, ignored, resul
         signature.rawSignature = "fakesig"
     else:
         signature = None
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.handle_hang.return_value = False
diff --git a/grizzly/session.py b/grizzly/session.py
index d2c07629..544623bf 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -8,7 +8,6 @@
 from .common.iomanager import IOManager
 from .common.runner import Runner, RunResult
 from .common.status import Status
-from .common.storage import TestFile
 from .target import TargetLaunchError
 
 __all__ = ("SessionError", "LogOutputLimiter", "Session")
@@ -139,11 +138,6 @@ def generate_testcase(self, time_limit):
         with self.status.measure("generate"):
             self.adapter.generate(test, self.iomanager.server_map)
         self.status.test_name = test.input_fname
-        # TODO: update TestCase to better handle assets
-        if self.target.assets.get("prefs"):
-            test.add_meta(
-                TestFile.from_file(self.target.assets.get("prefs"), "prefs.js")
-            )
         return test
 
     def run(
@@ -222,6 +216,7 @@ def run(
                     coverage=self._coverage,
                 )
             current_test.duration = result.duration
+            current_test.assets = self.target.assets
             # adapter callbacks
             if result.timeout:
                 current_test.hang = True
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index bc412865..d9bea189 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -42,7 +42,13 @@ class PuppetTarget(Target):
     __slots__ = ("use_valgrind", "_extension", "_prefs", "_puppet")
 
     def __init__(self, binary, launch_timeout, log_limit, memory_limit, **kwds):
-        super().__init__(binary, launch_timeout, log_limit, memory_limit)
+        super().__init__(
+            binary,
+            launch_timeout,
+            log_limit,
+            memory_limit,
+            assets=kwds.pop("assets", None),
+        )
         # TODO: clean up handling debuggers
         debugger = Debugger.NONE
         if kwds.pop("pernosco", False):
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index e3c30ee1..b46b6d9e 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -4,8 +4,8 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from abc import ABCMeta, abstractmethod, abstractproperty
 from logging import getLogger
-from os import unlink
-from os.path import basename, dirname, exists, isfile
+from os import makedirs, unlink
+from os.path import basename, dirname, exists, isdir, isfile
 from os.path import join as pathjoin
 from shutil import copyfile, copytree, rmtree
 from tempfile import mkdtemp
@@ -35,6 +35,7 @@ def __exit__(self, *exc):
 
     def add(self, asset, path):
         assert isinstance(asset, str)
+        assert self.path, "cleanup() was called"
         if not path or not exists(path):
             raise OSError("Asset %r not found %r" % (asset, path))
         assert asset not in self.assets
@@ -53,15 +54,47 @@ def add(self, asset, path):
             self.assets[asset] = path
         LOG.debug("added asset %r from %r", asset, path)
 
+    def add_batch(self, assets):
+        for asset, path in assets:
+            self.add(asset, path)
+
     def cleanup(self):
         if self.path:
             rmtree(self.path, ignore_errors=True)
             self.assets.clear()
             self.path = None
 
+    def dump(self, dst_path, subdir="_assets_"):
+        dumped = dict()
+        if self.assets:
+            if subdir:
+                dst_path = pathjoin(dst_path, subdir)
+            makedirs(dst_path, exist_ok=not subdir)
+            for asset, src in self.assets.items():
+                dst_name = basename(src)
+                dumped[asset] = dst_name
+                if isfile(src):
+                    copyfile(src, pathjoin(dst_path, dst_name))
+                elif isdir(src):
+                    copytree(src, pathjoin(dst_path, dst_name))
+                else:
+                    dumped.pop(asset)
+                    LOG.warning("Failed to dump asset %r from %r", asset, src)
+        return dumped
+
     def get(self, asset):
         return self.assets.get(asset, None)
 
+    def is_empty(self):
+        return not self.assets
+
+    @classmethod
+    def load(cls, assets, src_path):
+        obj = cls()
+        for asset, src_name in assets.items():
+            obj.add(asset, pathjoin(src_path, src_name))
+        return obj
+
     def remove(self, asset):
         path = self.assets.pop(asset, None)
         if path:
@@ -94,22 +127,23 @@ class Target(metaclass=ABCMeta):
     SUPPORTED_ASSETS = None
 
     __slots__ = (
+        "_assets",
         "_lock",
         "_monitor",
-        "assets",
         "binary",
         "launch_timeout",
         "log_limit",
         "memory_limit",
     )
 
-    def __init__(self, binary, launch_timeout, log_limit, memory_limit):
+    def __init__(self, binary, launch_timeout, log_limit, memory_limit, assets=None):
         assert log_limit >= 0
         assert memory_limit >= 0
         assert binary is not None and isfile(binary)
+        assert assets is None or isinstance(assets, AssetManager)
+        self._assets = assets if assets else AssetManager(base_path=grz_tmp("target"))
         self._lock = Lock()
         self._monitor = None
-        self.assets = AssetManager(base_path=grz_tmp("target"))
         self.binary = binary
         self.launch_timeout = max(launch_timeout, 300)
         self.log_limit = log_limit
@@ -122,8 +156,19 @@ def __exit__(self, *exc):
         self.cleanup()
 
     def add_abort_token(self, _token):  # pylint: disable=no-self-use
+        # TODO: change this to asset file containing tokens
         LOG.warning("add_abort_token() not implemented!")
 
+    @property
+    def assets(self):
+        return self._assets
+
+    @assets.setter
+    def assets(self, assets):
+        self._assets.cleanup()
+        assert isinstance(assets, AssetManager)
+        self._assets = assets
+
     @abstractmethod
     def _cleanup(self):
         pass
@@ -131,7 +176,7 @@ def _cleanup(self):
     def cleanup(self):
         # call target specific _cleanup first
         self._cleanup()
-        self.assets.cleanup()
+        self._assets.cleanup()
 
     @abstractmethod
     def close(self, force_close=False):
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index e0cd8e72..4ee0e2fe 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -10,7 +10,7 @@
 from pytest import mark, raises
 
 from .puppet_target import PuppetTarget
-from .target import Target, TargetLaunchError, TargetLaunchTimeout
+from .target import AssetManager, Target, TargetLaunchError, TargetLaunchTimeout
 
 
 def test_puppet_target_01(mocker, tmp_path):
@@ -21,7 +21,11 @@ def test_puppet_target_01(mocker, tmp_path):
     fake_file = tmp_path / "fake"
     fake_file.touch()
     with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
+        assert target.assets
         assert target.closed
+        assert target.launch_timeout == 300
+        assert target.log_limit == 25
+        assert target.memory_limit == 5000
         assert target.detect_failure([]) == Target.RESULT_NONE
         assert target.log_size() == 1124
         fake_ffp.return_value.log_length.assert_any_call("stderr")
@@ -44,7 +48,6 @@ def test_puppet_target_02(mocker, tmp_path):
     fake_file.touch()
     # test providing prefs.js
     with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
-        target.assets.add("prefs", str(fake_file))
         # launch success
         target.launch("launch_target_page")
         assert fake_ffp.return_value.launch.call_count == 1
@@ -307,11 +310,12 @@ def test_puppet_target_08(mocker, tmp_path):
         assert isfile(target.assets.get("prefs"))
         assert target.assets.get("prefs").endswith("prefs.js")
     # prefs file provided
-    with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
-        target.assets.add("prefs", str(fake_file))
-        target.process_assets()
-        assert isfile(target.assets.get("prefs"))
-        assert target.assets.get("prefs").endswith("fake")
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        assets.add("prefs", str(fake_file))
+        with PuppetTarget(str(fake_file), 300, 25, 5000, assets=assets) as target:
+            target.process_assets()
+            assert isfile(target.assets.get("prefs"))
+            assert target.assets.get("prefs").endswith("fake")
 
 
 @mark.parametrize(
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index c2503a3e..08c5712b 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -2,6 +2,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
+from os.path import isfile
 from pathlib import Path
 from shutil import rmtree
 
@@ -55,6 +56,9 @@ def test_target_01(tmp_path):
     with SimpleTarget(str(fake_file), 321, 2, 3) as target:
         assert target.binary == str(fake_file)
         assert target.assets
+        org_path = target.assets.path
+        target.assets = AssetManager(base_path=str(tmp_path))
+        assert target.assets.path != org_path
         assert not target.is_idle(0)
         assert target.launch_timeout == 321
         assert target.log_size() == 0
@@ -124,3 +128,49 @@ def test_assert_manager_01(tmp_path):
         assets.cleanup()
         assert not assets.assets
         assert assets.path is None
+
+
+def test_assert_manager_02(tmp_path):
+    """test AssetManager() dump/load"""
+    # test dump()
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        # add file
+        example = Path(assets.path) / "example.txt"
+        example.write_text("example")
+        assets.add("example_file", str(example))
+        # add directory
+        example = Path(assets.path) / "example_path"
+        example.mkdir()
+        (example / "a").mkdir()
+        (example / "a" / "1.txt").write_text("1")
+        assets.add("example_path", str(example))
+        # invalid entry
+        assets.assets["invalid"] = "bad/path"
+        # dump
+        dump_path = tmp_path / "dump"
+        dumped = assets.dump(str(dump_path), subdir="sub")
+    assert len(dumped) == 2
+    assert (dump_path / "sub" / "example.txt").is_file()
+    assert (dump_path / "sub" / "example_path" / "a" / "1.txt").is_file()
+    # test load()
+    with AssetManager.load(dumped, str(dump_path / "sub")) as assets:
+        assert len(assets.assets) == 2
+        assert isfile(assets.assets["example_file"])
+
+
+def test_assert_manager_03(tmp_path):
+    """test AssetManager.add_batch()"""
+    batch = list()
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        # add file
+        example = Path(assets.path) / "example.txt"
+        example.write_text("example")
+        batch.append(["example_file", str(example)])
+        # add directory
+        example = Path(assets.path) / "example_path"
+        example.mkdir()
+        (example / "a").mkdir()
+        (example / "a" / "1.txt").write_text("1")
+        batch.append(["example_path", str(example)])
+        assets.add_batch(batch)
+        assert len(assets.assets) == 2
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index f2a8a666..1a81676f 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -8,9 +8,10 @@
 from .args import CommonArgs, GrizzlyArgs
 
 
-def test_common_args_01(capsys, mocker):
+def test_common_args_01(capsys, mocker, tmp_path):
     """test CommonArgs.parse_args()"""
-    mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=[])
+    scan_plugins = mocker.patch("grizzly.args.scan_plugins", autospec=True)
+    scan_plugins.return_value = []
     # test help
     with raises(SystemExit):
         CommonArgs().parse_args(argv=["-h"])
@@ -19,23 +20,15 @@ def test_common_args_01(capsys, mocker):
     with raises(SystemExit):
         CommonArgs().parse_args(argv=[])
     assert "the following arguments are required: binary" in capsys.readouterr()[-1]
-
-
-def test_common_args_01a(capsys, mocker, tmp_path):
-    """test CommonArgs.parse_args()"""
-    mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=["targ1"])
+    # test with missing bin
+    scan_plugins.return_value = ["targ1"]
     fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
-    # test with missing bin
     with raises(SystemExit):
         CommonArgs().parse_args(argv=["missing-bin"])
     assert "error: file not found: 'missing-bin'" in capsys.readouterr()[-1]
     # test success
     CommonArgs().parse_args(argv=[str(fake_bin), "--platform", "targ1"])
-    # test invalid extension
-    with raises(SystemExit):
-        CommonArgs().parse_args(argv=[str(fake_bin), "--extension", str(fake_bin)])
-    assert "error: Extension must be a folder or .xpi" in capsys.readouterr()[-1]
 
 
 @mark.parametrize(
@@ -53,16 +46,8 @@ def test_common_args_01a(capsys, mocker, tmp_path):
         (["--memory", "-1"], "error: --memory must be >= 0", ["targ1"]),
         # test invalid relaunch value
         (["--relaunch", "0"], "error: --relaunch must be >= 1", ["targ1"]),
-        # test missing extension
-        (["--extension", "missing"], "error: 'missing' does not exist", ["targ1"]),
         # test invalid platform/target
         (["--platform", "bad"], "error: Platform 'bad' not installed", ["targ1"]),
-        # test invalid prefs file
-        (
-            ["--platform", "targ1", "--prefs", "bad"],
-            "error: --prefs file not found",
-            ["targ1"],
-        ),
         # test invalid asset
         (
             ["--platform", "targ1", "--asset", "bad", "a"],
@@ -72,7 +57,7 @@ def test_common_args_01a(capsys, mocker, tmp_path):
         # test invalid asset path
         (
             ["--platform", "targ1", "--asset", "a", "a"],
-            "error: 'a' does not exist",
+            "error: Failed to add asset 'a' cannot find 'a'",
             ["targ1"],
         ),
         # test invalid time-limit
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index a13928cb..c5ab9ac2 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -10,7 +10,7 @@
 from .adapter import Adapter
 from .main import main
 from .session import Session
-from .target import Target, TargetLaunchError
+from .target import AssetManager, Target, TargetLaunchError
 
 
 class FakeArgs:
@@ -18,6 +18,7 @@ def __init__(self):
         self.binary = None
         self.input = None
         self.adapter = None
+        self.asset = list()
         self.collect = 1
         self.coverage = False
         self.enable_profiling = False
@@ -66,7 +67,9 @@ def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, verbose):
     fake_adapter = mocker.NonCallableMock(spec_set=Adapter)
     fake_adapter.RELAUNCH = adpt_relaunch
     fake_adapter.TIME_LIMIT = 10
-    fake_target = mocker.NonCallableMock(spec_set=Target)
+    fake_target = mocker.NonCallableMock(
+        spec_set=Target, assets=mocker.Mock(set_spec=AssetManager)
+    )
     plugin_loader = mocker.patch("grizzly.main.load_plugin", autospec=True)
     plugin_loader.side_effect = (
         mocker.Mock(spec_set=Adapter, return_value=fake_adapter),
@@ -76,12 +79,13 @@ def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, verbose):
     fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     args = FakeArgs()
+    args.asset = [
+        ["fake", "fake"],
+    ]
     args.adapter = "fake"
-    args.extension = "fake"
     args.ignore = ["fake", "fake"]
     args.limit = limit
     args.runtime = runtime
-    args.prefs = "fake"
     args.rr = True
     args.valgrind = True
     args.xvfb = True
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 4fb73949..fa5a6001 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -16,7 +16,7 @@
 from .common.reporter import Report, Reporter
 from .common.runner import RunResult
 from .session import LogOutputLimiter, Session, SessionError
-from .target import Target, TargetLaunchError
+from .target import AssetManager, Target, TargetLaunchError
 
 
 class SimpleAdapter(Adapter):
@@ -69,9 +69,11 @@ def test_session_01(
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     mocker.patch("grizzly.common.status.time", side_effect=count(start=1.0, step=1.0))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    prefs = tmp_path / "prefs.js"
-    prefs.touch()
-    target = mocker.Mock(spec=Target, launch_timeout=30, assets={"prefs": str(prefs)})
+    target = mocker.Mock(
+        spec_set=Target,
+        launch_timeout=30,
+        assets=mocker.Mock(spec_set=AssetManager),
+    )
     target.log_size.return_value = 1000
     target.monitor.launches = 1
     # avoid shutdown delay
@@ -137,7 +139,11 @@ def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
     """test Session with playback Adapter"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, launch_timeout=30, assets=dict())
+    target = mocker.Mock(
+        spec_set=Target,
+        launch_timeout=30,
+        assets=mocker.Mock(spec_set=AssetManager),
+    )
     # calculate if the target is 'closed' based on relaunch
     type(target).closed = mocker.PropertyMock(
         side_effect=((x % relaunch == 0) for x in range(remaining))
@@ -189,7 +195,11 @@ def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
     report = mocker.Mock(spec=Report, major="major123", minor="minor456")
     report.crash_info.createShortSignature.return_value = "[@ sig]"
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, launch_timeout=30, assets=dict())
+    target = mocker.Mock(
+        spec_set=Target,
+        launch_timeout=30,
+        assets=mocker.Mock(spec_set=AssetManager),
+    )
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     target.monitor.launches = 1
@@ -228,7 +238,11 @@ def generate(self, _testcase, _server_map):
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_NONE, [])
-    target = mocker.Mock(spec=Target, launch_timeout=30, assets=dict())
+    target = mocker.Mock(
+        spec_set=Target,
+        launch_timeout=30,
+        assets=mocker.Mock(spec_set=AssetManager),
+    )
     target.monitor.launches = 1
     with Session(FuzzAdapter("fuzz"), None, server, target) as session:
         with raises(SessionError, match="Test case is missing landing page"):
@@ -240,7 +254,11 @@ def test_session_05(mocker, tmp_path):
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_TIMEOUT, [])
-    target = mocker.Mock(spec=Target, launch_timeout=30, assets=dict())
+    target = mocker.Mock(
+        spec_set=Target,
+        launch_timeout=30,
+        assets=mocker.Mock(spec_set=AssetManager),
+    )
     target.monitor.launches = 1
     with Session(SimpleAdapter(False), None, server, target) as session:
         with raises(SessionError, match="Please check Adapter and Target"):
@@ -265,7 +283,11 @@ def test_session_06(mocker, tmp_path, harness, report_size):
     report = mocker.Mock(spec=Report, major="major123", minor="minor456")
     report.crash_info.createShortSignature.return_value = "[@ sig]"
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, launch_timeout=30, assets=dict())
+    target = mocker.Mock(
+        spec_set=Target,
+        launch_timeout=30,
+        assets=mocker.Mock(spec_set=AssetManager),
+    )
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     target.monitor.launches = 1
@@ -307,7 +329,12 @@ def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, resul
     report.crash_info.createShortSignature.return_value = "[@ sig]"
     reporter = mocker.Mock(spec=Reporter)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30, assets=dict())
+    target = mocker.Mock(
+        spec_set=Target,
+        closed=True,
+        launch_timeout=30,
+        assets=mocker.Mock(spec_set=AssetManager),
+    )
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     target.monitor.launches = 1
@@ -332,11 +359,10 @@ def test_session_08(tmp_path, mocker):
     result.attempted = True
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.run.return_value = result
-    mocker.patch("grizzly.session.TestFile", autospec=True)
     adapter = mocker.Mock(spec=Adapter, remaining=None)
     adapter.IGNORE_UNSERVED = False
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, assets=dict())
+    target = mocker.Mock(spec_set=Target, assets=mocker.Mock(spec_set=AssetManager))
     target.monitor.launches = 1
     with Session(adapter, None, server, target) as session:
         session.run([], 10, iteration_limit=1)
@@ -355,7 +381,6 @@ def test_session_09(tmp_path, mocker):
     report = mocker.Mock(spec=Report, major="major123", minor="minor456")
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.launch.side_effect = TargetLaunchError("test", report)
-    mocker.patch("grizzly.session.TestFile", autospec=True)
     adapter = mocker.Mock(spec=Adapter, remaining=None)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
     target = mocker.Mock(spec=Target)
@@ -375,12 +400,11 @@ def test_session_10(tmp_path, mocker):
     result.attempted = True
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.run.return_value = result
-    mocker.patch("grizzly.session.TestFile", autospec=True)
     adapter = mocker.Mock(spec=Adapter, remaining=None)
     report = mocker.Mock(spec=Report, major="major123", minor="minor456")
     reporter = mocker.Mock(spec=Reporter)
     server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, assets=dict())
+    target = mocker.Mock(spec_set=Target, assets=mocker.Mock(spec_set=AssetManager))
     target.monitor.launches = 1
     target.create_report.return_value = report
     with Session(adapter, reporter, server, target) as session:

From a9be0b01c1d8590ae5251d663bfc48ce9072c3b3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 15 Jul 2021 11:33:09 -0700
Subject: [PATCH 286/531] [tests] Use `spec_set` with Mock where possible -
 This can help prevent bit-rot and typos

---
 grizzly/common/test_plugins.py      |  17 +--
 grizzly/common/test_reporter.py     |  14 +-
 grizzly/common/test_runner.py       |  52 +++----
 grizzly/reduce/test_reduce.py       |  33 ++---
 grizzly/reduce/test_strategies.py   |  15 +-
 grizzly/replay/test_main.py         |  32 +++--
 grizzly/replay/test_replay.py       | 203 +++++++++++++++++-----------
 grizzly/test_main.py                |   4 +-
 grizzly/test_session.py             |  48 +++----
 sapphire/test_connection_manager.py |  20 +--
 sapphire/test_sapphire.py           |   4 +-
 sapphire/test_worker.py             |  22 +--
 12 files changed, 253 insertions(+), 211 deletions(-)

diff --git a/grizzly/common/test_plugins.py b/grizzly/common/test_plugins.py
index f2e2e366..da0d8c13 100644
--- a/grizzly/common/test_plugins.py
+++ b/grizzly/common/test_plugins.py
@@ -28,7 +28,8 @@ def test_load_01(mocker):
 
 def test_load_02(mocker):
     """test load() - successful load"""
-    entry = mocker.Mock(set_spec=EntryPoint)
+    # Note: Mock.name cannot be set via the constructor so spec_set cannot be used
+    entry = mocker.Mock(spec=EntryPoint)
     entry.name = "test-name"
     entry.load.return_value = FakeType1
     mocker.patch(
@@ -39,7 +40,7 @@ def test_load_02(mocker):
 
 def test_load_03(mocker):
     """test load() - invalid type"""
-    entry = mocker.Mock(set_spec=EntryPoint)
+    entry = mocker.Mock(spec=EntryPoint)
     entry.name = "test-name"
     entry.load.return_value = FakeType1
     mocker.patch(
@@ -59,7 +60,7 @@ def test_scan_01(mocker):
 
 def test_scan_02(mocker):
     """test scan() - duplicate entry"""
-    entry = mocker.Mock(set_spec=EntryPoint)
+    entry = mocker.Mock(spec=EntryPoint)
     entry.name = "test_entry"
     mocker.patch(
         "grizzly.common.plugins.iter_entry_points",
@@ -72,7 +73,7 @@ def test_scan_02(mocker):
 
 def test_scan_03(mocker):
     """test scan() - success"""
-    entry = mocker.Mock(set_spec=EntryPoint)
+    entry = mocker.Mock(spec=EntryPoint)
     entry.name = "test-name"
     mocker.patch(
         "grizzly.common.plugins.iter_entry_points",
@@ -84,12 +85,12 @@ def test_scan_03(mocker):
 
 def test_scan_target_assets_01(mocker):
     """test scan_target_assets() - success"""
-    targ1 = mocker.Mock(set_spec=EntryPoint)
+    targ1 = mocker.Mock(spec=EntryPoint)
     targ1.name = "t1"
-    targ1.load.return_value = mocker.Mock(set_spec=Target, SUPPORTED_ASSETS=None)
-    targ2 = mocker.Mock(set_spec=EntryPoint)
+    targ1.load.return_value = mocker.Mock(spec_set=Target, SUPPORTED_ASSETS=None)
+    targ2 = mocker.Mock(spec=EntryPoint)
     targ2.name = "t2"
-    targ2.load.return_value = mocker.Mock(set_spec=Target, SUPPORTED_ASSETS=("a", "B"))
+    targ2.load.return_value = mocker.Mock(spec_set=Target, SUPPORTED_ASSETS=("a", "B"))
     mocker.patch(
         "grizzly.common.plugins.iter_entry_points",
         autospec=True,
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index ef1f17ac..8911a92f 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -353,7 +353,7 @@ def _submit_report(self, report, test_cases):
             pass
 
     reporter = SimpleReporter()
-    reporter.submit([], report=mocker.Mock(spec=Report))
+    reporter.submit([], report=mocker.Mock(spec_set=Report))
 
 
 def test_filesystem_reporter_01(tmp_path):
@@ -385,7 +385,7 @@ def test_filesystem_reporter_02(tmp_path, mocker):
     (log_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (log_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     _create_crash_log(log_path / "log_asan_blah.txt")
-    tests = list(mocker.Mock(spec=TestCase) for _ in range(10))
+    tests = list(mocker.Mock(spec_set=TestCase) for _ in range(10))
     report_path = tmp_path / "reports"
     assert not report_path.exists()
     reporter = FilesystemReporter(str(report_path))
@@ -398,7 +398,7 @@ def test_filesystem_reporter_02(tmp_path, mocker):
     log_path.mkdir()
     (log_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (log_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    tests = list(mocker.Mock(spec=TestCase) for _ in range(2))
+    tests = list(mocker.Mock(spec_set=TestCase) for _ in range(2))
     reporter.submit(tests, Report(str(log_path), "fake_bin"))
     assert all(x.dump.call_count == 1 for x in tests)
     assert len(tuple(report_path.iterdir())) == 2
@@ -421,7 +421,7 @@ def test_filesystem_reporter_04(mocker, tmp_path):
     """test FilesystemReporter w/o major bucket"""
     fake_report = tmp_path / "fake_report"
     fake_report.mkdir()
-    report = mocker.Mock(spec=Report, path=str(fake_report), prefix="test_prefix")
+    report = mocker.Mock(spec_set=Report, path=str(fake_report), prefix="test_prefix")
     reporter = FilesystemReporter(str(tmp_path / "dst"), major_bucket=False)
     reporter.submit([], report)
     assert not fake_report.is_dir()
@@ -432,7 +432,7 @@ def test_filesystem_reporter_04(mocker, tmp_path):
 def test_fuzzmanager_reporter_01(mocker, tmp_path):
     """test FuzzManagerReporter.sanity_check()"""
     fake_reporter = mocker.patch("grizzly.common.reporter.ProgramConfiguration")
-    fake_reporter.fromBinary.return_value = mocker.Mock(spec=ProgramConfiguration)
+    fake_reporter.fromBinary.return_value = mocker.Mock(spec_set=ProgramConfiguration)
     # missing global FM config file
     FuzzManagerReporter.FM_CONFIG = "no_file"
     with pytest.raises(IOError, match="Missing: no_file"):
@@ -474,7 +474,7 @@ def test_fuzzmanager_reporter_02(mocker, tmp_path):
     (log_path / "rr-traces").mkdir()
     (tmp_path / "screenlog.0").touch()
     fake_test = mocker.Mock(
-        spec=TestCase,
+        spec_set=TestCase,
         adapter_name="adapter",
         env_vars={"TEST": "1"},
         input_fname="input",
@@ -630,7 +630,7 @@ def test_s3fuzzmanager_reporter_02(mocker, tmp_path):
     mocker.patch("grizzly.common.reporter.getenv", autospec=True, return_value="test")
     fake_resource = mocker.patch("grizzly.common.reporter.resource", autospec=True)
 
-    fake_report = mocker.Mock(spec=Report)
+    fake_report = mocker.Mock(spec_set=Report)
     fake_report.path = "no-path"
     reporter = S3FuzzManagerReporter("fake_bin")
     # test will missing rr-trace
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index a4b95ad9..15d759c7 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -26,15 +26,15 @@
 def test_runner_01(mocker, tmp_path):
     """test Runner()"""
     mocker.patch("grizzly.common.runner.time", autospec=True, side_effect=count())
-    server = mocker.Mock(spec=Sapphire)
-    target = mocker.Mock(spec=Target)
+    server = mocker.Mock(spec_set=Sapphire)
+    target = mocker.Mock(spec_set=Target)
     target.detect_failure.return_value = target.RESULT_NONE
     runner = Runner(server, target, relaunch=10)
     assert runner._idle is None
     assert runner._relaunch == 10
     assert runner._tests_run == 0
     serv_files = ["a.bin", "/another/file.bin"]
-    testcase = mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[])
+    testcase = mocker.Mock(spec_set=TestCase, landing_page=serv_files[0], optional=[])
     # all files served
     serv_map = ServerMap()
     server.serve_path.return_value = (SERVED_ALL, serv_files)
@@ -86,12 +86,12 @@ def test_runner_02(mocker):
     """test Runner.run() relaunch"""
     mocker.patch("grizzly.common.runner.time", autospec=True, return_value=1)
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    server = mocker.Mock(spec=Sapphire)
-    target = mocker.Mock(spec=Target)
+    server = mocker.Mock(spec_set=Sapphire)
+    target = mocker.Mock(spec_set=Target)
     target.detect_failure.return_value = target.RESULT_NONE
     serv_files = ["a.bin"]
     server.serve_path.return_value = (SERVED_ALL, serv_files)
-    testcase = mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[])
+    testcase = mocker.Mock(spec_set=TestCase, landing_page=serv_files[0], optional=[])
     # single run/iteration relaunch (not idle exit)
     target.is_idle.return_value = False
     runner = Runner(server, target, relaunch=1)
@@ -158,11 +158,11 @@ def test_runner_02(mocker):
 )
 def test_runner_03(mocker, srv_result, served):
     """test Runner() errors"""
-    server = mocker.Mock(spec=Sapphire)
+    server = mocker.Mock(spec_set=Sapphire)
     server.serve_path.return_value = (srv_result, served)
-    target = mocker.Mock(spec=Target)
+    target = mocker.Mock(spec_set=Target)
     target.detect_failure.return_value = target.RESULT_NONE
-    testcase = mocker.Mock(spec=TestCase, landing_page="x", optional=[])
+    testcase = mocker.Mock(spec_set=TestCase, landing_page="x", optional=[])
     runner = Runner(server, target)
     result = runner.run([], ServerMap(), testcase)
     assert result.status is None
@@ -186,9 +186,9 @@ def test_runner_03(mocker, srv_result, served):
 )
 def test_runner_04(mocker, ignore, status, idle, detect_failure):
     """test reporting timeout"""
-    server = mocker.Mock(spec=Sapphire)
-    target = mocker.Mock(spec=Target)
-    testcase = mocker.Mock(spec=TestCase, landing_page="a.bin", optional=[])
+    server = mocker.Mock(spec_set=Sapphire)
+    target = mocker.Mock(spec_set=Target)
+    testcase = mocker.Mock(spec_set=TestCase, landing_page="a.bin", optional=[])
     serv_files = ["a.bin", "/another/file.bin"]
     server.serve_path.return_value = (SERVED_TIMEOUT, serv_files)
     target.detect_failure.return_value = target.RESULT_FAILURE
@@ -218,14 +218,14 @@ def test_runner_04(mocker, ignore, status, idle, detect_failure):
 )
 def test_runner_05(mocker, served, attempted, target_result, status):
     """test reporting failures"""
-    server = mocker.Mock(spec=Sapphire)
+    server = mocker.Mock(spec_set=Sapphire)
     server.serve_path.return_value = (SERVED_REQUEST, served)
-    target = mocker.Mock(spec=Target, launch_timeout=10)
+    target = mocker.Mock(spec_set=Target, launch_timeout=10)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = target_result
     target.monitor.is_healthy.return_value = False
-    testcase = mocker.Mock(spec=TestCase, landing_page="a.bin", optional=[])
+    testcase = mocker.Mock(spec_set=TestCase, landing_page="a.bin", optional=[])
     runner = Runner(server, target)
     runner.launch("http://a/")
     result = runner.run([], ServerMap(), testcase)
@@ -238,8 +238,8 @@ def test_runner_05(mocker, served, attempted, target_result, status):
 
 def test_runner_06(mocker):
     """test Runner() with idle checking"""
-    server = mocker.Mock(spec=Sapphire)
-    target = mocker.Mock(spec=Target)
+    server = mocker.Mock(spec_set=Sapphire)
+    target = mocker.Mock(spec_set=Target)
     target.detect_failure.return_value = target.RESULT_NONE
     serv_files = ["/fake/file", "/another/file.bin"]
     server.serve_path.return_value = (SERVED_ALL, serv_files)
@@ -248,7 +248,7 @@ def test_runner_06(mocker):
     result = runner.run(
         [],
         ServerMap(),
-        mocker.Mock(spec=TestCase, landing_page=serv_files[0], optional=[]),
+        mocker.Mock(spec_set=TestCase, landing_page=serv_files[0], optional=[]),
     )
     assert result.status is None
     assert result.attempted
@@ -257,8 +257,8 @@ def test_runner_06(mocker):
 
 def test_runner_07(mocker):
     """test Runner._keep_waiting()"""
-    server = mocker.Mock(spec=Sapphire)
-    target = mocker.Mock(spec=Target)
+    server = mocker.Mock(spec_set=Sapphire)
+    target = mocker.Mock(spec_set=Target)
 
     target.monitor.is_healthy.return_value = True
     runner = Runner(server, target)
@@ -267,7 +267,7 @@ def test_runner_07(mocker):
     target.monitor.is_healthy.return_value = False
     assert not runner._keep_waiting()
 
-    runner._idle = mocker.Mock(spec=_IdleChecker)
+    runner._idle = mocker.Mock(spec_set=_IdleChecker)
     runner._idle.is_idle.return_value = False
     target.monitor.is_healthy.return_value = True
     assert runner._keep_waiting()
@@ -297,8 +297,8 @@ def test_runner_08():
 
 def test_runner_09(mocker):
     """test Runner.launch()"""
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, launch_timeout=30)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
+    target = mocker.Mock(spec_set=Target, launch_timeout=30)
     runner = Runner(server, target)
     # successful launch
     runner._tests_run = 1
@@ -307,7 +307,7 @@ def test_runner_09(mocker):
     assert target.launch.call_count == 1
     target.reset_mock()
     # target launch error
-    target.launch.side_effect = TargetLaunchError("test", mocker.Mock(spec=Report))
+    target.launch.side_effect = TargetLaunchError("test", mocker.Mock(spec_set=Report))
     with raises(TargetLaunchError, match="test"):
         runner.launch("http://a/")
     assert target.launch.call_count == 3
@@ -321,8 +321,8 @@ def test_runner_09(mocker):
 
 def test_runner_10(mocker, tmp_path):
     """test Runner.run() adding includes to testcase"""
-    server = mocker.Mock(spec=Sapphire)
-    target = mocker.Mock(spec=Target)
+    server = mocker.Mock(spec_set=Sapphire)
+    target = mocker.Mock(spec_set=Target)
     target.detect_failure.return_value = target.RESULT_NONE
     runner = Runner(server, target, relaunch=10)
     # create test files
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index e89229df..aa721db4 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -297,8 +297,8 @@ def _stop_early(_):
     try:
         mgr = ReduceManager(
             None,
-            mocker.Mock(spec=Sapphire, timeout=30),
-            mocker.Mock(spec=Target),
+            mocker.Mock(spec_set=Sapphire, timeout=30),
+            mocker.Mock(spec_set=Target),
             tests,
             None,
             log_path,
@@ -553,12 +553,11 @@ def replay_run(testcases, _time_limit, **_):
     tests = [test]
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec=Target)
-    target.relaunch = 1
+    target = mocker.Mock(spec_set=Target)
     try:
         mgr = ReduceManager(
             [],
-            mocker.Mock(spec=Sapphire, timeout=30),
+            mocker.Mock(spec_set=Sapphire, timeout=30),
             target,
             tests,
             strategies,
@@ -622,7 +621,7 @@ def replay_run(_tests, _time_limit, **_kw):
     assert testcases
     log_path = tmp_path / "logs"
 
-    fake_strat = mocker.MagicMock(spec=Strategy)
+    fake_strat = mocker.MagicMock(spec_set=Strategy)
     fake_strat.return_value.name = "fake"
 
     def fake_iter():
@@ -636,12 +635,11 @@ def fake_iter():
     fake_strat.return_value.__iter__.side_effect = fake_iter
     mocker.patch("grizzly.reduce.core.STRATEGIES", new={"fake": fake_strat})
 
-    target = mocker.Mock(spec=Target)
-    target.relaunch = 1
+    target = mocker.Mock(spec_set=Target)
     try:
         mgr = ReduceManager(
             [],
-            mocker.Mock(spec=Sapphire, timeout=30),
+            mocker.Mock(spec_set=Sapphire, timeout=30),
             target,
             testcases,
             ["fake"],
@@ -692,7 +690,7 @@ def replay_run(_tests, _time_limit, **_kw):
     assert testcases
     log_path = tmp_path / "logs"
 
-    fake_strat = mocker.MagicMock(spec=Strategy)
+    fake_strat = mocker.MagicMock(spec_set=Strategy)
     fake_strat.return_value.name = "fake"
 
     def fake_iter():
@@ -707,12 +705,11 @@ def fake_iter():
     fake_strat.return_value.__iter__.side_effect = fake_iter
     mocker.patch("grizzly.reduce.core.STRATEGIES", new={"fake": fake_strat})
 
-    target = mocker.Mock(spec=Target)
-    target.relaunch = 1
+    target = mocker.Mock(spec_set=Target)
     try:
         mgr = ReduceManager(
             [],
-            mocker.Mock(spec=Sapphire, timeout=30),
+            mocker.Mock(spec_set=Sapphire, timeout=30),
             target,
             testcases,
             ["fake"],
@@ -767,12 +764,11 @@ def replay_run(testcases, _time_limit, **_kw):
     reporter = mocker.patch("grizzly.reduce.core.FuzzManagerReporter")
     reporter.QUAL_REDUCED_RESULT = 0
     update_coll = mocker.patch("grizzly.common.fuzzmanager.Collector")
-    target = mocker.Mock(spec=Target)
-    target.relaunch = 1
+    target = mocker.Mock(spec_set=Target)
     try:
         mgr = ReduceManager(
             [],
-            mocker.Mock(spec=Sapphire, timeout=30),
+            mocker.Mock(spec_set=Sapphire, timeout=30),
             target,
             testcases,
             ["check", "lines"],
@@ -899,9 +895,8 @@ def replay_run(_testcases, _time_limit, **_):
     tests = [test]
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec=Target)
-    target.relaunch = 1
-    server = mocker.Mock(spec=Sapphire)
+    target = mocker.Mock(spec_set=Target)
+    server = mocker.Mock(spec_set=Sapphire)
     server.timeout = iter_input
     try:
         mgr = ReduceManager(
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index e09bb42b..e8f2af93 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -175,12 +175,11 @@ def replay_run(testcases, _time_limit, **_):
         tests.append(test)
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec=Target)
-    target.relaunch = 1
+    target = mocker.Mock(spec_set=Target)
     try:
         mgr = ReduceManager(
             [],
-            mocker.Mock(spec=Sapphire, timeout=30),
+            mocker.Mock(spec_set=Sapphire, timeout=30),
             target,
             tests,
             strategies,
@@ -355,12 +354,11 @@ def replay_run(testcases, _time_limit, **_):
         tests.append(test)
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec=Target)
-    target.relaunch = 1
+    target = mocker.Mock(spec_set=Target)
     try:
         mgr = ReduceManager(
             [],
-            mocker.Mock(spec=Sapphire, timeout=30),
+            mocker.Mock(spec_set=Sapphire, timeout=30),
             target,
             tests,
             strategies,
@@ -414,12 +412,11 @@ def replay_run(testcases, _time_limit, **_):
     tests = [test]
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec=Target)
-    target.relaunch = 1
+    target = mocker.Mock(spec_set=Target)
     try:
         mgr = ReduceManager(
             [],
-            mocker.Mock(spec=Sapphire, timeout=30),
+            mocker.Mock(spec_set=Sapphire, timeout=30),
             target,
             tests,
             ["lines"],
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 66403af0..bfb49819 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -2,7 +2,6 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-# pylint: disable=protected-access
 """
 unit tests for grizzly.replay.main
 """
@@ -97,7 +96,7 @@ def test_main_02(mocker, tmp_path):
     )
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_plugin")
-    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="bin", launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     load_target.return_value.return_value = target
@@ -191,9 +190,12 @@ def test_main_04(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.FuzzManagerReporter", autospec=True)
     mocker.patch("grizzly.replay.replay.Sapphire", autospec=True)
     mocker.patch("grizzly.replay.replay.TestCase", autospec=True)
-    target = mocker.Mock(spec=Target, launch_timeout=30)
-    load_target = mocker.patch("grizzly.replay.replay.load_plugin", autospec=True)
-    load_target.return_value.return_value = target
+    target = mocker.NonCallableMock(spec_set=Target, launch_timeout=30)
+    mocker.patch(
+        "grizzly.replay.replay.load_plugin",
+        autospec=True,
+        return_value=mocker.Mock(spec_set=Target, return_value=target),
+    )
     fake_tmp = tmp_path / "grz_tmp"
     fake_tmp.mkdir()
     mocker.patch(
@@ -219,7 +221,7 @@ def test_main_04(mocker, tmp_path):
     # target launch error
     fake_logs = tmp_path / "fake_report"
     fake_logs.mkdir()
-    report = mocker.Mock(spec=Report, prefix="fake_report", path=str(fake_logs))
+    report = mocker.Mock(spec_set=Report, prefix="fake_report", path=str(fake_logs))
     mocker.patch(
         "grizzly.replay.replay.ReplayManager.run",
         side_effect=TargetLaunchError("", report),
@@ -322,11 +324,14 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
         return_value=(SERVED_ALL, ["test.html"]),  # passed to Target.detect_failure
     )
     # setup Target
-    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
+    target = mocker.NonCallableMock(spec_set=Target, binary="bin", launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
-    load_target = mocker.patch("grizzly.replay.replay.load_plugin")
-    load_target.return_value.return_value = target
+    mocker.patch(
+        "grizzly.replay.replay.load_plugin",
+        autospec=True,
+        return_value=mocker.Mock(spec_set=Target, return_value=target),
+    )
     # create test to load
     with TestCase("test.html", None, None) as test:
         test_file = tmp_path / "test.html"
@@ -384,11 +389,14 @@ def test_main_07(mocker, tmp_path, pernosco, rr, valgrind, no_harness):
         return_value=(SERVED_ALL, ["test.html"]),  # passed to Target.detect_failure
     )
     # setup Target
-    load_target = mocker.patch("grizzly.replay.replay.load_plugin")
-    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
+    target = mocker.NonCallableMock(spec_set=Target, binary="bin", launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
-    load_target.return_value.return_value = target
+    load_target = mocker.patch(
+        "grizzly.replay.replay.load_plugin",
+        autospec=True,
+        return_value=mocker.Mock(spec_set=Target, return_value=target),
+    )
     # setup args
     (tmp_path / "test.html").touch()
     args = mocker.Mock(
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index aaa952b1..db448723 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -36,9 +36,12 @@ def _fake_save_logs(result_logs, _meta=False):
 def test_replay_01(mocker):
     """test ReplayManager.cleanup()"""
     replay = ReplayManager(
-        [], mocker.Mock(spec=Sapphire), mocker.Mock(spec=Target), [mocker.Mock()]
+        [],
+        mocker.Mock(spec_set=Sapphire),
+        mocker.Mock(spec_set=Target),
+        [mocker.Mock()],
     )
-    replay.status = mocker.Mock(spec=Status)
+    replay.status = mocker.Mock(spec_set=Status)
     replay.cleanup()
     assert replay.status.cleanup.call_count == 1
 
@@ -46,9 +49,9 @@ def test_replay_01(mocker):
 def test_replay_02(mocker, tmp_path):
     """test ReplayManager.run() - no repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     target.monitor.is_healthy.return_value = False
@@ -68,9 +71,9 @@ def test_replay_02(mocker, tmp_path):
 
 def test_replay_03(mocker):
     """test ReplayManager.run() - no repro - with repeats"""
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=False, launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, closed=False, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     target.monitor.is_healthy.return_value = False
@@ -97,9 +100,9 @@ def test_replay_04(mocker):
         new_callable=mocker.PropertyMock,
         return_value=0,
     )
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=False, launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, closed=False, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
@@ -119,9 +122,9 @@ def test_replay_05(mocker, tmp_path):
     """test ReplayManager.run() - successful repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     served = ["index.html"]
-    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_ALL, served)
-    target = mocker.Mock(spec=Target, binary="C:\\fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="C:\\fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
@@ -151,12 +154,14 @@ def test_replay_05(mocker, tmp_path):
 def test_replay_06(mocker, tmp_path):
     """test ReplayManager.run() - error - landing page not requested"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target, binary="bin", closed=True, launch_timeout=30)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
+    target = mocker.Mock(spec_set=Target, binary="bin", closed=True, launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        )
     ]
     # test target unresponsive
     target.detect_failure.return_value = Target.RESULT_NONE
@@ -189,8 +194,8 @@ def test_replay_07(mocker, tmp_path):
     """test ReplayManager.run()
     delayed failure - following test landing page not requested"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
-    target = mocker.Mock(spec=Target, binary="bin", launch_timeout=30)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
+    target = mocker.Mock(spec_set=Target, binary="bin", launch_timeout=30)
     type(target).closed = mocker.PropertyMock(side_effect=(True, False, True))
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
@@ -198,7 +203,9 @@ def test_replay_07(mocker, tmp_path):
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        )
     ]
     server.serve_path.side_effect = (
         (SERVED_ALL, ["index.html"]),
@@ -216,14 +223,16 @@ def test_replay_07(mocker, tmp_path):
 def test_replay_08(mocker, tmp_path):
     """test ReplayManager.run() - ignored"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = Target.RESULT_IGNORED
     target.monitor.is_healthy.return_value = False
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        )
     ]
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases, 10)
@@ -239,15 +248,17 @@ def test_replay_09(mocker, tmp_path):
     """test ReplayManager.run() - early exit"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="path/fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="path/fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
     target.save_logs = _fake_save_logs
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        )
     ]
     # early failure
     target.detect_failure.side_effect = (
@@ -310,32 +321,34 @@ def test_replay_10(mocker, tmp_path):
     mocker.patch(
         "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
     )
-    report_0 = mocker.Mock(spec=Report)
+    report_0 = mocker.Mock(spec_set=Report)
     report_0.crash_info.createShortSignature.return_value = "No crash detected"
     report_1 = mocker.Mock(
-        spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
+        spec_set=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
     )
     report_1.crash_info.createShortSignature.return_value = "[@ test1]"
     report_2 = mocker.Mock(
-        spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
+        spec_set=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
     )
     report_2.crash_info.createShortSignature.return_value = "[@ test2]"
     report_3 = mocker.Mock(
-        spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
+        spec_set=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
     )
     report_3.crash_info.createShortSignature.return_value = "[@ test2]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1, report_2, report_3)
     fake_report.calc_hash.return_value = "bucketHASH"
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, False, False)
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        )
     ]
     with ReplayManager(
         [], server, target, signature=signature, use_harness=False
@@ -363,26 +376,26 @@ def test_replay_11(mocker, tmp_path):
         "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
     )
     report_0 = mocker.Mock(
-        spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
+        spec_set=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
     )
     report_0.crash_info.createShortSignature.return_value = "[@ test1]"
     report_1 = mocker.Mock(
-        spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
+        spec_set=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
     )
     report_1.crash_info.createShortSignature.return_value = "[@ test2]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1)
     fake_report.calc_hash.return_value = "bucketHASH"
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["a.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, True)
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[])
+        mocker.Mock(spec_set=TestCase, env_vars=[], landing_page="a.html", optional=[])
     ]
     with ReplayManager(
         [], server, target, signature=signature, use_harness=False
@@ -407,26 +420,28 @@ def test_replay_12(mocker, tmp_path):
     mocker.patch(
         "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
     )
-    report_0 = mocker.Mock(spec=Report)
+    report_0 = mocker.Mock(spec_set=Report)
     report_0.crash_info.createShortSignature.return_value = "No crash detected"
     report_1 = mocker.Mock(
-        spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
+        spec_set=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
     )
     report_1.crash_info.createShortSignature.return_value = "[@ test1]"
     report_2 = mocker.Mock(
-        spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
+        spec_set=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
     )
     report_2.crash_info.createShortSignature.return_value = "[@ test2]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1, report_2)
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        )
     ]
     with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
         results = replay.run(testcases, 10, repeat=3, min_results=2)
@@ -449,28 +464,30 @@ def test_replay_13(mocker, tmp_path):
     mocker.patch(
         "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
     )
-    report_0 = mocker.Mock(spec=Report)
+    report_0 = mocker.Mock(spec_set=Report)
     report_0.crash_info.createShortSignature.return_value = "No crash detected"
     report_1 = mocker.Mock(
-        spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
+        spec_set=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
     )
     report_1.crash_info.createShortSignature.return_value = "[@ test1]"
     report_2 = mocker.Mock(
-        spec=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
+        spec_set=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
     )
     report_2.crash_info.createShortSignature.return_value = "[@ test2]"
-    report_3 = mocker.Mock(spec=Report)
+    report_3 = mocker.Mock(spec_set=Report)
     report_3.crash_info.createShortSignature.return_value = "No crash detected"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1, report_2, report_3)
-    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        )
     ]
     with ReplayManager([], server, target, any_crash=True) as replay:
         assert not replay.run(testcases, 10, repeat=4, min_results=3)
@@ -491,25 +508,33 @@ def test_replay_14(mocker, tmp_path):
     mocker.patch(
         "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
     )
-    report_1 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123", minor="9999")
+    report_1 = mocker.Mock(
+        spec_set=Report, crash_hash="hash1", major="0123", minor="9999"
+    )
     report_1.crash_info.createShortSignature.return_value = "[@ test1]"
     auto_sig = mocker.Mock()
     auto_sig.matches.side_effect = (True, False, True)
     report_1.crash_signature = auto_sig
-    report_2 = mocker.Mock(spec=Report, crash_hash="hash2", major="abcd", minor="9876")
+    report_2 = mocker.Mock(
+        spec_set=Report, crash_hash="hash2", major="abcd", minor="9876"
+    )
     report_2.crash_info.createShortSignature.return_value = "[@ test2]"
-    report_3 = mocker.Mock(spec=Report, crash_hash="hash1", major="0123", minor="9999")
+    report_3 = mocker.Mock(
+        spec_set=Report, crash_hash="hash1", major="0123", minor="9999"
+    )
     report_3.crash_info.createShortSignature.return_value = "[@ test1]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_1, report_2, report_3)
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        )
     ]
     with ReplayManager([], server, target, use_harness=False) as replay:
         results = replay.run(testcases, 10, repeat=3, min_results=2)
@@ -533,18 +558,20 @@ def test_replay_15(mocker, tmp_path):
         "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
     )
     report_0 = mocker.Mock(
-        spec=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
+        spec_set=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
     )
     report_0.crash_info.createShortSignature.return_value = "[@ test1]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0,)
-    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.side_effect = ((SERVED_ALL, ["index.html"]), KeyboardInterrupt)
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[])
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        )
     ]
     with ReplayManager(
         [], server, target, any_crash=True, use_harness=True, relaunch=2
@@ -564,15 +591,21 @@ def test_replay_15(mocker, tmp_path):
 def test_replay_16(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        ),
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        ),
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        ),
     ]
     with ReplayManager([], server, target, use_harness=True) as replay:
         assert not replay.run(testcases, 10)
@@ -585,18 +618,24 @@ def test_replay_16(mocker):
 
 def test_replay_17(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
-    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, launch_timeout=30)
     # test relaunch < repeat
     type(target).closed = mocker.PropertyMock(side_effect=cycle([True, False]))
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     target.monitor.is_healthy.return_value = False
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="index.html", optional=[]),
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        ),
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        ),
+        mocker.Mock(
+            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
+        ),
     ]
     with ReplayManager([], server, target, use_harness=True, relaunch=2) as replay:
         assert not replay.run(testcases, 10, repeat=10)
@@ -613,13 +652,13 @@ def test_replay_17(mocker):
 def test_replay_18(mocker, tmp_path):
     """test ReplayManager.run() - multiple TestCases - successful repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.side_effect = (
         (SERVED_ALL, ["a.html"]),
         (SERVED_ALL, ["b.html"]),
         (SERVED_ALL, ["c.html"]),
     )
-    target = mocker.Mock(spec=Target, binary="fake_bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.side_effect = (
@@ -630,9 +669,9 @@ def test_replay_18(mocker, tmp_path):
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     testcases = [
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="a.html", optional=[]),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="b.html", optional=[]),
-        mocker.Mock(spec=TestCase, env_vars=[], landing_page="c.html", optional=[]),
+        mocker.Mock(spec_set=TestCase, env_vars=[], landing_page="a.html", optional=[]),
+        mocker.Mock(spec_set=TestCase, env_vars=[], landing_page="b.html", optional=[]),
+        mocker.Mock(spec_set=TestCase, env_vars=[], landing_page="c.html", optional=[]),
     ]
     with ReplayManager([], server, target, use_harness=True) as replay:
         results = replay.run(testcases, 30)
@@ -653,9 +692,9 @@ def test_replay_19(mocker, tmp_path):
     """test ReplayManager.run() - multiple calls"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337, timeout=10)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (SERVED_ALL, ["index.html"])
-    target = mocker.Mock(spec=Target, closed=True, launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
@@ -677,26 +716,26 @@ def test_replay_20(mocker, tmp_path):
     # with reports and tests
     (tmp_path / "report_expected").mkdir()
     result0 = mocker.Mock(
-        ReplayResult, count=1, durations=[1], expected=True, served=[]
+        spec_set=ReplayResult, count=1, durations=[1], expected=True, served=[]
     )
     result0.report = mocker.Mock(
-        spec=Report, path=str(tmp_path / "report_expected"), prefix="expected"
+        spec_set=Report, path=str(tmp_path / "report_expected"), prefix="expected"
     )
     (tmp_path / "report_other1").mkdir()
     result1 = mocker.Mock(
-        ReplayResult, count=1, durations=[1], expected=False, served=None
+        spec_set=ReplayResult, count=1, durations=[1], expected=False, served=None
     )
     result1.report = mocker.Mock(
-        spec=Report, path=str(tmp_path / "report_other1"), prefix="other1"
+        spec_set=Report, path=str(tmp_path / "report_other1"), prefix="other1"
     )
     (tmp_path / "report_other2").mkdir()
     result2 = mocker.Mock(
-        ReplayResult, count=1, durations=[1], expected=False, served=None
+        spec_set=ReplayResult, count=1, durations=[1], expected=False, served=None
     )
     result2.report = mocker.Mock(
-        spec=Report, path=str(tmp_path / "report_other2"), prefix="other2"
+        spec_set=Report, path=str(tmp_path / "report_other2"), prefix="other2"
     )
-    test = mocker.Mock(spec=TestCase)
+    test = mocker.Mock(spec_set=TestCase)
     path = tmp_path / "dest"
     ReplayManager.report_to_filesystem(
         str(path), [result0, result1, result2], tests=[test]
@@ -723,7 +762,7 @@ def test_replay_20(mocker, tmp_path):
 
 def test_replay_21(mocker, tmp_path):
     """test ReplayManager.load_testcases()"""
-    fake_load = mocker.patch("grizzly.replay.replay.TestCase.load", autospec=True)
+    fake_load = mocker.patch("grizzly.replay.replay.TestCase.load")
     test0 = mocker.Mock(spec_set=TestCase)
     test0.pop_assets.return_value = None
     test1 = mocker.Mock(spec_set=TestCase, landing_page="x.html")
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index c5ab9ac2..97b4fad0 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -68,14 +68,14 @@ def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, verbose):
     fake_adapter.RELAUNCH = adpt_relaunch
     fake_adapter.TIME_LIMIT = 10
     fake_target = mocker.NonCallableMock(
-        spec_set=Target, assets=mocker.Mock(set_spec=AssetManager)
+        spec_set=Target, assets=mocker.Mock(spec_set=AssetManager)
     )
     plugin_loader = mocker.patch("grizzly.main.load_plugin", autospec=True)
     plugin_loader.side_effect = (
         mocker.Mock(spec_set=Adapter, return_value=fake_adapter),
         mocker.Mock(spec_set=Target, return_value=fake_target),
     )
-    fake_session = mocker.patch("grizzly.main.Session", autospec=True)
+    fake_session = mocker.patch("grizzly.main.Session", autospec_set=True)
     fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
     fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     args = FakeArgs()
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index fa5a6001..18ab78d2 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -68,7 +68,7 @@ def test_session_01(
     """test Session with typical fuzzer Adapter"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     mocker.patch("grizzly.common.status.time", side_effect=count(start=1.0, step=1.0))
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
         spec_set=Target,
         launch_timeout=30,
@@ -138,7 +138,7 @@ def test_session_01(
 def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
     """test Session with playback Adapter"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
         spec_set=Target,
         launch_timeout=30,
@@ -191,10 +191,10 @@ def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
     """test Session - detecting failure"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     adapter = SimpleAdapter(harness)
-    reporter = mocker.Mock(spec=Reporter)
-    report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    reporter = mocker.Mock(spec_set=Reporter)
+    report = mocker.Mock(spec_set=Report, major="major123", minor="minor456")
     report.crash_info.createShortSignature.return_value = "[@ sig]"
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
         spec_set=Target,
         launch_timeout=30,
@@ -236,7 +236,7 @@ def generate(self, _testcase, _server_map):
             pass
 
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_NONE, [])
     target = mocker.Mock(
         spec_set=Target,
@@ -252,7 +252,7 @@ def generate(self, _testcase, _server_map):
 def test_session_05(mocker, tmp_path):
     """test Target not requesting landing page"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (SERVED_TIMEOUT, [])
     target = mocker.Mock(
         spec_set=Target,
@@ -279,10 +279,10 @@ def test_session_05(mocker, tmp_path):
 def test_session_06(mocker, tmp_path, harness, report_size):
     """test Session - handle Target delayed failures"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
-    reporter = mocker.Mock(spec=Reporter)
-    report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    reporter = mocker.Mock(spec_set=Reporter)
+    report = mocker.Mock(spec_set=Report, major="major123", minor="minor456")
     report.crash_info.createShortSignature.return_value = "[@ sig]"
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
         spec_set=Target,
         launch_timeout=30,
@@ -325,10 +325,10 @@ def test_session_06(mocker, tmp_path, harness, report_size):
 def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, results):
     """test Session.run() - initial test case was not served"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
-    report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    report = mocker.Mock(spec_set=Report, major="major123", minor="minor456")
     report.crash_info.createShortSignature.return_value = "[@ sig]"
-    reporter = mocker.Mock(spec=Reporter)
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    reporter = mocker.Mock(spec_set=Reporter)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
         spec_set=Target,
         closed=True,
@@ -359,9 +359,9 @@ def test_session_08(tmp_path, mocker):
     result.attempted = True
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.run.return_value = result
-    adapter = mocker.Mock(spec=Adapter, remaining=None)
+    adapter = mocker.Mock(spec_set=Adapter, remaining=None)
     adapter.IGNORE_UNSERVED = False
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(spec_set=Target, assets=mocker.Mock(spec_set=AssetManager))
     target.monitor.launches = 1
     with Session(adapter, None, server, target) as session:
@@ -378,14 +378,14 @@ def test_session_08(tmp_path, mocker):
 def test_session_09(tmp_path, mocker):
     """test Session.run() handle TargetLaunchError"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
-    report = mocker.Mock(spec=Report, major="major123", minor="minor456")
+    report = mocker.Mock(spec_set=Report, major="major123", minor="minor456")
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.launch.side_effect = TargetLaunchError("test", report)
-    adapter = mocker.Mock(spec=Adapter, remaining=None)
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
-    target = mocker.Mock(spec=Target)
+    adapter = mocker.Mock(spec_set=Adapter, remaining=None)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
+    target = mocker.Mock(spec_set=Target)
     target.monitor.launches = 1
-    with Session(adapter, mocker.Mock(spec=Reporter), server, target) as session:
+    with Session(adapter, mocker.Mock(spec_set=Reporter), server, target) as session:
         with raises(TargetLaunchError, match="test"):
             session.run([], 10, iteration_limit=2)
         assert session.status.iteration == 1
@@ -400,10 +400,10 @@ def test_session_10(tmp_path, mocker):
     result.attempted = True
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.run.return_value = result
-    adapter = mocker.Mock(spec=Adapter, remaining=None)
-    report = mocker.Mock(spec=Report, major="major123", minor="minor456")
-    reporter = mocker.Mock(spec=Reporter)
-    server = mocker.Mock(spec=Sapphire, port=0x1337)
+    adapter = mocker.Mock(spec_set=Adapter, remaining=None)
+    report = mocker.Mock(spec_set=Report, major="major123", minor="minor456")
+    reporter = mocker.Mock(spec_set=Reporter)
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(spec_set=Target, assets=mocker.Mock(spec_set=AssetManager))
     target.monitor.launches = 1
     target.create_report.return_value = report
diff --git a/sapphire/test_connection_manager.py b/sapphire/test_connection_manager.py
index f99d7397..7df99e18 100644
--- a/sapphire/test_connection_manager.py
+++ b/sapphire/test_connection_manager.py
@@ -18,9 +18,9 @@ def test_connection_manager_01(mocker, tmp_path):
     """test basic ConnectionManager"""
     (tmp_path / "testfile").write_bytes(b"test")
     job = Job(str(tmp_path))
-    clnt_sock = mocker.Mock(spec=socket)
+    clnt_sock = mocker.Mock(spec_set=socket)
     clnt_sock.recv.return_value = b"GET /testfile HTTP/1.1"
-    serv_sock = mocker.Mock(spec=socket)
+    serv_sock = mocker.Mock(spec_set=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
     assert not job.is_complete()
     with ConnectionManager(job, serv_sock) as loadmgr:
@@ -36,7 +36,7 @@ def test_connection_manager_02(mocker):
     mocker.patch("sapphire.connection_manager.sleep", autospec=True)
     fake_thread = mocker.patch("sapphire.connection_manager.Thread", autospec=True)
     fake_thread.return_value.start.side_effect = ThreadError
-    job = mocker.Mock(spec=Job)
+    job = mocker.Mock(spec_set=Job)
     job.pending = True
     loadmgr = ConnectionManager(job, None)
     with raises(ThreadError):
@@ -51,7 +51,7 @@ def test_connection_manager_03(mocker, tmp_path):
     (tmp_path / "test2").touch()
     (tmp_path / "test3").touch()
     job = Job(str(tmp_path))
-    clnt_sock = mocker.Mock(spec=socket)
+    clnt_sock = mocker.Mock(spec_set=socket)
     clnt_sock.recv.side_effect = (
         b"GET /test1 HTTP/1.1",
         b"GET /missing HTTP/1.1",
@@ -62,7 +62,7 @@ def test_connection_manager_03(mocker, tmp_path):
         b"GET /test1 HTTP/1.1",
         b"GET /test3 HTTP/1.1",
     )
-    serv_sock = mocker.Mock(spec=socket)
+    serv_sock = mocker.Mock(spec_set=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
     assert not job.is_complete()
     with ConnectionManager(job, serv_sock, max_workers=2) as loadmgr:
@@ -75,9 +75,9 @@ def test_connection_manager_04(mocker, tmp_path):
     """test ConnectionManager.wait()"""
     (tmp_path / "test1").touch()
     job = Job(str(tmp_path))
-    clnt_sock = mocker.Mock(spec=socket)
+    clnt_sock = mocker.Mock(spec_set=socket)
     clnt_sock.recv.return_value = b""
-    serv_sock = mocker.Mock(spec=socket)
+    serv_sock = mocker.Mock(spec_set=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
     with ConnectionManager(job, serv_sock, max_workers=10) as loadmgr:
         # invalid callback
@@ -97,9 +97,9 @@ def test_connection_manager_05(mocker, tmp_path):
     """test ConnectionManager re-raise worker exceptions"""
     (tmp_path / "test1").touch()
     job = Job(str(tmp_path))
-    clnt_sock = mocker.Mock(spec=socket)
+    clnt_sock = mocker.Mock(spec_set=socket)
     clnt_sock.recv.side_effect = Exception("worker exception")
-    serv_sock = mocker.Mock(spec=socket)
+    serv_sock = mocker.Mock(spec_set=socket)
     serv_sock.accept.return_value = (clnt_sock, None)
     with raises(Exception, match="worker exception"):
         with ConnectionManager(job, serv_sock) as loadmgr:
@@ -113,7 +113,7 @@ def test_connection_manager_06(mocker, tmp_path):
     """test ConnectionManager re-raise launcher exceptions"""
     (tmp_path / "test1").touch()
     job = Job(str(tmp_path))
-    serv_sock = mocker.Mock(spec=socket)
+    serv_sock = mocker.Mock(spec_set=socket)
     serv_sock.accept.side_effect = Exception("launcher exception")
     with raises(Exception, match="launcher exception"):
         with ConnectionManager(job, serv_sock) as loadmgr:
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 4a155188..64088554 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -728,9 +728,9 @@ def test_sapphire_33(mocker):
     """test Sapphire.clear_backlog()"""
     mocker.patch("sapphire.core.socket", autospec=True)
     mocker.patch("sapphire.core.time", autospec=True, return_value=1)
-    pending = mocker.Mock(spec=socket.socket)
+    pending = mocker.Mock(spec_set=socket.socket)
     with Sapphire(timeout=10) as serv:
-        serv._socket = mocker.Mock(spec=socket.socket)
+        serv._socket = mocker.Mock(spec_set=socket.socket)
         serv._socket.accept.side_effect = ((pending, None), OSError, BlockingIOError)
         serv.clear_backlog()
         assert serv._socket.accept.call_count == 3
diff --git a/sapphire/test_worker.py b/sapphire/test_worker.py
index feb6ae92..8708ae35 100644
--- a/sapphire/test_worker.py
+++ b/sapphire/test_worker.py
@@ -15,9 +15,9 @@
 
 def test_worker_01(mocker):
     """test simple Worker in running state"""
-    wthread = mocker.Mock(spec=threading.Thread)
+    wthread = mocker.Mock(spec_set=threading.Thread)
     wthread.is_alive.return_value = True
-    worker = Worker(mocker.Mock(spec=socket.socket), wthread)
+    worker = Worker(mocker.Mock(spec_set=socket.socket), wthread)
     assert worker._conn is not None
     assert worker._thread is not None
     # it is assumed that launch() has already been called at this point
@@ -37,7 +37,9 @@ def test_worker_01(mocker):
 
 def test_worker_02(mocker):
     """test simple Worker fails to close"""
-    worker = Worker(mocker.Mock(spec=socket.socket), mocker.Mock(spec=threading.Thread))
+    worker = Worker(
+        mocker.Mock(spec_set=socket.socket), mocker.Mock(spec_set=threading.Thread)
+    )
     # it is assumed that launch() has already been called at this point
     worker._thread.is_alive.return_value = True
     with pytest.raises(WorkerError, match="Worker thread failed to join!"):
@@ -46,8 +48,8 @@ def test_worker_02(mocker):
 
 def test_worker_03(mocker):
     """test Worker.launch() fail cases"""
-    serv_con = mocker.Mock(spec=socket.socket)
-    serv_job = mocker.Mock(spec=Job)
+    serv_con = mocker.Mock(spec_set=socket.socket)
+    serv_job = mocker.Mock(spec_set=Job)
     fake_thread = mocker.patch("sapphire.worker.Thread", autospec=True)
     mocker.patch("sapphire.worker.sleep", autospec=True)
 
@@ -55,7 +57,7 @@ def test_worker_03(mocker):
     assert Worker.launch(serv_con, serv_job) is None
 
     serv_con.accept.side_effect = None
-    conn = mocker.Mock(spec=socket.socket)
+    conn = mocker.Mock(spec_set=socket.socket)
     serv_con.accept.return_value = (conn, None)
     fake_thread.side_effect = threading.ThreadError
     assert Worker.launch(serv_con, serv_job) is None
@@ -68,9 +70,9 @@ def test_worker_04(mocker, tmp_path):
     """test Worker.launch()"""
     (tmp_path / "testfile").touch()
     job = Job(str(tmp_path))
-    clnt_sock = mocker.Mock(spec=socket.socket)
+    clnt_sock = mocker.Mock(spec_set=socket.socket)
     clnt_sock.recv.return_value = b"GET /testfile HTTP/1.1"
-    serv_sock = mocker.Mock(spec=socket.socket)
+    serv_sock = mocker.Mock(spec_set=socket.socket)
     serv_sock.accept.return_value = (clnt_sock, None)
     worker = Worker.launch(serv_sock, job)
     assert worker is not None
@@ -85,9 +87,9 @@ def test_worker_04(mocker, tmp_path):
 
 def test_worker_05(mocker):
     """test Worker.handle_request() socket errors"""
-    serv_con = mocker.Mock(spec=socket.socket)
+    serv_con = mocker.Mock(spec_set=socket.socket)
     serv_con.recv.side_effect = socket.error
-    serv_job = mocker.Mock(spec=Job)
+    serv_job = mocker.Mock(spec_set=Job)
     Worker.handle_request(serv_con, serv_job)
     assert serv_job.accepting.set.call_count == 1
     assert serv_con.sendall.call_count == 0

From 3ba51708d3a50f1cc6c7b5ff41c68946569c3520 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 16 Jul 2021 13:41:40 -0700
Subject: [PATCH 287/531] Allow updating existing assets - Add additional
 checks when adding assets

---
 grizzly/common/storage.py       |   4 +-
 grizzly/target/__init__.py      |   2 +
 grizzly/target/puppet_target.py |  11 +--
 grizzly/target/target.py        | 116 +++++++++++++++++++++++++++-----
 grizzly/target/test_target.py   |  93 +++++++++++++++----------
 5 files changed, 167 insertions(+), 59 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index c18139eb..b915d9ab 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -16,7 +16,7 @@
 from zipfile import BadZipfile, ZipFile
 from zlib import error as zlib_error
 
-from ..target import AssetManager
+from ..target import AssetError, AssetManager
 from .utils import grz_tmp, sanitizer_opts
 
 __all__ = ("TestCase", "TestFile", "TestCaseLoadFailure", "TestFileExists")
@@ -433,7 +433,7 @@ def load_single(cls, path, adjacent=False, load_assets=True):
                         info.get("assets"),
                         pathjoin(path, info.get("assets_path", "")),
                     )
-            except OSError as exc:
+            except (AssetError, OSError) as exc:
                 raise TestCaseLoadFailure(str(exc)) from None
             # load environment variables
             try:
diff --git a/grizzly/target/__init__.py b/grizzly/target/__init__.py
index 705d7b5b..c8f5fb30 100644
--- a/grizzly/target/__init__.py
+++ b/grizzly/target/__init__.py
@@ -3,6 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from .target import (
+    AssetError,
     AssetManager,
     Target,
     TargetError,
@@ -11,6 +12,7 @@
 )
 
 __all__ = (
+    "AssetError",
     "AssetManager",
     "Target",
     "TargetError",
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index d9bea189..622239b8 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -12,7 +12,7 @@
     from signal import SIGUSR1
 except ImportError:
     SIGUSR1 = None
-from tempfile import mkdtemp
+from tempfile import TemporaryDirectory, mkdtemp
 from time import sleep, time
 
 from ffpuppet import BrowserTimeoutError, Debugger, FFPuppet, LaunchError, Reason
@@ -284,10 +284,11 @@ def process_assets(self):
             for template in PrefPicker.templates():
                 if template.endswith("browser-fuzzing.yml"):
                     LOG.debug("using prefpicker template %r", template)
-                    self._prefs = pathjoin(self.assets.path, "prefs.js")
-                    PrefPicker.load_template(template).create_prefsjs(self._prefs)
-                    LOG.debug("generated %r", self._prefs)
-                    self.assets.add("prefs", self._prefs)
+                    with TemporaryDirectory(dir=grz_tmp("target")) as tmp_path:
+                        prefs = pathjoin(tmp_path, "prefs.js")
+                        PrefPicker.load_template(template).create_prefsjs(prefs)
+                        LOG.debug("generated %r", prefs)
+                        self._prefs = self.assets.add("prefs", prefs, copy=False)
                     break
             else:  # pragma: no cover
                 raise TargetError("Failed to generate prefs.js")
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index b46b6d9e..d538f35d 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -5,21 +5,25 @@
 from abc import ABCMeta, abstractmethod, abstractproperty
 from logging import getLogger
 from os import makedirs, unlink
-from os.path import basename, dirname, exists, isdir, isfile
+from os.path import abspath, basename, exists, isdir, isfile
 from os.path import join as pathjoin
-from shutil import copyfile, copytree, rmtree
+from shutil import copyfile, copytree, move, rmtree
 from tempfile import mkdtemp
 from threading import Lock
 
 from ..common.utils import grz_tmp
 
-__all__ = ("Target", "TargetError", "TargetLaunchError")
+__all__ = ("AssetError", "AssetManager", "Target", "TargetError", "TargetLaunchError")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
 LOG = getLogger(__name__)
 
 
+class AssetError(Exception):
+    """Raised by AssetManager"""
+
+
 class AssetManager:
     __slots__ = ("assets", "path")
 
@@ -33,38 +37,81 @@ def __enter__(self):
     def __exit__(self, *exc):
         self.cleanup()
 
-    def add(self, asset, path):
+    def add(self, asset, path, copy=True):
+        """Add asset to the AssetManager.
+
+        Args:
+            asset (str): Name of asset.
+            path (str): Path of content to use as asset.
+            copy (bool): Copy or move the content.
+
+        Returns:
+            str: Path to the asset on the filesystem.
+        """
         assert isinstance(asset, str)
+        assert isinstance(path, str)
         assert self.path, "cleanup() was called"
-        if not path or not exists(path):
-            raise OSError("Asset %r not found %r" % (asset, path))
-        assert asset not in self.assets
+        if not exists(path):
+            raise OSError("%r does not exist" % (path,))
+        path = abspath(path)
         # only copy files from outside working path
-        if dirname(path) != self.path:
-            # check file name collision
-            dst_path = pathjoin(self.path, basename(path))
-            if exists(dst_path):
-                raise OSError("Name collision in asset path %r" % (basename(path),))
+        if path.startswith(self.path):
+            raise AssetError("Cannot add existing asset content %r" % (path,))
+        # remove existing asset with the same name
+        if asset in self.assets:
+            LOG.debug("asset %r exists, removing existing", asset)
+            self.remove(asset)
+        dst_path = pathjoin(self.path, basename(path))
+        # check file name collision
+        if exists(dst_path):
+            raise AssetError("%r is an existing asset" % (basename(path),))
+        if copy:
             if isfile(path):
                 copyfile(path, dst_path)
             else:
                 copytree(path, dst_path)
-            self.assets[asset] = dst_path
         else:
-            self.assets[asset] = path
-        LOG.debug("added asset %r from %r", asset, path)
+            move(path, self.path)
+        self.assets[asset] = dst_path
+        LOG.debug("added asset %r %s to %r", asset, "copied" if copy else "moved", path)
+        return dst_path
 
     def add_batch(self, assets):
+        """Add collection of assets to the AssetManager.
+
+        Args:
+            assets (list(list(str, str))): List of list that contain asset, path pairs.
+
+        Returns:
+            None
+        """
         for asset, path in assets:
             self.add(asset, path)
 
     def cleanup(self):
+        """Remove asset files from filesystem.
+
+        Args:
+            None
+
+        Returns:
+            None
+        """
         if self.path:
             rmtree(self.path, ignore_errors=True)
             self.assets.clear()
             self.path = None
 
     def dump(self, dst_path, subdir="_assets_"):
+        """Copy assets content to a given path.
+
+        Args:
+            dst_path (str): Path to copy assets content to.
+            subdir (str): Create and use as destination if given.
+
+        Returns:
+            dict: Collection asset paths keyed by asset name.
+        """
         dumped = dict()
         if self.assets:
             if subdir:
@@ -83,19 +130,54 @@ def dump(self, dst_path, subdir="_assets_"):
         return dumped
 
     def get(self, asset):
+        """Get path to content on filesystem for given asset.
+
+        Args:
+            asset (str): Asset to lookup.
+
+        Returns:
+            str: Path to asset content or None if asset does not exist.
+        """
         return self.assets.get(asset, None)
 
     def is_empty(self):
+        """Check if AssetManager contains entries.
+
+        Args:
+            None
+
+        Returns:
+            bool: True if AssetManager contains entries else False.
+        """
         return not self.assets
 
     @classmethod
-    def load(cls, assets, src_path):
-        obj = cls()
+    def load(cls, assets, src_path, base_path=None):
+        """Load assets from filesystem.
+
+        Args:
+            asset (dict): Asset paths on filesystem relative to src_path, key on
+                          asset name.
+            src_path (str): Path to scan for assets.
+            base_path (str): Base path to use to create local storage.
+
+        Returns:
+            AssetManager: Populated with contents provided by assets argument.
+        """
+        obj = cls(base_path=base_path)
         for asset, src_name in assets.items():
             obj.add(asset, pathjoin(src_path, src_name))
         return obj
 
     def remove(self, asset):
+        """Remove asset from AssetManager if asset exists.
+
+        Args:
+            asset (str): Asset to remove.
+
+        Returns:
+            None
+        """
         path = self.assets.pop(asset, None)
         if path:
             if isfile(path):
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index 08c5712b..1517f558 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -8,7 +8,7 @@
 
 from pytest import raises
 
-from .target import AssetManager, Target
+from .target import AssetError, AssetManager, Target
 
 
 class SimpleTarget(Target):
@@ -71,26 +71,25 @@ def test_target_01(tmp_path):
         target.reverse(1, 2)
 
 
-def test_assert_manager_01(tmp_path):
+def test_asset_manager_01(tmp_path):
     """test AssetManager()"""
     with AssetManager(base_path=str(tmp_path)) as assets:
         assert not assets.assets
         assert assets.path
-        # get missing
-        assert assets.get("missing") is None
-        # add missing file
-        with raises(OSError, match="Asset 'a' not found 'p'"):
-            assets.add("a", "p")
-        assert not assets.assets
-        # remove invalid asset
-        assets.remove("missing")
-        # add file
+        assert assets.is_empty()
+        # add file (move)
         example = tmp_path / "example.txt"
         example.write_text("example")
-        assets.add("example_file", str(example))
+        asset_location = assets.add("example_file", str(example), copy=False)
+        assert str(Path(assets.path) / "example.txt") == asset_location
         assert len(assets.assets) == 1
-        example.unlink()
-        assert any(tmp_path.glob("**/example.txt"))
+        assert not assets.is_empty()
+        assert not example.is_file()
+        assert any(Path(assets.path).glob("**/example.txt"))
+        # add existing asset - update asset (copy)
+        example.write_text("example")
+        assets.add("example_file", str(example))
+        assert example.is_file()
         # add directory
         example = tmp_path / "example_path"
         example.mkdir()
@@ -100,8 +99,8 @@ def test_assert_manager_01(tmp_path):
         (example / "b" / "2.txt").write_text("2")
         assets.add("example_path", str(example))
         rmtree(str(example))
-        assert any(tmp_path.glob("**/example_path/a/1.txt"))
-        assert any(tmp_path.glob("**/example_path/b/2.txt"))
+        assert any(Path(assets.path).glob("**/example_path/a/1.txt"))
+        assert any(Path(assets.path).glob("**/example_path/b/2.txt"))
         assert len(assets.assets) == 2
         # get
         assert "example.txt" in assets.get("example_file")
@@ -109,37 +108,59 @@ def test_assert_manager_01(tmp_path):
         # remove directory
         assets.remove("example_path")
         assert len(assets.assets) == 1
-        assert not any(tmp_path.glob("**/example_path"))
+        assert not any(Path(assets.path).glob("**/example_path"))
         # remove file
         assets.remove("example_file")
         assert len(assets.assets) == 0
-        assert not any(tmp_path.glob("**/example.txt"))
         assert not any(Path(assets.path).iterdir())
-        # add in working path
-        example = Path(assets.path) / "example.txt"
-        example.write_text("test")
-        assets.add("direct", str(example))
-        # add existing
-        example = tmp_path / "example.txt"
-        example.write_text("example")
-        with raises(OSError, match="Name collision in asset path"):
-            assets.add("example_file", str(example))
         # cleanup
         assets.cleanup()
         assert not assets.assets
         assert assets.path is None
 
 
-def test_assert_manager_02(tmp_path):
+def test_asset_manager_02(tmp_path):
+    """test AssetManager() failures"""
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        # get missing
+        assert assets.get("missing") is None
+        # add missing file
+        with raises(OSError, match="'missing' does not exist"):
+            assets.add("a", "missing")
+        assert not assets.assets
+        # remove invalid asset
+        assets.remove("missing")
+        # add file
+        example = tmp_path / "example.txt"
+        example.write_text("example")
+        assets.add("example_file", str(example), copy=True)
+        # add existing file under as different asset (collision)
+        with raises(AssetError, match="'example.txt' is an existing asset"):
+            assets.add("collide", str(example))
+        assert "collide" not in assets.assets
+        example.unlink()
+        # add file from existing asset
+        example = Path(assets.path) / "example.txt"
+        with raises(AssetError, match="Cannot add existing asset content"):
+            assets.add("existing", str(example))
+        assert "existing" not in assets.assets
+        # add file from existing asset with asset name collision
+        example = Path(assets.path) / "example.txt"
+        with raises(AssetError, match="Cannot add existing asset content"):
+            assets.add("example_file", str(example))
+        assert "example_file" in assets.assets
+
+
+def test_asset_manager_03(tmp_path):
     """test AssetManager() dump/load"""
     # test dump()
     with AssetManager(base_path=str(tmp_path)) as assets:
         # add file
-        example = Path(assets.path) / "example.txt"
+        example = tmp_path / "example.txt"
         example.write_text("example")
-        assets.add("example_file", str(example))
+        assets.add("example_file", str(example), copy=False)
         # add directory
-        example = Path(assets.path) / "example_path"
+        example = tmp_path / "example_path"
         example.mkdir()
         (example / "a").mkdir()
         (example / "a" / "1.txt").write_text("1")
@@ -153,21 +174,23 @@ def test_assert_manager_02(tmp_path):
     assert (dump_path / "sub" / "example.txt").is_file()
     assert (dump_path / "sub" / "example_path" / "a" / "1.txt").is_file()
     # test load()
-    with AssetManager.load(dumped, str(dump_path / "sub")) as assets:
+    with AssetManager.load(
+        dumped, str(dump_path / "sub"), base_path=str(tmp_path)
+    ) as assets:
         assert len(assets.assets) == 2
         assert isfile(assets.assets["example_file"])
 
 
-def test_assert_manager_03(tmp_path):
+def test_asset_manager_04(tmp_path):
     """test AssetManager.add_batch()"""
     batch = list()
     with AssetManager(base_path=str(tmp_path)) as assets:
         # add file
-        example = Path(assets.path) / "example.txt"
+        example = tmp_path / "example.txt"
         example.write_text("example")
         batch.append(["example_file", str(example)])
         # add directory
-        example = Path(assets.path) / "example_path"
+        example = tmp_path / "example_path"
         example.mkdir()
         (example / "a").mkdir()
         (example / "a" / "1.txt").write_text("1")

From a64fc17aa297c361c636f255d4200d174d0a7fee Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 19 Jul 2021 13:34:47 -0700
Subject: [PATCH 288/531] Move AssetManager to assets.py

---
 grizzly/target/__init__.py    |  10 +-
 grizzly/target/assets.py      | 182 ++++++++++++++++++++++++++++++++++
 grizzly/target/target.py      | 175 +-------------------------------
 grizzly/target/test_assets.py | 138 ++++++++++++++++++++++++++
 grizzly/target/test_target.py | 138 +-------------------------
 5 files changed, 327 insertions(+), 316 deletions(-)
 create mode 100644 grizzly/target/assets.py
 create mode 100644 grizzly/target/test_assets.py

diff --git a/grizzly/target/__init__.py b/grizzly/target/__init__.py
index c8f5fb30..4d94fa81 100644
--- a/grizzly/target/__init__.py
+++ b/grizzly/target/__init__.py
@@ -2,14 +2,8 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from .target import (
-    AssetError,
-    AssetManager,
-    Target,
-    TargetError,
-    TargetLaunchError,
-    TargetLaunchTimeout,
-)
+from .assets import AssetError, AssetManager
+from .target import Target, TargetError, TargetLaunchError, TargetLaunchTimeout
 
 __all__ = (
     "AssetError",
diff --git a/grizzly/target/assets.py b/grizzly/target/assets.py
new file mode 100644
index 00000000..5712ef28
--- /dev/null
+++ b/grizzly/target/assets.py
@@ -0,0 +1,182 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from logging import getLogger
+from os import makedirs, unlink
+from os.path import abspath, basename, exists, isdir, isfile
+from os.path import join as pathjoin
+from shutil import copyfile, copytree, move, rmtree
+from tempfile import mkdtemp
+
+__all__ = ("AssetError", "AssetManager")
+__author__ = "Tyson Smith"
+__credits__ = ["Tyson Smith"]
+
+LOG = getLogger(__name__)
+
+
+class AssetError(Exception):
+    """Raised by AssetManager"""
+
+
+class AssetManager:
+    __slots__ = ("assets", "path")
+
+    def __init__(self, base_path=None):
+        self.assets = dict()
+        self.path = mkdtemp(prefix="assets_", dir=base_path)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.cleanup()
+
+    def add(self, asset, path, copy=True):
+        """Add asset to the AssetManager.
+
+        Args:
+            asset (str): Name of asset.
+            path (str): Path of content to use as asset.
+            copy (bool): Copy or move the content.
+
+        Returns:
+            str: Path to the asset on the filesystem.
+        """
+        assert isinstance(asset, str)
+        assert isinstance(path, str)
+        assert self.path, "cleanup() was called"
+        if not exists(path):
+            raise OSError("%r does not exist" % (path,))
+        path = abspath(path)
+        # only copy files from outside working path
+        if path.startswith(self.path):
+            raise AssetError("Cannot add existing asset content %r" % (path,))
+        # remove existing asset with the same name
+        if asset in self.assets:
+            LOG.debug("asset %r exists, removing existing", asset)
+            self.remove(asset)
+        dst_path = pathjoin(self.path, basename(path))
+        # avoid overwriting data that is part of an existing asset
+        if exists(dst_path):
+            raise AssetError("%r is an existing asset" % (basename(path),))
+        if copy:
+            if isfile(path):
+                copyfile(path, dst_path)
+            else:
+                copytree(path, dst_path)
+        else:
+            move(path, self.path)
+        self.assets[asset] = dst_path
+        LOG.debug("added asset %r %s to %r", asset, "copied" if copy else "moved", path)
+        return dst_path
+
+    def add_batch(self, assets):
+        """Add collection of assets to the AssetManager.
+
+        Args:
+            assets (list(list(str, str))): List of list that contain asset, path pairs.
+
+        Returns:
+            None
+        """
+        for asset, path in assets:
+            self.add(asset, path)
+
+    def cleanup(self):
+        """Remove asset files from filesystem.
+
+        Args:
+            None
+
+        Returns:
+            None
+        """
+        if self.path:
+            rmtree(self.path, ignore_errors=True)
+            self.assets.clear()
+            self.path = None
+
+    def dump(self, dst_path, subdir="_assets_"):
+        """Copy assets content to a given path.
+
+        Args:
+            dst_path (str): Path to copy assets content to.
+            subdir (str): Create and use as destination if given.
+
+        Returns:
+            dict: Collection asset paths keyed by asset name.
+        """
+        dumped = dict()
+        if self.assets:
+            if subdir:
+                dst_path = pathjoin(dst_path, subdir)
+            makedirs(dst_path, exist_ok=not subdir)
+            for asset, src in self.assets.items():
+                dst_name = basename(src)
+                dumped[asset] = dst_name
+                if isfile(src):
+                    copyfile(src, pathjoin(dst_path, dst_name))
+                elif isdir(src):
+                    copytree(src, pathjoin(dst_path, dst_name))
+                else:
+                    dumped.pop(asset)
+                    LOG.warning("Failed to dump asset %r from %r", asset, src)
+        return dumped
+
+    def get(self, asset):
+        """Get path to content on filesystem for given asset.
+
+        Args:
+            asset (str): Asset to lookup.
+
+        Returns:
+            str: Path to asset content or None if asset does not exist.
+        """
+        return self.assets.get(asset, None)
+
+    def is_empty(self):
+        """Check if AssetManager contains entries.
+
+        Args:
+            None
+
+        Returns:
+            bool: True if AssetManager contains entries else False.
+        """
+        return not self.assets
+
+    @classmethod
+    def load(cls, assets, src_path, base_path=None):
+        """Load assets from filesystem.
+
+        Args:
+            asset (dict): Asset paths on filesystem relative to src_path, keyed on
+                          asset name.
+            src_path (str): Path to scan for assets.
+            base_path (str): Base path to use to create local storage.
+
+        Returns:
+            AssetManager: Populated with contents provided by assets argument.
+        """
+        obj = cls(base_path=base_path)
+        for asset, src_name in assets.items():
+            obj.add(asset, pathjoin(src_path, src_name))
+        return obj
+
+    def remove(self, asset):
+        """Remove asset from AssetManager if asset exists.
+
+        Args:
+            asset (str): Asset to remove.
+
+        Returns:
+            None
+        """
+        path = self.assets.pop(asset, None)
+        if path:
+            if isfile(path):
+                unlink(path)
+            else:
+                rmtree(path, ignore_errors=True)
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index d538f35d..5af98425 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -4,188 +4,19 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from abc import ABCMeta, abstractmethod, abstractproperty
 from logging import getLogger
-from os import makedirs, unlink
-from os.path import abspath, basename, exists, isdir, isfile
-from os.path import join as pathjoin
-from shutil import copyfile, copytree, move, rmtree
-from tempfile import mkdtemp
+from os.path import isfile
 from threading import Lock
 
 from ..common.utils import grz_tmp
+from .assets import AssetManager
 
-__all__ = ("AssetError", "AssetManager", "Target", "TargetError", "TargetLaunchError")
+__all__ = ("Target", "TargetError", "TargetLaunchError")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
 LOG = getLogger(__name__)
 
 
-class AssetError(Exception):
-    """Raised by AssetManager"""
-
-
-class AssetManager:
-    __slots__ = ("assets", "path")
-
-    def __init__(self, base_path=None):
-        self.assets = dict()
-        self.path = mkdtemp(prefix="assets_", dir=base_path)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *exc):
-        self.cleanup()
-
-    def add(self, asset, path, copy=True):
-        """Add asset to the AssetManager.
-
-        Args:
-            asset (str): Name of asset.
-            path (str): Path of content to use as asset.
-            copy (bool): Copy or move the content.
-
-        Returns:
-            str: Path to the asset on the filesystem.
-        """
-        assert isinstance(asset, str)
-        assert isinstance(path, str)
-        assert self.path, "cleanup() was called"
-        if not exists(path):
-            raise OSError("%r does not exist" % (path,))
-        path = abspath(path)
-        # only copy files from outside working path
-        if path.startswith(self.path):
-            raise AssetError("Cannot add existing asset content %r" % (path,))
-        # remove existing asset with the same name
-        if asset in self.assets:
-            LOG.debug("asset %r exists, removing existing", asset)
-            self.remove(asset)
-        dst_path = pathjoin(self.path, basename(path))
-        # check file name collision
-        if exists(dst_path):
-            raise AssetError("%r is an existing asset" % (basename(path),))
-        if copy:
-            if isfile(path):
-                copyfile(path, dst_path)
-            else:
-                copytree(path, dst_path)
-        else:
-            move(path, self.path)
-        self.assets[asset] = dst_path
-        LOG.debug("added asset %r %s to %r", asset, "copied" if copy else "moved", path)
-        return dst_path
-
-    def add_batch(self, assets):
-        """Add collection of assets to the AssetManager.
-
-        Args:
-            assets (list(list(str, str))): List of list that contain asset, path pairs.
-
-        Returns:
-            None
-        """
-        for asset, path in assets:
-            self.add(asset, path)
-
-    def cleanup(self):
-        """Remove asset files from filesystem.
-
-        Args:
-            None
-
-        Returns:
-            None
-        """
-        if self.path:
-            rmtree(self.path, ignore_errors=True)
-            self.assets.clear()
-            self.path = None
-
-    def dump(self, dst_path, subdir="_assets_"):
-        """Copy assets content to a given path.
-
-        Args:
-            dst_path (str): Path to copy assets content to.
-            subdir (str): Create and use as destination if given.
-
-        Returns:
-            dict: Collection asset paths keyed by asset name.
-        """
-        dumped = dict()
-        if self.assets:
-            if subdir:
-                dst_path = pathjoin(dst_path, subdir)
-            makedirs(dst_path, exist_ok=not subdir)
-            for asset, src in self.assets.items():
-                dst_name = basename(src)
-                dumped[asset] = dst_name
-                if isfile(src):
-                    copyfile(src, pathjoin(dst_path, dst_name))
-                elif isdir(src):
-                    copytree(src, pathjoin(dst_path, dst_name))
-                else:
-                    dumped.pop(asset)
-                    LOG.warning("Failed to dump asset %r from %r", asset, src)
-        return dumped
-
-    def get(self, asset):
-        """Get path to content on filesystem for given asset.
-
-        Args:
-            asset (str): Asset to lookup.
-
-        Returns:
-            str: Path to asset content or None if asset does not exist.
-        """
-        return self.assets.get(asset, None)
-
-    def is_empty(self):
-        """Check if AssetManager contains entries.
-
-        Args:
-            None
-
-        Returns:
-            bool: True if AssetManager contains entries else False.
-        """
-        return not self.assets
-
-    @classmethod
-    def load(cls, assets, src_path, base_path=None):
-        """Load assets from filesystem.
-
-        Args:
-            asset (dict): Asset paths on filesystem relative to src_path, key on
-                          asset name.
-            src_path (str): Path to scan for assets.
-            base_path (str): Base path to use to create local storage.
-
-        Returns:
-            AssetManager: Populated with contents provided by assets argument.
-        """
-        obj = cls(base_path=base_path)
-        for asset, src_name in assets.items():
-            obj.add(asset, pathjoin(src_path, src_name))
-        return obj
-
-    def remove(self, asset):
-        """Remove asset from AssetManager if asset exists.
-
-        Args:
-            asset (str): Asset to remove.
-
-        Returns:
-            None
-        """
-        path = self.assets.pop(asset, None)
-        if path:
-            if isfile(path):
-                unlink(path)
-            else:
-                rmtree(path, ignore_errors=True)
-
-
 class TargetError(Exception):
     """Raised by Target"""
 
diff --git a/grizzly/target/test_assets.py b/grizzly/target/test_assets.py
new file mode 100644
index 00000000..2345ee8a
--- /dev/null
+++ b/grizzly/target/test_assets.py
@@ -0,0 +1,138 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from os.path import isfile
+from pathlib import Path
+from shutil import rmtree
+
+from pytest import raises
+
+from .assets import AssetError, AssetManager
+
+
+def test_asset_manager_01(tmp_path):
+    """test AssetManager()"""
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        assert not assets.assets
+        assert assets.path
+        assert assets.is_empty()
+        # add file (move)
+        example = tmp_path / "example.txt"
+        example.write_text("example")
+        asset_location = assets.add("example_file", str(example), copy=False)
+        assert str(Path(assets.path) / "example.txt") == asset_location
+        assert len(assets.assets) == 1
+        assert not assets.is_empty()
+        assert not example.is_file()
+        assert any(Path(assets.path).glob("**/example.txt"))
+        # add existing asset - update asset (copy)
+        example.write_text("example")
+        assets.add("example_file", str(example))
+        assert example.is_file()
+        # add directory
+        example = tmp_path / "example_path"
+        example.mkdir()
+        (example / "a").mkdir()
+        (example / "a" / "1.txt").write_text("1")
+        (example / "b").mkdir()
+        (example / "b" / "2.txt").write_text("2")
+        assets.add("example_path", str(example))
+        rmtree(str(example))
+        assert any(Path(assets.path).glob("**/example_path/a/1.txt"))
+        assert any(Path(assets.path).glob("**/example_path/b/2.txt"))
+        assert len(assets.assets) == 2
+        # get
+        assert "example.txt" in assets.get("example_file")
+        assert "example_path" in assets.get("example_path")
+        # remove directory
+        assets.remove("example_path")
+        assert len(assets.assets) == 1
+        assert not any(Path(assets.path).glob("**/example_path"))
+        # remove file
+        assets.remove("example_file")
+        assert len(assets.assets) == 0
+        assert not any(Path(assets.path).iterdir())
+        # cleanup
+        assets.cleanup()
+        assert not assets.assets
+        assert assets.path is None
+
+
+def test_asset_manager_02(tmp_path):
+    """test AssetManager() failures"""
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        # get missing
+        assert assets.get("missing") is None
+        # add missing file
+        with raises(OSError, match="'missing' does not exist"):
+            assets.add("a", "missing")
+        assert not assets.assets
+        # remove invalid asset
+        assets.remove("missing")
+        # add file
+        example = tmp_path / "example.txt"
+        example.write_text("example")
+        assets.add("example_file", str(example), copy=True)
+        # add existing file under as different asset (collision)
+        with raises(AssetError, match="'example.txt' is an existing asset"):
+            assets.add("collide", str(example))
+        assert "collide" not in assets.assets
+        example.unlink()
+        # add file from existing asset
+        example = Path(assets.path) / "example.txt"
+        with raises(AssetError, match="Cannot add existing asset content"):
+            assets.add("existing", str(example))
+        assert "existing" not in assets.assets
+        # add file from existing asset with asset name collision
+        example = Path(assets.path) / "example.txt"
+        with raises(AssetError, match="Cannot add existing asset content"):
+            assets.add("example_file", str(example))
+        assert "example_file" in assets.assets
+
+
+def test_asset_manager_03(tmp_path):
+    """test AssetManager() dump/load"""
+    # test dump()
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        # add file
+        example = tmp_path / "example.txt"
+        example.write_text("example")
+        assets.add("example_file", str(example), copy=False)
+        # add directory
+        example = tmp_path / "example_path"
+        example.mkdir()
+        (example / "a").mkdir()
+        (example / "a" / "1.txt").write_text("1")
+        assets.add("example_path", str(example))
+        # invalid entry
+        assets.assets["invalid"] = "bad/path"
+        # dump
+        dump_path = tmp_path / "dump"
+        dumped = assets.dump(str(dump_path), subdir="sub")
+    assert len(dumped) == 2
+    assert (dump_path / "sub" / "example.txt").is_file()
+    assert (dump_path / "sub" / "example_path" / "a" / "1.txt").is_file()
+    # test load()
+    with AssetManager.load(
+        dumped, str(dump_path / "sub"), base_path=str(tmp_path)
+    ) as assets:
+        assert len(assets.assets) == 2
+        assert isfile(assets.assets["example_file"])
+
+
+def test_asset_manager_04(tmp_path):
+    """test AssetManager.add_batch()"""
+    batch = list()
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        # add file
+        example = tmp_path / "example.txt"
+        example.write_text("example")
+        batch.append(["example_file", str(example)])
+        # add directory
+        example = tmp_path / "example_path"
+        example.mkdir()
+        (example / "a").mkdir()
+        (example / "a" / "1.txt").write_text("1")
+        batch.append(["example_path", str(example)])
+        assets.add_batch(batch)
+        assert len(assets.assets) == 2
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index 1517f558..dd66d8bb 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -1,14 +1,8 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-from os.path import isfile
-from pathlib import Path
-from shutil import rmtree
-
-from pytest import raises
-
-from .target import AssetError, AssetManager, Target
+from .assets import AssetManager
+from .target import Target
 
 
 class SimpleTarget(Target):
@@ -69,131 +63,3 @@ def test_target_01(tmp_path):
         target.add_abort_token("none!")
         target.dump_coverage()
         target.reverse(1, 2)
-
-
-def test_asset_manager_01(tmp_path):
-    """test AssetManager()"""
-    with AssetManager(base_path=str(tmp_path)) as assets:
-        assert not assets.assets
-        assert assets.path
-        assert assets.is_empty()
-        # add file (move)
-        example = tmp_path / "example.txt"
-        example.write_text("example")
-        asset_location = assets.add("example_file", str(example), copy=False)
-        assert str(Path(assets.path) / "example.txt") == asset_location
-        assert len(assets.assets) == 1
-        assert not assets.is_empty()
-        assert not example.is_file()
-        assert any(Path(assets.path).glob("**/example.txt"))
-        # add existing asset - update asset (copy)
-        example.write_text("example")
-        assets.add("example_file", str(example))
-        assert example.is_file()
-        # add directory
-        example = tmp_path / "example_path"
-        example.mkdir()
-        (example / "a").mkdir()
-        (example / "a" / "1.txt").write_text("1")
-        (example / "b").mkdir()
-        (example / "b" / "2.txt").write_text("2")
-        assets.add("example_path", str(example))
-        rmtree(str(example))
-        assert any(Path(assets.path).glob("**/example_path/a/1.txt"))
-        assert any(Path(assets.path).glob("**/example_path/b/2.txt"))
-        assert len(assets.assets) == 2
-        # get
-        assert "example.txt" in assets.get("example_file")
-        assert "example_path" in assets.get("example_path")
-        # remove directory
-        assets.remove("example_path")
-        assert len(assets.assets) == 1
-        assert not any(Path(assets.path).glob("**/example_path"))
-        # remove file
-        assets.remove("example_file")
-        assert len(assets.assets) == 0
-        assert not any(Path(assets.path).iterdir())
-        # cleanup
-        assets.cleanup()
-        assert not assets.assets
-        assert assets.path is None
-
-
-def test_asset_manager_02(tmp_path):
-    """test AssetManager() failures"""
-    with AssetManager(base_path=str(tmp_path)) as assets:
-        # get missing
-        assert assets.get("missing") is None
-        # add missing file
-        with raises(OSError, match="'missing' does not exist"):
-            assets.add("a", "missing")
-        assert not assets.assets
-        # remove invalid asset
-        assets.remove("missing")
-        # add file
-        example = tmp_path / "example.txt"
-        example.write_text("example")
-        assets.add("example_file", str(example), copy=True)
-        # add existing file under as different asset (collision)
-        with raises(AssetError, match="'example.txt' is an existing asset"):
-            assets.add("collide", str(example))
-        assert "collide" not in assets.assets
-        example.unlink()
-        # add file from existing asset
-        example = Path(assets.path) / "example.txt"
-        with raises(AssetError, match="Cannot add existing asset content"):
-            assets.add("existing", str(example))
-        assert "existing" not in assets.assets
-        # add file from existing asset with asset name collision
-        example = Path(assets.path) / "example.txt"
-        with raises(AssetError, match="Cannot add existing asset content"):
-            assets.add("example_file", str(example))
-        assert "example_file" in assets.assets
-
-
-def test_asset_manager_03(tmp_path):
-    """test AssetManager() dump/load"""
-    # test dump()
-    with AssetManager(base_path=str(tmp_path)) as assets:
-        # add file
-        example = tmp_path / "example.txt"
-        example.write_text("example")
-        assets.add("example_file", str(example), copy=False)
-        # add directory
-        example = tmp_path / "example_path"
-        example.mkdir()
-        (example / "a").mkdir()
-        (example / "a" / "1.txt").write_text("1")
-        assets.add("example_path", str(example))
-        # invalid entry
-        assets.assets["invalid"] = "bad/path"
-        # dump
-        dump_path = tmp_path / "dump"
-        dumped = assets.dump(str(dump_path), subdir="sub")
-    assert len(dumped) == 2
-    assert (dump_path / "sub" / "example.txt").is_file()
-    assert (dump_path / "sub" / "example_path" / "a" / "1.txt").is_file()
-    # test load()
-    with AssetManager.load(
-        dumped, str(dump_path / "sub"), base_path=str(tmp_path)
-    ) as assets:
-        assert len(assets.assets) == 2
-        assert isfile(assets.assets["example_file"])
-
-
-def test_asset_manager_04(tmp_path):
-    """test AssetManager.add_batch()"""
-    batch = list()
-    with AssetManager(base_path=str(tmp_path)) as assets:
-        # add file
-        example = tmp_path / "example.txt"
-        example.write_text("example")
-        batch.append(["example_file", str(example)])
-        # add directory
-        example = tmp_path / "example_path"
-        example.mkdir()
-        (example / "a").mkdir()
-        (example / "a" / "1.txt").write_text("1")
-        batch.append(["example_path", str(example)])
-        assets.add_batch(batch)
-        assert len(assets.assets) == 2

From bfceeea68807bb9c71ad3b920cfd44f8e57379c3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 19 Jul 2021 14:19:04 -0700
Subject: [PATCH 289/531] Replace Target.add_abort_token() with asset

---
 grizzly/target/puppet_target.py      | 13 ++++++++++---
 grizzly/target/target.py             |  4 ----
 grizzly/target/test_puppet_target.py | 13 ++++++++++---
 grizzly/target/test_target.py        |  1 -
 4 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 622239b8..982daa89 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -33,6 +33,8 @@
 
 class PuppetTarget(Target):
     SUPPORTED_ASSETS = (
+        # file containing line separated list of tokens to scan stderr/out for
+        "abort-tokens",
         # xpi or directory containing the unpacked extension
         "extension",
         # prefs.js file to use
@@ -72,9 +74,6 @@ def __init__(self, binary, launch_timeout, log_limit, memory_limit, **kwds):
                 "PuppetTarget ignoring unsupported arguments: %s", ", ".join(kwds)
             )
 
-    def add_abort_token(self, token):
-        self._puppet.add_abort_token(token)
-
     def _cleanup(self):
         # prevent parallel calls to FFPuppet.close() and/or FFPuppet.clean_up()
         with self._lock:
@@ -292,6 +291,14 @@ def process_assets(self):
                     break
             else:  # pragma: no cover
                 raise TargetError("Failed to generate prefs.js")
+        abort_tokens = self.assets.get("abort-tokens")
+        if abort_tokens:
+            LOG.debug("loading 'abort tokens' from %r", abort_tokens)
+            with open(abort_tokens, "r") as in_fp:
+                for line in in_fp:
+                    line = line.strip()
+                    if line:
+                        self._puppet.add_abort_token(line)
 
     def save_logs(self, *args, **kwargs):
         self._puppet.save_logs(*args, **kwargs)
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 5af98425..ae277e51 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -68,10 +68,6 @@ def __enter__(self):
     def __exit__(self, *exc):
         self.cleanup()
 
-    def add_abort_token(self, _token):  # pylint: disable=no-self-use
-        # TODO: change this to asset file containing tokens
-        LOG.warning("add_abort_token() not implemented!")
-
     @property
     def assets(self):
         return self._assets
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 4ee0e2fe..13b415e8 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -31,8 +31,6 @@ def test_puppet_target_01(mocker, tmp_path):
         fake_ffp.return_value.log_length.assert_any_call("stderr")
         fake_ffp.return_value.log_length.assert_any_call("stdout")
         assert target.monitor is not None
-        target.add_abort_token("test")
-        assert fake_ffp.return_value.add_abort_token.call_count == 1
         target.save_logs("fake_dest")
         assert fake_ffp.return_value.save_logs.call_count == 1
     assert fake_ffp.return_value.clean_up.call_count == 1
@@ -302,7 +300,7 @@ def test_puppet_target_08(mocker, tmp_path):
     """test PuppetTarget.process_assets()"""
     mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_file = tmp_path / "fake"
-    fake_file.touch()
+    fake_file.write_text("1\n2\n")
     # no prefs file provided
     with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
         assert target.assets.get("prefs") is None
@@ -316,6 +314,15 @@ def test_puppet_target_08(mocker, tmp_path):
             target.process_assets()
             assert isfile(target.assets.get("prefs"))
             assert target.assets.get("prefs").endswith("fake")
+    # abort tokens file provided
+    assert target._puppet.add_abort_token.call_count == 0
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        assets.add("abort-tokens", str(fake_file))
+        with PuppetTarget(str(fake_file), 300, 25, 5000, assets=assets) as target:
+            target.process_assets()
+            assert isfile(target.assets.get("abort-tokens"))
+            assert target.assets.get("abort-tokens").endswith("fake")
+            assert target._puppet.add_abort_token.call_count == 2
 
 
 @mark.parametrize(
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index dd66d8bb..1aeb0fd3 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -60,6 +60,5 @@ def test_target_01(tmp_path):
         assert target.memory_limit == 3
         assert target.monitor is None
         # test stubs
-        target.add_abort_token("none!")
         target.dump_coverage()
         target.reverse(1, 2)

From 1dabb0a1cc14594a8d0ac20e55d9eee386dd1bee Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 19 Jul 2021 14:55:16 -0700
Subject: [PATCH 290/531] [ci] Update pinned tool versions

---
 .pre-commit-config.yaml              | 4 ++--
 grizzly/target/target.py             | 8 +++++---
 grizzly/target/target_monitor.py     | 5 +++--
 grizzly/target/test_puppet_target.py | 5 ++++-
 tox.ini                              | 2 +-
 5 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 75b28584..32225bdb 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/pycqa/isort
-    rev: 5.9.1
+    rev: 5.9.2
     hooks:
       - id: isort
   - repo: https://github.com/asottile/yesqa
@@ -8,7 +8,7 @@ repos:
     hooks:
       - id: yesqa
   - repo: https://github.com/ambv/black
-    rev: 21.6b0
+    rev: 21.7b0
     hooks:
       - id: black
   - repo: https://gitlab.com/pycqa/flake8
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index ae277e51..1b5068c7 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -2,7 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from abc import ABCMeta, abstractmethod, abstractproperty
+from abc import ABCMeta, abstractmethod
 from logging import getLogger
 from os.path import isfile
 from threading import Lock
@@ -91,7 +91,8 @@ def cleanup(self):
     def close(self, force_close=False):
         pass
 
-    @abstractproperty
+    @property
+    @abstractmethod
     def closed(self):
         pass
 
@@ -123,7 +124,8 @@ def log_size(self):  # pylint: disable=no-self-use
         LOG.debug("log_size() not implemented! returning 0")
         return 0
 
-    @abstractproperty
+    @property
+    @abstractmethod
     def monitor(self):
         pass
 
diff --git a/grizzly/target/target_monitor.py b/grizzly/target/target_monitor.py
index bc346ec7..b611a864 100644
--- a/grizzly/target/target_monitor.py
+++ b/grizzly/target/target_monitor.py
@@ -2,7 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from abc import ABCMeta, abstractmethod, abstractproperty
+from abc import ABCMeta, abstractmethod
 from os import remove
 
 __all__ = ("TargetMonitor",)
@@ -23,7 +23,8 @@ def is_healthy(self):
     def is_running(self):
         pass
 
-    @abstractproperty
+    @property
+    @abstractmethod
     def launches(self):
         pass
 
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 13b415e8..30375c30 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -315,10 +315,13 @@ def test_puppet_target_08(mocker, tmp_path):
             assert isfile(target.assets.get("prefs"))
             assert target.assets.get("prefs").endswith("fake")
     # abort tokens file provided
-    assert target._puppet.add_abort_token.call_count == 0
     with AssetManager(base_path=str(tmp_path)) as assets:
         assets.add("abort-tokens", str(fake_file))
         with PuppetTarget(str(fake_file), 300, 25, 5000, assets=assets) as target:
+            # ignore E1101: (pylint 2.9.3 bug?)
+            #    Method 'add_abort_token' has no 'call_count' member (no-member)
+            # pylint: disable=no-member
+            assert target._puppet.add_abort_token.call_count == 0
             target.process_assets()
             assert isfile(target.assets.get("abort-tokens"))
             assert target.assets.get("abort-tokens").endswith("fake")
diff --git a/tox.ini b/tox.ini
index 8e89a5bb..4e253fff 100644
--- a/tox.ini
+++ b/tox.ini
@@ -42,7 +42,7 @@ skip_install = true
 commands =
     pylint {posargs}
 deps =
-    pylint==2.8.3
+    pylint==2.9.3
 usedevelop = true
 
 [testenv:pypi]

From c3adf7dd0c3671686e4f28b4cb35b4a990cbe361 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 23 Jul 2021 16:54:27 -0700
Subject: [PATCH 291/531] Move environment handling to Target

---
 grizzly/common/iomanager.py          |  62 +---------------
 grizzly/common/runner.py             |   5 +-
 grizzly/common/storage.py            |  41 +++-------
 grizzly/common/test_iomanager.py     |  59 +--------------
 grizzly/common/test_storage.py       | 101 ++++++++-----------------
 grizzly/common/test_utils.py         |   6 +-
 grizzly/common/utils.py              |   4 +-
 grizzly/reduce/core.py               |   7 +-
 grizzly/reduce/test_main.py          |   3 +-
 grizzly/reduce/test_reduce.py        |  15 ++--
 grizzly/replay/replay.py             |  34 ++++++---
 grizzly/replay/test_main.py          |  26 +++++--
 grizzly/replay/test_replay.py        | 107 ++++++++++-----------------
 grizzly/session.py                   |   1 +
 grizzly/target/assets.py             |   4 +-
 grizzly/target/puppet_target.py      |  49 +++++++++++-
 grizzly/target/target.py             |  16 +++-
 grizzly/target/test_puppet_target.py |  40 ++++++++++
 grizzly/target/test_target.py        |  27 +++++--
 grizzly/test_session.py              |  31 +++++---
 20 files changed, 295 insertions(+), 343 deletions(-)

diff --git a/grizzly/common/iomanager.py b/grizzly/common/iomanager.py
index c1ee1d03..ef2d465e 100644
--- a/grizzly/common/iomanager.py
+++ b/grizzly/common/iomanager.py
@@ -3,13 +3,10 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from collections import deque
-from os import environ
-from os.path import isfile
 
 from sapphire.server_map import ServerMap
 
-from .storage import TestCase, TestFile
-from .utils import sanitizer_opts
+from .storage import TestCase
 
 __all__ = ("IOManager",)
 __author__ = "Tyson Smith"
@@ -17,21 +14,10 @@
 
 
 class IOManager:
-    # TODO: some of these are target specific
-    TRACKED_ENVVARS = (
-        "ASAN_OPTIONS",
-        "LSAN_OPTIONS",
-        "GNOME_ACCESSIBILITY",
-        "MOZ_CHAOSMODE",
-        "XPCOM_DEBUG_BREAK",
-    )
-
     __slots__ = (
-        "_environ_files",
         "_generated",
         "_report_size",
         "_test",
-        "_tracked_env",
         "harness",
         "server_map",
         "tests",
@@ -42,13 +28,9 @@ def __init__(self, report_size=1):
         self.harness = None
         self.server_map = ServerMap()
         self.tests = deque()
-        self._environ_files = list()
         self._generated = 0  # number of test cases generated
         self._report_size = report_size
         self._test = None
-        # used to record environment variable that directly impact the browser
-        self._tracked_env = self.tracked_environ()
-        self._add_suppressions()
 
     def __enter__(self):
         return self
@@ -56,20 +38,7 @@ def __enter__(self):
     def __exit__(self, *exc):
         self.cleanup()
 
-    def _add_suppressions(self):
-        # Add suppression files to environment files
-        for env_var in (x for x in environ if "SAN_OPTIONS" in x):
-            opts = sanitizer_opts(environ.get(env_var, ""))
-            if "suppressions" not in opts:
-                continue
-            supp_file = opts["suppressions"].strip("'\"")
-            if isfile(supp_file):
-                fname = "%s.supp" % (env_var.split("_")[0].lower(),)
-                self._environ_files.append(TestFile.from_file(supp_file, fname))
-
     def cleanup(self):
-        for e_file in self._environ_files:
-            e_file.close()
         self.purge()
 
     def commit(self):
@@ -89,9 +58,6 @@ def create_testcase(self, adapter_name, time_limit):
             adapter_name=adapter_name,
             time_limit=time_limit,
         )
-        # add environment variable info to the test case
-        for e_name, e_value in self._tracked_env.items():
-            self._test.add_environ_var(e_name, e_value)
         # reset redirect map
         self.server_map.redirect.clear()
         self.server_map.set_redirect(
@@ -115,29 +81,3 @@ def purge(self):
         for testcase in self.tests:
             testcase.cleanup()
         self.tests.clear()
-
-    @staticmethod
-    def tracked_environ():
-        # Scan os.environ and collect environment variables
-        # that are relevant to Grizzly or the test case.
-        env = dict()
-        tracked_san_opts = ("detect_leaks",)
-        for var in IOManager.TRACKED_ENVVARS:
-            if var not in environ:
-                continue
-            if var.endswith("SAN_OPTIONS"):
-                opts = sanitizer_opts(environ.get(var, ""))
-                # strip unwanted options
-                tracked = dict()
-                for opt in tracked_san_opts:
-                    if opt in opts:
-                        tracked[opt] = opts[opt]
-                # only record *SAN_OPTIONS if there are options
-                if tracked:
-                    env[var] = ":".join("=".join((k, v)) for k, v in tracked.items())
-            elif var == "XPCOM_DEBUG_BREAK" and environ.get(var, "").lower() == "warn":
-                # ignore FFPuppet default XPCOM_DEBUG_BREAK value (set in helpers.py)
-                continue
-            else:
-                env[var] = environ[var]
-        return env
diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index b8b77c75..a6c16a5f 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -104,12 +104,11 @@ def __init__(
         self._target = target  # target to run test case
         self._tests_run = 0  # number of tests run since target (re)launched
 
-    def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
+    def launch(self, location, max_retries=3, retry_delay=0):
         """Launch a target and open `location`.
 
         Args:
             location (str): URL to open via Target.
-            env_mod (dict): Environment modifications.
             max_retries (int): Number of retries to perform before re-raising
                                TargetLaunchTimeout.
             retry_delay (int): Time in seconds to wait between retries.
@@ -125,7 +124,7 @@ def launch(self, location, env_mod=None, max_retries=3, retry_delay=0):
         LOG.debug("launching target (timeout %ds)", self._target.launch_timeout)
         for retries in reversed(range(max_retries)):
             try:
-                self._target.launch(location, env_mod=env_mod)
+                self._target.launch(location)
             except TargetLaunchError as exc:
                 # This is likely due to a bad build or environment configuration.
                 if retries:
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index b915d9ab..907b5580 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -17,7 +17,7 @@
 from zlib import error as zlib_error
 
 from ..target import AssetError, AssetManager
-from .utils import grz_tmp, sanitizer_opts
+from .utils import grz_tmp
 
 __all__ = ("TestCase", "TestFile", "TestCaseLoadFailure", "TestFileExists")
 __author__ = "Tyson Smith"
@@ -64,7 +64,7 @@ def __init__(
         self.adapter_name = adapter_name
         self.assets = None
         self.duration = None
-        self.env_vars = dict()  # environment variables
+        self.env_vars = dict()
         self.hang = False
         self.input_fname = input_fname  # file that was used to create the test case
         self.landing_page = landing_page
@@ -119,18 +119,6 @@ def add_batch(self, path, include_files, prefix=None):
                 test_path = "/".join((prefix, test_path))
             self.add_from_file(fname, file_name=test_path)
 
-    def add_environ_var(self, name, value):
-        """Add environment variable to TestCase.
-
-        Args:
-            name (str): Environment variable name.
-            value (str): Environment variable value.
-
-        Returns:
-            None
-        """
-        self.env_vars[name] = value
-
     def add_file(self, test_file, required=True):
         """Add a TestFile to TestCase.
 
@@ -220,6 +208,7 @@ def clone(self):
         result.duration = self.duration
         result.hang = self.hang
         result.env_vars.update(self.env_vars)
+        # TODO: should we handle assets?
         for entry in self._files.optional:
             result.add_file(entry.clone(), required=False)
         for entry in self._files.required:
@@ -356,23 +345,6 @@ def load(cls, path, adjacent=False):
                 rmtree(unpacked, ignore_errors=True)
         return tests
 
-    def load_environ(self, path, env_data):
-        # sanity check environment variable data
-        for name, value in env_data.items():
-            if not isinstance(name, str) or not isinstance(value, str):
-                raise TestCaseLoadFailure("'env_data' contains invalid 'env' entries")
-        self.env_vars = env_data
-        known_suppressions = ("lsan.supp", "tsan.supp", "ubsan.supp")
-        for supp in listdir(path):
-            if supp.lower() in known_suppressions:
-                # Update *SAN_OPTIONS to use provided suppression files.
-                opt_key = "%s_OPTIONS" % (supp.split(".")[0].upper(),)
-                opts = sanitizer_opts(self.env_vars.get(opt_key, ""))
-                opts["suppressions"] = "'%s'" % (pathjoin(path, supp),)
-                self.env_vars[opt_key] = ":".join(
-                    "=".join((k, v)) for k, v in opts.items()
-                )
-
     @classmethod
     def load_single(cls, path, adjacent=False, load_assets=True):
         """Load contents of a TestCase from disk. If `path` is a directory it must
@@ -437,7 +409,12 @@ def load_single(cls, path, adjacent=False, load_assets=True):
                 raise TestCaseLoadFailure(str(exc)) from None
             # load environment variables
             try:
-                test.load_environ(path, info.get("env", {}))
+                test.env_vars = info.get("env", dict())
+                assert isinstance(test.env_vars, dict)
+                # sanity check environment variable data
+                for name, value in test.env_vars.items():
+                    if not isinstance(name, str) or not isinstance(value, str):
+                        raise TestCaseLoadFailure("'env' contains invalid entries")
             except TestCaseLoadFailure:
                 test.cleanup(skip_assets=False)
                 raise
diff --git a/grizzly/common/test_iomanager.py b/grizzly/common/test_iomanager.py
index 12df2033..574d36aa 100644
--- a/grizzly/common/test_iomanager.py
+++ b/grizzly/common/test_iomanager.py
@@ -6,7 +6,6 @@
 from pytest import mark
 
 from .iomanager import IOManager
-from .storage import TestFile
 
 
 def test_iomanager_01():
@@ -15,7 +14,6 @@ def test_iomanager_01():
         assert iom.harness is None
         assert iom.server_map is not None
         assert not iom.tests
-        assert not iom._environ_files
         assert iom._generated == 0
         assert iom._report_size == 1
         assert iom._test is None
@@ -60,27 +58,7 @@ def test_iomanager_03():
         assert iom.page_name() == next_page
 
 
-def test_iomanager_04(mocker, tmp_path):
-    """test IOManager._add_suppressions()"""
-    mocker.patch.dict("grizzly.common.iomanager.environ", values={})
-    with IOManager() as iom:
-        assert not iom._environ_files
-        supp_file = tmp_path / "supp_file.txt"
-        supp_file.touch()
-        mocker.patch.dict(
-            "grizzly.common.iomanager.environ",
-            values={
-                "ASAN_OPTIONS": "blah=1:suppressions='%s':foo=2" % (str(supp_file),),
-                "DEBUG": "1",
-                "LSAN_OPTIONS": "nothing=1",
-                "JUNK": "test",
-            },
-        )
-        iom._add_suppressions()
-        assert "asan.supp" in (x.file_name for x in iom._environ_files)
-
-
-def test_iomanager_05():
+def test_iomanager_04():
     """test IOManager.create_testcase()"""
     time_limit = 10
     with IOManager() as iom:
@@ -90,8 +68,6 @@ def test_iomanager_05():
         assert not iom.server_map.dynamic
         assert not iom.server_map.include
         assert not iom.server_map.redirect
-        iom._tracked_env = {"TEST": "1"}
-        iom._environ_files = [TestFile.from_data(b"data", "e.txt")]
         # without a harness, no input files
         tcase = iom.create_testcase("test-adapter", time_limit)
         assert tcase is not None
@@ -113,36 +89,3 @@ def test_iomanager_05():
         assert iom.server_map.redirect["grz_current_test"].target == tcase.landing_page
         assert "grz_next_test" in iom.server_map.redirect
         assert "grz_harness" in iom.server_map.dynamic
-
-
-def test_iomanager_06(mocker):
-    """test IOManager.tracked_environ()"""
-    mocker.patch.dict("grizzly.common.iomanager.environ", values={})
-    assert not IOManager.tracked_environ()
-    mocker.patch.dict(
-        "grizzly.common.iomanager.environ",
-        values={
-            "ASAN_OPTIONS": "blah='z:/a':detect_leaks=1:foo=2",
-            "LSAN_OPTIONS": "detect_leaks='x:\\a.1':a=1",
-            # should be added since it is in IOManager.TRACKED_ENVVARS
-            "MOZ_CHAOSMODE": "1",
-            # this should be skipped because it uses the FFPuppet debug
-            "XPCOM_DEBUG_BREAK": "warn",
-            "TEST_BAD": "FAIL",
-        },
-        clear=True,
-    )
-    tracked = IOManager.tracked_environ()
-    assert "TEST_BAD" not in tracked
-    assert "XPCOM_DEBUG_BREAK" not in tracked
-    assert "ASAN_OPTIONS" in tracked
-    assert "MOZ_CHAOSMODE" in tracked
-    assert tracked["ASAN_OPTIONS"] == "detect_leaks=1"
-    assert "LSAN_OPTIONS" in tracked
-    assert tracked["LSAN_OPTIONS"] == "detect_leaks='x:\\a.1'"
-    mocker.patch.dict(
-        "grizzly.common.iomanager.environ",
-        values={"ASAN_OPTIONS": "ignored=x"},
-        clear=True,
-    )
-    assert not IOManager.tracked_environ()
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index a101d3ea..c9722891 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -4,11 +4,10 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
 
-import json
 import os
-import re
-import zipfile
 from itertools import chain
+from json import dumps, loads
+from zipfile import ZIP_DEFLATED, ZipFile
 
 from pytest import raises
 
@@ -45,10 +44,7 @@ def test_testcase_01(tmp_path):
 
 def test_testcase_02(tmp_path):
     """test TestCase with TestFiles"""
-    tcase = TestCase(
-        "land_page.html", "redirect.html", "test-adapter", input_fname="testinput.bin"
-    )
-    try:
+    with TestCase("land_page.html", "a.html", "adpt", input_fname="in.bin") as tcase:
         in_file = tmp_path / "testfile1.bin"
         in_file.write_bytes(b"test_req")
         tcase.add_from_file(str(in_file))
@@ -66,36 +62,19 @@ def test_testcase_02(tmp_path):
         assert len(opt_files) == 1
         tcase.dump(str(tmp_path), include_details=True)
         assert (tmp_path / "nested").is_dir()
-        test_info = json.loads((tmp_path / "test_info.json").read_text())
-        assert test_info["adapter"] == "test-adapter"
-        assert test_info["input"] == "testinput.bin"
+        test_info = loads((tmp_path / "test_info.json").read_text())
+        assert test_info["adapter"] == "adpt"
+        assert test_info["input"] == "in.bin"
         assert test_info["target"] == "land_page.html"
         assert isinstance(test_info["env"], dict)
         assert in_file.read_bytes() == b"test_req"
         assert (tmp_path / "nested" / "testfile2.bin").read_bytes() == b"test_nreq"
         assert (tmp_path / "testfile3.bin").read_bytes() == b"test_blah"
         assert (tmp_path / "dir" / "file.bin").read_bytes() == b"test_windows"
-    finally:
         tcase.cleanup()
 
 
-def test_testcase_03(tmp_path):
-    """test TestCase.add_environ_var() and TestCase.env_vars"""
-    with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
-        tcase.add_environ_var("TEST_ENV_VAR", "1")
-        assert len(tcase.env_vars) == 1
-        tcase.add_environ_var("TEST_NONE", None)
-        assert len(tcase.env_vars) == 2
-        dmp_path = tmp_path / "dmp_test"
-        dmp_path.mkdir()
-        tcase.dump(str(dmp_path), include_details=True)
-        data = json.loads((dmp_path / "test_info.json").read_text())
-        assert "env" in data
-        assert data["env"]["TEST_ENV_VAR"] == "1"
-        assert data["env"]["TEST_NONE"] is None
-
-
-def test_testcase_04():
+def test_testcase_03():
     """test TestCase.purge_optional()"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
         tcase.add_from_data("foo", "testfile1.bin")
@@ -120,7 +99,7 @@ def test_testcase_04():
         assert not any(tcase.optional)
 
 
-def test_testcase_05():
+def test_testcase_04():
     """test TestCase.data_size"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
         assert tcase.data_size == 0
@@ -130,7 +109,7 @@ def test_testcase_05():
         assert tcase.data_size == 3
 
 
-def test_testcase_06(tmp_path):
+def test_testcase_05(tmp_path):
     """test TestCase.load_single() using a directory - fail cases"""
     # missing test_info.json
     with raises(TestCaseLoadFailure, match="Missing 'test_info.json'"):
@@ -160,13 +139,15 @@ def test_testcase_06(tmp_path):
     # bad 'env' entry in test_info.json
     entry_point.touch()
     with TestCase("target.bin", None, "test-adapter") as src:
-        src.add_environ_var("TEST_ENV_VAR", 100)
         src.dump(str(src_dir), include_details=True)
-    with raises(TestCaseLoadFailure, match="'env_data' contains invalid 'env' entries"):
+    test_info = loads((src_dir / "test_info.json").read_text())
+    test_info["env"] = {"bad": 1}
+    (src_dir / "test_info.json").write_text(dumps(test_info))
+    with raises(TestCaseLoadFailure, match="'env' contains invalid entries"):
         TestCase.load_single(str(src_dir))
 
 
-def test_testcase_07(mocker, tmp_path):
+def test_testcase_06(mocker, tmp_path):
     """test TestCase.load_single() using a directory"""
     # build a valid test case
     src_dir = tmp_path / "src"
@@ -186,7 +167,7 @@ def test_testcase_07(mocker, tmp_path):
     with AssetManager(base_path=str(tmp_path)) as assets:
         assets.add("example", str(asset_file))
         with TestCase("target.bin", None, "test-adapter") as src:
-            src.add_environ_var("TEST_ENV_VAR", "100")
+            src.env_vars["TEST_ENV_VAR"] = "100"
             src.add_from_file(str(entry_point))
             src.add_from_file(str(src_dir / "optional.bin"), required=False)
             src.add_from_file(str(src_dir / "x.bin"), required=False)
@@ -220,7 +201,7 @@ def test_testcase_07(mocker, tmp_path):
         TestCase.load_single(str(dst_dir))
 
 
-def test_testcase_08(tmp_path):
+def test_testcase_07(tmp_path):
     """test TestCase.load_single() using a file"""
     # invalid entry_point specified
     with raises(TestCaseLoadFailure, match="Missing or invalid TestCase"):
@@ -234,6 +215,7 @@ def test_testcase_08(tmp_path):
     # load single file test case
     with TestCase.load_single(str(entry_point), adjacent=False) as tcase:
         assert tcase.assets is None
+        assert not tcase.env_vars
         assert tcase.landing_page == "target.bin"
         assert "target.bin" in (x.file_name for x in tcase._files.required)
         assert "optional.bin" not in (x.file_name for x in tcase._files.optional)
@@ -245,7 +227,7 @@ def test_testcase_08(tmp_path):
         assert "optional.bin" in (x.file_name for x in tcase._files.optional)
 
 
-def test_testcase_09(tmp_path):
+def test_testcase_08(tmp_path):
     """test TestCase - dump, load and compare"""
     working = tmp_path / "working"
     working.mkdir()
@@ -277,7 +259,7 @@ def test_testcase_09(tmp_path):
             loaded.cleanup(skip_assets=False)
 
 
-def test_testcase_10(tmp_path):
+def test_testcase_09(tmp_path):
     """test TestCase.load() - missing file and empty directory"""
     # missing file
     with raises(TestCaseLoadFailure, match="Invalid TestCase path"):
@@ -286,7 +268,7 @@ def test_testcase_10(tmp_path):
     assert not TestCase.load(str(tmp_path), adjacent=True)
 
 
-def test_testcase_11(tmp_path):
+def test_testcase_10(tmp_path):
     """test TestCase.load() - single file"""
     tfile = tmp_path / "testcase.html"
     tfile.touch()
@@ -298,7 +280,7 @@ def test_testcase_11(tmp_path):
         map(lambda x: x.cleanup, testcases)
 
 
-def test_testcase_12(tmp_path):
+def test_testcase_11(tmp_path):
     """test TestCase.load() - single directory"""
     with TestCase("target.bin", None, "test-adapter") as src:
         src.add_from_data("test", "target.bin")
@@ -311,7 +293,7 @@ def test_testcase_12(tmp_path):
         map(lambda x: x.cleanup(), testcases)
 
 
-def test_testcase_13(tmp_path):
+def test_testcase_12(tmp_path):
     """test TestCase.load() - multiple directories (with assets)"""
     nested = tmp_path / "nested"
     nested.mkdir()
@@ -338,7 +320,7 @@ def test_testcase_13(tmp_path):
     assert not TestCase.load(str(tmp_path))
 
 
-def test_testcase_14(tmp_path):
+def test_testcase_13(tmp_path):
     """test TestCase.load() - archive"""
     archive = tmp_path / "testcase.zip"
     # bad archive
@@ -355,9 +337,7 @@ def test_testcase_14(tmp_path):
     (tmp_path / "log_dummy.txt").touch()
     (tmp_path / "not_a_tc").mkdir()
     (tmp_path / "not_a_tc" / "file.txt").touch()
-    with zipfile.ZipFile(
-        str(archive), mode="w", compression=zipfile.ZIP_DEFLATED
-    ) as zfp:
+    with ZipFile(str(archive), mode="w", compression=ZIP_DEFLATED) as zfp:
         for dir_name, _, dir_files in os.walk(str(tmp_path)):
             arc_path = os.path.relpath(dir_name, str(tmp_path))
             for file_name in dir_files:
@@ -373,25 +353,7 @@ def test_testcase_14(tmp_path):
         map(lambda x: x.cleanup, testcases)
 
 
-def test_testcase_15(tmp_path):
-    """test TestCase.load_environ()"""
-    (tmp_path / "ubsan.supp").touch()
-    (tmp_path / "other_file").touch()
-    with TestCase("a.html", "b.html", "test-adapter") as tcase:
-        tcase.load_environ(str(tmp_path), {})
-        assert "UBSAN_OPTIONS" in tcase.env_vars
-        assert "ubsan.supp" in tcase.env_vars["UBSAN_OPTIONS"]
-        # existing *SAN_OPTIONS
-        tcase.load_environ(str(tmp_path), {"UBSAN_OPTIONS": "a=1:b=2"})
-        assert "UBSAN_OPTIONS" in tcase.env_vars
-        assert "ubsan.supp" in tcase.env_vars["UBSAN_OPTIONS"]
-        opts = re.split(r":(?![\\|/])", tcase.env_vars["UBSAN_OPTIONS"])
-        assert "a=1" in opts
-        assert "b=2" in opts
-        assert len(opts) == 3
-
-
-def test_testcase_16(tmp_path):
+def test_testcase_14(tmp_path):
     """test TestCase.add_batch()"""
     include = tmp_path / "inc_path"
     include.mkdir()
@@ -431,7 +393,7 @@ def test_testcase_16(tmp_path):
             tcase.add_batch(str(include), [str(inc_1)])
 
 
-def test_testcase_17(tmp_path):
+def test_testcase_15(tmp_path):
     """test TestCase.scan_path()"""
     # empty path
     (tmp_path / "not-test").mkdir()
@@ -449,7 +411,7 @@ def test_testcase_17(tmp_path):
     assert len(tc_paths) == 1
 
 
-def test_testcase_18():
+def test_testcase_16():
     """test TestCase.get_file()"""
     with TestCase("test.htm", None, "test-adapter") as src:
         src.add_from_data("test", "test.htm")
@@ -457,14 +419,14 @@ def test_testcase_18():
         assert src.get_file("test.htm").data == b"test"
 
 
-def test_testcase_19():
+def test_testcase_17():
     """test TestCase.clone()"""
     with TestCase("a.htm", "b.htm", "adpt", input_fname="fn", time_limit=2) as src:
         src.duration = 1.2
         src.hang = True
         src.add_from_data("123", "test.htm")
         src.add_from_data("456", "opt.htm", required=False)
-        src.add_environ_var("go", "away")
+        src.env_vars["foo"] = "bar"
         with src.clone() as tgt:
             for prop in TestCase.__slots__:
                 if prop.startswith("_"):
@@ -479,10 +441,7 @@ def test_testcase_19():
                 tgt.get_file(file).write(b"tgt")
                 assert src.get_file(file).data == data + b"src"
                 assert tgt.get_file(file).data == data + b"tgt"
-            src.add_environ_var("foo", "bar")
-            tgt.add_environ_var("hello", "kitty")
-            assert src.env_vars == {"foo": "bar", "go": "away"}
-            assert tgt.env_vars == {"hello": "kitty", "go": "away"}
+            assert tgt.env_vars == {"foo": "bar"}
 
 
 def test_testfile_01():
diff --git a/grizzly/common/test_utils.py b/grizzly/common/test_utils.py
index 53d088e5..7f62fd67 100644
--- a/grizzly/common/test_utils.py
+++ b/grizzly/common/test_utils.py
@@ -6,7 +6,7 @@
 
 from pytest import mark
 
-from .utils import configure_logging, grz_tmp, sanitizer_opts
+from .utils import configure_logging, grz_tmp, split_sanitizer_opts
 
 
 def test_grz_tmp_01(mocker, tmp_path):
@@ -80,8 +80,8 @@ def test_configure_logging_01(mocker, env, log_level):
     ],
 )
 def test_sanitizer_opts_01(to_parse, expected):
-    """test sanitizer_opts()"""
-    parsed = sanitizer_opts(to_parse)
+    """test split_sanitizer_opts()"""
+    parsed = split_sanitizer_opts(to_parse)
     assert len(parsed) == len(expected)
     for key in expected:
         assert expected[key] == parsed[key]
diff --git a/grizzly/common/utils.py b/grizzly/common/utils.py
index 0ab362e1..385c5949 100644
--- a/grizzly/common/utils.py
+++ b/grizzly/common/utils.py
@@ -12,7 +12,7 @@
     "ConfigError",
     "configure_logging",
     "grz_tmp",
-    "sanitizer_opts",
+    "split_sanitizer_opts",
     "TIMEOUT_DELAY",
 )
 __author__ = "Tyson Smith"
@@ -58,7 +58,7 @@ def grz_tmp(*subdir):
     return path
 
 
-def sanitizer_opts(env_data):
+def split_sanitizer_opts(env_data):
     """Parse the values defined in given *SAN_OPTIONS environment variable.
     For example "ASAN_OPTIONS=debug=false:log_path='/test/file.log'"
     would return {"debug": "false", "log_path": "'/test/file.log'"}
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 1edde1bb..edbdaf11 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -731,7 +731,7 @@ def main(cls, args):
                     signature_desc = meta["shortDescription"]
 
             try:
-                testcases, assets = ReplayManager.load_testcases(
+                testcases, assets, env_vars = ReplayManager.load_testcases(
                     args.input, subset=args.test_index
                 )
             except TestCaseLoadFailure as exc:
@@ -777,6 +777,11 @@ def main(cls, args):
                 valgrind=args.valgrind,
                 xvfb=args.xvfb,
             )
+            # local environ takes priority over environ loaded from test case
+            if env_vars is not None:
+                env_vars.update(target.environ)
+                target.environ = env_vars
+                env_vars = None
             # TODO: support overriding existing assets
             # prioritize specified assets over included
             target.assets.add_batch(args.asset)
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index dcdfe40b..ff3c6dc3 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -110,7 +110,7 @@ def test_args_04(capsys, tmp_path):
         (
             "grizzly.reduce.core.ReplayManager.load_testcases",
             None,
-            ([Mock(hang=False), Mock(hang=False)], Mock(spec_set=AssetManager)),
+            ([Mock(hang=False), Mock(hang=False)], Mock(spec_set=AssetManager), dict()),
             {"no_harness": True},
             2,
         ),
@@ -157,6 +157,7 @@ def test_main_launch_error(mocker, exc_type):
         return_value=(
             [mocker.Mock(spec_set=TestCase, hang=False, adapter_name="fake")],
             None,
+            dict(),
         ),
     )
     mocker.patch(
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index aa721db4..345e7821 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -10,8 +10,7 @@
 from itertools import count
 from logging import getLogger
 
-import pytest
-from pytest import raises
+from pytest import mark, raises
 
 from sapphire import Sapphire
 
@@ -24,9 +23,7 @@
 from .strategies import Strategy
 
 LOG = getLogger(__name__)
-pytestmark = pytest.mark.usefixtures(
-    "tmp_path_fm_config", "reporter_sequential_strftime"
-)
+pytestmark = mark.usefixtures("tmp_path_fm_config", "reporter_sequential_strftime")
 
 
 def _fake_save_logs_foo(result_logs, meta=False):  # pylint: disable=unused-argument
@@ -60,7 +57,7 @@ def _fake_save_logs_bar(result_logs, meta=False):  # pylint: disable=unused-argu
 )
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     AnalysisTestParams._fields,
     [
         # perfect with harness
@@ -333,7 +330,7 @@ def wrapped(_):
 )
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     ReproTestParams._fields,
     [
         # no repro
@@ -506,7 +503,7 @@ def wrapped(_):
         ),
     ],
 )
-@pytest.mark.usefixtures("reporter_sequential_strftime")
+@mark.usefixtures("reporter_sequential_strftime")
 def test_repro(
     mocker,
     tmp_path,
@@ -802,7 +799,7 @@ def replay_run(testcases, _time_limit, **_kw):
 )
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     TimeoutTestParams._fields,
     [
         # 0 duration test sets both timeouts to minimum
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index aa538f7a..eeeba34b 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -152,13 +152,23 @@ def load_testcases(cls, path, subset=None):
         testcases = TestCase.load(path)
         if not testcases:
             raise TestCaseLoadFailure("Failed to load TestCases")
-        # remove loaded assets from test cases
+        # remove loaded assets and environment variables from test cases
         assets = None
+        env_vars = None
         for test in testcases:
             if assets is None:
                 assets = test.pop_assets()
             else:
                 test.pop_assets()
+            if not env_vars and test.env_vars:
+                env_vars = dict(test.env_vars)
+            test.env_vars.clear()
+        LOG.debug(
+            "loaded TestCase(s): %d, assets: %r, env vars: %r",
+            len(testcases),
+            assets is not None,
+            env_vars is not None,
+        )
         if subset:
             count = len(testcases)
             # deduplicate and limit requested indices to valid range
@@ -171,7 +181,7 @@ def load_testcases(cls, path, subset=None):
             for test in testcases:
                 test.cleanup()
             testcases = selected
-        return testcases, assets
+        return testcases, assets, env_vars
 
     @staticmethod
     def report_to_filesystem(path, results, tests=None):
@@ -293,12 +303,7 @@ def run(
                             time_limit=time_limit,
                         )
                     startup_error = False
-                    # The environment from the initial testcase is used because
-                    # a sequence of testcases is expected to be run without
-                    # relaunching the Target to match the functionality of
-                    # Grizzly. If this is not the case each TestCase should
-                    # be run individually.
-                    runner.launch(location, env_mod=testcases[0].env_vars)
+                    runner.launch(location)
                 # run tests
                 durations = list()
                 served = list()
@@ -571,7 +576,9 @@ def main(cls, args):
             signature = None
 
         try:
-            testcases, assets = cls.load_testcases(args.input, subset=args.test_index)
+            testcases, assets, env_vars = cls.load_testcases(
+                args.input, subset=args.test_index
+            )
         except TestCaseLoadFailure as exc:
             LOG.error("Error: %s", str(exc))
             return Session.EXIT_ERROR
@@ -616,6 +623,11 @@ def main(cls, args):
                 valgrind=args.valgrind,
                 xvfb=args.xvfb,
             )
+            # local environ takes priority over environ loaded from test case
+            if env_vars is not None:
+                env_vars.update(target.environ)
+                target.environ = env_vars
+                env_vars = None
             # TODO: support overriding existing assets
             # prioritize specified assets over included
             target.assets.add_batch(args.asset)
@@ -654,6 +666,10 @@ def main(cls, args):
                 if not target.assets.is_empty():
                     for test in testcases:
                         test.assets = target.assets
+                # add target environment variables
+                if target.environ:
+                    for test in testcases:
+                        test.env_vars = dict(target.environ)
                 cls.report_to_filesystem(
                     args.logs, results, testcases if args.include_test else None
                 )
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index bfb49819..c41e809d 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -31,7 +31,7 @@ def test_main_01(mocker, tmp_path):
     )
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_plugin", autospec=True)
-    target = mocker.Mock(spec_set=Target, binary="bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="bin", environ={}, launch_timeout=30)
     target.assets = mocker.Mock(spec_set=AssetManager)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
@@ -43,19 +43,23 @@ def test_main_01(mocker, tmp_path):
     )
     target.save_logs = _fake_save_logs
     load_target.return_value.return_value = target
+    with TestCase("test.html", None, "adpt") as src:
+        src.env_vars["TEST_VAR"] = "100"
+        src.add_from_data("test", "test.html")
+        src.dump(str(tmp_path / "testcase"), include_details=True)
     # setup args
     log_path = tmp_path / "logs"
-    (tmp_path / "test.html").touch()
     (tmp_path / "sig.json").write_bytes(
         b'{"symptoms": [{"type": "crashAddress", "address": "0"}]}'
     )
     args = mocker.Mock(
+        any_crash=False,
         asset=list(),
         fuzzmanager=False,
         idle_delay=0,
         idle_threshold=0,
         ignore=["fake", "timeout"],
-        input=str(tmp_path / "test.html"),
+        input=str(tmp_path / "testcase"),
         logs=str(log_path),
         min_crashes=2,
         no_harness=False,
@@ -73,6 +77,7 @@ def test_main_01(mocker, tmp_path):
     assert target.reverse.call_count == 1
     assert target.launch.call_count == 3
     assert target.detect_failure.call_count == 3
+    assert "TEST_VAR" in target.environ
     assert serve_path.call_count == 3
     assert load_target.call_count == 1
     assert target.close.call_count == 4
@@ -96,7 +101,7 @@ def test_main_02(mocker, tmp_path):
     )
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_plugin")
-    target = mocker.Mock(spec_set=Target, binary="bin", launch_timeout=30)
+    target = mocker.Mock(spec_set=Target, binary="bin", environ={}, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     load_target.return_value.return_value = target
@@ -123,6 +128,7 @@ def test_main_02(mocker, tmp_path):
     )
     assert ReplayManager.main(args) == Session.EXIT_FAILURE
     assert target.detect_failure.call_count == 1
+    assert not target.environ
     assert target.close.call_count == 2
     assert target.cleanup.call_count == 1
 
@@ -166,19 +172,21 @@ def test_main_03(mocker):
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
     # multiple test cases with --no-harness
-    fake_tc.load.return_value = [mocker.Mock(hang=False), mocker.Mock(hang=False)]
+    fake_tc.load.return_value = [
+        mocker.Mock(spec_set=TestCase, env_vars={}, hang=False) for _ in range(2)
+    ]
     assert ReplayManager.main(args) == Session.EXIT_ARGS
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
     # signature required replaying hang
-    fake_tc.load.return_value = [mocker.Mock(hang=True)]
+    fake_tc.load.return_value = [mocker.Mock(spec_set=TestCase, env_vars={}, hang=True)]
     assert ReplayManager.main(args) == Session.EXIT_ERROR
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
     # can't ignore timeout replaying hang
     args.ignore = ["timeout"]
     args.sig = "sig"
-    fake_tc.load.return_value = [mocker.Mock(hang=True)]
+    fake_tc.load.return_value = [mocker.Mock(spec_set=TestCase, env_vars={}, hang=True)]
     assert ReplayManager.main(args) == Session.EXIT_ERROR
     assert fake_sig.fromFile.call_count == 1
     assert fake_load_target.call_count == 0
@@ -244,7 +252,9 @@ def test_main_05(mocker, tmp_path):
         return_value=(None, ["test.html"]),  # passed to Target.detect_failure
     )
     # setup Target
-    target = mocker.NonCallableMock(spec_set=Target, binary="bin", launch_timeout=30)
+    target = mocker.NonCallableMock(
+        spec_set=Target, binary="bin", environ={}, launch_timeout=30
+    )
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index db448723..c8214c4b 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -159,9 +159,7 @@ def test_replay_06(mocker, tmp_path):
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
     testcases = [
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        )
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     # test target unresponsive
     target.detect_failure.return_value = Target.RESULT_NONE
@@ -203,12 +201,10 @@ def test_replay_07(mocker, tmp_path):
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     testcases = [
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        )
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     server.serve_path.side_effect = (
-        (SERVED_ALL, ["index.html"]),
+        (SERVED_ALL, ["a.html"]),
         (SERVED_REQUEST, ["x"]),
     )
     with ReplayManager([], server, target, use_harness=True, relaunch=10) as replay:
@@ -224,15 +220,13 @@ def test_replay_08(mocker, tmp_path):
     """test ReplayManager.run() - ignored"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = Target.RESULT_IGNORED
     target.monitor.is_healthy.return_value = False
     testcases = [
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        )
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases, 10)
@@ -249,16 +243,14 @@ def test_replay_09(mocker, tmp_path):
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="path/fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.RESULT_NONE = Target.RESULT_NONE
     target.save_logs = _fake_save_logs
     testcases = [
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        )
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     # early failure
     target.detect_failure.side_effect = (
@@ -339,16 +331,14 @@ def test_replay_10(mocker, tmp_path):
     fake_report.side_effect = (report_0, report_1, report_2, report_3)
     fake_report.calc_hash.return_value = "bucketHASH"
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, False, False)
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        )
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     with ReplayManager(
         [], server, target, signature=signature, use_harness=False
@@ -395,7 +385,7 @@ def test_replay_11(mocker, tmp_path):
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
     testcases = [
-        mocker.Mock(spec_set=TestCase, env_vars=[], landing_page="a.html", optional=[])
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     with ReplayManager(
         [], server, target, signature=signature, use_harness=False
@@ -433,15 +423,13 @@ def test_replay_12(mocker, tmp_path):
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1, report_2)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
     testcases = [
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        )
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
         results = replay.run(testcases, 10, repeat=3, min_results=2)
@@ -479,15 +467,13 @@ def test_replay_13(mocker, tmp_path):
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1, report_2, report_3)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
     testcases = [
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        )
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     with ReplayManager([], server, target, any_crash=True) as replay:
         assert not replay.run(testcases, 10, repeat=4, min_results=3)
@@ -526,15 +512,13 @@ def test_replay_14(mocker, tmp_path):
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_1, report_2, report_3)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     target.monitor.is_healthy.return_value = False
     testcases = [
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        )
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     with ReplayManager([], server, target, use_harness=False) as replay:
         results = replay.run(testcases, 10, repeat=3, min_results=2)
@@ -564,14 +548,12 @@ def test_replay_15(mocker, tmp_path):
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0,)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.side_effect = ((SERVED_ALL, ["index.html"]), KeyboardInterrupt)
+    server.serve_path.side_effect = ((SERVED_ALL, ["a.html"]), KeyboardInterrupt)
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
     testcases = [
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        )
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     with ReplayManager(
         [], server, target, any_crash=True, use_harness=True, relaunch=2
@@ -592,20 +574,13 @@ def test_replay_16(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
     testcases = [
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        ),
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        ),
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        ),
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
+        for _ in range(3)
     ]
     with ReplayManager([], server, target, use_harness=True) as replay:
         assert not replay.run(testcases, 10)
@@ -619,7 +594,7 @@ def test_replay_16(mocker):
 def test_replay_17(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, launch_timeout=30)
     # test relaunch < repeat
     type(target).closed = mocker.PropertyMock(side_effect=cycle([True, False]))
@@ -627,15 +602,8 @@ def test_replay_17(mocker):
     target.detect_failure.return_value = Target.RESULT_NONE
     target.monitor.is_healthy.return_value = False
     testcases = [
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        ),
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        ),
-        mocker.Mock(
-            spec_set=TestCase, env_vars=[], landing_page="index.html", optional=[]
-        ),
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
+        for _ in range(3)
     ]
     with ReplayManager([], server, target, use_harness=True, relaunch=2) as replay:
         assert not replay.run(testcases, 10, repeat=10)
@@ -669,9 +637,9 @@ def test_replay_18(mocker, tmp_path):
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     testcases = [
-        mocker.Mock(spec_set=TestCase, env_vars=[], landing_page="a.html", optional=[]),
-        mocker.Mock(spec_set=TestCase, env_vars=[], landing_page="b.html", optional=[]),
-        mocker.Mock(spec_set=TestCase, env_vars=[], landing_page="c.html", optional=[]),
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[]),
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="b.html", optional=[]),
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="c.html", optional=[]),
     ]
     with ReplayManager([], server, target, use_harness=True) as replay:
         results = replay.run(testcases, 30)
@@ -763,11 +731,11 @@ def test_replay_20(mocker, tmp_path):
 def test_replay_21(mocker, tmp_path):
     """test ReplayManager.load_testcases()"""
     fake_load = mocker.patch("grizzly.replay.replay.TestCase.load")
-    test0 = mocker.Mock(spec_set=TestCase)
+    test0 = mocker.Mock(spec_set=TestCase, env_vars={"env": "var"})
     test0.pop_assets.return_value = None
-    test1 = mocker.Mock(spec_set=TestCase, landing_page="x.html")
+    test1 = mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="x.html")
     test1.pop_assets.return_value = None
-    test2 = mocker.Mock(spec_set=TestCase)
+    test2 = mocker.Mock(spec_set=TestCase, env_vars={})
     test2.pop_assets.return_value = None
     # failure
     fake_load.return_value = ()
@@ -775,15 +743,22 @@ def test_replay_21(mocker, tmp_path):
         ReplayManager.load_testcases(str(tmp_path))
     # success
     fake_load.return_value = [test0, test1]
-    tests, assets = ReplayManager.load_testcases(str(tmp_path))
+    tests, assets, env_vars = ReplayManager.load_testcases(str(tmp_path))
+    assert env_vars["env"] == "var"
+    assert not any(x.env_vars for x in tests)
     assert len(tests) == 2
     assert tests[0].cleanup.call_count == 0
     assert tests[1].cleanup.call_count == 0
     assert assets is None
     # success select
     test0.pop_assets.return_value = mocker.Mock(spec_set=AssetManager)
-    fake_load.return_value = [test0, test1, test2, mocker.Mock(spec_set=TestCase)]
-    tests, assets = ReplayManager.load_testcases(str(tmp_path), subset=[1, 3])
+    fake_load.return_value = [
+        test0,
+        test1,
+        test2,
+        mocker.Mock(spec_set=TestCase, env_vars={}),
+    ]
+    tests, assets, _ = ReplayManager.load_testcases(str(tmp_path), subset=[1, 3])
     assert len(tests) == 2
     assert tests[0].landing_page == "x.html"
     assert test0.cleanup.call_count == 1
@@ -795,7 +770,7 @@ def test_replay_21(mocker, tmp_path):
     # select (first and last) with invalid input
     test0.pop_assets.return_value = None
     fake_load.return_value = [test0, test1, test2]
-    tests, _ = ReplayManager.load_testcases(str(tmp_path), subset=[0, 10, -10, -1])
+    tests, _a, _e = ReplayManager.load_testcases(str(tmp_path), subset=[0, 10, -10, -1])
     assert len(tests) == 2
     assert test0.cleanup.call_count == 0
     assert test1.cleanup.call_count == 1
diff --git a/grizzly/session.py b/grizzly/session.py
index 544623bf..3d7267b0 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -217,6 +217,7 @@ def run(
                 )
             current_test.duration = result.duration
             current_test.assets = self.target.assets
+            current_test.env_vars = dict(self.target.environ)
             # adapter callbacks
             if result.timeout:
                 current_test.hang = True
diff --git a/grizzly/target/assets.py b/grizzly/target/assets.py
index 5712ef28..6d954356 100644
--- a/grizzly/target/assets.py
+++ b/grizzly/target/assets.py
@@ -69,7 +69,9 @@ def add(self, asset, path, copy=True):
         else:
             move(path, self.path)
         self.assets[asset] = dst_path
-        LOG.debug("added asset %r %s to %r", asset, "copied" if copy else "moved", path)
+        LOG.debug(
+            "added asset %r %s to %r", asset, "copied" if copy else "moved", dst_path
+        )
         return dst_path
 
     def add_batch(self, assets):
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 982daa89..21db22ba 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -4,6 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
 from os import kill
+from os.path import isfile
 from os.path import join as pathjoin
 from platform import system
 from signal import SIGABRT
@@ -20,7 +21,7 @@
 from psutil import AccessDenied, NoSuchProcess, Process, process_iter
 
 from ..common.reporter import Report
-from ..common.utils import grz_tmp
+from ..common.utils import grz_tmp, split_sanitizer_opts
 from .target import Target, TargetError, TargetLaunchError, TargetLaunchTimeout
 from .target_monitor import TargetMonitor
 
@@ -37,8 +38,24 @@ class PuppetTarget(Target):
         "abort-tokens",
         # xpi or directory containing the unpacked extension
         "extension",
+        # LSan suppression list file
+        "lsan-suppressions",
         # prefs.js file to use
         "prefs",
+        # TSan suppression list file
+        "tsan-suppressions",
+        # UBSan suppression list file
+        "ubsan-suppressions",
+    )
+
+    TRACKED_ENVVARS = (
+        "ASAN_OPTIONS",
+        "LSAN_OPTIONS",
+        "TSAN_OPTIONS",
+        "UBSAN_OPTIONS",
+        "GNOME_ACCESSIBILITY",
+        "MOZ_CHAOSMODE",
+        "XPCOM_DEBUG_BREAK",
     )
 
     __slots__ = ("use_valgrind", "_extension", "_prefs", "_puppet")
@@ -248,9 +265,9 @@ def dump_coverage(self, timeout=15):
                 break
             sleep(delay)
 
-    def launch(self, location, env_mod=None):
+    def launch(self, location):
         # setup environment
-        env_mod = dict(env_mod or [])
+        env_mod = dict(self.environ)
         # do not allow network connections to non local endpoints
         env_mod["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1"
         env_mod["MOZ_CRASHREPORTER_SHUTDOWN"] = "1"
@@ -300,5 +317,31 @@ def process_assets(self):
                     if line:
                         self._puppet.add_abort_token(line)
 
+        # configure sanitizer suppressions
+        for sanitizer in ("lsan", "tsan", "ubsan"):
+            var_name = "%s_OPTIONS" % (sanitizer.upper(),)
+            # load existing sanitizer options from environment
+            if var_name in self.environ:
+                opts = split_sanitizer_opts(self.environ[var_name])
+            else:
+                opts = dict()
+            asset = "%s-suppressions" % (sanitizer,)
+            supp_file = opts.pop("suppressions", "").strip("'")
+            if self.assets.get(asset):
+                # use suppression file if provided as asset
+                opts["suppressions"] = "%r" % (self.assets.get(asset),)
+            elif isfile(supp_file):
+                # use environment specified suppression file
+                LOG.debug("using %r from environment", asset)
+                opts["suppressions"] = "%r" % (self.assets.add(asset, supp_file),)
+            elif supp_file:
+                LOG.warning("Missing %s suppressions file %r", sanitizer, supp_file)
+            # update sanitized *SAN_OPTIONS
+            if "suppressions" in opts:
+                LOG.debug("updating suppressions in %r", var_name)
+                self.environ[var_name] = ":".join(
+                    "=".join((k, v)) for k, v in opts.items()
+                )
+
     def save_logs(self, *args, **kwargs):
         self._puppet.save_logs(*args, **kwargs)
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 1b5068c7..5cce5b72 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -4,6 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from abc import ABCMeta, abstractmethod
 from logging import getLogger
+from os import environ
 from os.path import isfile
 from threading import Lock
 
@@ -38,12 +39,14 @@ class Target(metaclass=ABCMeta):
     RESULT_FAILURE = 1
     RESULT_IGNORED = 2
     SUPPORTED_ASSETS = None
+    TRACKED_ENVVARS = ()
 
     __slots__ = (
         "_assets",
         "_lock",
         "_monitor",
         "binary",
+        "environ",
         "launch_timeout",
         "log_limit",
         "memory_limit",
@@ -58,6 +61,7 @@ def __init__(self, binary, launch_timeout, log_limit, memory_limit, assets=None)
         self._lock = Lock()
         self._monitor = None
         self.binary = binary
+        self.environ = self.scan_environment(dict(environ), self.TRACKED_ENVVARS)
         self.launch_timeout = max(launch_timeout, 300)
         self.log_limit = log_limit
         self.memory_limit = memory_limit
@@ -117,7 +121,7 @@ def is_idle(self, _threshold):  # pylint: disable=no-self-use
         return False
 
     @abstractmethod
-    def launch(self, _location, _env_mod=None):
+    def launch(self, location):
         pass
 
     def log_size(self):  # pylint: disable=no-self-use
@@ -137,6 +141,16 @@ def reverse(self, remote, local):
         # remote->device, local->desktop
         pass
 
+    @staticmethod
+    def scan_environment(to_scan, tracked):
+        # scan environment for tracked environment variables
+        env = dict()
+        if tracked:
+            for var in tracked:
+                if var in to_scan:
+                    env[var] = to_scan[var]
+        return env
+
     @abstractmethod
     def save_logs(self, *args, **kwargs):
         pass
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 30375c30..3135f999 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -358,3 +358,43 @@ def test_puppet_target_09(mocker, tmp_path, pernosco, rr, valgrind):
         assert fake_ffp.call_args[-1]["debugger"] == Debugger.VALGRIND
     else:
         assert fake_ffp.call_args[-1]["debugger"] == Debugger.NONE
+
+
+@mark.parametrize(
+    "asset, env",
+    [
+        # suppressions via asset
+        (True, False),
+        # suppressions via env
+        (False, True),
+        # suppressions via both asset and env (asset should be preferred)
+        (True, True),
+        # missing suppressions file
+        (False, False),
+    ],
+)
+def test_puppet_target_10(tmp_path, asset, env):
+    """test PuppetTarget.process_assets() - configure sanitizer suppressions"""
+    fake_file = tmp_path / "fake"
+    fake_file.touch()
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        assets.add("prefs", str(fake_file))
+        if asset:
+            supp_asset = tmp_path / "supp_asset"
+            supp_asset.touch()
+            assets.add("lsan-suppressions", str(supp_asset))
+        with PuppetTarget(str(fake_file), 300, 25, 5000, assets=assets) as target:
+            if env:
+                supp_env = tmp_path / "supp_env"
+                supp_env.touch()
+                target.environ["LSAN_OPTIONS"] = "suppressions='%s'" % (str(supp_env),)
+            else:
+                target.environ["LSAN_OPTIONS"] = "suppressions='missing'"
+            target.process_assets()
+            if asset:
+                assert supp_asset.name in target.environ["LSAN_OPTIONS"]
+            elif env:
+                assert supp_env.name in target.environ["LSAN_OPTIONS"]
+                assert assets.get("lsan-suppressions")
+            else:
+                assert not assets.get("lsan-suppressions")
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index 1aeb0fd3..2a652f71 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -6,6 +6,8 @@
 
 
 class SimpleTarget(Target):
+    TRACKED_ENVVARS = ("TEST_INC",)
+
     def _cleanup(self):
         pass
 
@@ -25,17 +27,13 @@ def detect_failure(self, ignored):
     def handle_hang(self, ignore_idle=True):
         pass
 
-    def launch(self, _location, _env_mod=None):
+    def launch(self, location):
         pass
 
     @property
     def monitor(self):
         return self._monitor
 
-    @property
-    def prefs(self):
-        pass
-
     def process_assets(self):
         pass
 
@@ -53,6 +51,7 @@ def test_target_01(tmp_path):
         org_path = target.assets.path
         target.assets = AssetManager(base_path=str(tmp_path))
         assert target.assets.path != org_path
+        assert not target.environ
         assert not target.is_idle(0)
         assert target.launch_timeout == 321
         assert target.log_size() == 0
@@ -62,3 +61,21 @@ def test_target_01(tmp_path):
         # test stubs
         target.dump_coverage()
         target.reverse(1, 2)
+
+
+def test_target_02(mocker, tmp_path):
+    """test loading TRACKED_ENVVARS"""
+    mocker.patch.dict("grizzly.target.target.environ", {"SKIP": "x", "TEST_INC": "1"})
+    fake_file = tmp_path / "fake"
+    fake_file.touch()
+    with SimpleTarget(str(fake_file), 321, 2, 3) as target:
+        assert target.environ
+        assert "SKIP" not in target.environ
+        assert target.environ["TEST_INC"] == "1"
+
+
+def test_target_03():
+    """test Target.scan_environment()"""
+    assert not Target.scan_environment({"a": "1"}, [])
+    assert not Target.scan_environment({}, ["a"])
+    assert Target.scan_environment({"a": "1", "b": "2"}, ["a"]) == {"a": "1"}
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 18ab78d2..fb71fb3b 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -71,8 +71,9 @@ def test_session_01(
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
         spec_set=Target,
-        launch_timeout=30,
         assets=mocker.Mock(spec_set=AssetManager),
+        environ=dict(),
+        launch_timeout=30,
     )
     target.log_size.return_value = 1000
     target.monitor.launches = 1
@@ -141,8 +142,9 @@ def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
         spec_set=Target,
-        launch_timeout=30,
         assets=mocker.Mock(spec_set=AssetManager),
+        environ=dict(),
+        launch_timeout=30,
     )
     # calculate if the target is 'closed' based on relaunch
     type(target).closed = mocker.PropertyMock(
@@ -197,8 +199,9 @@ def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
         spec_set=Target,
-        launch_timeout=30,
         assets=mocker.Mock(spec_set=AssetManager),
+        environ=dict(),
+        launch_timeout=30,
     )
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
@@ -240,8 +243,9 @@ def generate(self, _testcase, _server_map):
     server.serve_path.return_value = (SERVED_NONE, [])
     target = mocker.Mock(
         spec_set=Target,
-        launch_timeout=30,
         assets=mocker.Mock(spec_set=AssetManager),
+        environ=dict(),
+        launch_timeout=30,
     )
     target.monitor.launches = 1
     with Session(FuzzAdapter("fuzz"), None, server, target) as session:
@@ -256,8 +260,9 @@ def test_session_05(mocker, tmp_path):
     server.serve_path.return_value = (SERVED_TIMEOUT, [])
     target = mocker.Mock(
         spec_set=Target,
-        launch_timeout=30,
         assets=mocker.Mock(spec_set=AssetManager),
+        environ=dict(),
+        launch_timeout=30,
     )
     target.monitor.launches = 1
     with Session(SimpleAdapter(False), None, server, target) as session:
@@ -285,8 +290,9 @@ def test_session_06(mocker, tmp_path, harness, report_size):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
         spec_set=Target,
-        launch_timeout=30,
         assets=mocker.Mock(spec_set=AssetManager),
+        environ=dict(),
+        launch_timeout=30,
     )
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
@@ -331,9 +337,10 @@ def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, resul
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
         spec_set=Target,
+        assets=mocker.Mock(spec_set=AssetManager),
         closed=True,
+        environ=dict(),
         launch_timeout=30,
-        assets=mocker.Mock(spec_set=AssetManager),
     )
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_NONE = Target.RESULT_NONE
@@ -362,7 +369,9 @@ def test_session_08(tmp_path, mocker):
     adapter = mocker.Mock(spec_set=Adapter, remaining=None)
     adapter.IGNORE_UNSERVED = False
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    target = mocker.Mock(spec_set=Target, assets=mocker.Mock(spec_set=AssetManager))
+    target = mocker.Mock(
+        spec_set=Target, assets=mocker.Mock(spec_set=AssetManager), environ=dict()
+    )
     target.monitor.launches = 1
     with Session(adapter, None, server, target) as session:
         session.run([], 10, iteration_limit=1)
@@ -404,7 +413,11 @@ def test_session_10(tmp_path, mocker):
     report = mocker.Mock(spec_set=Report, major="major123", minor="minor456")
     reporter = mocker.Mock(spec_set=Reporter)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    target = mocker.Mock(spec_set=Target, assets=mocker.Mock(spec_set=AssetManager))
+    target = mocker.Mock(
+        spec_set=Target,
+        assets=mocker.Mock(spec_set=AssetManager),
+        environ=dict(),
+    )
     target.monitor.launches = 1
     target.create_report.return_value = report
     with Session(adapter, reporter, server, target) as session:

From 06d8488b48ea2d50e3de6eb47aa3adfe153f57ac Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 27 Jul 2021 16:41:51 -0700
Subject: [PATCH 292/531] Fix '--prefs' argument

---
 grizzly/args.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 7da6bde1..d373cf64 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -231,7 +231,7 @@ def sanity_check(self, args):
 
         # TODO: remove deprecated 'prefs' from args
         if args.prefs:  # pragma: no cover
-            args.asset.append(["prefs", args.extension])
+            args.asset.append(["prefs", args.prefs])
 
         # check args.platform before args.asset since it is used
         if args.asset:

From e628d0c151217c2340e9efa073dbffcb4c95004e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 27 Jul 2021 16:59:01 -0700
Subject: [PATCH 293/531] TestCase is not responsible for calling
 AssetManager.cleanup()

---
 grizzly/common/storage.py      | 13 ++++++-------
 grizzly/common/test_storage.py |  9 ++++++---
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 907b5580..6657d9f3 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -173,11 +173,11 @@ def add_from_file(self, input_file, file_name=None, required=True):
             tfile.close()
             raise
 
-    def cleanup(self, skip_assets=True):
+    def cleanup(self):
         """Close all the test files.
 
         Args:
-            skip_assets (bool): Skip calling cleanup() on assets.
+            None
 
         Returns:
             None
@@ -185,8 +185,6 @@ def cleanup(self, skip_assets=True):
         for file_group in self._files:
             for test_file in file_group:
                 test_file.close()
-        if not skip_assets and self.assets:
-            self.assets.cleanup()
 
     def clone(self):
         """Make a copy of the TestCase.
@@ -205,10 +203,10 @@ def clone(self):
             self.time_limit,
             self.timestamp,
         )
+        result.assets = self.assets
         result.duration = self.duration
+        result.env_vars = dict(self.env_vars)
         result.hang = self.hang
-        result.env_vars.update(self.env_vars)
-        # TODO: should we handle assets?
         for entry in self._files.optional:
             result.add_file(entry.clone(), required=False)
         for entry in self._files.required:
@@ -416,7 +414,8 @@ def load_single(cls, path, adjacent=False, load_assets=True):
                     if not isinstance(name, str) or not isinstance(value, str):
                         raise TestCaseLoadFailure("'env' contains invalid entries")
             except TestCaseLoadFailure:
-                test.cleanup(skip_assets=False)
+                if test.assets:
+                    test.assets.cleanup()
                 raise
         # load all adjacent data from directory
         if adjacent:
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index c9722891..9342b8d2 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -256,7 +256,8 @@ def test_testcase_08(tmp_path):
             assert loaded.assets
             assert "fake" in loaded.assets.assets
         finally:
-            loaded.cleanup(skip_assets=False)
+            if loaded.assets:
+                loaded.assets.cleanup()
 
 
 def test_testcase_09(tmp_path):
@@ -290,7 +291,7 @@ def test_testcase_11(tmp_path):
         assert len(testcases) == 1
         assert all(x.assets is None for x in testcases)
     finally:
-        map(lambda x: x.cleanup(), testcases)
+        map(lambda x: x.cleanup, testcases)
 
 
 def test_testcase_12(tmp_path):
@@ -315,7 +316,9 @@ def test_testcase_12(tmp_path):
         assert asset is not None
         assert "example" in asset.assets
     finally:
-        map(lambda x: x.cleanup(skip_assets=False), testcases)
+        for test in testcases:
+            if test.assets:
+                test.cleanup()
     # try loading testcases that are nested too deep
     assert not TestCase.load(str(tmp_path))
 

From d0f0d97073f79a0a53b4393c1aed23c3cf7a8bb4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 27 Jul 2021 17:15:58 -0700
Subject: [PATCH 294/531] Include assets in reduced test cases

---
 grizzly/reduce/core.py            |  10 ++-
 grizzly/reduce/test_reduce.py     | 101 ++++++++++++++++++++++++------
 grizzly/reduce/test_strategies.py |  11 ++--
 3 files changed, 99 insertions(+), 23 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index edbdaf11..7cf6206e 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -533,6 +533,14 @@ def run(self, repeat=1, min_results=1):
                                     LOG.info("Reduction succeeded")
                                     for testcase in self.testcases:
                                         testcase.cleanup()
+                                    # add target assets to test cases
+                                    if not self.target.assets.is_empty():
+                                        for test in reduction:
+                                            test.assets = self.target.assets
+                                    # add target environment variables
+                                    if self.target.environ:
+                                        for test in reduction:
+                                            test.env_vars = dict(self.target.environ)
                                     self.testcases = reduction
                                     keep_reduction = True
                                     # cleanup old best results
@@ -682,7 +690,7 @@ def report(self, results, testcases, stats=None):
                 if result.served is not None:
                     for clone, served in zip(clones, result.served):
                         clone.purge_optional(served)
-                ret_values.append(reporter.submit(clones, report=result.report))
+                ret_values.append(reporter.submit(clones, result.report))
             finally:
                 for clone in clones:
                     clone.cleanup()
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 345e7821..f4b5db87 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -17,7 +17,7 @@
 from ..common.reporter import Report
 from ..common.storage import TestCase
 from ..replay import ReplayResult
-from ..target import Target
+from ..target import AssetManager, Target
 from . import ReduceManager
 from .exceptions import NotReproducible
 from .strategies import Strategy
@@ -550,7 +550,8 @@ def replay_run(testcases, _time_limit, **_):
     tests = [test]
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec_set=Target)
+    target = mocker.Mock(spec_set=Target, environ={})
+    target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
             [],
@@ -614,7 +615,7 @@ def replay_run(_tests, _time_limit, **_kw):
     replayer.run.side_effect = replay_run
 
     (tmp_path / "test.html").touch()
-    testcases = TestCase.load(str(tmp_path / "test.html"), False)
+    testcases = TestCase.load(str(tmp_path / "test.html"))
     assert testcases
     log_path = tmp_path / "logs"
 
@@ -625,14 +626,15 @@ def fake_iter():
         for count_ in range(1, 61):
             LOG.debug("fake_iter() %d", count_)
             (tmp_path / "test.html").write_text(str(count_))
-            testcases = TestCase.load(str(tmp_path / "test.html"), False)
+            testcases = TestCase.load(str(tmp_path / "test.html"))
             assert testcases
             yield testcases
 
     fake_strat.return_value.__iter__.side_effect = fake_iter
     mocker.patch("grizzly.reduce.core.STRATEGIES", new={"fake": fake_strat})
 
-    target = mocker.Mock(spec_set=Target)
+    target = mocker.Mock(spec_set=Target, environ={})
+    target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
             [],
@@ -683,7 +685,7 @@ def replay_run(_tests, _time_limit, **_kw):
     replayer.run.side_effect = replay_run
 
     (tmp_path / "test.html").touch()
-    testcases = TestCase.load(str(tmp_path / "test.html"), False)
+    testcases = TestCase.load(str(tmp_path / "test.html"))
     assert testcases
     log_path = tmp_path / "logs"
 
@@ -694,7 +696,7 @@ def fake_iter():
         for count_ in range(1, 31):
             LOG.debug("fake_iter() %d", count_)
             (tmp_path / "test.html").write_text(str(count_))
-            testcases = TestCase.load(str(tmp_path / "test.html"), False)
+            testcases = TestCase.load(str(tmp_path / "test.html"))
             assert testcases
             yield testcases
         raise KeyboardInterrupt()
@@ -702,7 +704,8 @@ def fake_iter():
     fake_strat.return_value.__iter__.side_effect = fake_iter
     mocker.patch("grizzly.reduce.core.STRATEGIES", new={"fake": fake_strat})
 
-    target = mocker.Mock(spec_set=Target)
+    target = mocker.Mock(spec_set=Target, environ={})
+    target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
             [],
@@ -753,15 +756,16 @@ def replay_run(testcases, _time_limit, **_kw):
     replayer.run.side_effect = replay_run
 
     (tmp_path / "test.html").write_text("123\n")
-    testcases = TestCase.load(str(tmp_path / "test.html"), False)
+    testcases = TestCase.load(str(tmp_path / "test.html"))
     assert testcases
     log_path = tmp_path / "logs"
 
-    mocker.patch("grizzly.common.reporter.Collector")
-    reporter = mocker.patch("grizzly.reduce.core.FuzzManagerReporter")
+    mocker.patch("grizzly.common.reporter.Collector", autospec=True)
+    reporter = mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
     reporter.QUAL_REDUCED_RESULT = 0
     update_coll = mocker.patch("grizzly.common.fuzzmanager.Collector")
-    target = mocker.Mock(spec_set=Target)
+    target = mocker.Mock(spec_set=Target, environ={})
+    target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
             [],
@@ -779,12 +783,12 @@ def replay_run(testcases, _time_limit, **_kw):
             test.cleanup()
 
     assert reporter.return_value.submit.call_count == 1
-    report_args, report_kwds = reporter.return_value.submit.call_args
-    assert len(report_args) == 1
+    report_args, _ = reporter.return_value.submit.call_args
+    assert len(report_args) == 2
     assert isinstance(report_args[0], list)
     assert len(report_args[0]) == 1
     assert isinstance(report_args[0][0], TestCase)
-    assert report_kwds.keys() == {"report"}
+    assert isinstance(report_args[1], Report)
     assert update_coll.call_count == 1
     assert update_coll.return_value.patch.call_count == 1
     assert update_coll.return_value.patch.call_args[1] == {
@@ -792,6 +796,67 @@ def replay_run(testcases, _time_limit, **_kw):
     }
 
 
+def test_include_assets_and_environ(mocker, tmp_path):
+    """test report with assets and environment variables"""
+    mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
+    replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
+    replayer = replayer.return_value
+    replayer.status.iteration = 1
+
+    def replay_run(testcases, _time_limit, **_kw):
+        for test in testcases:
+            contents = test.get_file("test.html").data.decode("ascii")
+            if not contents.strip():
+                continue
+            log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
+            log_path.mkdir()
+            _fake_save_logs_foo(log_path)
+            report = Report(str(log_path), "bin")
+            return [ReplayResult(report, [["test.html"]], [], True)]
+        return []
+
+    replayer.run.side_effect = replay_run
+
+    (tmp_path / "test.html").write_text("123\n")
+    testcases = TestCase.load(str(tmp_path / "test.html"))
+    assert testcases
+    log_path = tmp_path / "logs"
+
+    reporter = mocker.patch("grizzly.reduce.core.FilesystemReporter", autospec=True)
+
+    def submit(test_cases, report):
+        assert test_cases
+        assert isinstance(report, Report)
+        for test in test_cases:
+            assert test.assets.get("example")
+            assert test.env_vars == {"test": "abc"}
+            test.cleanup()
+
+    reporter.return_value.submit.side_effect = submit
+
+    target = mocker.Mock(spec_set=Target, environ={"test": "abc"})
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        (tmp_path / "example_asset").touch()
+        assets.add("example", str(tmp_path / "example_asset"), copy=False)
+        target.assets = assets
+        try:
+            mgr = ReduceManager(
+                [],
+                mocker.Mock(spec_set=Sapphire, timeout=30),
+                target,
+                testcases,
+                ["check", "lines"],
+                log_path,
+                use_analysis=False,
+            )
+            assert mgr.run() == 0
+        finally:
+            for test in testcases:
+                test.cleanup()
+
+    assert reporter.return_value.submit.call_count == 1
+
+
 TimeoutTestParams = namedtuple(
     "TimeoutTestParams",
     "durations, interesting, static_timeout, idle_input, idle_output, iter_input,"
@@ -892,9 +957,9 @@ def replay_run(_testcases, _time_limit, **_):
     tests = [test]
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec_set=Target)
-    server = mocker.Mock(spec_set=Sapphire)
-    server.timeout = iter_input
+    target = mocker.Mock(spec_set=Target, environ={})
+    target.assets = mocker.Mock(spec_set=AssetManager)
+    server = mocker.Mock(spec_set=Sapphire, timeout=iter_input)
     try:
         mgr = ReduceManager(
             [],
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index e8f2af93..af4a7ddb 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -14,7 +14,7 @@
 from ..common.reporter import Report
 from ..common.storage import TestCase
 from ..replay import ReplayResult
-from ..target import Target
+from ..target import AssetManager, Target
 from . import ReduceManager
 from .strategies import Strategy, _load_strategies
 
@@ -175,7 +175,8 @@ def replay_run(testcases, _time_limit, **_):
         tests.append(test)
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec_set=Target)
+    target = mocker.Mock(spec_set=Target, environ={})
+    target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
             [],
@@ -354,7 +355,8 @@ def replay_run(testcases, _time_limit, **_):
         tests.append(test)
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec_set=Target)
+    target = mocker.Mock(spec_set=Target, environ={})
+    target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
             [],
@@ -412,7 +414,8 @@ def replay_run(testcases, _time_limit, **_):
     tests = [test]
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec_set=Target)
+    target = mocker.Mock(spec_set=Target, environ={})
+    target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
             [],

From 2296b15c83995057b5da6c9a39629064a206b6bf Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 29 Jul 2021 11:26:26 -0700
Subject: [PATCH 295/531] [test] Add coverage and comment to storage.py

---
 grizzly/common/storage.py      |  8 ++++++++
 grizzly/common/test_storage.py | 35 +++++++++++++++++++++++-----------
 2 files changed, 32 insertions(+), 11 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 6657d9f3..e749edb8 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -448,6 +448,14 @@ def optional(self):
             yield test.file_name
 
     def pop_assets(self):
+        """Remove AssetManager from TestCase.
+
+        Args:
+            None
+
+        Returns:
+            AssetManager: AssetManager if exists otherwise None.
+        """
         if self.assets is None:
             assets = None
         else:
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 9342b8d2..c101720a 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -9,7 +9,7 @@
 from json import dumps, loads
 from zipfile import ZIP_DEFLATED, ZipFile
 
-from pytest import raises
+from pytest import mark, raises
 
 from ..target import AssetManager
 from .storage import TestCase, TestCaseLoadFailure, TestFile, TestFileExists
@@ -77,6 +77,9 @@ def test_testcase_02(tmp_path):
 def test_testcase_03():
     """test TestCase.purge_optional()"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
+        # no optional files
+        tcase.purge_optional(["foo"])
+        # setup
         tcase.add_from_data("foo", "testfile1.bin")
         tcase.add_from_data("foo", "testfile2.bin", required=False)
         tcase.add_from_data("foo", "testfile3.bin", required=False)
@@ -138,8 +141,12 @@ def test_testcase_05(tmp_path):
         TestCase.load_single(str(src_dir))
     # bad 'env' entry in test_info.json
     entry_point.touch()
-    with TestCase("target.bin", None, "test-adapter") as src:
-        src.dump(str(src_dir), include_details=True)
+    with AssetManager(base_path=str(tmp_path)) as assets:
+        (tmp_path / "example_asset").touch()
+        assets.add("example", str(tmp_path / "example_asset"), copy=False)
+        with TestCase("target.bin", None, "test-adapter") as src:
+            src.assets = assets
+            src.dump(str(src_dir), include_details=True)
     test_info = loads((src_dir / "test_info.json").read_text())
     test_info["env"] = {"bad": 1}
     (src_dir / "test_info.json").write_text(dumps(test_info))
@@ -182,10 +189,8 @@ def test_testcase_06(mocker, tmp_path):
     with TestCase.load_single(str(dst_dir)) as dst:
         asset = dst.pop_assets()
         assert asset
-        try:
+        with asset:
             assert "example" in asset.assets
-        finally:
-            asset.cleanup()
         assert dst.landing_page == "target.bin"
         assert "target.bin" in (x.file_name for x in dst._files.required)
         assert "optional.bin" in (x.file_name for x in dst._files.optional)
@@ -513,14 +518,22 @@ def test_testfile_04(tmp_path):
         assert out_file.is_file()
 
 
-def test_testfile_05(tmp_path):
+@mark.parametrize(
+    "in_data, out_data",
+    [
+        # data as string
+        ("foo", "foo"),
+        # data as binary
+        (b"foo", "foo"),
+    ],
+)
+def test_testfile_05(tmp_path, in_data, out_data):
     """test TestFile.from_data()"""
-    # TODO: different encodings
-    with TestFile.from_data("foo", "test_file.txt") as tfile:
-        out_file = tmp_path / "test_file.txt"
+    with TestFile.from_data(in_data, "test_file.txt") as tfile:
         tfile.dump(str(tmp_path))
+        out_file = tmp_path / "test_file.txt"
         assert out_file.is_file()
-        assert out_file.read_text() == "foo"
+        assert out_file.read_text() == out_data
 
 
 def test_testfile_06(tmp_path):

From 493d5b38bd2bfe17f69aab159c104cdade4d32b9 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 5 Aug 2021 17:10:27 -0700
Subject: [PATCH 296/531] [sapphire] Use enum for served status codes

---
 grizzly/common/runner.py      |  4 +--
 grizzly/common/test_runner.py | 29 ++++++---------
 grizzly/replay/test_main.py   | 10 +++---
 grizzly/replay/test_replay.py | 46 ++++++++++++------------
 grizzly/test_session.py       | 20 +++++------
 sapphire/__init__.py          |  7 ++--
 sapphire/core.py              | 16 ++++-----
 sapphire/job.py               | 24 ++++++++-----
 sapphire/test_job.py          | 20 +++++------
 sapphire/test_sapphire.py     | 68 +++++++++++++++++------------------
 10 files changed, 121 insertions(+), 123 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index a6c16a5f..78ea290d 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -7,7 +7,7 @@
 from tempfile import mkdtemp
 from time import sleep, time
 
-from sapphire import SERVED_TIMEOUT
+from sapphire import Served
 
 from ..target import TargetLaunchError, TargetLaunchTimeout
 from .utils import grz_tmp
@@ -221,7 +221,7 @@ def run(
             # remove temporary files
             if test_path is None:
                 rmtree(wwwdir)
-        result = RunResult(served, duration, timeout=server_status == SERVED_TIMEOUT)
+        result = RunResult(served, duration, timeout=server_status == Served.TIMEOUT)
         result.attempted = testcase.landing_page in result.served
         result.initial = self._tests_run == 0
         # TODO: fix calling TestCase.add_batch() for multi-test replay
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 15d759c7..c1d3b3d2 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -8,14 +8,7 @@
 
 from pytest import mark, raises
 
-from sapphire import (
-    SERVED_ALL,
-    SERVED_NONE,
-    SERVED_REQUEST,
-    SERVED_TIMEOUT,
-    Sapphire,
-    ServerMap,
-)
+from sapphire import Sapphire, Served, ServerMap
 
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from .reporter import Report
@@ -37,7 +30,7 @@ def test_runner_01(mocker, tmp_path):
     testcase = mocker.Mock(spec_set=TestCase, landing_page=serv_files[0], optional=[])
     # all files served
     serv_map = ServerMap()
-    server.serve_path.return_value = (SERVED_ALL, serv_files)
+    server.serve_path.return_value = (Served.ALL, serv_files)
     result = runner.run([], serv_map, testcase)
     assert result.attempted
     assert runner._tests_run == 1
@@ -53,7 +46,7 @@ def test_runner_01(mocker, tmp_path):
     assert testcase.dump.call_count == 1
     # dump coverage
     serv_map = ServerMap()
-    server.serve_path.return_value = (SERVED_ALL, serv_files)
+    server.serve_path.return_value = (Served.ALL, serv_files)
     result = runner.run([], serv_map, testcase, coverage=True)
     assert result.attempted
     assert runner._tests_run == 2
@@ -70,7 +63,7 @@ def test_runner_01(mocker, tmp_path):
     tc_path = tmp_path / "tc"
     tc_path.mkdir()
     serv_map = ServerMap()
-    server.serve_path.return_value = (SERVED_ALL, serv_files)
+    server.serve_path.return_value = (Served.ALL, serv_files)
     result = runner.run([], serv_map, testcase, test_path=str(tc_path))
     assert result.attempted
     assert runner._tests_run == 3
@@ -90,7 +83,7 @@ def test_runner_02(mocker):
     target = mocker.Mock(spec_set=Target)
     target.detect_failure.return_value = target.RESULT_NONE
     serv_files = ["a.bin"]
-    server.serve_path.return_value = (SERVED_ALL, serv_files)
+    server.serve_path.return_value = (Served.ALL, serv_files)
     testcase = mocker.Mock(spec_set=TestCase, landing_page=serv_files[0], optional=[])
     # single run/iteration relaunch (not idle exit)
     target.is_idle.return_value = False
@@ -151,9 +144,9 @@ def test_runner_02(mocker):
     "srv_result, served",
     [
         # no files served
-        (SERVED_NONE, []),
+        (Served.NONE, []),
         # landing page not served
-        (SERVED_REQUEST, ["harness"]),
+        (Served.REQUEST, ["harness"]),
     ],
 )
 def test_runner_03(mocker, srv_result, served):
@@ -190,7 +183,7 @@ def test_runner_04(mocker, ignore, status, idle, detect_failure):
     target = mocker.Mock(spec_set=Target)
     testcase = mocker.Mock(spec_set=TestCase, landing_page="a.bin", optional=[])
     serv_files = ["a.bin", "/another/file.bin"]
-    server.serve_path.return_value = (SERVED_TIMEOUT, serv_files)
+    server.serve_path.return_value = (Served.TIMEOUT, serv_files)
     target.detect_failure.return_value = target.RESULT_FAILURE
     target.handle_hang.return_value = idle
     target.monitor.is_healthy.return_value = False
@@ -219,7 +212,7 @@ def test_runner_04(mocker, ignore, status, idle, detect_failure):
 def test_runner_05(mocker, served, attempted, target_result, status):
     """test reporting failures"""
     server = mocker.Mock(spec_set=Sapphire)
-    server.serve_path.return_value = (SERVED_REQUEST, served)
+    server.serve_path.return_value = (Served.REQUEST, served)
     target = mocker.Mock(spec_set=Target, launch_timeout=10)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
@@ -242,7 +235,7 @@ def test_runner_06(mocker):
     target = mocker.Mock(spec_set=Target)
     target.detect_failure.return_value = target.RESULT_NONE
     serv_files = ["/fake/file", "/another/file.bin"]
-    server.serve_path.return_value = (SERVED_ALL, serv_files)
+    server.serve_path.return_value = (Served.ALL, serv_files)
     runner = Runner(server, target, idle_threshold=0.01, idle_delay=0.01, relaunch=10)
     assert runner._idle is not None
     result = runner.run(
@@ -342,7 +335,7 @@ def test_runner_10(mocker, tmp_path):
     smap.set_include("/", str(inc_path1))
     smap.set_include("/test", str(inc_path2))
     serv_files = ["a.b", str(inc1), str(inc2), str(inc3)]
-    server.serve_path.return_value = (SERVED_ALL, serv_files)
+    server.serve_path.return_value = (Served.ALL, serv_files)
     with TestCase("a.b", "x", "x") as tcase:
         result = runner.run([], smap, tcase)
         assert result.attempted
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index c41e809d..7d2e9b33 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -7,7 +7,7 @@
 """
 from pytest import mark
 
-from sapphire import SERVED_ALL
+from sapphire import Served
 
 from ..common.reporter import Report
 from ..common.storage import TestCase, TestCaseLoadFailure
@@ -27,7 +27,7 @@ def test_main_01(mocker, tmp_path):
     serve_path = mocker.patch(
         "grizzly.replay.replay.Sapphire.serve_path",
         autospec=True,
-        return_value=(SERVED_ALL, ["test.html"]),  # passed to Target.detect_failure
+        return_value=(Served.ALL, ["test.html"]),  # passed to Target.detect_failure
     )
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_plugin", autospec=True)
@@ -97,7 +97,7 @@ def test_main_02(mocker, tmp_path):
     mocker.patch(
         "grizzly.replay.replay.Sapphire.serve_path",
         autospec=True,
-        return_value=(SERVED_ALL, ["test.html"]),  # passed to Target.detect_failure
+        return_value=(Served.ALL, ["test.html"]),  # passed to Target.detect_failure
     )
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_plugin")
@@ -331,7 +331,7 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
     mocker.patch(
         "grizzly.replay.replay.Sapphire.serve_path",
         autospec=True,
-        return_value=(SERVED_ALL, ["test.html"]),  # passed to Target.detect_failure
+        return_value=(Served.ALL, ["test.html"]),  # passed to Target.detect_failure
     )
     # setup Target
     target = mocker.NonCallableMock(spec_set=Target, binary="bin", launch_timeout=30)
@@ -396,7 +396,7 @@ def test_main_07(mocker, tmp_path, pernosco, rr, valgrind, no_harness):
     mocker.patch(
         "grizzly.replay.replay.Sapphire.serve_path",
         autospec=True,
-        return_value=(SERVED_ALL, ["test.html"]),  # passed to Target.detect_failure
+        return_value=(Served.ALL, ["test.html"]),  # passed to Target.detect_failure
     )
     # setup Target
     target = mocker.NonCallableMock(spec_set=Target, binary="bin", launch_timeout=30)
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index c8214c4b..70c54262 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -11,7 +11,7 @@
 
 from pytest import mark, raises
 
-from sapphire import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT, Sapphire
+from sapphire import Sapphire, Served
 
 from ..common.reporter import Report
 from ..common.status import Status
@@ -50,7 +50,7 @@ def test_replay_02(mocker, tmp_path):
     """test ReplayManager.run() - no repro"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
@@ -72,7 +72,7 @@ def test_replay_02(mocker, tmp_path):
 def test_replay_03(mocker):
     """test ReplayManager.run() - no repro - with repeats"""
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=False, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
@@ -101,7 +101,7 @@ def test_replay_04(mocker):
         return_value=0,
     )
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=False, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
@@ -123,7 +123,7 @@ def test_replay_05(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     served = ["index.html"]
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.return_value = (SERVED_ALL, served)
+    server.serve_path.return_value = (Served.ALL, served)
     target = mocker.Mock(spec_set=Target, binary="C:\\fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
@@ -163,7 +163,7 @@ def test_replay_06(mocker, tmp_path):
     ]
     # test target unresponsive
     target.detect_failure.return_value = Target.RESULT_NONE
-    server.serve_path.return_value = (SERVED_NONE, [])
+    server.serve_path.return_value = (Served.NONE, [])
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases, 10, repeat=1)
         assert replay.status.ignored == 0
@@ -204,8 +204,8 @@ def test_replay_07(mocker, tmp_path):
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     server.serve_path.side_effect = (
-        (SERVED_ALL, ["a.html"]),
-        (SERVED_REQUEST, ["x"]),
+        (Served.ALL, ["a.html"]),
+        (Served.REQUEST, ["x"]),
     )
     with ReplayManager([], server, target, use_harness=True, relaunch=10) as replay:
         assert replay.run(testcases, 10, repeat=2)
@@ -220,7 +220,7 @@ def test_replay_08(mocker, tmp_path):
     """test ReplayManager.run() - ignored"""
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
+    server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
     target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = Target.RESULT_IGNORED
@@ -243,7 +243,7 @@ def test_replay_09(mocker, tmp_path):
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
+    server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="path/fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.RESULT_IGNORED = Target.RESULT_IGNORED
@@ -331,7 +331,7 @@ def test_replay_10(mocker, tmp_path):
     fake_report.side_effect = (report_0, report_1, report_2, report_3)
     fake_report.calc_hash.return_value = "bucketHASH"
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
+    server.serve_path.return_value = (Served.ALL, ["a.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, False, False)
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
@@ -377,7 +377,7 @@ def test_replay_11(mocker, tmp_path):
     fake_report.side_effect = (report_0, report_1)
     fake_report.calc_hash.return_value = "bucketHASH"
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
+    server.serve_path.return_value = (Served.ALL, ["a.html"])
     signature = mocker.Mock()
     signature.matches.side_effect = (True, True)
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
@@ -423,7 +423,7 @@ def test_replay_12(mocker, tmp_path):
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1, report_2)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
+    server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
@@ -467,7 +467,7 @@ def test_replay_13(mocker, tmp_path):
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0, report_1, report_2, report_3)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
+    server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
@@ -512,7 +512,7 @@ def test_replay_14(mocker, tmp_path):
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_1, report_2, report_3)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
+    server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
@@ -548,7 +548,7 @@ def test_replay_15(mocker, tmp_path):
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
     fake_report.side_effect = (report_0,)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.side_effect = ((SERVED_ALL, ["a.html"]), KeyboardInterrupt)
+    server.serve_path.side_effect = ((Served.ALL, ["a.html"]), KeyboardInterrupt)
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
     target.detect_failure.return_value = Target.RESULT_FAILURE
@@ -574,7 +574,7 @@ def test_replay_16(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
+    server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
@@ -594,7 +594,7 @@ def test_replay_16(mocker):
 def test_replay_17(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.return_value = (SERVED_ALL, ["a.html"])
+    server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, launch_timeout=30)
     # test relaunch < repeat
     type(target).closed = mocker.PropertyMock(side_effect=cycle([True, False]))
@@ -622,9 +622,9 @@ def test_replay_18(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.side_effect = (
-        (SERVED_ALL, ["a.html"]),
-        (SERVED_ALL, ["b.html"]),
-        (SERVED_ALL, ["c.html"]),
+        (Served.ALL, ["a.html"]),
+        (Served.ALL, ["b.html"]),
+        (Served.ALL, ["c.html"]),
     )
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
     target.RESULT_FAILURE = Target.RESULT_FAILURE
@@ -661,7 +661,7 @@ def test_replay_19(mocker, tmp_path):
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.return_value = (SERVED_ALL, ["index.html"])
+    server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
     target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.return_value = Target.RESULT_NONE
@@ -797,7 +797,7 @@ def test_replay_22(mocker, tmp_path, is_hang, use_sig, match_sig, ignored, resul
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     served = ["index.html"]
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.return_value = (SERVED_TIMEOUT, served)
+    server.serve_path.return_value = (Served.TIMEOUT, served)
     if use_sig:
         signature = mocker.Mock()
         signature.matches.return_value = match_sig
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index fb71fb3b..5e829acc 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -10,7 +10,7 @@
 
 from pytest import mark, raises
 
-from sapphire import SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT, Sapphire
+from sapphire import Sapphire, Served
 
 from .adapter import Adapter
 from .common.reporter import Report, Reporter
@@ -96,7 +96,7 @@ def test_session_01(
         relaunch=relaunch,
     ) as session:
         server.serve_path = lambda *a, **kv: (
-            SERVED_ALL,
+            Served.ALL,
             [session.iomanager.page_name(offset=-1)],
         )
         session.run(
@@ -162,7 +162,7 @@ def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
         relaunch=relaunch,
     ) as session:
         server.serve_path = lambda *a, **kv: (
-            SERVED_ALL,
+            Served.ALL,
             [session.iomanager.page_name(offset=-1)],
         )
         session.run([], 10)
@@ -222,7 +222,7 @@ def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
         adapter, reporter, server, target, relaunch=relaunch, report_size=report_size
     ) as session:
         server.serve_path = lambda *a, **kv: (
-            SERVED_ALL,
+            Served.ALL,
             [session.iomanager.page_name(offset=-1)],
         )
         session.run([], 10, input_path="file.bin", iteration_limit=iters)
@@ -240,7 +240,7 @@ def generate(self, _testcase, _server_map):
 
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_NONE, [])
+    server.serve_path.return_value = (Served.NONE, [])
     target = mocker.Mock(
         spec_set=Target,
         assets=mocker.Mock(spec_set=AssetManager),
@@ -257,7 +257,7 @@ def test_session_05(mocker, tmp_path):
     """test Target not requesting landing page"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
-    server.serve_path.return_value = (SERVED_TIMEOUT, [])
+    server.serve_path.return_value = (Served.TIMEOUT, [])
     target = mocker.Mock(
         spec_set=Target,
         assets=mocker.Mock(spec_set=AssetManager),
@@ -310,8 +310,8 @@ def test_session_06(mocker, tmp_path, harness, report_size):
         report_size=report_size,
     ) as session:
         server.serve_path.side_effect = (
-            (SERVED_ALL, [session.iomanager.page_name()]),
-            (SERVED_NONE, []),
+            (Served.ALL, [session.iomanager.page_name()]),
+            (Served.NONE, []),
         )
         session.run([], 10, iteration_limit=2)
         assert reporter.submit.call_count == 1
@@ -323,9 +323,9 @@ def test_session_06(mocker, tmp_path, harness, report_size):
     "srv_results, target_result, ignored, results",
     [
         # delayed startup crash
-        (SERVED_NONE, Target.RESULT_FAILURE, 0, 1),
+        (Served.NONE, Target.RESULT_FAILURE, 0, 1),
         # startup hang/unresponsive
-        (SERVED_TIMEOUT, Target.RESULT_NONE, 1, 0),
+        (Served.TIMEOUT, Target.RESULT_NONE, 1, 0),
     ],
 )
 def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, results):
diff --git a/sapphire/__init__.py b/sapphire/__init__.py
index 7103f0ab..453cb513 100644
--- a/sapphire/__init__.py
+++ b/sapphire/__init__.py
@@ -7,15 +7,12 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from .core import Sapphire
-from .job import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
+from .job import Served
 from .server_map import ServerMap
 
 __all__ = (
     "Sapphire",
-    "SERVED_ALL",
-    "SERVED_NONE",
-    "SERVED_REQUEST",
-    "SERVED_TIMEOUT",
+    "Served",
     "ServerMap",
 )
 __author__ = "Tyson Smith"
diff --git a/sapphire/core.py b/sapphire/core.py
index caf8cb20..31a5585c 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -13,7 +13,7 @@
 from time import sleep, time
 
 from .connection_manager import ConnectionManager
-from .job import SERVED_ALL, SERVED_NONE, SERVED_TIMEOUT, Job
+from .job import Job, Served
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
@@ -139,9 +139,9 @@ def serve_path(
         """Serve files in path. On completion a list served files and a status
         code will be returned.
         The status codes include:
-            - SERVED_ALL: All files excluding files in optional_files were served
-            - SERVED_NONE: No files were served
-            - SERVED_REQUEST: Some files were requested
+            - Served.ALL: All files excluding files in optional_files were served
+            - Served.NONE: No files were served
+            - Served.REQUEST: Some files were requested
 
         Args:
             path (str): Directory to use as wwwroot.
@@ -167,11 +167,11 @@ def serve_path(
         if not job.pending:
             job.finish()
             LOG.debug("nothing to serve")
-            return (SERVED_NONE, tuple())
+            return (Served.NONE, tuple())
         with ConnectionManager(job, self._socket, self._max_workers) as loadmgr:
             was_timeout = not loadmgr.wait(self.timeout, continue_cb=continue_cb)
-        LOG.debug("status: %r, timeout: %r", job.status, was_timeout)
-        return (SERVED_TIMEOUT if was_timeout else job.status, tuple(job.served))
+        LOG.debug("%s, timeout: %r", job.status, was_timeout)
+        return (Served.TIMEOUT if was_timeout else job.status, tuple(job.served))
 
     @property
     def timeout(self):
@@ -215,7 +215,7 @@ def main(cls, args):
                     serv.port,
                 )
                 status = serv.serve_path(args.path)[0]
-            if status == SERVED_ALL:
+            if status == Served.ALL:
                 LOG.info("All test case content was served")
             else:
                 LOG.warning("Failed to serve all test content")
diff --git a/sapphire/job.py b/sapphire/job.py
index 84157167..d699aec7 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -6,6 +6,7 @@
 Sapphire HTTP server job
 """
 from collections import defaultdict, namedtuple
+from enum import Enum, unique
 from logging import getLogger
 from mimetypes import guess_type
 from os import walk
@@ -23,11 +24,18 @@
 LOG = getLogger(__name__)
 
 
-# job status codes
-SERVED_ALL = 0  # all expected requests for required files have been received
-SERVED_NONE = 1  # no requests for required files have been received
-SERVED_REQUEST = 2  # some requests for required files have been received
-SERVED_TIMEOUT = 3  # timeout occurred
+@unique
+class Served(Enum):
+    """Server Job status codes"""
+
+    # all expected requests for required files have been received
+    ALL = 0
+    # no requests for required files have been received
+    NONE = 1
+    # some requests for required files have been received
+    REQUEST = 2
+    # timeout occurred
+    TIMEOUT = 3
 
 
 Tracker = namedtuple("Tracker", "files lock")
@@ -239,7 +247,7 @@ def status(self):
         with self._pending.lock:
             queue_size = len(self._pending.files)
         if queue_size == 0:
-            return SERVED_ALL
+            return Served.ALL
         if queue_size < self.initial_queue_size:
-            return SERVED_REQUEST
-        return SERVED_NONE
+            return Served.REQUEST
+        return Served.NONE
diff --git a/sapphire/test_job.py b/sapphire/test_job.py
index 29e28682..1648db6e 100644
--- a/sapphire/test_job.py
+++ b/sapphire/test_job.py
@@ -8,7 +8,7 @@
 
 import pytest
 
-from .job import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, Job
+from .job import Job, Served
 from .server_map import Resource, ServerMap
 
 
@@ -16,7 +16,7 @@ def test_job_01(tmp_path):
     """test creating an empty Job"""
     job = Job(str(tmp_path))
     assert not job.forever
-    assert job.status == SERVED_ALL
+    assert job.status == Served.ALL
     assert job.check_request("") is None
     assert job.check_request("test") is None
     assert job.check_request("test/test/") is None
@@ -45,7 +45,7 @@ def test_job_02(tmp_path):
     job = Job(
         str(tmp_path), optional_files=[opt1_path.name, "nested/%s" % (opt2_path.name,)]
     )
-    assert job.status == SERVED_NONE
+    assert job.status == Served.NONE
     assert not job.is_complete()
     resource = job.check_request("req_file_1.txt")
     assert resource.required
@@ -56,10 +56,10 @@ def test_job_02(tmp_path):
     assert not job.remove_pending("no_file.test")
     assert job.pending == 2
     assert not job.remove_pending(str(req1_path))
-    assert job.status == SERVED_REQUEST
+    assert job.status == Served.REQUEST
     assert job.pending == 1
     assert job.remove_pending(str(req2_path))
-    assert job.status == SERVED_ALL
+    assert job.status == Served.ALL
     assert job.pending == 0
     assert job.remove_pending(str(req1_path))
     resource = job.check_request("opt_file_1.txt")
@@ -81,7 +81,7 @@ def test_job_03(tmp_path):
     smap.set_redirect("one", "somefile.txt", required=False)
     smap.set_redirect("two", "reqfile.txt")
     job = Job(str(tmp_path), server_map=smap)
-    assert job.status == SERVED_NONE
+    assert job.status == Served.NONE
     resource = job.check_request("one")
     assert resource.type == Resource.URL_REDIRECT
     resource = job.check_request("two?q=123")
@@ -121,7 +121,7 @@ def test_job_04(mocker, tmp_path):
     smap.include[""] = Resource(Resource.URL_INCLUDE, str(srv_include))
     smap.set_include("testinc/inc2", str(srv_include_2))
     job = Job(str(srv_root), server_map=smap)
-    assert job.status == SERVED_NONE
+    assert job.status == Served.NONE
     # test includes that map to 'srv_include'
     for incl, inc_path in smap.include.items():
         if inc_path != str(srv_include):  # only check 'srv_include' mappings
@@ -198,7 +198,7 @@ def test_job_06(tmp_path):
     smap.set_dynamic_response("cb1", lambda: 0, mime_type="mime_type")
     smap.set_dynamic_response("cb2", lambda: 1)
     job = Job(str(tmp_path), server_map=smap)
-    assert job.status == SERVED_ALL
+    assert job.status == Served.ALL
     assert job.pending == 0
     resource = job.check_request("cb1")
     assert resource.type == Resource.URL_DYNAMIC
@@ -220,7 +220,7 @@ def test_job_07(tmp_path):
     no_access = tmp_path / "no_access.txt"
     no_access.write_bytes(b"a")
     job = Job(str(srv_root))
-    assert job.status == SERVED_NONE
+    assert job.status == Served.NONE
     assert job.pending == 1
     resource = job.check_request("../no_access.txt")
     assert resource.target == str(no_access)
@@ -236,7 +236,7 @@ def test_job_08(tmp_path):
     test_file.write_bytes(b"a")
     (tmp_path / "?_2.txt").write_bytes(b"a")
     job = Job(str(tmp_path))
-    assert job.status == SERVED_NONE
+    assert job.status == Served.NONE
     assert job.pending == 1
     assert job.check_request("test.txt").target == str(test_file)
 
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 64088554..5493384d 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -13,7 +13,7 @@
 import pytest
 
 from .core import Sapphire
-from .job import SERVED_ALL, SERVED_NONE, SERVED_REQUEST, SERVED_TIMEOUT
+from .job import Served
 from .server_map import ServerMap
 from .worker import Worker
 
@@ -51,7 +51,7 @@ def test_sapphire_00(client, tmp_path):
         assert serv.timeout == 10
         test = _create_test("test_case.html", tmp_path)
         client.launch("127.0.0.1", serv.port, [test])
-        assert serv.serve_path(str(tmp_path))[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
     assert client.wait(timeout=10)
     assert test.code == 200
     assert test.len_srv == test.len_org
@@ -69,7 +69,7 @@ def test_sapphire_01(client, tmp_path):
     with Sapphire(timeout=30) as serv:
         client.launch("127.0.0.1", serv.port, to_serve)
         status, files_served = serv.serve_path(str(tmp_path))
-    assert status == SERVED_ALL
+    assert status == Served.ALL
     assert len(to_serve) == len(files_served)
     assert client.wait(timeout=10)
     for t_file in to_serve:
@@ -87,7 +87,7 @@ def test_sapphire_02(client, tmp_path):
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve, in_order=True)
         status, served_list = serv.serve_path(str(tmp_path), optional_files=optional)
-    assert status == SERVED_ALL
+    assert status == Served.ALL
     assert len(files_to_serve) == len(served_list)
     assert client.wait(timeout=10)
     for t_file in files_to_serve:
@@ -104,7 +104,7 @@ def test_sapphire_03(client, tmp_path):
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve[1:])
         status, served_list = serv.serve_path(str(tmp_path), optional_files=optional)
-    assert status == SERVED_ALL
+    assert status == Served.ALL
     assert len(served_list) == len(files_to_serve) - 1
     assert client.wait(timeout=10)
     assert files_to_serve[0].code is None
@@ -121,7 +121,7 @@ def test_sapphire_04(client, tmp_path):
     files_to_serve.append(_create_test("test_case.html", tmp_path))
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve, in_order=True)
-        assert serv.serve_path(str(tmp_path))[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
     assert client.wait(timeout=10)
     assert "does_not_exist.html" in files_to_serve[0].url
     assert files_to_serve[0].code == 404
@@ -145,7 +145,7 @@ def test_sapphire_05(client, tmp_path):
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve, in_order=True)
         status, files_served = serv.serve_path(str(root_dir))
-    assert status == SERVED_ALL
+    assert status == Served.ALL
     assert len(files_served) == 1
     assert client.wait(timeout=10)
     assert os.path.basename(__file__) in files_to_serve[0].url
@@ -160,7 +160,7 @@ def test_sapphire_06(client, tmp_path):
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [])
         status, files_served = serv.serve_path(str(tmp_path))
-    assert status == SERVED_NONE
+    assert status == Served.NONE
     assert not files_served
 
 
@@ -177,12 +177,12 @@ def test_sapphire_07(tmp_path):
         _create_test("test_case.html", tmp_path)
         serv._timeout = 0.01  # force shorter timeout for faster tests
         status, files_served = serv.serve_path(str(tmp_path))
-    assert status == SERVED_TIMEOUT
+    assert status == Served.TIMEOUT
     assert not files_served
 
 
 def test_sapphire_08(client, tmp_path):
-    """test only serving some files (SERVED_REQUEST)"""
+    """test only serving some files (Served.REQUEST)"""
     cb_status = {"count": 0}
 
     def is_running():
@@ -195,7 +195,7 @@ def is_running():
     with Sapphire() as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve[1:])
         status, files_served = serv.serve_path(str(tmp_path), continue_cb=is_running)
-    assert status == SERVED_REQUEST
+    assert status == Served.REQUEST
     assert len(files_served) < len(files_to_serve)
 
 
@@ -219,7 +219,7 @@ def test_sapphire_09(client, tmp_path):
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [test["file"] for test in tests])
         status, served_list = serv.serve_path(str(tmp_path))
-    assert status == SERVED_ALL
+    assert status == Served.ALL
     assert len(served_list) == len(tests)
     assert client.wait(timeout=10)
     for test in tests:
@@ -241,7 +241,7 @@ def test_sapphire_10(client, tmp_path):
     t_file.md5_org = data_hash.hexdigest()
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [t_file])
-        assert serv.serve_path(str(tmp_path))[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
     assert client.wait(timeout=10)
     assert t_file.code == 200
     assert t_file.len_srv == (100 * 1024 * 1024)
@@ -255,7 +255,7 @@ def test_sapphire_11(client, tmp_path):
     )
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [t_file])
-        assert serv.serve_path(str(tmp_path))[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
     assert client.wait(timeout=10)
     assert t_file.code == 200
     assert t_file.len_srv == t_file.len_org
@@ -277,7 +277,7 @@ def test_sapphire_13(client, tmp_path):
     files_to_serve.append(_create_test("test_case", tmp_path, data=os.urandom(5)))
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve)
-        assert serv.serve_path(str(tmp_path))[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
     assert client.wait(timeout=10)
     content_types = set()
     for test in files_to_serve:
@@ -302,7 +302,7 @@ def _test_callback():
     with Sapphire(timeout=10) as serv:
         _create_test("test_case.html", tmp_path)
         assert (
-            serv.serve_path(str(tmp_path), continue_cb=_test_callback)[0] == SERVED_NONE
+            serv.serve_path(str(tmp_path), continue_cb=_test_callback)[0] == Served.NONE
         )
     assert cb_status["count"] == 2
 
@@ -313,7 +313,7 @@ def test_sapphire_15(client, tmp_path):
         for i in range(3):
             test = _create_test("test_case_%d.html" % i, tmp_path)
             client.launch("127.0.0.1", serv.port, [test])
-            assert serv.serve_path(str(tmp_path))[0] == SERVED_ALL
+            assert serv.serve_path(str(tmp_path))[0] == Served.ALL
             assert client.wait(timeout=10)
             client.close()
             assert test.code == 200
@@ -328,7 +328,7 @@ def test_sapphire_16(client, tmp_path):
     test = _create_test("test_case.html", tmp_path)
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [test])
-        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert test.code == 200
     assert test.len_srv == test.len_org
@@ -350,7 +350,7 @@ def test_sapphire_17(client, tmp_path):
         files_to_serve.append(test)
         client.launch("127.0.0.1", serv.port, files_to_serve)
         status, served_list = serv.serve_path(str(tmp_path), server_map=smap)
-    assert status == SERVED_ALL
+    assert status == Served.ALL
     assert len(served_list) == len(files_to_serve)
     assert client.wait(timeout=10)
     assert test.code == 200
@@ -408,7 +408,7 @@ def test_sapphire_18(client, tmp_path):
         smap.set_include("inc_test", str(inc2_path))  # mount at '/inc_test'
         client.launch("127.0.0.1", serv.port, files_to_serve, in_order=True)
         status, files_served = serv.serve_path(str(root_path), server_map=smap)
-    assert status == SERVED_ALL
+    assert status == Served.ALL
     assert "test_case.html" in files_served
     assert str(inc1_path / "included_file1.html") in files_served
     assert str(inc2_path / "included_file2.html") in files_served
@@ -434,7 +434,7 @@ def test_sapphire_19(client, tmp_path):
     test = _create_test("test_case.html", tmp_path)
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [test_dr, test], in_order=True)
-        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert test.code == 200
     assert test.len_srv == test.len_org
@@ -455,7 +455,7 @@ def test_sapphire_20(client, tmp_path):
     )
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [test_dr], in_order=True)
-        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert test_dr.code == 200
     assert test_dr.len_srv == test_dr.len_org
@@ -477,7 +477,7 @@ def test_sapphire_21(client_factory, tmp_path):
         )
         client = client_factory(rx_size=2)
         client.launch("127.0.0.1", serv.port, [test], throttle=0.1)
-        assert serv.serve_path(str(tmp_path), optional_files=optional)[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path), optional_files=optional)[0] == Served.ALL
     assert client_defer.wait(timeout=10)
     assert client.wait(timeout=10)
     assert test.code == 200
@@ -492,7 +492,7 @@ def test_sapphire_22(client, tmp_path):
     test = _create_test("test_case.html", tmp_path)
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [bad_test, test], in_order=True)
-        assert serv.serve_path(str(tmp_path), optional_files=optional)[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path), optional_files=optional)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert test.code == 200
     assert bad_test.code == 400
@@ -512,7 +512,7 @@ def test_sapphire_23(client, tmp_path):
             indicate_failure=True,
             in_order=True,
         )
-        assert serv.serve_path(str(tmp_path), optional_files=optional)[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path), optional_files=optional)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert test.code == 200
     assert bad_test.code == 0
@@ -540,7 +540,7 @@ def test_sapphire_24(client_factory, tmp_path):
             for client in clients:
                 assert client.wait(timeout=10)
                 client.close()
-    assert status == SERVED_ALL
+    assert status == Served.ALL
     assert len(to_serve) == len(files_served)
     for t_file in to_serve:
         assert t_file.code == 200
@@ -583,7 +583,7 @@ def _dyn_test_cb():
             clients.append(client_factory(rx_size=1))
             throttle = 0.05 if random.getrandbits(1) else 0
             clients[-1].launch("127.0.0.1", serv.port, to_serve, throttle=throttle)
-        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == Served.ALL
 
 
 def test_sapphire_26(client, tmp_path):
@@ -610,7 +610,7 @@ def test_sapphire_27(client, tmp_path):
     client.rx_size = 0x2800
     with Sapphire(timeout=60) as serv:
         client.launch("127.0.0.1", serv.port, [t_file], throttle=0.25)
-        assert serv.serve_path(str(tmp_path))[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
     assert client.wait(timeout=10)
     assert t_file.code == 200
     assert t_file.len_srv == t_file.len_org
@@ -631,7 +631,7 @@ def test_sapphire_28(client, tmp_path):
             "127.0.0.1", serv.port, files_to_serve, indicate_failure=True, throttle=0.1
         )
         status, files_served = serv.serve_path(str(tmp_path))
-    assert status == SERVED_TIMEOUT
+    assert status == Served.TIMEOUT
     assert len(files_served) < len(files_to_serve)
 
 
@@ -652,7 +652,7 @@ def _test_callback():
 
         assert (
             serv.serve_path(str(tmp_path), continue_cb=_test_callback, forever=True)[0]
-            == SERVED_ALL
+            == Served.ALL
         )
     for client in clients:
         assert client.wait(timeout=10)
@@ -672,7 +672,7 @@ def test_sapphire_30(client, tmp_path):
     ]
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, to_serve)
-        assert serv.serve_path(str(tmp_path))[0] == SERVED_ALL
+        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
     assert client.wait(timeout=10)
     assert all(t_file.code == 200 for t_file in to_serve)
 
@@ -689,7 +689,7 @@ def test_sapphire_31(client, tmp_path):
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, to_serve, in_order=True)
         assert (
-            serv.serve_path(str(tmp_path), optional_files=[all_bytes])[0] == SERVED_ALL
+            serv.serve_path(str(tmp_path), optional_files=[all_bytes])[0] == Served.ALL
         )
     assert client.wait(timeout=10)
     assert all(t_file.code is not None for t_file in to_serve)
@@ -742,9 +742,9 @@ def test_main_01(mocker, tmp_path):
     """test Sapphire.main()"""
     args = mocker.Mock(path=str(tmp_path), port=4536, remote=False, timeout=None)
     fake_srv = mocker.patch("sapphire.core.Sapphire.serve_path", autospec=True)
-    fake_srv.return_value = (SERVED_ALL, None)
+    fake_srv.return_value = (Served.ALL, None)
     Sapphire.main(args)
-    fake_srv.return_value = (SERVED_NONE, None)
+    fake_srv.return_value = (Served.NONE, None)
     Sapphire.main(args)
     fake_srv.side_effect = KeyboardInterrupt
     Sapphire.main(args)

From 556ad6cd17616308def8dbf2613b4bcd3e69cc4f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 5 Aug 2021 17:39:59 -0700
Subject: [PATCH 297/531] Use enum for Target Result codes

---
 grizzly/common/runner.py             |  6 +-
 grizzly/common/test_runner.py        | 22 ++++----
 grizzly/replay/test_main.py          | 29 +++++-----
 grizzly/replay/test_replay.py        | 84 ++++++++++------------------
 grizzly/target/__init__.py           |  3 +-
 grizzly/target/puppet_target.py      | 10 ++--
 grizzly/target/target.py             | 15 +++--
 grizzly/target/test_puppet_target.py | 18 +++---
 grizzly/test_session.py              | 20 +++----
 9 files changed, 91 insertions(+), 116 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 78ea290d..bfb8d037 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -9,7 +9,7 @@
 
 from sapphire import Served
 
-from ..target import TargetLaunchError, TargetLaunchTimeout
+from ..target import Result, TargetLaunchError, TargetLaunchTimeout
 from .utils import grz_tmp
 
 __all__ = ("Runner", "RunResult")
@@ -271,9 +271,9 @@ def run(
         # detect failure
         if result.status is None:
             failure_detected = self._target.detect_failure(ignore)
-            if failure_detected == self._target.RESULT_FAILURE:
+            if failure_detected == Result.FAILURE:
                 result.status = RunResult.FAILED
-            elif failure_detected == self._target.RESULT_IGNORED:
+            elif failure_detected == Result.IGNORED:
                 result.status = RunResult.IGNORED
         return result
 
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index c1d3b3d2..14d6c75a 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -10,7 +10,7 @@
 
 from sapphire import Sapphire, Served, ServerMap
 
-from ..target import Target, TargetLaunchError, TargetLaunchTimeout
+from ..target import Result, Target, TargetLaunchError, TargetLaunchTimeout
 from .reporter import Report
 from .runner import Runner, RunResult, _IdleChecker
 from .storage import TestCase
@@ -21,7 +21,7 @@ def test_runner_01(mocker, tmp_path):
     mocker.patch("grizzly.common.runner.time", autospec=True, side_effect=count())
     server = mocker.Mock(spec_set=Sapphire)
     target = mocker.Mock(spec_set=Target)
-    target.detect_failure.return_value = target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     runner = Runner(server, target, relaunch=10)
     assert runner._idle is None
     assert runner._relaunch == 10
@@ -81,7 +81,7 @@ def test_runner_02(mocker):
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     server = mocker.Mock(spec_set=Sapphire)
     target = mocker.Mock(spec_set=Target)
-    target.detect_failure.return_value = target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     serv_files = ["a.bin"]
     server.serve_path.return_value = (Served.ALL, serv_files)
     testcase = mocker.Mock(spec_set=TestCase, landing_page=serv_files[0], optional=[])
@@ -154,7 +154,7 @@ def test_runner_03(mocker, srv_result, served):
     server = mocker.Mock(spec_set=Sapphire)
     server.serve_path.return_value = (srv_result, served)
     target = mocker.Mock(spec_set=Target)
-    target.detect_failure.return_value = target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     testcase = mocker.Mock(spec_set=TestCase, landing_page="x", optional=[])
     runner = Runner(server, target)
     result = runner.run([], ServerMap(), testcase)
@@ -184,7 +184,7 @@ def test_runner_04(mocker, ignore, status, idle, detect_failure):
     testcase = mocker.Mock(spec_set=TestCase, landing_page="a.bin", optional=[])
     serv_files = ["a.bin", "/another/file.bin"]
     server.serve_path.return_value = (Served.TIMEOUT, serv_files)
-    target.detect_failure.return_value = target.RESULT_FAILURE
+    target.detect_failure.return_value = Result.FAILURE
     target.handle_hang.return_value = idle
     target.monitor.is_healthy.return_value = False
     runner = Runner(server, target, relaunch=1)
@@ -202,11 +202,11 @@ def test_runner_04(mocker, ignore, status, idle, detect_failure):
     "served, attempted, target_result, status",
     [
         # FAILURE
-        (["a.bin"], True, Target.RESULT_FAILURE, RunResult.FAILED),
+        (["a.bin"], True, Result.FAILURE, RunResult.FAILED),
         # IGNORED
-        (["a.bin"], True, Target.RESULT_IGNORED, RunResult.IGNORED),
+        (["a.bin"], True, Result.IGNORED, RunResult.IGNORED),
         # failure before serving landing page
-        (["harness"], False, Target.RESULT_FAILURE, RunResult.FAILED),
+        (["harness"], False, Result.FAILURE, RunResult.FAILED),
     ],
 )
 def test_runner_05(mocker, served, attempted, target_result, status):
@@ -214,8 +214,6 @@ def test_runner_05(mocker, served, attempted, target_result, status):
     server = mocker.Mock(spec_set=Sapphire)
     server.serve_path.return_value = (Served.REQUEST, served)
     target = mocker.Mock(spec_set=Target, launch_timeout=10)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.RESULT_IGNORED = Target.RESULT_IGNORED
     target.detect_failure.return_value = target_result
     target.monitor.is_healthy.return_value = False
     testcase = mocker.Mock(spec_set=TestCase, landing_page="a.bin", optional=[])
@@ -233,7 +231,7 @@ def test_runner_06(mocker):
     """test Runner() with idle checking"""
     server = mocker.Mock(spec_set=Sapphire)
     target = mocker.Mock(spec_set=Target)
-    target.detect_failure.return_value = target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     serv_files = ["/fake/file", "/another/file.bin"]
     server.serve_path.return_value = (Served.ALL, serv_files)
     runner = Runner(server, target, idle_threshold=0.01, idle_delay=0.01, relaunch=10)
@@ -316,7 +314,7 @@ def test_runner_10(mocker, tmp_path):
     """test Runner.run() adding includes to testcase"""
     server = mocker.Mock(spec_set=Sapphire)
     target = mocker.Mock(spec_set=Target)
-    target.detect_failure.return_value = target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     runner = Runner(server, target, relaunch=10)
     # create test files
     inc_path1 = tmp_path / "include"
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 7d2e9b33..54ee5071 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -12,7 +12,13 @@
 from ..common.reporter import Report
 from ..common.storage import TestCase, TestCaseLoadFailure
 from ..session import Session
-from ..target import AssetManager, Target, TargetLaunchError, TargetLaunchTimeout
+from ..target import (
+    AssetManager,
+    Result,
+    Target,
+    TargetLaunchError,
+    TargetLaunchTimeout,
+)
 from .replay import ReplayManager
 from .test_replay import _fake_save_logs
 
@@ -33,13 +39,10 @@ def test_main_01(mocker, tmp_path):
     load_target = mocker.patch("grizzly.replay.replay.load_plugin", autospec=True)
     target = mocker.Mock(spec_set=Target, binary="bin", environ={}, launch_timeout=30)
     target.assets = mocker.Mock(spec_set=AssetManager)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.RESULT_IGNORED = Target.RESULT_IGNORED
-    target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.side_effect = (
-        Target.RESULT_FAILURE,
-        Target.RESULT_NONE,
-        Target.RESULT_FAILURE,
+        Result.FAILURE,
+        Result.NONE,
+        Result.FAILURE,
     )
     target.save_logs = _fake_save_logs
     load_target.return_value.return_value = target
@@ -102,8 +105,7 @@ def test_main_02(mocker, tmp_path):
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_plugin")
     target = mocker.Mock(spec_set=Target, binary="bin", environ={}, launch_timeout=30)
-    target.RESULT_NONE = Target.RESULT_NONE
-    target.detect_failure.return_value = Target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     load_target.return_value.return_value = target
     # setup args
     (tmp_path / "test.html").touch()
@@ -255,8 +257,7 @@ def test_main_05(mocker, tmp_path):
     target = mocker.NonCallableMock(
         spec_set=Target, binary="bin", environ={}, launch_timeout=30
     )
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Result.FAILURE
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     mocker.patch(
@@ -335,8 +336,7 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
     )
     # setup Target
     target = mocker.NonCallableMock(spec_set=Target, binary="bin", launch_timeout=30)
-    target.RESULT_NONE = Target.RESULT_NONE
-    target.detect_failure.return_value = Target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     mocker.patch(
         "grizzly.replay.replay.load_plugin",
         autospec=True,
@@ -400,8 +400,7 @@ def test_main_07(mocker, tmp_path, pernosco, rr, valgrind, no_harness):
     )
     # setup Target
     target = mocker.NonCallableMock(spec_set=Target, binary="bin", launch_timeout=30)
-    target.RESULT_NONE = Target.RESULT_NONE
-    target.detect_failure.return_value = Target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     load_target = mocker.patch(
         "grizzly.replay.replay.load_plugin",
         autospec=True,
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 70c54262..2a13cb6d 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -16,7 +16,7 @@
 from ..common.reporter import Report
 from ..common.status import Status
 from ..common.storage import TestCase, TestCaseLoadFailure
-from ..target import AssetManager, Target
+from ..target import AssetManager, Result, Target
 from .replay import ReplayManager, ReplayResult
 
 
@@ -52,8 +52,7 @@ def test_replay_02(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
-    target.RESULT_NONE = Target.RESULT_NONE
-    target.detect_failure.return_value = Target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     target.monitor.is_healthy.return_value = False
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True, relaunch=1) as replay:
@@ -74,8 +73,7 @@ def test_replay_03(mocker):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=False, launch_timeout=30)
-    target.RESULT_NONE = Target.RESULT_NONE
-    target.detect_failure.return_value = Target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     target.monitor.is_healthy.return_value = False
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager(
@@ -103,8 +101,7 @@ def test_replay_04(mocker):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=False, launch_timeout=30)
-    target.RESULT_NONE = Target.RESULT_NONE
-    target.detect_failure.return_value = Target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager(
             [], server, target, use_harness=True, relaunch=100
@@ -125,8 +122,7 @@ def test_replay_05(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, served)
     target = mocker.Mock(spec_set=Target, binary="C:\\fake_bin", launch_timeout=30)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Result.FAILURE
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
@@ -156,13 +152,11 @@ def test_replay_06(mocker, tmp_path):
     mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(spec_set=Target, binary="bin", closed=True, launch_timeout=30)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.RESULT_NONE = Target.RESULT_NONE
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     # test target unresponsive
-    target.detect_failure.return_value = Target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     server.serve_path.return_value = (Served.NONE, [])
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases, 10, repeat=1)
@@ -173,7 +167,7 @@ def test_replay_06(mocker, tmp_path):
         assert target.close.call_count == 2
     target.reset_mock()
     # test target crashed
-    target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Result.FAILURE
     target.save_logs = _fake_save_logs
     with ReplayManager([], server, target, use_harness=False) as replay:
         results = replay.run(testcases, 10, repeat=1)
@@ -195,9 +189,7 @@ def test_replay_07(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     target = mocker.Mock(spec_set=Target, binary="bin", launch_timeout=30)
     type(target).closed = mocker.PropertyMock(side_effect=(True, False, True))
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.RESULT_NONE = Target.RESULT_NONE
-    target.detect_failure.side_effect = (Target.RESULT_NONE, Target.RESULT_FAILURE)
+    target.detect_failure.side_effect = (Result.NONE, Result.FAILURE)
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     testcases = [
@@ -222,8 +214,7 @@ def test_replay_08(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
-    target.RESULT_IGNORED = Target.RESULT_IGNORED
-    target.detect_failure.return_value = Target.RESULT_IGNORED
+    target.detect_failure.return_value = Result.IGNORED
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -245,18 +236,15 @@ def test_replay_09(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="path/fake_bin", launch_timeout=30)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.RESULT_IGNORED = Target.RESULT_IGNORED
-    target.RESULT_NONE = Target.RESULT_NONE
     target.save_logs = _fake_save_logs
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     # early failure
     target.detect_failure.side_effect = (
-        Target.RESULT_FAILURE,
-        Target.RESULT_IGNORED,
-        Target.RESULT_NONE,
+        Result.FAILURE,
+        Result.IGNORED,
+        Result.NONE,
     )
     target.monitor.is_healthy.side_effect = (False, False, True, False)
     with ReplayManager([], server, target, use_harness=False) as replay:
@@ -268,9 +256,9 @@ def test_replay_09(mocker, tmp_path):
     # early success
     target.reset_mock()
     target.detect_failure.side_effect = (
-        Target.RESULT_FAILURE,
-        Target.RESULT_IGNORED,
-        Target.RESULT_FAILURE,
+        Result.FAILURE,
+        Result.IGNORED,
+        Result.FAILURE,
     )
     target.monitor.is_healthy.side_effect = (False, False, False)
     with ReplayManager([], server, target, use_harness=False) as replay:
@@ -283,7 +271,7 @@ def test_replay_09(mocker, tmp_path):
     assert sum(x.count for x in results) == 2
     target.reset_mock()
     # ignore early failure (perform all repeats)
-    target.detect_failure.return_value = Target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     target.detect_failure.side_effect = None
     target.monitor.is_healthy.side_effect = None
     target.monitor.is_healthy.return_value = True
@@ -295,7 +283,7 @@ def test_replay_09(mocker, tmp_path):
         assert replay.status.ignored == 0
     target.reset_mock()
     # ignore early success (perform all repeats)
-    target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Result.FAILURE
     target.monitor.is_healthy.return_value = False
     with ReplayManager([], server, target, use_harness=False) as replay:
         results = replay.run(testcases, 10, repeat=4, min_results=1, exit_early=False)
@@ -335,8 +323,7 @@ def test_replay_10(mocker, tmp_path):
     signature = mocker.Mock()
     signature.matches.side_effect = (True, False, False)
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Result.FAILURE
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
@@ -381,8 +368,7 @@ def test_replay_11(mocker, tmp_path):
     signature = mocker.Mock()
     signature.matches.side_effect = (True, True)
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Result.FAILURE
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -425,8 +411,7 @@ def test_replay_12(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Result.FAILURE
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -469,8 +454,7 @@ def test_replay_13(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Result.FAILURE
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -514,8 +498,7 @@ def test_replay_14(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Result.FAILURE
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -550,8 +533,7 @@ def test_replay_15(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.side_effect = ((Served.ALL, ["a.html"]), KeyboardInterrupt)
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Result.FAILURE
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
@@ -576,8 +558,7 @@ def test_replay_16(mocker):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
-    target.RESULT_NONE = Target.RESULT_NONE
-    target.detect_failure.return_value = Target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
         for _ in range(3)
@@ -598,8 +579,7 @@ def test_replay_17(mocker):
     target = mocker.Mock(spec_set=Target, launch_timeout=30)
     # test relaunch < repeat
     type(target).closed = mocker.PropertyMock(side_effect=cycle([True, False]))
-    target.RESULT_NONE = Target.RESULT_NONE
-    target.detect_failure.return_value = Target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -627,12 +607,10 @@ def test_replay_18(mocker, tmp_path):
         (Served.ALL, ["c.html"]),
     )
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.RESULT_NONE = Target.RESULT_NONE
     target.detect_failure.side_effect = (
-        Target.RESULT_NONE,
-        Target.RESULT_NONE,
-        Target.RESULT_FAILURE,
+        Result.NONE,
+        Result.NONE,
+        Result.FAILURE,
     )
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
@@ -663,8 +641,7 @@ def test_replay_19(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
-    target.RESULT_NONE = Target.RESULT_NONE
-    target.detect_failure.return_value = Target.RESULT_NONE
+    target.detect_failure.return_value = Result.NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True) as replay:
             assert not replay.run([testcase], 30)
@@ -805,8 +782,7 @@ def test_replay_22(mocker, tmp_path, is_hang, use_sig, match_sig, ignored, resul
     else:
         signature = None
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.detect_failure.return_value = Target.RESULT_FAILURE
+    target.detect_failure.return_value = Result.FAILURE
     target.handle_hang.return_value = False
     target.save_logs = _fake_save_logs
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
diff --git a/grizzly/target/__init__.py b/grizzly/target/__init__.py
index 4d94fa81..f29edcc6 100644
--- a/grizzly/target/__init__.py
+++ b/grizzly/target/__init__.py
@@ -3,11 +3,12 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from .assets import AssetError, AssetManager
-from .target import Target, TargetError, TargetLaunchError, TargetLaunchTimeout
+from .target import Result, Target, TargetError, TargetLaunchError, TargetLaunchTimeout
 
 __all__ = (
     "AssetError",
     "AssetManager",
+    "Result",
     "Target",
     "TargetError",
     "TargetLaunchError",
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 21db22ba..32601123 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -22,7 +22,7 @@
 
 from ..common.reporter import Report
 from ..common.utils import grz_tmp, split_sanitizer_opts
-from .target import Target, TargetError, TargetLaunchError, TargetLaunchTimeout
+from .target import Result, Target, TargetError, TargetLaunchError, TargetLaunchTimeout
 from .target_monitor import TargetMonitor
 
 __all__ = ("PuppetTarget",)
@@ -142,7 +142,7 @@ def log_length(_, log_id):
         return self._monitor
 
     def detect_failure(self, ignored):
-        status = self.RESULT_NONE
+        status = Result.NONE
         # check if there has been a crash, hangs will appear as SIGABRT
         if not self._puppet.is_healthy():
             self.close()
@@ -156,19 +156,19 @@ def detect_failure(self, ignored):
                 and "memory" in ignored
                 and "ffp_worker_memory_usage" in self._puppet.available_logs()
             ):
-                status = self.RESULT_IGNORED
+                status = Result.IGNORED
                 LOG.debug("memory limit exceeded")
             elif (
                 self._puppet.reason == Reason.WORKER
                 and "log-limit" in ignored
                 and "ffp_worker_log_size" in self._puppet.available_logs()
             ):
-                status = self.RESULT_IGNORED
+                status = Result.IGNORED
                 LOG.debug("log size limit exceeded")
             else:
                 # crash or hang (forced SIGABRT) has been detected
                 LOG.debug("failure detected, ffpuppet %s", self._puppet.reason)
-                status = self.RESULT_FAILURE
+                status = Result.FAILURE
         return status
 
     def handle_hang(self, ignore_idle=True):
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 5cce5b72..e0f8c2cb 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -3,6 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from abc import ABCMeta, abstractmethod
+from enum import Enum, unique
 from logging import getLogger
 from os import environ
 from os.path import isfile
@@ -11,13 +12,22 @@
 from ..common.utils import grz_tmp
 from .assets import AssetManager
 
-__all__ = ("Target", "TargetError", "TargetLaunchError")
+__all__ = ("Result", "Target", "TargetError", "TargetLaunchError")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
 LOG = getLogger(__name__)
 
 
+@unique
+class Result(Enum):
+    """Target results codes"""
+
+    NONE = 0
+    FAILURE = 1
+    IGNORED = 2
+
+
 class TargetError(Exception):
     """Raised by Target"""
 
@@ -35,9 +45,6 @@ class TargetLaunchTimeout(TargetError):
 
 
 class Target(metaclass=ABCMeta):
-    RESULT_NONE = 0
-    RESULT_FAILURE = 1
-    RESULT_IGNORED = 2
     SUPPORTED_ASSETS = None
     TRACKED_ENVVARS = ()
 
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 3135f999..60c8c831 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -10,7 +10,7 @@
 from pytest import mark, raises
 
 from .puppet_target import PuppetTarget
-from .target import AssetManager, Target, TargetLaunchError, TargetLaunchTimeout
+from .target import AssetManager, Result, TargetLaunchError, TargetLaunchTimeout
 
 
 def test_puppet_target_01(mocker, tmp_path):
@@ -26,7 +26,7 @@ def test_puppet_target_01(mocker, tmp_path):
         assert target.launch_timeout == 300
         assert target.log_limit == 25
         assert target.memory_limit == 5000
-        assert target.detect_failure([]) == Target.RESULT_NONE
+        assert target.detect_failure([]) == Result.NONE
         assert target.log_size() == 1124
         fake_ffp.return_value.log_length.assert_any_call("stderr")
         fake_ffp.return_value.log_length.assert_any_call("stdout")
@@ -76,19 +76,19 @@ def test_puppet_target_02(mocker, tmp_path):
     "healthy, reason, ignore, result, closes",
     [
         # running as expected - no failures
-        (True, None, [], Target.RESULT_NONE, 0),
+        (True, None, [], Result.NONE, 0),
         # browser process closed
-        (False, Reason.CLOSED, [], Target.RESULT_NONE, 1),
+        (False, Reason.CLOSED, [], Result.NONE, 1),
         # browser process crashed
-        (False, Reason.ALERT, [], Target.RESULT_FAILURE, 1),
+        (False, Reason.ALERT, [], Result.FAILURE, 1),
         # browser exit with no crash logs
-        (False, Reason.EXITED, [], Target.RESULT_NONE, 1),
+        (False, Reason.EXITED, [], Result.NONE, 1),
         # ffpuppet check failed
-        (False, Reason.WORKER, [], Target.RESULT_FAILURE, 1),
+        (False, Reason.WORKER, [], Result.FAILURE, 1),
         # ffpuppet check ignored (memory)
-        (False, Reason.WORKER, ["memory"], Target.RESULT_IGNORED, 1),
+        (False, Reason.WORKER, ["memory"], Result.IGNORED, 1),
         # ffpuppet check ignored (log-limit)
-        (False, Reason.WORKER, ["log-limit"], Target.RESULT_IGNORED, 1),
+        (False, Reason.WORKER, ["log-limit"], Result.IGNORED, 1),
     ],
 )
 def test_puppet_target_03(mocker, tmp_path, healthy, reason, ignore, result, closes):
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 5e829acc..b49c138f 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -16,7 +16,7 @@
 from .common.reporter import Report, Reporter
 from .common.runner import RunResult
 from .session import LogOutputLimiter, Session, SessionError
-from .target import AssetManager, Target, TargetLaunchError
+from .target import AssetManager, Result, Target, TargetLaunchError
 
 
 class SimpleAdapter(Adapter):
@@ -203,8 +203,6 @@ def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
         environ=dict(),
         launch_timeout=30,
     )
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.RESULT_NONE = Target.RESULT_NONE
     target.monitor.launches = 1
     # avoid shutdown delay
     target.monitor.is_healthy.return_value = False
@@ -213,9 +211,9 @@ def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
         side_effect=((x % relaunch == 0) for x in range(iters))
     )
     # failure is on final iteration
-    target.detect_failure.side_effect = [
-        Target.RESULT_NONE for x in range(iters - 1)
-    ] + [Target.RESULT_FAILURE]
+    target.detect_failure.side_effect = [Result.NONE for x in range(iters - 1)] + [
+        Result.FAILURE
+    ]
     target.log_size.return_value = 1
     target.create_report.return_value = report
     with Session(
@@ -294,11 +292,9 @@ def test_session_06(mocker, tmp_path, harness, report_size):
         environ=dict(),
         launch_timeout=30,
     )
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.RESULT_NONE = Target.RESULT_NONE
     target.monitor.launches = 1
     type(target).closed = mocker.PropertyMock(side_effect=(True, False))
-    target.detect_failure.side_effect = (Target.RESULT_NONE, Target.RESULT_FAILURE)
+    target.detect_failure.side_effect = (Result.NONE, Result.FAILURE)
     target.log_size.return_value = 1
     target.create_report.return_value = report
     with Session(
@@ -323,9 +319,9 @@ def test_session_06(mocker, tmp_path, harness, report_size):
     "srv_results, target_result, ignored, results",
     [
         # delayed startup crash
-        (Served.NONE, Target.RESULT_FAILURE, 0, 1),
+        (Served.NONE, Result.FAILURE, 0, 1),
         # startup hang/unresponsive
-        (Served.TIMEOUT, Target.RESULT_NONE, 1, 0),
+        (Served.TIMEOUT, Result.NONE, 1, 0),
     ],
 )
 def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, results):
@@ -342,8 +338,6 @@ def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, resul
         environ=dict(),
         launch_timeout=30,
     )
-    target.RESULT_FAILURE = Target.RESULT_FAILURE
-    target.RESULT_NONE = Target.RESULT_NONE
     target.monitor.launches = 1
     target.detect_failure.side_effect = (target_result,)
     target.create_report.return_value = report

From e1dadc18f6b0b935c1f160e795a5ea6bcc5a82d8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 6 Aug 2021 11:56:52 -0700
Subject: [PATCH 298/531] Rename Target.detect_failure() ->
 Target.check_result()

- Use Result enum in RunResult
- Update Result enum members
---
 grizzly/common/runner.py             | 19 +++-------
 grizzly/common/test_runner.py        | 52 +++++++++++++-------------
 grizzly/replay/replay.py             | 12 +++---
 grizzly/replay/test_main.py          | 32 ++++++++--------
 grizzly/replay/test_replay.py        | 56 ++++++++++++++--------------
 grizzly/session.py                   | 10 ++---
 grizzly/target/puppet_target.py      | 12 +++---
 grizzly/target/target.py             | 10 ++---
 grizzly/target/test_puppet_target.py | 10 ++---
 grizzly/target/test_target.py        |  6 +--
 grizzly/test_session.py              | 20 +++++-----
 11 files changed, 116 insertions(+), 123 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index bfb8d037..9b45715a 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -231,12 +231,12 @@ def run(
         if result.timeout:
             LOG.debug("timeout detected")
             if self._target.handle_hang(ignore_idle=True) or "timeout" in ignore:
-                result.status = RunResult.IGNORED
+                result.status = Result.IGNORED
             server_map.dynamic.pop("grz_empty", None)
         if result.attempted:
             self._tests_run += 1
             if coverage and not result.timeout:
-                # dump_coverage() should be called before detect_failure()
+                # dump_coverage() should be called before check_result()
                 # to help catch any coverage related issues.
                 self._target.dump_coverage()
             # relaunch check
@@ -268,13 +268,9 @@ def run(
             # previous iteration put target in a bad state?
             LOG.debug("landing page %r not served!", testcase.landing_page)
             self._target.close()
-        # detect failure
-        if result.status is None:
-            failure_detected = self._target.detect_failure(ignore)
-            if failure_detected == Result.FAILURE:
-                result.status = RunResult.FAILED
-            elif failure_detected == Result.IGNORED:
-                result.status = RunResult.IGNORED
+        # detect results
+        if result.status == Result.NONE:
+            result.status = self._target.check_result(ignore)
         return result
 
     def _keep_waiting(self):
@@ -305,12 +301,9 @@ class RunResult:
         timeout (bool): A timeout occurred waiting for test to complete.
     """
 
-    FAILED = 1
-    IGNORED = 2
-
     __slots__ = ("attempted", "duration", "initial", "served", "status", "timeout")
 
-    def __init__(self, served, duration, status=None, timeout=False):
+    def __init__(self, served, duration, status=Result.NONE, timeout=False):
         self.attempted = False
         self.duration = duration
         self.initial = False
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 14d6c75a..4155d1e3 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -12,7 +12,7 @@
 
 from ..target import Result, Target, TargetLaunchError, TargetLaunchTimeout
 from .reporter import Report
-from .runner import Runner, RunResult, _IdleChecker
+from .runner import Runner, _IdleChecker
 from .storage import TestCase
 
 
@@ -21,7 +21,7 @@ def test_runner_01(mocker, tmp_path):
     mocker.patch("grizzly.common.runner.time", autospec=True, side_effect=count())
     server = mocker.Mock(spec_set=Sapphire)
     target = mocker.Mock(spec_set=Target)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     runner = Runner(server, target, relaunch=10)
     assert runner._idle is None
     assert runner._relaunch == 10
@@ -36,7 +36,7 @@ def test_runner_01(mocker, tmp_path):
     assert runner._tests_run == 1
     assert result.duration == 1
     assert result.initial
-    assert result.status is None
+    assert result.status == Result.NONE
     assert result.served == serv_files
     assert not result.timeout
     assert not serv_map.dynamic
@@ -51,7 +51,7 @@ def test_runner_01(mocker, tmp_path):
     assert result.attempted
     assert runner._tests_run == 2
     assert not result.initial
-    assert result.status is None
+    assert result.status == Result.NONE
     assert result.served == serv_files
     assert not result.timeout
     assert not serv_map.dynamic
@@ -68,7 +68,7 @@ def test_runner_01(mocker, tmp_path):
     assert result.attempted
     assert runner._tests_run == 3
     assert not result.initial
-    assert result.status is None
+    assert result.status == Result.NONE
     assert not serv_map.dynamic
     assert target.close.call_count == 0
     assert testcase.dump.call_count == 0
@@ -81,7 +81,7 @@ def test_runner_02(mocker):
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     server = mocker.Mock(spec_set=Sapphire)
     target = mocker.Mock(spec_set=Target)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     serv_files = ["a.bin"]
     server.serve_path.return_value = (Served.ALL, serv_files)
     testcase = mocker.Mock(spec_set=TestCase, landing_page=serv_files[0], optional=[])
@@ -96,7 +96,7 @@ def test_runner_02(mocker):
     assert target.close.call_count == 1
     assert target.is_idle.call_count > 0
     assert target.monitor.is_healthy.call_count > 0
-    assert result.status is None
+    assert result.status == Result.NONE
     assert result.served == serv_files
     assert not smap.dynamic
     assert smap.redirect.get("grz_next_test").target == "grz_empty"
@@ -122,7 +122,7 @@ def test_runner_02(mocker):
         assert result.attempted
         assert target.close.call_count == 0
         assert target.monitor.is_healthy.call_count == 0
-        assert result.status is None
+        assert result.status == Result.NONE
         assert result.served == serv_files
         assert not result.timeout
         assert not smap.dynamic
@@ -134,7 +134,7 @@ def test_runner_02(mocker):
     assert target.close.call_count == 1
     assert target.is_idle.call_count == 0
     assert target.monitor.is_healthy.call_count == 1
-    assert result.status is None
+    assert result.status == Result.NONE
     assert result.served == serv_files
     assert not smap.dynamic
     assert smap.redirect.get("grz_next_test").target == "grz_empty"
@@ -154,11 +154,11 @@ def test_runner_03(mocker, srv_result, served):
     server = mocker.Mock(spec_set=Sapphire)
     server.serve_path.return_value = (srv_result, served)
     target = mocker.Mock(spec_set=Target)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     testcase = mocker.Mock(spec_set=TestCase, landing_page="x", optional=[])
     runner = Runner(server, target)
     result = runner.run([], ServerMap(), testcase)
-    assert result.status is None
+    assert result.status == Result.NONE
     assert not result.attempted
     assert result.initial
     assert set(result.served) == set(served)
@@ -167,24 +167,24 @@ def test_runner_03(mocker, srv_result, served):
 
 
 @mark.parametrize(
-    "ignore, status, idle, detect_failure",
+    "ignore, status, idle, check_result",
     [
         # detect a hang
-        (["memory"], RunResult.FAILED, False, 1),
+        (["memory"], Result.FOUND, False, 1),
         # ignore a hang
-        (["timeout"], RunResult.IGNORED, False, 0),
+        (["timeout"], Result.IGNORED, False, 0),
         # ignore idle hang
-        ([], RunResult.IGNORED, True, 0),
+        ([], Result.IGNORED, True, 0),
     ],
 )
-def test_runner_04(mocker, ignore, status, idle, detect_failure):
+def test_runner_04(mocker, ignore, status, idle, check_result):
     """test reporting timeout"""
     server = mocker.Mock(spec_set=Sapphire)
     target = mocker.Mock(spec_set=Target)
     testcase = mocker.Mock(spec_set=TestCase, landing_page="a.bin", optional=[])
     serv_files = ["a.bin", "/another/file.bin"]
     server.serve_path.return_value = (Served.TIMEOUT, serv_files)
-    target.detect_failure.return_value = Result.FAILURE
+    target.check_result.return_value = Result.FOUND
     target.handle_hang.return_value = idle
     target.monitor.is_healthy.return_value = False
     runner = Runner(server, target, relaunch=1)
@@ -194,7 +194,7 @@ def test_runner_04(mocker, ignore, status, idle, detect_failure):
     assert result.served == serv_files
     assert result.timeout
     assert "grz_empty" not in serv_map.dynamic
-    assert target.detect_failure.call_count == detect_failure
+    assert target.check_result.call_count == check_result
     assert target.handle_hang.call_count == 1
 
 
@@ -202,11 +202,11 @@ def test_runner_04(mocker, ignore, status, idle, detect_failure):
     "served, attempted, target_result, status",
     [
         # FAILURE
-        (["a.bin"], True, Result.FAILURE, RunResult.FAILED),
+        (["a.bin"], True, Result.FOUND, Result.FOUND),
         # IGNORED
-        (["a.bin"], True, Result.IGNORED, RunResult.IGNORED),
+        (["a.bin"], True, Result.IGNORED, Result.IGNORED),
         # failure before serving landing page
-        (["harness"], False, Result.FAILURE, RunResult.FAILED),
+        (["harness"], False, Result.FOUND, Result.FOUND),
     ],
 )
 def test_runner_05(mocker, served, attempted, target_result, status):
@@ -214,7 +214,7 @@ def test_runner_05(mocker, served, attempted, target_result, status):
     server = mocker.Mock(spec_set=Sapphire)
     server.serve_path.return_value = (Served.REQUEST, served)
     target = mocker.Mock(spec_set=Target, launch_timeout=10)
-    target.detect_failure.return_value = target_result
+    target.check_result.return_value = target_result
     target.monitor.is_healthy.return_value = False
     testcase = mocker.Mock(spec_set=TestCase, landing_page="a.bin", optional=[])
     runner = Runner(server, target)
@@ -231,7 +231,7 @@ def test_runner_06(mocker):
     """test Runner() with idle checking"""
     server = mocker.Mock(spec_set=Sapphire)
     target = mocker.Mock(spec_set=Target)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     serv_files = ["/fake/file", "/another/file.bin"]
     server.serve_path.return_value = (Served.ALL, serv_files)
     runner = Runner(server, target, idle_threshold=0.01, idle_delay=0.01, relaunch=10)
@@ -241,7 +241,7 @@ def test_runner_06(mocker):
         ServerMap(),
         mocker.Mock(spec_set=TestCase, landing_page=serv_files[0], optional=[]),
     )
-    assert result.status is None
+    assert result.status == Result.NONE
     assert result.attempted
     assert target.close.call_count == 0
 
@@ -314,7 +314,7 @@ def test_runner_10(mocker, tmp_path):
     """test Runner.run() adding includes to testcase"""
     server = mocker.Mock(spec_set=Sapphire)
     target = mocker.Mock(spec_set=Target)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     runner = Runner(server, target, relaunch=10)
     # create test files
     inc_path1 = tmp_path / "include"
@@ -337,7 +337,7 @@ def test_runner_10(mocker, tmp_path):
     with TestCase("a.b", "x", "x") as tcase:
         result = runner.run([], smap, tcase)
         assert result.attempted
-        assert result.status is None
+        assert result.status == Result.NONE
         assert "inc_file.bin" in tcase._existing_paths
         assert pathjoin("nested", "nested_inc.bin") in tcase._existing_paths
         assert pathjoin("test", "inc_file3.txt") in tcase._existing_paths
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index eeeba34b..cd9e419b 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -15,12 +15,12 @@
 
 from ..common.plugins import load as load_plugin
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter, Report
-from ..common.runner import Runner, RunResult
+from ..common.runner import Runner
 from ..common.status import Status
 from ..common.storage import TestCase, TestCaseLoadFailure
 from ..common.utils import TIMEOUT_DELAY, ConfigError, configure_logging, grz_tmp
 from ..session import Session
-from ..target import Target, TargetLaunchError, TargetLaunchTimeout
+from ..target import Result, Target, TargetLaunchError, TargetLaunchTimeout
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
@@ -343,19 +343,19 @@ def run(
                     )
                     durations.append(run_result.duration)
                     served.append(run_result.served)
-                    if run_result.status is not None or not run_result.attempted:
+                    if run_result.status != Result.NONE or not run_result.attempted:
                         break
                 if not run_result.attempted:
                     LOG.warning("Test case was not served")
                     if run_result.initial:
                         startup_error = True
-                        if run_result.status == RunResult.FAILED:
+                        if run_result.status == Result.FOUND:
                             # TODO: what is to best action to take in this case?
                             LOG.warning("Delayed startup failure detected")
                         else:
                             LOG.warning("Timeout too short? System too busy?")
                 # process run results
-                if run_result.status == RunResult.FAILED:
+                if run_result.status == Result.FOUND:
                     # TODO: use self.target.create_report here
                     log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
                     self.target.save_logs(log_path)
@@ -430,7 +430,7 @@ def run(
                     if report is not None:
                         report.cleanup()
                         report = None
-                elif run_result.status == RunResult.IGNORED:
+                elif run_result.status == Result.IGNORED:
                     self.status.ignored += 1
                     LOG.info("Result: Ignored (%d)", self.status.ignored)
 
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 54ee5071..fc15481e 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -33,16 +33,16 @@ def test_main_01(mocker, tmp_path):
     serve_path = mocker.patch(
         "grizzly.replay.replay.Sapphire.serve_path",
         autospec=True,
-        return_value=(Served.ALL, ["test.html"]),  # passed to Target.detect_failure
+        return_value=(Served.ALL, ["test.html"]),  # passed to Target.check_result
     )
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_plugin", autospec=True)
     target = mocker.Mock(spec_set=Target, binary="bin", environ={}, launch_timeout=30)
     target.assets = mocker.Mock(spec_set=AssetManager)
-    target.detect_failure.side_effect = (
-        Result.FAILURE,
+    target.check_result.side_effect = (
+        Result.FOUND,
         Result.NONE,
-        Result.FAILURE,
+        Result.FOUND,
     )
     target.save_logs = _fake_save_logs
     load_target.return_value.return_value = target
@@ -79,7 +79,7 @@ def test_main_01(mocker, tmp_path):
     assert ReplayManager.main(args) == Session.EXIT_SUCCESS
     assert target.reverse.call_count == 1
     assert target.launch.call_count == 3
-    assert target.detect_failure.call_count == 3
+    assert target.check_result.call_count == 3
     assert "TEST_VAR" in target.environ
     assert serve_path.call_count == 3
     assert load_target.call_count == 1
@@ -100,12 +100,12 @@ def test_main_02(mocker, tmp_path):
     mocker.patch(
         "grizzly.replay.replay.Sapphire.serve_path",
         autospec=True,
-        return_value=(Served.ALL, ["test.html"]),  # passed to Target.detect_failure
+        return_value=(Served.ALL, ["test.html"]),  # passed to Target.check_result
     )
     # setup Target
     load_target = mocker.patch("grizzly.replay.replay.load_plugin")
     target = mocker.Mock(spec_set=Target, binary="bin", environ={}, launch_timeout=30)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     load_target.return_value.return_value = target
     # setup args
     (tmp_path / "test.html").touch()
@@ -129,7 +129,7 @@ def test_main_02(mocker, tmp_path):
         valgrind=False,
     )
     assert ReplayManager.main(args) == Session.EXIT_FAILURE
-    assert target.detect_failure.call_count == 1
+    assert target.check_result.call_count == 1
     assert not target.environ
     assert target.close.call_count == 2
     assert target.cleanup.call_count == 1
@@ -251,13 +251,13 @@ def test_main_05(mocker, tmp_path):
     serve_path = mocker.patch(
         "grizzly.replay.replay.Sapphire.serve_path",
         autospec=True,
-        return_value=(None, ["test.html"]),  # passed to Target.detect_failure
+        return_value=(None, ["test.html"]),  # passed to Target.check_result
     )
     # setup Target
     target = mocker.NonCallableMock(
         spec_set=Target, binary="bin", environ={}, launch_timeout=30
     )
-    target.detect_failure.return_value = Result.FAILURE
+    target.check_result.return_value = Result.FOUND
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     mocker.patch(
@@ -302,7 +302,7 @@ def test_main_05(mocker, tmp_path):
         assert ReplayManager.main(args) == Session.EXIT_SUCCESS
         assert "from_cmdline" in target.assets.assets
     assert target.launch.call_count == 1
-    assert target.detect_failure.call_count == 1
+    assert target.check_result.call_count == 1
     assert serve_path.call_count == 1
     assert log_path.is_dir()
     assert any(log_path.glob("**/sample_asset"))
@@ -332,11 +332,11 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
     mocker.patch(
         "grizzly.replay.replay.Sapphire.serve_path",
         autospec=True,
-        return_value=(Served.ALL, ["test.html"]),  # passed to Target.detect_failure
+        return_value=(Served.ALL, ["test.html"]),  # passed to Target.check_result
     )
     # setup Target
     target = mocker.NonCallableMock(spec_set=Target, binary="bin", launch_timeout=30)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     mocker.patch(
         "grizzly.replay.replay.load_plugin",
         autospec=True,
@@ -396,11 +396,11 @@ def test_main_07(mocker, tmp_path, pernosco, rr, valgrind, no_harness):
     mocker.patch(
         "grizzly.replay.replay.Sapphire.serve_path",
         autospec=True,
-        return_value=(Served.ALL, ["test.html"]),  # passed to Target.detect_failure
+        return_value=(Served.ALL, ["test.html"]),  # passed to Target.check_result
     )
     # setup Target
     target = mocker.NonCallableMock(spec_set=Target, binary="bin", launch_timeout=30)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     load_target = mocker.patch(
         "grizzly.replay.replay.load_plugin",
         autospec=True,
@@ -430,7 +430,7 @@ def test_main_07(mocker, tmp_path, pernosco, rr, valgrind, no_harness):
     # maximum one debugger allowed at a time
     assert sum((pernosco, rr, valgrind)) < 2, "test broken!"
     assert ReplayManager.main(args) == Session.EXIT_FAILURE
-    assert target.detect_failure.call_count == 1
+    assert target.check_result.call_count == 1
     assert target.close.call_count == 2
     assert target.cleanup.call_count == 1
     assert load_target.return_value.call_args[-1]["pernosco"] == pernosco
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 2a13cb6d..28d8f551 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -52,7 +52,7 @@ def test_replay_02(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     target.monitor.is_healthy.return_value = False
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True, relaunch=1) as replay:
@@ -73,7 +73,7 @@ def test_replay_03(mocker):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=False, launch_timeout=30)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     target.monitor.is_healthy.return_value = False
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager(
@@ -101,7 +101,7 @@ def test_replay_04(mocker):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=False, launch_timeout=30)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager(
             [], server, target, use_harness=True, relaunch=100
@@ -122,7 +122,7 @@ def test_replay_05(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, served)
     target = mocker.Mock(spec_set=Target, binary="C:\\fake_bin", launch_timeout=30)
-    target.detect_failure.return_value = Result.FAILURE
+    target.check_result.return_value = Result.FOUND
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
@@ -156,7 +156,7 @@ def test_replay_06(mocker, tmp_path):
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     # test target unresponsive
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     server.serve_path.return_value = (Served.NONE, [])
     with ReplayManager([], server, target, use_harness=False) as replay:
         assert not replay.run(testcases, 10, repeat=1)
@@ -167,7 +167,7 @@ def test_replay_06(mocker, tmp_path):
         assert target.close.call_count == 2
     target.reset_mock()
     # test target crashed
-    target.detect_failure.return_value = Result.FAILURE
+    target.check_result.return_value = Result.FOUND
     target.save_logs = _fake_save_logs
     with ReplayManager([], server, target, use_harness=False) as replay:
         results = replay.run(testcases, 10, repeat=1)
@@ -189,7 +189,7 @@ def test_replay_07(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     target = mocker.Mock(spec_set=Target, binary="bin", launch_timeout=30)
     type(target).closed = mocker.PropertyMock(side_effect=(True, False, True))
-    target.detect_failure.side_effect = (Result.NONE, Result.FAILURE)
+    target.check_result.side_effect = (Result.NONE, Result.FOUND)
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     testcases = [
@@ -214,7 +214,7 @@ def test_replay_08(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
-    target.detect_failure.return_value = Result.IGNORED
+    target.check_result.return_value = Result.IGNORED
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -241,8 +241,8 @@ def test_replay_09(mocker, tmp_path):
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     # early failure
-    target.detect_failure.side_effect = (
-        Result.FAILURE,
+    target.check_result.side_effect = (
+        Result.FOUND,
         Result.IGNORED,
         Result.NONE,
     )
@@ -255,10 +255,10 @@ def test_replay_09(mocker, tmp_path):
         assert replay.status.ignored == 1
     # early success
     target.reset_mock()
-    target.detect_failure.side_effect = (
-        Result.FAILURE,
+    target.check_result.side_effect = (
+        Result.FOUND,
         Result.IGNORED,
-        Result.FAILURE,
+        Result.FOUND,
     )
     target.monitor.is_healthy.side_effect = (False, False, False)
     with ReplayManager([], server, target, use_harness=False) as replay:
@@ -271,8 +271,8 @@ def test_replay_09(mocker, tmp_path):
     assert sum(x.count for x in results) == 2
     target.reset_mock()
     # ignore early failure (perform all repeats)
-    target.detect_failure.return_value = Result.NONE
-    target.detect_failure.side_effect = None
+    target.check_result.return_value = Result.NONE
+    target.check_result.side_effect = None
     target.monitor.is_healthy.side_effect = None
     target.monitor.is_healthy.return_value = True
     with ReplayManager([], server, target, use_harness=False) as replay:
@@ -283,7 +283,7 @@ def test_replay_09(mocker, tmp_path):
         assert replay.status.ignored == 0
     target.reset_mock()
     # ignore early success (perform all repeats)
-    target.detect_failure.return_value = Result.FAILURE
+    target.check_result.return_value = Result.FOUND
     target.monitor.is_healthy.return_value = False
     with ReplayManager([], server, target, use_harness=False) as replay:
         results = replay.run(testcases, 10, repeat=4, min_results=1, exit_early=False)
@@ -323,7 +323,7 @@ def test_replay_10(mocker, tmp_path):
     signature = mocker.Mock()
     signature.matches.side_effect = (True, False, False)
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.detect_failure.return_value = Result.FAILURE
+    target.check_result.return_value = Result.FOUND
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
@@ -368,7 +368,7 @@ def test_replay_11(mocker, tmp_path):
     signature = mocker.Mock()
     signature.matches.side_effect = (True, True)
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.detect_failure.return_value = Result.FAILURE
+    target.check_result.return_value = Result.FOUND
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -411,7 +411,7 @@ def test_replay_12(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.detect_failure.return_value = Result.FAILURE
+    target.check_result.return_value = Result.FOUND
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -454,7 +454,7 @@ def test_replay_13(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.detect_failure.return_value = Result.FAILURE
+    target.check_result.return_value = Result.FOUND
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -498,7 +498,7 @@ def test_replay_14(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.detect_failure.return_value = Result.FAILURE
+    target.check_result.return_value = Result.FOUND
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -533,7 +533,7 @@ def test_replay_15(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.side_effect = ((Served.ALL, ["a.html"]), KeyboardInterrupt)
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.detect_failure.return_value = Result.FAILURE
+    target.check_result.return_value = Result.FOUND
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
@@ -558,7 +558,7 @@ def test_replay_16(mocker):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
         for _ in range(3)
@@ -579,7 +579,7 @@ def test_replay_17(mocker):
     target = mocker.Mock(spec_set=Target, launch_timeout=30)
     # test relaunch < repeat
     type(target).closed = mocker.PropertyMock(side_effect=cycle([True, False]))
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -607,10 +607,10 @@ def test_replay_18(mocker, tmp_path):
         (Served.ALL, ["c.html"]),
     )
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.detect_failure.side_effect = (
+    target.check_result.side_effect = (
         Result.NONE,
         Result.NONE,
-        Result.FAILURE,
+        Result.FOUND,
     )
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
@@ -641,7 +641,7 @@ def test_replay_19(mocker, tmp_path):
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
-    target.detect_failure.return_value = Result.NONE
+    target.check_result.return_value = Result.NONE
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True) as replay:
             assert not replay.run([testcase], 30)
@@ -782,7 +782,7 @@ def test_replay_22(mocker, tmp_path, is_hang, use_sig, match_sig, ignored, resul
     else:
         signature = None
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.detect_failure.return_value = Result.FAILURE
+    target.check_result.return_value = Result.FOUND
     target.handle_hang.return_value = False
     target.save_logs = _fake_save_logs
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
diff --git a/grizzly/session.py b/grizzly/session.py
index 3d7267b0..fd7a6457 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -6,9 +6,9 @@
 from time import time
 
 from .common.iomanager import IOManager
-from .common.runner import Runner, RunResult
+from .common.runner import Runner
 from .common.status import Status
-from .target import TargetLaunchError
+from .target import Result, TargetLaunchError
 
 __all__ = ("SessionError", "LogOutputLimiter", "Session")
 __author__ = "Tyson Smith"
@@ -234,7 +234,7 @@ def run(
                 if result.initial:
                     # since this is the first iteration since the Target launched
                     # something is likely wrong with the Target or Adapter
-                    if result.status == RunResult.FAILED:
+                    if result.status == Result.FOUND:
                         LOG.warning("Delayed startup failure detected")
                     else:
                         LOG.warning("Timeout too short? System too busy?")
@@ -248,7 +248,7 @@ def run(
                     current_test.purge_optional(result.served)
                 self.iomanager.commit()
             # process results
-            if result.status == RunResult.FAILED:
+            if result.status == Result.FOUND:
                 LOG.debug("result detected")
                 report = self.target.create_report(is_hang=result.timeout)
                 if result.timeout:
@@ -261,7 +261,7 @@ def run(
                 self.reporter.submit(self.iomanager.tests, report)
                 report.cleanup()
                 self.status.count_result(short_sig)
-            elif result.status == RunResult.IGNORED:
+            elif result.status == Result.IGNORED:
                 self.status.ignored += 1
                 LOG.info("Ignored (%d)", self.status.ignored)
 
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 32601123..30c5f0ff 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -141,8 +141,8 @@ def log_length(_, log_id):
             self._monitor = _PuppetMonitor()
         return self._monitor
 
-    def detect_failure(self, ignored):
-        status = Result.NONE
+    def check_result(self, ignored):
+        result = Result.NONE
         # check if there has been a crash, hangs will appear as SIGABRT
         if not self._puppet.is_healthy():
             self.close()
@@ -156,20 +156,20 @@ def detect_failure(self, ignored):
                 and "memory" in ignored
                 and "ffp_worker_memory_usage" in self._puppet.available_logs()
             ):
-                status = Result.IGNORED
+                result = Result.IGNORED
                 LOG.debug("memory limit exceeded")
             elif (
                 self._puppet.reason == Reason.WORKER
                 and "log-limit" in ignored
                 and "ffp_worker_log_size" in self._puppet.available_logs()
             ):
-                status = Result.IGNORED
+                result = Result.IGNORED
                 LOG.debug("log size limit exceeded")
             else:
                 # crash or hang (forced SIGABRT) has been detected
                 LOG.debug("failure detected, ffpuppet %s", self._puppet.reason)
-                status = Result.FAILURE
-        return status
+                result = Result.FOUND
+        return result
 
     def handle_hang(self, ignore_idle=True):
         was_idle = False
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index e0f8c2cb..44837e00 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -24,7 +24,7 @@ class Result(Enum):
     """Target results codes"""
 
     NONE = 0
-    FAILURE = 1
+    FOUND = 1
     IGNORED = 2
 
 
@@ -93,6 +93,10 @@ def assets(self, assets):
     def _cleanup(self):
         pass
 
+    @abstractmethod
+    def check_result(self, ignored):
+        pass
+
     def cleanup(self):
         # call target specific _cleanup first
         self._cleanup()
@@ -111,10 +115,6 @@ def closed(self):
     def create_report(self, is_hang=False):
         pass
 
-    @abstractmethod
-    def detect_failure(self, ignored):
-        pass
-
     def dump_coverage(self, _timeout=0):  # pylint: disable=no-self-use
         LOG.warning("dump_coverage() is not supported!")
 
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 60c8c831..0f152422 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -26,7 +26,7 @@ def test_puppet_target_01(mocker, tmp_path):
         assert target.launch_timeout == 300
         assert target.log_limit == 25
         assert target.memory_limit == 5000
-        assert target.detect_failure([]) == Result.NONE
+        assert target.check_result([]) == Result.NONE
         assert target.log_size() == 1124
         fake_ffp.return_value.log_length.assert_any_call("stderr")
         fake_ffp.return_value.log_length.assert_any_call("stdout")
@@ -80,11 +80,11 @@ def test_puppet_target_02(mocker, tmp_path):
         # browser process closed
         (False, Reason.CLOSED, [], Result.NONE, 1),
         # browser process crashed
-        (False, Reason.ALERT, [], Result.FAILURE, 1),
+        (False, Reason.ALERT, [], Result.FOUND, 1),
         # browser exit with no crash logs
         (False, Reason.EXITED, [], Result.NONE, 1),
         # ffpuppet check failed
-        (False, Reason.WORKER, [], Result.FAILURE, 1),
+        (False, Reason.WORKER, [], Result.FOUND, 1),
         # ffpuppet check ignored (memory)
         (False, Reason.WORKER, ["memory"], Result.IGNORED, 1),
         # ffpuppet check ignored (log-limit)
@@ -92,7 +92,7 @@ def test_puppet_target_02(mocker, tmp_path):
     ],
 )
 def test_puppet_target_03(mocker, tmp_path, healthy, reason, ignore, result, closes):
-    """test PuppetTarget.detect_failure()"""
+    """test PuppetTarget.check_result()"""
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_file = tmp_path / "fake"
     fake_file.touch()
@@ -103,7 +103,7 @@ def test_puppet_target_03(mocker, tmp_path, healthy, reason, ignore, result, clo
         fake_ffp.return_value.available_logs.return_value = "ffp_worker_log_size"
     fake_ffp.return_value.is_healthy.return_value = healthy
     fake_ffp.return_value.reason = reason
-    assert target.detect_failure(ignore) == result
+    assert target.check_result(ignore) == result
     assert fake_ffp.return_value.close.call_count == closes
 
 
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index 2a652f71..4391b9f6 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -11,6 +11,9 @@ class SimpleTarget(Target):
     def _cleanup(self):
         pass
 
+    def check_result(self, ignored):
+        pass
+
     def close(self, force_close=False):
         pass
 
@@ -21,9 +24,6 @@ def closed(self):
     def create_report(self, is_hang=False):
         pass
 
-    def detect_failure(self, ignored):
-        pass
-
     def handle_hang(self, ignore_idle=True):
         pass
 
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index b49c138f..b3f5e602 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -109,7 +109,7 @@ def test_session_01(
         assert session.status.iteration == max_iters
         assert session.status.test_name == "file.bin"
         assert target.close.call_count == max_iters / relaunch
-        assert target.detect_failure.call_count == max_iters
+        assert target.check_result.call_count == max_iters
         assert target.handle_hang.call_count == 0
         if profiling:
             assert any(session.status.profile_entries()) == profiling
@@ -168,7 +168,7 @@ def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
         session.run([], 10)
         assert session.status.iteration == remaining
         assert session.status.test_name is None
-        assert target.detect_failure.call_count == remaining
+        assert target.check_result.call_count == remaining
         assert target.handle_hang.call_count == 0
 
 
@@ -211,8 +211,8 @@ def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
         side_effect=((x % relaunch == 0) for x in range(iters))
     )
     # failure is on final iteration
-    target.detect_failure.side_effect = [Result.NONE for x in range(iters - 1)] + [
-        Result.FAILURE
+    target.check_result.side_effect = [Result.NONE for x in range(iters - 1)] + [
+        Result.FOUND
     ]
     target.log_size.return_value = 1
     target.create_report.return_value = report
@@ -294,7 +294,7 @@ def test_session_06(mocker, tmp_path, harness, report_size):
     )
     target.monitor.launches = 1
     type(target).closed = mocker.PropertyMock(side_effect=(True, False))
-    target.detect_failure.side_effect = (Result.NONE, Result.FAILURE)
+    target.check_result.side_effect = (Result.NONE, Result.FOUND)
     target.log_size.return_value = 1
     target.create_report.return_value = report
     with Session(
@@ -319,7 +319,7 @@ def test_session_06(mocker, tmp_path, harness, report_size):
     "srv_results, target_result, ignored, results",
     [
         # delayed startup crash
-        (Served.NONE, Result.FAILURE, 0, 1),
+        (Served.NONE, Result.FOUND, 0, 1),
         # startup hang/unresponsive
         (Served.TIMEOUT, Result.NONE, 1, 0),
     ],
@@ -339,7 +339,7 @@ def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, resul
         launch_timeout=30,
     )
     target.monitor.launches = 1
-    target.detect_failure.side_effect = (target_result,)
+    target.check_result.side_effect = (target_result,)
     target.create_report.return_value = report
     with Session(SimpleAdapter(False), reporter, server, target) as session:
         server.serve_path.return_value = (srv_results, [])
@@ -349,14 +349,14 @@ def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, resul
         assert session.status.results == results
         assert session.status.ignored == ignored
         assert reporter.submit.call_count == results
-        assert target.detect_failure.call_count == results
+        assert target.check_result.call_count == results
         assert target.handle_hang.call_count == ignored
 
 
 def test_session_08(tmp_path, mocker):
     """test Session.run() ignoring failures"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
-    result = RunResult([], 0.1, status=RunResult.IGNORED)
+    result = RunResult([], 0.1, status=Result.IGNORED)
     result.attempted = True
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.run.return_value = result
@@ -399,7 +399,7 @@ def test_session_09(tmp_path, mocker):
 def test_session_10(tmp_path, mocker):
     """test Session.run() report hang"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
-    result = RunResult([], 60.0, status=RunResult.FAILED, timeout=True)
+    result = RunResult([], 60.0, status=Result.FOUND, timeout=True)
     result.attempted = True
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.run.return_value = result

From 113180d2492dec237ae743f6f8a3d060fe695cf0 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 6 Aug 2021 17:28:18 -0700
Subject: [PATCH 299/531] Use enum for Exit codes

---
 grizzly/common/reporter.py     |  1 +
 grizzly/common/utils.py        | 19 ++++++++++++++
 grizzly/main.py                | 10 ++++----
 grizzly/reduce/bucket.py       |  6 ++---
 grizzly/reduce/core.py         | 19 +++++++-------
 grizzly/reduce/crash.py        | 23 ++++++-----------
 grizzly/reduce/exceptions.py   |  6 ++---
 grizzly/reduce/test_main_fm.py | 19 +++++++-------
 grizzly/replay/replay.py       | 19 +++++++-------
 grizzly/replay/test_main.py    | 46 ++++++++++++++++------------------
 grizzly/session.py             |  6 -----
 grizzly/test_main.py           | 35 ++++++++++----------------
 12 files changed, 101 insertions(+), 108 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 6f6cc9e1..d575b1f5 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -518,6 +518,7 @@ class FuzzManagerReporter(Reporter):
     # max number of times to report a non-frequent signature to FuzzManager
     MAX_REPORTS = 10
 
+    # TODO: Use enum?
     # testcase quality values
     QUAL_REDUCED_RESULT = 0  # the final reduced testcase
     QUAL_REDUCED_ORIGINAL = 1  # the original used for successful reduction
diff --git a/grizzly/common/utils.py b/grizzly/common/utils.py
index 385c5949..2025497e 100644
--- a/grizzly/common/utils.py
+++ b/grizzly/common/utils.py
@@ -2,6 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from enum import Enum, unique
 from logging import DEBUG, basicConfig
 from os import getenv, makedirs
 from os.path import join as pathjoin
@@ -11,6 +12,7 @@
 __all__ = (
     "ConfigError",
     "configure_logging",
+    "Exit",
     "grz_tmp",
     "split_sanitizer_opts",
     "TIMEOUT_DELAY",
@@ -31,6 +33,23 @@ def __init__(self, message, exit_code):
         self.exit_code = exit_code
 
 
+@unique
+class Exit(Enum):
+    """Exit codes"""
+
+    SUCCESS = 0
+    # unexpected error occurred (invalid input, unhanded exception, etc)
+    ERROR = 1
+    # invalid argument
+    ARGS = 2
+    # run aborted (ctrl+c, etc)
+    ABORT = 3
+    # unrelated Target failure (browser startup crash, etc)
+    LAUNCH_FAILURE = 4
+    # expected results not reproduced (opposite of SUCCESS)
+    FAILURE = 5
+
+
 def configure_logging(log_level):
     """Configure log output level and formatting.
 
diff --git a/grizzly/main.py b/grizzly/main.py
index 5860b373..7511e2e6 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -15,7 +15,7 @@
     FuzzManagerReporter,
     S3FuzzManagerReporter,
 )
-from .common.utils import TIMEOUT_DELAY, configure_logging
+from .common.utils import TIMEOUT_DELAY, Exit, configure_logging
 from .session import Session
 from .target import Target, TargetLaunchError, TargetLaunchTimeout
 
@@ -65,7 +65,7 @@ def main(args):
         LOG.info("Using test time limit: %ds, timeout: %ds", time_limit, timeout)
         if timeout < time_limit:
             LOG.error("Timeout must be at least test time limit if not greater")
-            return Session.EXIT_ARGS
+            return Exit.ARGS.value
         if adapter.HARNESS_FILE and time_limit == timeout:
             LOG.warning(
                 "To avoid relaunches due to tests failing to close"
@@ -144,11 +144,11 @@ def main(args):
 
     except KeyboardInterrupt:
         LOG.info("Ctrl+C detected.")
-        return Session.EXIT_ABORT
+        return Exit.ABORT.value
 
     except (TargetLaunchError, TargetLaunchTimeout) as exc:
         LOG.error(str(exc))
-        return Session.EXIT_LAUNCH_FAILURE
+        return Exit.LAUNCH_FAILURE.value
 
     finally:
         LOG.info("Shutting down...")
@@ -163,4 +163,4 @@ def main(args):
             adapter.cleanup()
         LOG.info("Done.")
 
-    return Session.EXIT_SUCCESS
+    return Exit.SUCCESS.value
diff --git a/grizzly/reduce/bucket.py b/grizzly/reduce/bucket.py
index ec342153..373480be 100644
--- a/grizzly/reduce/bucket.py
+++ b/grizzly/reduce/bucket.py
@@ -5,8 +5,8 @@
 from logging import getLogger
 
 from ..common.fuzzmanager import Bucket
+from ..common.utils import Exit
 from ..main import configure_logging
-from ..session import Session
 from .args import ReduceFuzzManagerIDQualityArgs
 from .crash import main as crash_main
 
@@ -29,7 +29,7 @@ def main(args):
     orig_tool = args.tool
 
     # if no crashes in bucket, return success
-    result = Session.EXIT_SUCCESS
+    result = Exit.SUCCESS.value
 
     bucket = Bucket(args.input)
     try:
@@ -42,7 +42,7 @@ def main(args):
 
             # call grizzly.reduce.crash
             result = crash_main(args)
-            if result in {Session.EXIT_SUCCESS, Session.EXIT_ABORT}:
+            if result in {Exit.SUCCESS.value, Exit.ABORT.value}:
                 break
 
     finally:
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 7cf6206e..856567c4 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -20,9 +20,8 @@
 from ..common.plugins import load as load_plugin
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter
 from ..common.storage import TestCaseLoadFailure
-from ..common.utils import ConfigError, configure_logging, grz_tmp
+from ..common.utils import ConfigError, Exit, configure_logging, grz_tmp
 from ..replay import ReplayManager
-from ..session import Session
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from .exceptions import GrizzlyReduceBaseException, NotReproducible
 from .stats import ReductionStats
@@ -417,7 +416,7 @@ def run(self, repeat=1, min_results=1):
                                be considered successful.
 
         Returns:
-            int: One of the `Session.EXIT_*` constants.
+            int: One of the Exit enum values.
         """
         any_success = False
         sig_given = self._signature is not None
@@ -648,8 +647,8 @@ def run(self, repeat=1, min_results=1):
         )
 
         if any_success:
-            return Session.EXIT_SUCCESS
-        return Session.EXIT_FAILURE
+            return Exit.SUCCESS.value
+        return Exit.FAILURE.value
 
     def report(self, results, testcases, stats=None):
         """Report results, either to FuzzManager or to filesystem.
@@ -744,7 +743,7 @@ def main(cls, args):
                 )
             except TestCaseLoadFailure as exc:
                 LOG.error("Error: %s", str(exc))
-                return Session.EXIT_ERROR
+                return Exit.ERROR.value
 
             if args.tool is None and testcases[0].adapter_name is not None:
                 LOG.warning(
@@ -761,7 +760,7 @@ def main(cls, args):
                         "Error: '--no-harness' cannot be used with multiple "
                         "testcases. Perhaps '--test-index' can help."
                     )
-                    return Session.EXIT_ARGS
+                    return Exit.ARGS.value
                 LOG.debug("--no-harness specified relaunch set to 1")
                 args.relaunch = 1
 
@@ -828,7 +827,7 @@ def main(cls, args):
 
         except KeyboardInterrupt as exc:
             LOG.error("Exception: %r", exc)
-            return Session.EXIT_ABORT
+            return Exit.ABORT.value
 
         except (TargetLaunchError, TargetLaunchTimeout) as exc:
             LOG.error("Exception: %s", exc)
@@ -837,7 +836,7 @@ def main(cls, args):
                 LOG.error("Logs can be found here %r", path)
                 reporter = FilesystemReporter(path, major_bucket=False)
                 reporter.submit([], exc.report)
-            return Session.EXIT_LAUNCH_FAILURE
+            return Exit.LAUNCH_FAILURE.value
 
         except GrizzlyReduceBaseException as exc:
             LOG.error(exc.msg)
@@ -845,7 +844,7 @@ def main(cls, args):
 
         except Exception:  # pylint: disable=broad-except
             LOG.exception("Exception during reduction!")
-            return Session.EXIT_ERROR
+            return Exit.ERROR.value
 
         finally:
             LOG.info("Shutting down...")
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index 8b8e62c2..482a7859 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -6,8 +6,8 @@
 
 from ..common.fuzzmanager import Bucket, CrashEntry
 from ..common.reporter import FuzzManagerReporter
+from ..common.utils import Exit
 from ..main import configure_logging
-from ..session import Session
 from .args import ReduceFuzzManagerIDArgs
 from .core import ReduceManager
 
@@ -34,36 +34,29 @@ def main(args):
             bucket = Bucket(crash.bucket)
             args.sig = str(bucket.signature_path())
         if args.tool is None:
-            LOG.info(
-                "Setting default --tool=%s from CrashEntry",
-                crash.tool,
-            )
+            LOG.info("Setting default --tool=%s from CrashEntry", crash.tool)
             args.tool = crash.tool
 
         # call grizzly.reduce
         result = ReduceManager.main(args)
 
         # update quality
-        # map Session.EXIT_* -> FuzzManagerReporter.QUAL_*
+        # map Exit.* -> FuzzManagerReporter.QUAL_*
         # default back to UNREDUCED
         # most errors will not be related to the testcase
         # so they should be retried later
         if args.fuzzmanager:
             quality = {
-                Session.EXIT_ERROR: FuzzManagerReporter.QUAL_REDUCER_ERROR,
-                Session.EXIT_ABORT: crash.testcase_quality,
-                Session.EXIT_SUCCESS: FuzzManagerReporter.QUAL_REDUCED_ORIGINAL,
-                Session.EXIT_FAILURE: FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE,
+                Exit.ERROR.value: FuzzManagerReporter.QUAL_REDUCER_ERROR,
+                Exit.ABORT.value: crash.testcase_quality,
+                Exit.SUCCESS.value: FuzzManagerReporter.QUAL_REDUCED_ORIGINAL,
+                Exit.FAILURE.value: FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE,
             }.get(result, FuzzManagerReporter.QUAL_UNREDUCED)
             # don't ever set things back to Q4, default to Q5 for that case.
             # Q4 is only used in automation, so ABORT should never happen.
             if quality == FuzzManagerReporter.QUAL_REDUCING:
                 quality = FuzzManagerReporter.QUAL_UNREDUCED
-            LOG.info(
-                "reducer finished -> exit(%d) -> Q%d",
-                result,
-                quality,
-            )
+            LOG.info("reducer finished -> exit(%d) -> Q%d", result, quality)
             crash.testcase_quality = quality
     finally:
         crash.cleanup()
diff --git a/grizzly/reduce/exceptions.py b/grizzly/reduce/exceptions.py
index 7781a91e..ae6709bc 100644
--- a/grizzly/reduce/exceptions.py
+++ b/grizzly/reduce/exceptions.py
@@ -3,13 +3,13 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Grizzly Reduction exceptions."""
-from ..session import Session
+from ..common.utils import Exit
 
 
 class GrizzlyReduceBaseException(Exception):
     """Base for other Grizzly Reducer specific exceptions."""
 
-    def __init__(self, msg, code=Session.EXIT_ERROR):
+    def __init__(self, msg, code=Exit.ERROR.value):
         super().__init__()
         self.msg = msg
         self.code = code
@@ -19,4 +19,4 @@ class NotReproducible(GrizzlyReduceBaseException):
     """Crash was not observed when expected during reduction."""
 
     def __init__(self, msg):
-        super().__init__(msg, code=Session.EXIT_FAILURE)
+        super().__init__(msg, code=Exit.FAILURE.value)
diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
index 07bab57b..7bfb8e83 100644
--- a/grizzly/reduce/test_main_fm.py
+++ b/grizzly/reduce/test_main_fm.py
@@ -8,6 +8,7 @@
 
 import pytest
 
+from ..common.utils import Exit
 from .bucket import main as bucket_main
 from .crash import main as crash_main
 
@@ -54,13 +55,13 @@ def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_
 @pytest.mark.parametrize(
     "mgr_exit_code, pre_quality, post_quality",
     [
-        (0, 5, 1),
-        (1, 5, 9),
-        (2, 6, 5),
-        (3, 4, 5),
-        (3, 0, 0),
-        (4, 6, 5),
-        (5, 5, 10),
+        (Exit.SUCCESS, 5, 1),
+        (Exit.ERROR, 5, 9),
+        (Exit.ARGS, 6, 5),
+        (Exit.ABORT, 4, 5),
+        (Exit.ABORT, 0, 0),
+        (Exit.LAUNCH_FAILURE, 6, 5),
+        (Exit.FAILURE, 5, 10),
     ],
 )
 def test_crash_main_quality(mocker, mgr_exit_code, pre_quality, post_quality):
@@ -73,14 +74,14 @@ def test_crash_main_quality(mocker, mgr_exit_code, pre_quality, post_quality):
     crash.return_value.testcase_quality = pre_quality
     crash.return_value.bucket = None
     crash.return_value.tool = "test-tool"
-    mgr.main.return_value = mgr_exit_code
+    mgr.main.return_value = mgr_exit_code.value
 
     args = mocker.Mock(
         input=12345,
         sig=None,
         tool=None,
     )
-    assert crash_main(args) == mgr_exit_code
+    assert crash_main(args) == mgr_exit_code.value
     assert crash.return_value.testcase_quality == post_quality
 
 
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index cd9e419b..2895465b 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -18,8 +18,7 @@
 from ..common.runner import Runner
 from ..common.status import Status
 from ..common.storage import TestCase, TestCaseLoadFailure
-from ..common.utils import TIMEOUT_DELAY, ConfigError, configure_logging, grz_tmp
-from ..session import Session
+from ..common.utils import TIMEOUT_DELAY, ConfigError, Exit, configure_logging, grz_tmp
 from ..target import Result, Target, TargetLaunchError, TargetLaunchTimeout
 
 __author__ = "Tyson Smith"
@@ -129,11 +128,11 @@ def expect_hang(ignore, signature, tests):
         if is_hang:
             if signature is None:
                 raise ConfigError(
-                    "Hangs require a signature to replay", Session.EXIT_ERROR
+                    "Hangs require a signature to replay", Exit.ERROR.value
                 )
             if "timeout" in ignore:
                 raise ConfigError(
-                    "Cannot ignore 'timeout' when detecting hangs", Session.EXIT_ERROR
+                    "Cannot ignore 'timeout' when detecting hangs", Exit.ERROR.value
                 )
         return is_hang
 
@@ -546,7 +545,7 @@ def time_limits(cls, time_limit, timeout, tests):
             raise ConfigError(
                 "Timeout (%d) cannot be less than time limit (%d)"
                 % (timeout, time_limit),
-                Session.EXIT_ARGS,
+                Exit.ARGS.value,
             )
         return time_limit, timeout
 
@@ -581,7 +580,7 @@ def main(cls, args):
             )
         except TestCaseLoadFailure as exc:
             LOG.error("Error: %s", str(exc))
-            return Session.EXIT_ERROR
+            return Exit.ERROR.value
 
         results = None
         target = None
@@ -591,7 +590,7 @@ def main(cls, args):
                     "'--no-harness' cannot be used with multiple testcases. "
                     "Perhaps '--test-index' can help."
                 )
-                return Session.EXIT_ARGS
+                return Exit.ARGS.value
             # check if hangs are expected
             expect_hang = cls.expect_hang(args.ignore, signature, testcases)
             # check test time limit and timeout
@@ -674,14 +673,14 @@ def main(cls, args):
                     args.logs, results, testcases if args.include_test else None
                 )
             # TODO: add fuzzmanager reporting
-            return Session.EXIT_SUCCESS if success else Session.EXIT_FAILURE
+            return Exit.SUCCESS.value if success else Exit.FAILURE.value
 
         except ConfigError as exc:
             LOG.error(str(exc))
             return exc.exit_code
 
         except KeyboardInterrupt:
-            return Session.EXIT_ABORT
+            return Exit.ABORT.value
 
         except (TargetLaunchError, TargetLaunchTimeout) as exc:
             LOG.error(str(exc))
@@ -690,7 +689,7 @@ def main(cls, args):
                 LOG.error("Logs can be found here %r", path)
                 reporter = FilesystemReporter(path, major_bucket=False)
                 reporter.submit([], exc.report)
-            return Session.EXIT_LAUNCH_FAILURE
+            return Exit.LAUNCH_FAILURE.value
 
         finally:
             LOG.info("Shutting down...")
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index fc15481e..9deaa5bf 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -11,7 +11,7 @@
 
 from ..common.reporter import Report
 from ..common.storage import TestCase, TestCaseLoadFailure
-from ..session import Session
+from ..common.utils import Exit
 from ..target import (
     AssetManager,
     Result,
@@ -39,11 +39,7 @@ def test_main_01(mocker, tmp_path):
     load_target = mocker.patch("grizzly.replay.replay.load_plugin", autospec=True)
     target = mocker.Mock(spec_set=Target, binary="bin", environ={}, launch_timeout=30)
     target.assets = mocker.Mock(spec_set=AssetManager)
-    target.check_result.side_effect = (
-        Result.FOUND,
-        Result.NONE,
-        Result.FOUND,
-    )
+    target.check_result.side_effect = (Result.FOUND, Result.NONE, Result.FOUND)
     target.save_logs = _fake_save_logs
     load_target.return_value.return_value = target
     with TestCase("test.html", None, "adpt") as src:
@@ -76,7 +72,7 @@ def test_main_01(mocker, tmp_path):
         timeout=None,
         valgrind=False,
     )
-    assert ReplayManager.main(args) == Session.EXIT_SUCCESS
+    assert ReplayManager.main(args) == Exit.SUCCESS.value
     assert target.reverse.call_count == 1
     assert target.launch.call_count == 3
     assert target.check_result.call_count == 3
@@ -128,7 +124,7 @@ def test_main_02(mocker, tmp_path):
         timeout=None,
         valgrind=False,
     )
-    assert ReplayManager.main(args) == Session.EXIT_FAILURE
+    assert ReplayManager.main(args) == Exit.FAILURE.value
     assert target.check_result.call_count == 1
     assert not target.environ
     assert target.close.call_count == 2
@@ -161,35 +157,35 @@ def test_main_03(mocker):
     )
     # user abort
     fake_load_target.side_effect = KeyboardInterrupt
-    assert ReplayManager.main(args) == Session.EXIT_ABORT
+    assert ReplayManager.main(args) == Exit.ABORT.value
     fake_load_target.reset_mock()
     # invalid test case
     fake_tc.load.side_effect = TestCaseLoadFailure
-    assert ReplayManager.main(args) == Session.EXIT_ERROR
+    assert ReplayManager.main(args) == Exit.ERROR.value
     assert fake_load_target.call_count == 0
     # no test cases
     fake_tc.load.side_effect = None
     fake_tc.load.return_value = list()
-    assert ReplayManager.main(args) == Session.EXIT_ERROR
+    assert ReplayManager.main(args) == Exit.ERROR.value
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
     # multiple test cases with --no-harness
     fake_tc.load.return_value = [
         mocker.Mock(spec_set=TestCase, env_vars={}, hang=False) for _ in range(2)
     ]
-    assert ReplayManager.main(args) == Session.EXIT_ARGS
+    assert ReplayManager.main(args) == Exit.ARGS.value
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
     # signature required replaying hang
     fake_tc.load.return_value = [mocker.Mock(spec_set=TestCase, env_vars={}, hang=True)]
-    assert ReplayManager.main(args) == Session.EXIT_ERROR
+    assert ReplayManager.main(args) == Exit.ERROR.value
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
     # can't ignore timeout replaying hang
     args.ignore = ["timeout"]
     args.sig = "sig"
     fake_tc.load.return_value = [mocker.Mock(spec_set=TestCase, env_vars={}, hang=True)]
-    assert ReplayManager.main(args) == Session.EXIT_ERROR
+    assert ReplayManager.main(args) == Exit.ERROR.value
     assert fake_sig.fromFile.call_count == 1
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
@@ -236,14 +232,14 @@ def test_main_04(mocker, tmp_path):
         "grizzly.replay.replay.ReplayManager.run",
         side_effect=TargetLaunchError("", report),
     )
-    assert ReplayManager.main(args) == Session.EXIT_LAUNCH_FAILURE
+    assert ReplayManager.main(args) == Exit.LAUNCH_FAILURE.value
     assert not fake_logs.is_dir()
     assert "fake_report_logs" in (x.name for x in fake_tmp.iterdir())
     # target launch timeout
     mocker.patch(
         "grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchTimeout
     )
-    assert ReplayManager.main(args) == Session.EXIT_LAUNCH_FAILURE
+    assert ReplayManager.main(args) == Exit.LAUNCH_FAILURE.value
 
 
 def test_main_05(mocker, tmp_path):
@@ -299,7 +295,7 @@ def test_main_05(mocker, tmp_path):
     args.input = str(input_path)
     with AssetManager(base_path=str(tmp_path)) as assets:
         target.assets = assets
-        assert ReplayManager.main(args) == Session.EXIT_SUCCESS
+        assert ReplayManager.main(args) == Exit.SUCCESS.value
         assert "from_cmdline" in target.assets.assets
     assert target.launch.call_count == 1
     assert target.check_result.call_count == 1
@@ -312,17 +308,17 @@ def test_main_05(mocker, tmp_path):
     "arg_timelimit, arg_timeout, test_timelimit, result",
     [
         # use default test time limit and timeout values (test missing time limit)
-        (None, None, None, Session.EXIT_FAILURE),
+        (None, None, None, Exit.FAILURE),
         # use min test time limit and default timeout values
-        (None, None, 1, Session.EXIT_FAILURE),
+        (None, None, 1, Exit.FAILURE),
         # set test time limit
-        (10, None, None, Session.EXIT_FAILURE),
+        (10, None, None, Exit.FAILURE),
         # set both test time limit and timeout to the same value
-        (10, 10, None, Session.EXIT_FAILURE),
+        (10, 10, None, Exit.FAILURE),
         # set timeout greater than test time limit
-        (10, 11, None, Session.EXIT_FAILURE),
+        (10, 11, None, Exit.FAILURE),
         # set test time limit greater than timeout
-        (11, 10, None, Session.EXIT_ARGS),
+        (11, 10, None, Exit.ARGS),
     ],
 )
 def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, result):
@@ -371,7 +367,7 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
         timeout=arg_timeout,
         valgrind=False,
     )
-    assert ReplayManager.main(args) == result
+    assert ReplayManager.main(args) == result.value
 
 
 @mark.parametrize(
@@ -429,7 +425,7 @@ def test_main_07(mocker, tmp_path, pernosco, rr, valgrind, no_harness):
     )
     # maximum one debugger allowed at a time
     assert sum((pernosco, rr, valgrind)) < 2, "test broken!"
-    assert ReplayManager.main(args) == Session.EXIT_FAILURE
+    assert ReplayManager.main(args) == Exit.FAILURE.value
     assert target.check_result.call_count == 1
     assert target.close.call_count == 2
     assert target.cleanup.call_count == 1
diff --git a/grizzly/session.py b/grizzly/session.py
index fd7a6457..2b93af6b 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -61,12 +61,6 @@ def ready(self, cur_iter, launches):
 class Session:
     DISPLAY_VERBOSE = 0  # display status every iteration
     DISPLAY_NORMAL = 1  # quickly reduce the amount of output
-    EXIT_SUCCESS = 0
-    EXIT_ERROR = 1  # unexpected error occurred (invalid input, unhanded exception, etc)
-    EXIT_ARGS = 2  # invalid argument
-    EXIT_ABORT = 3  # run aborted (ctrl+c, etc)
-    EXIT_LAUNCH_FAILURE = 4  # unrelated Target failure (browser startup crash, etc)
-    EXIT_FAILURE = 5  # expected results not reproduced (opposite of EXIT_SUCCESS)
 
     # display warning when target log files exceed limit (25MB)
     TARGET_LOG_SIZE_WARN = 0x1900000
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 97b4fad0..38798642 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -8,8 +8,8 @@
 from sapphire import Sapphire
 
 from .adapter import Adapter
+from .common.utils import Exit
 from .main import main
-from .session import Session
 from .target import AssetManager, Target, TargetLaunchError
 
 
@@ -77,7 +77,6 @@ def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, verbose):
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec_set=True)
     fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
-    fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     args = FakeArgs()
     args.asset = [
         ["fake", "fake"],
@@ -93,7 +92,7 @@ def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, verbose):
     if not verbose:
         args.log_level = 20
     args.coverage = cov
-    assert main(args) == Session.EXIT_SUCCESS
+    assert main(args) == Exit.SUCCESS.value
     assert fake_session.mock_calls[0][-1]["coverage"] == cov
     if adpt_relaunch:
         assert fake_session.mock_calls[0][-1]["relaunch"] == adpt_relaunch
@@ -128,7 +127,6 @@ def test_main_02(mocker, reporter):
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
-    fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     args = FakeArgs()
     args.adapter = "fake"
     if reporter == "FuzzManager":
@@ -141,7 +139,7 @@ def test_main_02(mocker, reporter):
         )
         fake_reporter.sanity_check.return_value = True
         args.s3_fuzzmanager = True
-    assert main(args) == Session.EXIT_SUCCESS
+    assert main(args) == Exit.SUCCESS.value
     assert fake_target.cleanup.call_count == 1
 
 
@@ -149,9 +147,9 @@ def test_main_02(mocker, reporter):
     "exit_code, to_raise",
     [
         # test user abort
-        (Session.EXIT_ABORT, KeyboardInterrupt()),
+        (Exit.ABORT, KeyboardInterrupt()),
         # test launch failure
-        (Session.EXIT_LAUNCH_FAILURE, TargetLaunchError("test", None)),
+        (Exit.LAUNCH_FAILURE, TargetLaunchError("test", None)),
     ],
 )
 def test_main_03(mocker, exit_code, to_raise):
@@ -166,16 +164,12 @@ def test_main_03(mocker, exit_code, to_raise):
         mocker.Mock(spec_set=Target, return_value=fake_target),
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
-    fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
-    fake_session.EXIT_ABORT = Session.EXIT_ABORT
-    fake_session.EXIT_ARGS = fake_session.EXIT_ARGS = Session.EXIT_ARGS
-    fake_session.EXIT_LAUNCH_FAILURE = Session.EXIT_LAUNCH_FAILURE
     fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
     args = FakeArgs()
     args.adapter = "fake"
     args.input = "fake"
     fake_session.return_value.run.side_effect = to_raise
-    assert main(args) == exit_code
+    assert main(args) == exit_code.value
     assert fake_target.cleanup.call_count == 1
 
 
@@ -183,15 +177,15 @@ def test_main_03(mocker, exit_code, to_raise):
     "arg_testlimit, arg_timeout, exit_code",
     [
         # use default test time limit and timeout values
-        (None, None, Session.EXIT_SUCCESS),
+        (None, None, Exit.SUCCESS),
         # set test time limit
-        (10, None, Session.EXIT_SUCCESS),
+        (10, None, Exit.SUCCESS),
         # set both test time limit and timeout to the same value
-        (10, 10, Session.EXIT_SUCCESS),
+        (10, 10, Exit.SUCCESS),
         # set timeout greater than test time limit
-        (10, 11, Session.EXIT_SUCCESS),
+        (10, 11, Exit.SUCCESS),
         # set test time limit greater than timeout
-        (11, 10, Session.EXIT_ARGS),
+        (11, 10, Exit.ARGS),
     ],
 )
 def test_main_04(mocker, arg_testlimit, arg_timeout, exit_code):
@@ -207,13 +201,11 @@ def test_main_04(mocker, arg_testlimit, arg_timeout, exit_code):
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
-    fake_session.EXIT_ARGS = Session.EXIT_ARGS
-    fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     args = FakeArgs()
     args.adapter = "fake"
     args.time_limit = arg_testlimit
     args.timeout = arg_timeout
-    assert main(args) == exit_code
+    assert main(args) == exit_code.value
 
 
 @mark.parametrize(
@@ -242,7 +234,6 @@ def test_main_05(mocker, pernosco, rr, valgrind):
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
-    fake_session.EXIT_SUCCESS = Session.EXIT_SUCCESS
     args = FakeArgs()
     args.adapter = "fake"
     # maximum one debugger allowed at a time
@@ -250,7 +241,7 @@ def test_main_05(mocker, pernosco, rr, valgrind):
     args.pernosco = pernosco
     args.rr = rr
     args.valgrind = valgrind
-    assert main(args) == Session.EXIT_SUCCESS
+    assert main(args) == Exit.SUCCESS.value
     assert fake_target.call_args[-1]["pernosco"] == pernosco
     assert fake_target.call_args[-1]["rr"] == rr
     assert fake_target.call_args[-1]["valgrind"] == valgrind

From f19ec130bd06b8a468f1744eeb32b101c79966ed Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 6 Aug 2021 18:20:25 -0700
Subject: [PATCH 300/531] Use enum for testcase quality

---
 grizzly/common/reporter.py      | 53 +++++++++++++++++++--------------
 grizzly/common/test_reporter.py |  8 +----
 grizzly/reduce/core.py          | 13 ++++----
 grizzly/reduce/crash.py         | 23 ++++++++------
 grizzly/reduce/test_main.py     | 34 +++++++++++----------
 grizzly/reduce/test_main_fm.py  | 15 +++++-----
 grizzly/reduce/test_reduce.py   |  5 ++--
 7 files changed, 78 insertions(+), 73 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index d575b1f5..c92e61d9 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -5,6 +5,7 @@
 
 from abc import ABCMeta, abstractmethod
 from collections import namedtuple
+from enum import Enum, unique
 from hashlib import sha1
 from json import dump, dumps, loads
 from logging import WARNING, getLogger
@@ -46,6 +47,7 @@
 __all__ = (
     "FilesystemReporter",
     "FuzzManagerReporter",
+    "Quality",
     "Report",
     "S3FuzzManagerReporter",
 )
@@ -58,6 +60,30 @@
 LogMap = namedtuple("LogMap", "aux stderr stdout")
 
 
+@unique
+class Quality(Enum):
+    """testcase quality values"""
+
+    # final reduced testcase
+    REDUCED = 0
+    # original used for reduction (a reduced version exists)
+    ORIGINAL = 1
+    # the testcase is currently being reduced
+    REDUCING = 4
+    # haven't attempted reduction yet (1st attempt, generic reducer)
+    UNREDUCED = 5
+    # platform specific reduction requested (2nd attempt)
+    REQUEST_SPECIFIC = 6
+    # testcase not detected ("testcase" not a testcase?)
+    NO_TESTCASE = 7
+    # the testcase was reproducible, but broke during reduction
+    REDUCER_BROKE = 8
+    # reducer error
+    REDUCER_ERROR = 9
+    # could not reproduce the testcase
+    NOT_REPRODUCIBLE = 10
+
+
 class Report:
     DEFAULT_MAJOR = "NO_STACK"
     DEFAULT_MINOR = "0"
@@ -518,23 +544,11 @@ class FuzzManagerReporter(Reporter):
     # max number of times to report a non-frequent signature to FuzzManager
     MAX_REPORTS = 10
 
-    # TODO: Use enum?
-    # testcase quality values
-    QUAL_REDUCED_RESULT = 0  # the final reduced testcase
-    QUAL_REDUCED_ORIGINAL = 1  # the original used for successful reduction
-    QUAL_REDUCING = 4  # the testcase is currently being reduced
-    QUAL_UNREDUCED = 5  # haven't attempted reduction yet (1st attempt, generic reducer)
-    QUAL_REQUEST_SPECIFIC = 6  # platform specific reduction requested (2nd attempt)
-    QUAL_NO_TESTCASE = 7  # testcase not detected ("testcase" not a testcase?)
-    QUAL_REDUCER_BROKE = 8  # the testcase was reproducible, but broke during reduction
-    QUAL_REDUCER_ERROR = 9  # reducer error
-    QUAL_NOT_REPRODUCIBLE = 10  # could not reproduce the testcase
-
     def __init__(self, tool=None):
         self._extra_metadata = {}
         self.force_report = False
         self.max_reports = FuzzManagerReporter.MAX_REPORTS
-        self.quality = self.QUAL_UNREDUCED
+        self.quality = Quality.UNREDUCED
         self.tool = tool  # optional tool name
 
     def _post_submit(self):
@@ -572,13 +586,6 @@ def add_extra_metadata(self, key, value):
         # deep copy and ensure that value is JSON serializable
         self._extra_metadata[key] = loads(dumps(value))
 
-    @classmethod
-    def quality_name(cls, value):
-        for name in dir(cls):
-            if name.startswith("QUAL_") and getattr(cls, name) == value:
-                return name
-        return "unknown quality (%r)" % (value,)
-
     def _pre_submit(self, report):
         self._process_rr_trace(report)
 
@@ -688,7 +695,7 @@ def _submit_report(self, report, test_cases):
                 {"recorded_envvars": environ_string}
             )
         else:
-            self.quality = self.QUAL_NO_TESTCASE
+            self.quality = Quality.NO_TESTCASE
         report.crash_info.configuration.addMetadata(self._extra_metadata)
 
         # grab screen log (used in automation)
@@ -722,9 +729,9 @@ def _submit_report(self, report, test_cases):
                 LOG.info("Submitting new crash %r", cache_metadata["shortDescription"])
             # submit results to the FuzzManager server
             new_entry = collector.submit(
-                report.crash_info, testCase=zip_name, testCaseQuality=self.quality
+                report.crash_info, testCase=zip_name, testCaseQuality=self.quality.value
             )
-        LOG.info("Logged %d with quality %d", new_entry["id"], self.quality)
+        LOG.info("Logged %d (%s)", new_entry["id"], self.quality.name)
 
         return new_entry["id"]
 
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 8911a92f..bea3d543 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -582,13 +582,7 @@ def test_fuzzmanager_reporter_07(mocker, tmp_path):
     fake_collector.return_value.submit.assert_not_called()
 
 
-def test_fuzzmanager_reporter_08():
-    """test FuzzManagerReporter.quality_name()"""
-    assert FuzzManagerReporter.quality_name(0) == "QUAL_REDUCED_RESULT"
-    assert FuzzManagerReporter.quality_name(-1) == "unknown quality (-1)"
-
-
-def test_fuzzmanager_reporter_09(mocker, tmp_path):
+def test_fuzzmanager_reporter_08(mocker, tmp_path):
     """test FuzzManagerReporter._ignored()"""
     log_file = tmp_path / "test.log"
     log_file.touch()
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 856567c4..02a25a99 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -18,7 +18,7 @@
 
 from ..common.fuzzmanager import CrashEntry
 from ..common.plugins import load as load_plugin
-from ..common.reporter import FilesystemReporter, FuzzManagerReporter
+from ..common.reporter import FilesystemReporter, FuzzManagerReporter, Quality
 from ..common.storage import TestCaseLoadFailure
 from ..common.utils import ConfigError, Exit, configure_logging, grz_tmp
 from ..replay import ReplayManager
@@ -617,15 +617,12 @@ def run(self, repeat=1, min_results=1):
             if self._report_to_fuzzmanager and last_reports:
                 for crash_id in last_reports:
                     LOG.info(
-                        "Updating crash %d to quality %s",
+                        "Updating crash %d to %s (Q%d)",
                         crash_id,
-                        FuzzManagerReporter.quality_name(
-                            FuzzManagerReporter.QUAL_REDUCED_RESULT
-                        ),
+                        Quality.REDUCED.name,
+                        Quality.REDUCED.value,
                     )
-                    CrashEntry(
-                        crash_id
-                    ).testcase_quality = FuzzManagerReporter.QUAL_REDUCED_RESULT
+                    CrashEntry(crash_id).testcase_quality = Quality.REDUCED.value
 
         # it's possible we made it this far without ever setting signature_desc.
         # this is only possible if --no-analysis is given
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index 482a7859..872ac826 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -5,7 +5,7 @@
 from logging import getLogger
 
 from ..common.fuzzmanager import Bucket, CrashEntry
-from ..common.reporter import FuzzManagerReporter
+from ..common.reporter import Quality
 from ..common.utils import Exit
 from ..main import configure_logging
 from .args import ReduceFuzzManagerIDArgs
@@ -41,22 +41,27 @@ def main(args):
         result = ReduceManager.main(args)
 
         # update quality
-        # map Exit.* -> FuzzManagerReporter.QUAL_*
+        # map Exit.* -> Quality.*
         # default back to UNREDUCED
         # most errors will not be related to the testcase
         # so they should be retried later
         if args.fuzzmanager:
             quality = {
-                Exit.ERROR.value: FuzzManagerReporter.QUAL_REDUCER_ERROR,
+                Exit.ERROR.value: Quality.REDUCER_ERROR,
                 Exit.ABORT.value: crash.testcase_quality,
-                Exit.SUCCESS.value: FuzzManagerReporter.QUAL_REDUCED_ORIGINAL,
-                Exit.FAILURE.value: FuzzManagerReporter.QUAL_NOT_REPRODUCIBLE,
-            }.get(result, FuzzManagerReporter.QUAL_UNREDUCED)
+                Exit.SUCCESS.value: Quality.ORIGINAL,
+                Exit.FAILURE.value: Quality.NOT_REPRODUCIBLE,
+            }.get(result, Quality.UNREDUCED)
             # don't ever set things back to Q4, default to Q5 for that case.
             # Q4 is only used in automation, so ABORT should never happen.
-            if quality == FuzzManagerReporter.QUAL_REDUCING:
-                quality = FuzzManagerReporter.QUAL_UNREDUCED
-            LOG.info("reducer finished -> exit(%d) -> Q%d", result, quality)
+            if quality == Quality.REDUCING:
+                quality = Quality.UNREDUCED
+            LOG.info(
+                "reducer finished -> exit(%d) -> %s (Q%d)",
+                result,
+                quality.name,
+                quality.value,
+            )
             crash.testcase_quality = quality
     finally:
         crash.cleanup()
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index ff3c6dc3..b50a22d9 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -9,6 +9,7 @@
 from pytest import mark, raises
 
 from ..common.storage import TestCase, TestCaseLoadFailure
+from ..common.utils import Exit
 from ..target import AssetManager, TargetLaunchError, TargetLaunchTimeout
 from . import ReduceManager
 from .args import ReduceArgs, ReduceFuzzManagerIDArgs, ReduceFuzzManagerIDQualityArgs
@@ -81,49 +82,50 @@ def test_args_04(capsys, tmp_path):
 
 
 @mark.parametrize(
-    "patch_func, side_effect, return_value, kwargs, result",
+    "patch_func, side_effect, return_value, kwargs, exit_code",
     [
         (
             "grizzly.reduce.core.ReduceManager.run",
             TargetLaunchError("error", None),
             None,
             {},
-            1,
+            Exit.ERROR,
         ),
-        ("grizzly.reduce.core.ReduceManager.run", TargetLaunchTimeout, None, {}, 1),
-        ("grizzly.reduce.core.load_plugin", KeyboardInterrupt, None, {}, 1),
+        (
+            "grizzly.reduce.core.ReduceManager.run",
+            TargetLaunchTimeout,
+            None,
+            {},
+            Exit.ERROR,
+        ),
+        ("grizzly.reduce.core.load_plugin", KeyboardInterrupt, None, {}, Exit.ERROR),
         (
             "grizzly.reduce.core.load_plugin",
             GrizzlyReduceBaseException(""),
             None,
             {},
-            1,
+            Exit.ERROR,
         ),
         (
             "grizzly.reduce.core.ReplayManager.load_testcases",
             TestCaseLoadFailure,
             None,
             {},
-            1,
+            Exit.ERROR,
         ),
-        ("grizzly.reduce.core.ReplayManager.load_testcases", None, [], {}, 1),
+        ("grizzly.reduce.core.ReplayManager.load_testcases", None, [], {}, Exit.ERROR),
         (
             "grizzly.reduce.core.ReplayManager.load_testcases",
             None,
             ([Mock(hang=False), Mock(hang=False)], Mock(spec_set=AssetManager), dict()),
             {"no_harness": True},
-            2,
+            Exit.ARGS,
         ),
     ],
 )
-def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, result):
+def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, exit_code):
     """test ReduceManager.main() failure cases"""
-    mocker.patch(
-        "grizzly.reduce.core.FuzzManagerReporter",
-        autospec=True,
-        QUAL_NO_TESTCASE=7,
-        QUAL_REDUCER_ERROR=9,
-    )
+    mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
     mocker.patch("grizzly.reduce.core.load_plugin", autospec=True)
     mocker.patch("grizzly.reduce.core.Sapphire", autospec=True)
     # setup args
@@ -138,7 +140,7 @@ def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, result
     )
 
     mocker.patch(patch_func, side_effect=side_effect, return_value=return_value)
-    assert ReduceManager.main(args) == result
+    assert ReduceManager.main(args) == exit_code.value
 
 
 @mark.parametrize(
diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
index 7bfb8e83..acde2604 100644
--- a/grizzly/reduce/test_main_fm.py
+++ b/grizzly/reduce/test_main_fm.py
@@ -8,6 +8,7 @@
 
 import pytest
 
+from ..common.reporter import Quality
 from ..common.utils import Exit
 from .bucket import main as bucket_main
 from .crash import main as crash_main
@@ -55,13 +56,13 @@ def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_
 @pytest.mark.parametrize(
     "mgr_exit_code, pre_quality, post_quality",
     [
-        (Exit.SUCCESS, 5, 1),
-        (Exit.ERROR, 5, 9),
-        (Exit.ARGS, 6, 5),
-        (Exit.ABORT, 4, 5),
-        (Exit.ABORT, 0, 0),
-        (Exit.LAUNCH_FAILURE, 6, 5),
-        (Exit.FAILURE, 5, 10),
+        (Exit.SUCCESS, Quality.UNREDUCED, Quality.ORIGINAL),
+        (Exit.ERROR, Quality.UNREDUCED, Quality.REDUCER_ERROR),
+        (Exit.ARGS, Quality.REQUEST_SPECIFIC, Quality.UNREDUCED),
+        (Exit.ABORT, Quality.REDUCING, Quality.UNREDUCED),
+        (Exit.ABORT, Quality.REDUCED, Quality.REDUCED),
+        (Exit.LAUNCH_FAILURE, Quality.REQUEST_SPECIFIC, Quality.UNREDUCED),
+        (Exit.FAILURE, Quality.UNREDUCED, Quality.NOT_REPRODUCIBLE),
     ],
 )
 def test_crash_main_quality(mocker, mgr_exit_code, pre_quality, post_quality):
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index f4b5db87..522ed67d 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -14,7 +14,7 @@
 
 from sapphire import Sapphire
 
-from ..common.reporter import Report
+from ..common.reporter import Quality, Report
 from ..common.storage import TestCase
 from ..replay import ReplayResult
 from ..target import AssetManager, Target
@@ -762,7 +762,6 @@ def replay_run(testcases, _time_limit, **_kw):
 
     mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     reporter = mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
-    reporter.QUAL_REDUCED_RESULT = 0
     update_coll = mocker.patch("grizzly.common.fuzzmanager.Collector")
     target = mocker.Mock(spec_set=Target, environ={})
     target.assets = mocker.Mock(spec_set=AssetManager)
@@ -792,7 +791,7 @@ def replay_run(testcases, _time_limit, **_kw):
     assert update_coll.call_count == 1
     assert update_coll.return_value.patch.call_count == 1
     assert update_coll.return_value.patch.call_args[1] == {
-        "data": {"testcase_quality": reporter.QUAL_REDUCED_RESULT},
+        "data": {"testcase_quality": Quality.REDUCED.value},
     }
 
 

From 08fbfb22c563feda72c2192c061835a1f5c0e56b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 9 Aug 2021 11:16:50 -0700
Subject: [PATCH 301/531] Use enum for stack hasher modes

---
 grizzly/common/stack_hasher.py      | 61 +++++++++++++-------------
 grizzly/common/test_stack_hasher.py | 68 ++++++++++++++---------------
 2 files changed, 65 insertions(+), 64 deletions(-)

diff --git a/grizzly/common/stack_hasher.py b/grizzly/common/stack_hasher.py
index 93321a44..a32acd11 100644
--- a/grizzly/common/stack_hasher.py
+++ b/grizzly/common/stack_hasher.py
@@ -12,6 +12,7 @@
 crash id (1st hash) and a bug id (2nd hash). This is not perfect but works very
 well in most cases.
 """
+from enum import Enum, unique
 from hashlib import sha1
 from logging import DEBUG, INFO, basicConfig, getLogger
 from os.path import basename
@@ -28,15 +29,20 @@
 MAJOR_DEPTH_RUST = 10
 
 
-class StackFrame:
-    MODE_GDB = 0
-    MODE_MINIDUMP = 1
-    MODE_RR = 2
-    MODE_RUST = 3
-    MODE_SANITIZER = 4
-    MODE_TSAN = 5
-    MODE_VALGRIND = 6
+@unique
+class Mode(Enum):
+    """Parse mode for detected stack type"""
+
+    GDB = 0
+    MINIDUMP = 1
+    RR = 2
+    RUST = 3
+    SANITIZER = 4
+    TSAN = 5
+    VALGRIND = 6
+
 
+class StackFrame:
     _re_func_name = re_compile(r"(?P<func>.+?)[\(|\s|\<]{1}")
     # regexs for supported stack trace lines
     _re_gdb = re_compile(r"^#(?P<num>\d+)\s+(?P<off>0x[0-9a-f]+\sin\s)*(?P<line>.+)")
@@ -84,19 +90,19 @@ def __str__(self):
     def from_line(cls, input_line, parse_mode=None):
         assert "\n" not in input_line, "Input contains unexpected new line(s)"
         sframe = None
-        if parse_mode is None or parse_mode == cls.MODE_SANITIZER:
+        if parse_mode is None or parse_mode == Mode.SANITIZER:
             sframe = cls._parse_sanitizer(input_line)
-        if not sframe and parse_mode is None or parse_mode == cls.MODE_GDB:
+        if not sframe and parse_mode is None or parse_mode == Mode.GDB:
             sframe = cls._parse_gdb(input_line)
-        if not sframe and parse_mode is None or parse_mode == cls.MODE_MINIDUMP:
+        if not sframe and parse_mode is None or parse_mode == Mode.MINIDUMP:
             sframe = cls._parse_minidump(input_line)
-        if not sframe and parse_mode is None or parse_mode == cls.MODE_RR:
+        if not sframe and parse_mode is None or parse_mode == Mode.RR:
             sframe = cls._parse_rr(input_line)
-        if not sframe and parse_mode is None or parse_mode == cls.MODE_RUST:
+        if not sframe and parse_mode is None or parse_mode == Mode.RUST:
             sframe = cls._parse_rust(input_line)
-        if not sframe and parse_mode is None or parse_mode == cls.MODE_TSAN:
+        if not sframe and parse_mode is None or parse_mode == Mode.TSAN:
             sframe = cls._parse_tsan(input_line)
-        if not sframe and parse_mode is None or parse_mode == cls.MODE_VALGRIND:
+        if not sframe and parse_mode is None or parse_mode == Mode.VALGRIND:
             sframe = cls._parse_valgrind(input_line)
         return sframe
 
@@ -110,7 +116,7 @@ def _parse_gdb(cls, input_line):
         input_line = match.group("line").strip()
         if not input_line:
             return None
-        sframe = cls(mode=cls.MODE_GDB, stack_line=match.group("num"))
+        sframe = cls(mode=Mode.GDB, stack_line=match.group("num"))
         # sframe.offset = m.group("off")  # ignore binary offset for now
         # find function/method name
         match = cls._re_func_name.match(input_line)
@@ -142,7 +148,7 @@ def _parse_minidump(cls, input_line):
                 return None
         except ValueError:
             return None
-        sframe = cls(mode=cls.MODE_MINIDUMP, stack_line=stack_line)
+        sframe = cls(mode=Mode.MINIDUMP, stack_line=stack_line)
         if func_name:
             sframe.function = func_name.strip()
         if file_name:
@@ -166,23 +172,21 @@ def _parse_rr(cls, input_line):
         match = cls._re_rr.match(input_line)
         if match is None:
             return None
-        return cls(
-            location=match.group("loc"), mode=cls.MODE_RR, offset=match.group("off")
-        )
+        return cls(location=match.group("loc"), mode=Mode.RR, offset=match.group("off"))
 
     @classmethod
     def _parse_rust(cls, input_line):
         match = cls._re_rust_frame.match(input_line)
         if match is None:
             return None
-        sframe = cls(mode=cls.MODE_RUST, stack_line=match.group("num"))
+        sframe = cls(mode=Mode.RUST, stack_line=match.group("num"))
         sframe.function = match.group("line").strip().rsplit("::h", 1)[0]
         # Don't bother with the file offset stuff atm
         # match = cls._re_rust_file.match(input_line) if frame is None else None
         # if match is not None:
         #    frame = {
         #        "function": None,
-        #        "mode": cls.MODE_RUST,
+        #        "mode": Mode.RUST,
         #        "offset": None,
         #        "stack_line": None,
         #    }
@@ -200,7 +204,7 @@ def _parse_sanitizer(cls, input_line):
         match = cls._re_sanitizer.match(input_line)
         if match is None:
             return None
-        sframe = cls(mode=cls.MODE_SANITIZER, stack_line=match.group("num"))
+        sframe = cls(mode=Mode.SANITIZER, stack_line=match.group("num"))
         input_line = match.group("line")
         # check if line is symbolized
         if match.group("in"):
@@ -226,7 +230,7 @@ def _parse_tsan(cls, input_line):
         match = cls._re_tsan.match(input_line)
         if match is None:
             return None
-        sframe = cls(mode=cls.MODE_TSAN, stack_line=match.group("num"))
+        sframe = cls(mode=Mode.TSAN, stack_line=match.group("num"))
         input_line = match.group("line")
         location = basename(input_line)
         # try to parse file name and line number
@@ -261,7 +265,7 @@ def _parse_valgrind(cls, input_line):
             # this should not happen
             LOG.warning("failure in _parse_valgrind()")
             return None
-        sframe = cls(function=match.group("func"), mode=cls.MODE_VALGRIND)
+        sframe = cls(function=match.group("func"), mode=Mode.VALGRIND)
         try:
             location, sframe.offset = input_line.split(":")
             sframe.location = location.strip()
@@ -340,6 +344,7 @@ def from_text(cls, input_text, major_depth=MAJOR_DEPTH, parse_mode=None):
             # avoid issues with mixed stack types
             if parse_mode is None:
                 parse_mode = frame.mode
+                LOG.debug("parser mode: %s", parse_mode.name)
             elif parse_mode != frame.mode:
                 # don't mix parse modes!
                 continue
@@ -368,11 +373,7 @@ def from_text(cls, input_text, major_depth=MAJOR_DEPTH, parse_mode=None):
                     len(frames) - 1,
                 )
 
-        if (
-            frames
-            and frames[0].mode == StackFrame.MODE_RUST
-            and major_depth < MAJOR_DEPTH_RUST
-        ):
+        if frames and frames[0].mode == Mode.RUST and major_depth < MAJOR_DEPTH_RUST:
             major_depth = MAJOR_DEPTH_RUST
 
         return cls(frames=frames, major_depth=major_depth)
diff --git a/grizzly/common/test_stack_hasher.py b/grizzly/common/test_stack_hasher.py
index 36f3965e..9085ec35 100644
--- a/grizzly/common/test_stack_hasher.py
+++ b/grizzly/common/test_stack_hasher.py
@@ -5,7 +5,7 @@
 
 import pytest
 
-from .stack_hasher import Stack, StackFrame
+from .stack_hasher import Mode, Stack, StackFrame
 
 
 def test_stack_01():
@@ -109,7 +109,7 @@ def test_stack_06():
     stack = Stack.from_text(input_txt)
     assert len(stack.frames) == 6
     assert stack.minor != stack.major
-    assert stack.frames[0].mode == StackFrame.MODE_SANITIZER
+    assert stack.frames[0].mode == Mode.SANITIZER
 
 
 def test_stack_07():
@@ -126,7 +126,7 @@ def test_stack_07():
     stack = Stack.from_text(input_txt)
     assert len(stack.frames) == 4
     assert stack.minor != stack.major
-    assert stack.frames[0].mode == StackFrame.MODE_SANITIZER
+    assert stack.frames[0].mode == Mode.SANITIZER
 
 
 def test_stack_08():
@@ -143,7 +143,7 @@ def test_stack_08():
     assert stack.frames[0].function == "good::frame0"
     assert stack.frames[1].function == "good::frame1"
     assert stack.minor != stack.major
-    assert stack.frames[0].mode == StackFrame.MODE_SANITIZER
+    assert stack.frames[0].mode == Mode.SANITIZER
 
 
 def test_stack_09():
@@ -168,7 +168,7 @@ def test_stack_10():
     assert stack.frames[1].location == "libdbus-1.so.3"
     assert stack.frames[2].location == "<unknown module>"
     assert stack.minor != stack.major
-    assert stack.frames[0].mode == StackFrame.MODE_SANITIZER
+    assert stack.frames[0].mode == Mode.SANITIZER
 
 
 def test_stack_11():
@@ -187,7 +187,7 @@ def test_stack_11():
     assert stack.frames[2].function == "fSasd"
     assert stack.frames[3].function == "mz::as::asdf::SB"
     assert stack.minor != stack.major
-    assert stack.frames[0].mode == StackFrame.MODE_SANITIZER
+    assert stack.frames[0].mode == Mode.SANITIZER
 
 
 def test_stack_12():
@@ -212,7 +212,7 @@ def test_stack_12():
     assert stack.frames[3].function == "FooBar"
     assert stack.frames[4].function == "main"
     assert stack.minor != stack.major
-    assert stack.frames[0].mode == StackFrame.MODE_VALGRIND
+    assert stack.frames[0].mode == Mode.VALGRIND
 
 
 def test_stack_13():
@@ -266,7 +266,7 @@ def test_stack_13():
     )
     assert stack.frames[8].function == "Servo_Element_IsDisplayContents"
     assert stack.minor != stack.major
-    assert stack.frames[0].mode == StackFrame.MODE_RUST
+    assert stack.frames[0].mode == Mode.RUST
 
 
 def test_stack_14():
@@ -329,7 +329,7 @@ def test_sanitizer_stackframe_01():
     assert frame.function == "Abort"
     assert frame.location == "nsDebugImpl.cpp"
     assert frame.offset == "472"
-    assert frame.mode == StackFrame.MODE_SANITIZER
+    assert frame.mode == Mode.SANITIZER
 
 
 def test_sanitizer_stackframe_02():
@@ -341,7 +341,7 @@ def test_sanitizer_stackframe_02():
     assert frame.function == "main"
     assert frame.location == "nsBrowserApp.cpp"
     assert frame.offset == "399"
-    assert frame.mode == StackFrame.MODE_SANITIZER
+    assert frame.mode == Mode.SANITIZER
 
 
 def test_sanitizer_stackframe_03():
@@ -353,7 +353,7 @@ def test_sanitizer_stackframe_03():
     assert frame.function is None
     assert frame.location == "libpthread.so.0"
     assert frame.offset == "0x1033f"
-    assert frame.mode == StackFrame.MODE_SANITIZER
+    assert frame.mode == Mode.SANITIZER
 
 
 def test_sanitizer_stackframe_04():
@@ -365,7 +365,7 @@ def test_sanitizer_stackframe_04():
     assert frame.function == "start_thread"
     assert frame.location == "libpthread.so.0"
     assert frame.offset == "0x8181"
-    assert frame.mode == StackFrame.MODE_SANITIZER
+    assert frame.mode == Mode.SANITIZER
 
 
 def test_sanitizer_stackframe_05():
@@ -377,7 +377,7 @@ def test_sanitizer_stackframe_05():
     assert frame.function == "Call"
     assert frame.location == "b.cpp"
     assert frame.offset == "356"
-    assert frame.mode == StackFrame.MODE_SANITIZER
+    assert frame.mode == Mode.SANITIZER
 
 
 def test_sanitizer_stackframe_06():
@@ -387,7 +387,7 @@ def test_sanitizer_stackframe_06():
     assert frame.function is None
     assert frame.location == "<unknown module>"
     assert frame.offset is None
-    assert frame.mode == StackFrame.MODE_SANITIZER
+    assert frame.mode == Mode.SANITIZER
 
 
 def test_sanitizer_stackframe_07():
@@ -399,7 +399,7 @@ def test_sanitizer_stackframe_07():
     assert frame.function is None
     assert frame.location == "syscall-template.S"
     assert frame.offset == "84"
-    assert frame.mode == StackFrame.MODE_SANITIZER
+    assert frame.mode == Mode.SANITIZER
 
 
 def test_sanitizer_stackframe_08():
@@ -411,7 +411,7 @@ def test_sanitizer_stackframe_08():
     assert frame.function == "Call"
     assert frame.location == "file name.c"
     assert frame.offset == "1"
-    assert frame.mode == StackFrame.MODE_SANITIZER
+    assert frame.mode == Mode.SANITIZER
 
 
 def test_gdb_stackframe_01():
@@ -423,7 +423,7 @@ def test_gdb_stackframe_01():
     assert frame.function == "__memmove_ssse3_back"
     assert frame.location == "memcpy-ssse3-back.S"
     assert frame.offset == "1654"
-    assert frame.mode == StackFrame.MODE_GDB
+    assert frame.mode == Mode.GDB
 
 
 def test_gdb_stackframe_02():
@@ -433,7 +433,7 @@ def test_gdb_stackframe_02():
     assert frame.function == "main"
     assert frame.location is None
     assert frame.offset is None
-    assert frame.mode == StackFrame.MODE_GDB
+    assert frame.mode == Mode.GDB
 
 
 def test_gdb_stackframe_03():
@@ -443,7 +443,7 @@ def test_gdb_stackframe_03():
     assert frame.function == "main"
     assert frame.location == "test.c"
     assert frame.offset == "5"
-    assert frame.mode == StackFrame.MODE_GDB
+    assert frame.mode == Mode.GDB
 
 
 def test_minidump_stackframe_01():
@@ -455,7 +455,7 @@ def test_minidump_stackframe_01():
     assert frame.function == "main"
     assert frame.location == "file.cpp"
     assert frame.offset == "114"
-    assert frame.mode == StackFrame.MODE_MINIDUMP
+    assert frame.mode == Mode.MINIDUMP
 
 
 def test_minidump_stackframe_02():
@@ -465,7 +465,7 @@ def test_minidump_stackframe_02():
     assert frame.function is None
     assert frame.location == "libpthread-2.26.so"
     assert frame.offset == "0x10588"
-    assert frame.mode == StackFrame.MODE_MINIDUMP
+    assert frame.mode == Mode.MINIDUMP
 
 
 def test_minidump_stackframe_03():
@@ -477,7 +477,7 @@ def test_minidump_stackframe_03():
     assert frame.function == "foo"
     assert frame.location == "/usr/x86_64-linux-gnu/test.h"
     assert frame.offset == "85"
-    assert frame.mode == StackFrame.MODE_MINIDUMP
+    assert frame.mode == Mode.MINIDUMP
 
 
 def test_tsan_stackframe_01():
@@ -487,7 +487,7 @@ def test_tsan_stackframe_01():
     assert frame.function == "main"
     assert frame.location == "race.c"
     assert frame.offset == "10"
-    assert frame.mode == StackFrame.MODE_TSAN
+    assert frame.mode == Mode.TSAN
 
 
 def test_tsan_stackframe_02():
@@ -499,7 +499,7 @@ def test_tsan_stackframe_02():
     assert frame.function == "test1"
     assert frame.location == "c.h"
     assert frame.offset == "51"
-    assert frame.mode == StackFrame.MODE_TSAN
+    assert frame.mode == Mode.TSAN
 
 
 def test_tsan_stackframe_03():
@@ -509,7 +509,7 @@ def test_tsan_stackframe_03():
     assert frame.function is None
     assert frame.location is None
     assert frame.offset == "0xbad"
-    assert frame.mode == StackFrame.MODE_TSAN
+    assert frame.mode == Mode.TSAN
 
 
 def test_tsan_stackframe_04():
@@ -519,7 +519,7 @@ def test_tsan_stackframe_04():
     assert frame.function == "func"
     assert frame.location == "mod"
     assert frame.offset == "0x123ac"
-    assert frame.mode == StackFrame.MODE_TSAN
+    assert frame.mode == Mode.TSAN
 
 
 def test_valgrind_stackframe_01():
@@ -528,7 +528,7 @@ def test_valgrind_stackframe_01():
     assert frame.function == "FuncName"
     assert frame.location == "decode.c"
     assert frame.offset == "123"
-    assert frame.mode == StackFrame.MODE_VALGRIND
+    assert frame.mode == Mode.VALGRIND
 
 
 def test_valgrind_stackframe_02():
@@ -537,7 +537,7 @@ def test_valgrind_stackframe_02():
     assert frame.function == "main"
     assert frame.location == "foo.cc"
     assert frame.offset == "71"
-    assert frame.mode == StackFrame.MODE_VALGRIND
+    assert frame.mode == Mode.VALGRIND
 
 
 def test_valgrind_stackframe_03():
@@ -548,7 +548,7 @@ def test_valgrind_stackframe_03():
     assert frame.function == "malloc"
     assert frame.location == "blah-linux.so"
     assert frame.offset is None
-    assert frame.mode == StackFrame.MODE_VALGRIND
+    assert frame.mode == Mode.VALGRIND
 
 
 def test_valgrind_stackframe_04():
@@ -559,7 +559,7 @@ def test_valgrind_stackframe_04():
     assert frame.function == "(anon ns)::test(b2::a&, int)"
     assert frame.location == "main.cpp"
     assert frame.offset == "49"
-    assert frame.mode == StackFrame.MODE_VALGRIND
+    assert frame.mode == Mode.VALGRIND
 
 
 def test_valgrind_stackframe_05():
@@ -570,7 +570,7 @@ def test_valgrind_stackframe_05():
     assert frame.function == "Foo::Foo(char *, int, bool)"
     assert frame.location == "File.h"
     assert frame.offset == "37"
-    assert frame.mode == StackFrame.MODE_VALGRIND
+    assert frame.mode == Mode.VALGRIND
 
 
 def test_rr_stackframe_01():
@@ -579,7 +579,7 @@ def test_rr_stackframe_01():
     assert frame.function is None
     assert frame.location == "main"
     assert frame.offset == "0x244"
-    assert frame.mode == StackFrame.MODE_RR
+    assert frame.mode == Mode.RR
 
 
 def test_rust_stackframe_01():
@@ -589,7 +589,7 @@ def test_rust_stackframe_01():
     assert frame.function == "__libc_start_main"
     assert frame.location is None
     assert frame.offset is None
-    assert frame.mode == StackFrame.MODE_RUST
+    assert frame.mode == Mode.RUST
 
 
 def test_rust_stackframe_02():
@@ -601,4 +601,4 @@ def test_rust_stackframe_02():
     assert frame.location is None
     assert frame.function == "unwind::begin_unwind_fmt"
     assert frame.offset is None
-    assert frame.mode == StackFrame.MODE_RUST
+    assert frame.mode == Mode.RUST

From 7b4032f7f82c07cf332c1565fb66377cc4a9e4e1 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 9 Aug 2021 16:43:06 -0700
Subject: [PATCH 302/531] Minor refactor of TargetMonitor.log_data()

---
 grizzly/target/target_monitor.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/grizzly/target/target_monitor.py b/grizzly/target/target_monitor.py
index b611a864..280145a5 100644
--- a/grizzly/target/target_monitor.py
+++ b/grizzly/target/target_monitor.py
@@ -29,14 +29,15 @@ def launches(self):
         pass
 
     def log_data(self, log_id, offset=0):
+        data = None
         log_file = self.clone_log(log_id, offset=offset)
-        if log_file is None:
-            return None
-        try:
-            with open(log_file, "rb") as log_fp:
-                return log_fp.read()
-        finally:
-            remove(log_file)
+        if log_file:
+            try:
+                with open(log_file, "rb") as log_fp:
+                    data = log_fp.read()
+            finally:
+                remove(log_file)
+        return data
 
     @abstractmethod
     def log_length(self, log_id):

From 4e6829dc8e669a52e578e6587e3088ab97ce4c8b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 9 Aug 2021 16:43:29 -0700
Subject: [PATCH 303/531] [ci] Bump pinned pylint version

---
 tox.ini | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tox.ini b/tox.ini
index 4e253fff..77a22165 100644
--- a/tox.ini
+++ b/tox.ini
@@ -42,7 +42,7 @@ skip_install = true
 commands =
     pylint {posargs}
 deps =
-    pylint==2.9.3
+    pylint==2.9.6
 usedevelop = true
 
 [testenv:pypi]

From 3e9830a0cd9457c31f64ac5e6cca9dd9a39a68a6 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 10 Aug 2021 17:37:28 -0700
Subject: [PATCH 304/531] FM CrashEntry.testcase_quality is an int

---
 grizzly/reduce/bucket.py       |  8 ++++----
 grizzly/reduce/crash.py        | 12 ++++++------
 grizzly/reduce/test_main_fm.py | 28 ++++++++++++++++++----------
 3 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/grizzly/reduce/bucket.py b/grizzly/reduce/bucket.py
index 373480be..67138ea2 100644
--- a/grizzly/reduce/bucket.py
+++ b/grizzly/reduce/bucket.py
@@ -29,7 +29,7 @@ def main(args):
     orig_tool = args.tool
 
     # if no crashes in bucket, return success
-    result = Exit.SUCCESS.value
+    result = Exit.SUCCESS
 
     bucket = Bucket(args.input)
     try:
@@ -41,13 +41,13 @@ def main(args):
             args.tool = orig_tool
 
             # call grizzly.reduce.crash
-            result = crash_main(args)
-            if result in {Exit.SUCCESS.value, Exit.ABORT.value}:
+            result = Exit(crash_main(args))
+            if result in {Exit.SUCCESS, Exit.ABORT}:
                 break
 
     finally:
         bucket.cleanup()
-    return result
+    return result.value
 
 
 if __name__ == "__main__":
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index 872ac826..ac98d2d4 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -47,11 +47,11 @@ def main(args):
         # so they should be retried later
         if args.fuzzmanager:
             quality = {
-                Exit.ERROR.value: Quality.REDUCER_ERROR,
-                Exit.ABORT.value: crash.testcase_quality,
-                Exit.SUCCESS.value: Quality.ORIGINAL,
-                Exit.FAILURE.value: Quality.NOT_REPRODUCIBLE,
-            }.get(result, Quality.UNREDUCED)
+                Exit.ERROR: Quality.REDUCER_ERROR,
+                Exit.ABORT: Quality(crash.testcase_quality),
+                Exit.SUCCESS: Quality.ORIGINAL,
+                Exit.FAILURE: Quality.NOT_REPRODUCIBLE,
+            }.get(Exit(result), Quality.UNREDUCED)
             # don't ever set things back to Q4, default to Q5 for that case.
             # Q4 is only used in automation, so ABORT should never happen.
             if quality == Quality.REDUCING:
@@ -62,7 +62,7 @@ def main(args):
                 quality.name,
                 quality.value,
             )
-            crash.testcase_quality = quality
+            crash.testcase_quality = quality.value
     finally:
         crash.cleanup()
         if bucket is not None:
diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
index acde2604..4fac65e0 100644
--- a/grizzly/reduce/test_main_fm.py
+++ b/grizzly/reduce/test_main_fm.py
@@ -35,7 +35,9 @@ def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_
     mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
     crash = mocker.patch("grizzly.reduce.crash.CrashEntry", autospec=True)
     bucket = mocker.patch("grizzly.reduce.crash.Bucket", autospec=True)
-    mocker.patch("grizzly.reduce.crash.ReduceManager", autospec=True)
+    mocker.patch(
+        "grizzly.reduce.crash.ReduceManager.main", return_value=Exit.SUCCESS.value
+    )
     crash.return_value.testcase_path.return_value = "test_path.zip"
     crash.return_value.bucket = crash_bucket
     crash.return_value.testcase_quality = 5
@@ -83,24 +85,30 @@ def test_crash_main_quality(mocker, mgr_exit_code, pre_quality, post_quality):
         tool=None,
     )
     assert crash_main(args) == mgr_exit_code.value
-    assert crash.return_value.testcase_quality == post_quality
+    assert crash.return_value.testcase_quality == post_quality.value
 
 
 @pytest.mark.parametrize(
     "crashes, main_exit_codes, result, arg_sig, arg_tool",
     [
         # no crashes -> success
-        ([], [], 0, None, None),
+        ([], [], Exit.SUCCESS, None, None),
         # 1 crash fails -> no success
-        ([(123, "test-tool")], [1], 1, None, None),
+        ([(123, "test-tool")], [Exit.ERROR], Exit.ERROR, None, None),
         # second of 3 succeeds -> success
-        ([(123, "test-tool"), (456, "test-tool2")], [1, 0], 0, None, None),
+        (
+            [(123, "test-tool"), (456, "test-tool2")],
+            [Exit.ERROR, Exit.SUCCESS],
+            Exit.SUCCESS,
+            None,
+            None,
+        ),
         # --sig is respected
-        ([(123, "test-tool")], [0], 0, "test_sig2.json", None),
+        ([(123, "test-tool")], [Exit.SUCCESS], Exit.SUCCESS, "test_sig2.json", None),
         # --tool is respected
-        ([(123, "test-tool")], [0], 0, None, "test-tool-arg"),
+        ([(123, "test-tool")], [Exit.SUCCESS], Exit.SUCCESS, None, "test-tool-arg"),
         # abort in crash main should also abort bucket main
-        ([(123, "test-tool")], [3], 3, None, None),
+        ([(123, "test-tool")], [Exit.ABORT], Exit.ABORT, None, None),
     ],
 )
 def test_bucket_main(mocker, crashes, main_exit_codes, result, arg_sig, arg_tool):
@@ -109,7 +117,7 @@ def test_bucket_main(mocker, crashes, main_exit_codes, result, arg_sig, arg_tool
 
     def copy_args(args):
         call_args.append(deepcopy(args))
-        return main_exit_codes[main.call_count - 1]
+        return main_exit_codes[main.call_count - 1].value
 
     mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
     bucket = mocker.patch("grizzly.reduce.bucket.Bucket", autospec=True)
@@ -126,7 +134,7 @@ def copy_args(args):
         sig=arg_sig,
         tool=arg_tool,
     )
-    assert bucket_main(args) == result
+    assert bucket_main(args) == result.value
     assert main.call_count == len(main_exit_codes)
     for idx, (crash, _tool) in enumerate(crashes[: main.call_count]):
         assert call_args[idx].input == crash

From ca75f6103bf041bb50309540efb080cfc5ac64e9 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 10 Aug 2021 18:01:03 -0700
Subject: [PATCH 305/531] [reduce] Display initial quality in
 grizzly.reduce.crash

---
 grizzly/reduce/crash.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index ac98d2d4..fb855ad1 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -25,7 +25,8 @@ def main(args):
     """
     configure_logging(args.log_level)
     crash = CrashEntry(args.input)
-    LOG.info("Loaded crash %d", crash.crash_id)
+    initial_quality = Quality(crash.testcase_quality)
+    LOG.info("Loaded crash %d (%s)", crash.crash_id, initial_quality.name)
     bucket = None
     try:
         # download the crash
@@ -48,7 +49,7 @@ def main(args):
         if args.fuzzmanager:
             quality = {
                 Exit.ERROR: Quality.REDUCER_ERROR,
-                Exit.ABORT: Quality(crash.testcase_quality),
+                Exit.ABORT: initial_quality,
                 Exit.SUCCESS: Quality.ORIGINAL,
                 Exit.FAILURE: Quality.NOT_REPRODUCIBLE,
             }.get(Exit(result), Quality.UNREDUCED)

From 41ddbf8926720b28431a3596ea0e5cd90c1af470 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 10 Aug 2021 18:20:12 -0700
Subject: [PATCH 306/531] [reduce] Update comments to use quality name instead
 of Q#

---
 grizzly/reduce/crash.py       | 4 ++--
 grizzly/reduce/test_reduce.py | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index fb855ad1..797d76b5 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -53,8 +53,8 @@ def main(args):
                 Exit.SUCCESS: Quality.ORIGINAL,
                 Exit.FAILURE: Quality.NOT_REPRODUCIBLE,
             }.get(Exit(result), Quality.UNREDUCED)
-            # don't ever set things back to Q4, default to Q5 for that case.
-            # Q4 is only used in automation, so ABORT should never happen.
+            # don't ever set things back to REDUCING, default to UNREDUCED in that case.
+            # REDUCING is only used in automation, so ABORT should never happen.
             if quality == Quality.REDUCING:
                 quality = Quality.UNREDUCED
             LOG.info(
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 522ed67d..b3634cfe 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -735,7 +735,7 @@ def fake_iter():
 
 
 def test_quality_update(mocker, tmp_path):
-    """test that the final result gets changed to Q0 with --fuzzmanager"""
+    """test that the final result gets changed to REDUCED with --fuzzmanager"""
     mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value

From 079787663c7235645a1649fab49d10f98d204e92 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 17 Aug 2021 12:14:07 -0700
Subject: [PATCH 307/531] Add Target.filtered_environ()

---
 grizzly/common/test_utils.py         | 37 +------------
 grizzly/common/utils.py              | 22 --------
 grizzly/reduce/core.py               |  6 ++-
 grizzly/reduce/test_reduce.py        | 18 ++++---
 grizzly/reduce/test_strategies.py    |  9 ++--
 grizzly/replay/replay.py             |  4 +-
 grizzly/replay/test_main.py          |  8 +--
 grizzly/session.py                   |  2 +-
 grizzly/target/puppet_target.py      | 80 ++++++++++++++++++----------
 grizzly/target/target.py             |  4 ++
 grizzly/target/test_puppet_target.py | 17 ++++++
 setup.cfg                            |  2 +-
 12 files changed, 106 insertions(+), 103 deletions(-)

diff --git a/grizzly/common/test_utils.py b/grizzly/common/test_utils.py
index 7f62fd67..46d2491b 100644
--- a/grizzly/common/test_utils.py
+++ b/grizzly/common/test_utils.py
@@ -6,7 +6,7 @@
 
 from pytest import mark
 
-from .utils import configure_logging, grz_tmp, split_sanitizer_opts
+from .utils import configure_logging, grz_tmp
 
 
 def test_grz_tmp_01(mocker, tmp_path):
@@ -50,38 +50,3 @@ def test_configure_logging_01(mocker, env, log_level):
         assert config.call_args[-1]["level"] == DEBUG
     else:
         assert config.call_args[-1]["level"] == log_level
-
-
-@mark.parametrize(
-    "to_parse, expected",
-    [
-        # test empty string
-        ("", {}),
-        # test single value
-        ("test_value=true", {"test_value": "true"}),
-        # test multiple values
-        ("a=1:b=-2:C=3", {"a": "1", "b": "-2", "C": "3"}),
-        # path parsing
-        (
-            "p1='z:/a':p2='x:\\a.1':p3='/test/path/':p4='':p5=\"x:/a.a\"",
-            {
-                "p1": "'z:/a'",
-                "p2": "'x:\\a.1'",
-                "p3": "'/test/path/'",
-                "p4": "''",
-                "p5": '"x:/a.a"',
-            },
-        ),
-        # test platform specific parsing
-        (
-            "bar=1:file='%s':foo=2" % (__file__,),
-            {"bar": "1", "file": "'%s'" % (__file__,), "foo": "2"},
-        ),
-    ],
-)
-def test_sanitizer_opts_01(to_parse, expected):
-    """test split_sanitizer_opts()"""
-    parsed = split_sanitizer_opts(to_parse)
-    assert len(parsed) == len(expected)
-    for key in expected:
-        assert expected[key] == parsed[key]
diff --git a/grizzly/common/utils.py b/grizzly/common/utils.py
index 2025497e..9d1440c3 100644
--- a/grizzly/common/utils.py
+++ b/grizzly/common/utils.py
@@ -6,7 +6,6 @@
 from logging import DEBUG, basicConfig
 from os import getenv, makedirs
 from os.path import join as pathjoin
-from re import split as resplit
 from tempfile import gettempdir
 
 __all__ = (
@@ -14,7 +13,6 @@
     "configure_logging",
     "Exit",
     "grz_tmp",
-    "split_sanitizer_opts",
     "TIMEOUT_DELAY",
 )
 __author__ = "Tyson Smith"
@@ -75,23 +73,3 @@ def grz_tmp(*subdir):
     path = pathjoin(gettempdir(), "grizzly", *subdir)
     makedirs(path, exist_ok=True)
     return path
-
-
-def split_sanitizer_opts(env_data):
-    """Parse the values defined in given *SAN_OPTIONS environment variable.
-    For example "ASAN_OPTIONS=debug=false:log_path='/test/file.log'"
-    would return {"debug": "false", "log_path": "'/test/file.log'"}
-
-    Args:
-        env_var (str): *SAN_OPTIONS environment variable to parse.
-
-    Returns:
-        dict: Sanitized values from environment.
-    """
-    opts = dict()
-    for opt in resplit(r":(?![\\|/])", env_data):
-        if not opt:
-            continue
-        key, val = opt.split("=")
-        opts[key] = val
-    return opts
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 02a25a99..02a99e44 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -537,9 +537,11 @@ def run(self, repeat=1, min_results=1):
                                         for test in reduction:
                                             test.assets = self.target.assets
                                     # add target environment variables
-                                    if self.target.environ:
+                                    if self.target.filtered_environ():
                                         for test in reduction:
-                                            test.env_vars = dict(self.target.environ)
+                                            test.env_vars = (
+                                                self.target.filtered_environ()
+                                            )
                                     self.testcases = reduction
                                     keep_reduction = True
                                     # cleanup old best results
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index b3634cfe..b4a6abd1 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -550,7 +550,8 @@ def replay_run(testcases, _time_limit, **_):
     tests = [test]
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec_set=Target, environ={})
+    target = mocker.Mock(spec_set=Target)
+    target.filtered_environ.return_value = dict()
     target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
@@ -633,7 +634,8 @@ def fake_iter():
     fake_strat.return_value.__iter__.side_effect = fake_iter
     mocker.patch("grizzly.reduce.core.STRATEGIES", new={"fake": fake_strat})
 
-    target = mocker.Mock(spec_set=Target, environ={})
+    target = mocker.Mock(spec_set=Target)
+    target.filtered_environ.return_value = dict()
     target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
@@ -704,7 +706,8 @@ def fake_iter():
     fake_strat.return_value.__iter__.side_effect = fake_iter
     mocker.patch("grizzly.reduce.core.STRATEGIES", new={"fake": fake_strat})
 
-    target = mocker.Mock(spec_set=Target, environ={})
+    target = mocker.Mock(spec_set=Target)
+    target.filtered_environ.return_value = dict()
     target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
@@ -763,7 +766,8 @@ def replay_run(testcases, _time_limit, **_kw):
     mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     reporter = mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
     update_coll = mocker.patch("grizzly.common.fuzzmanager.Collector")
-    target = mocker.Mock(spec_set=Target, environ={})
+    target = mocker.Mock(spec_set=Target)
+    target.filtered_environ.return_value = dict()
     target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
@@ -833,7 +837,8 @@ def submit(test_cases, report):
 
     reporter.return_value.submit.side_effect = submit
 
-    target = mocker.Mock(spec_set=Target, environ={"test": "abc"})
+    target = mocker.Mock(spec_set=Target)
+    target.filtered_environ.return_value = {"test": "abc"}
     with AssetManager(base_path=str(tmp_path)) as assets:
         (tmp_path / "example_asset").touch()
         assets.add("example", str(tmp_path / "example_asset"), copy=False)
@@ -956,7 +961,8 @@ def replay_run(_testcases, _time_limit, **_):
     tests = [test]
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec_set=Target, environ={})
+    target = mocker.Mock(spec_set=Target)
+    target.filtered_environ.return_value = dict()
     target.assets = mocker.Mock(spec_set=AssetManager)
     server = mocker.Mock(spec_set=Sapphire, timeout=iter_input)
     try:
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index af4a7ddb..4c67f86b 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -175,7 +175,8 @@ def replay_run(testcases, _time_limit, **_):
         tests.append(test)
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec_set=Target, environ={})
+    target = mocker.Mock(spec_set=Target)
+    target.filtered_environ.return_value = dict()
     target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
@@ -355,7 +356,8 @@ def replay_run(testcases, _time_limit, **_):
         tests.append(test)
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec_set=Target, environ={})
+    target = mocker.Mock(spec_set=Target)
+    target.filtered_environ.return_value = dict()
     target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
@@ -414,7 +416,8 @@ def replay_run(testcases, _time_limit, **_):
     tests = [test]
     log_path = tmp_path / "logs"
 
-    target = mocker.Mock(spec_set=Target, environ={})
+    target = mocker.Mock(spec_set=Target)
+    target.filtered_environ.return_value = dict()
     target.assets = mocker.Mock(spec_set=AssetManager)
     try:
         mgr = ReduceManager(
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 2895465b..3fc05408 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -666,9 +666,9 @@ def main(cls, args):
                     for test in testcases:
                         test.assets = target.assets
                 # add target environment variables
-                if target.environ:
+                if target.filtered_environ():
                     for test in testcases:
-                        test.env_vars = dict(target.environ)
+                        test.env_vars = target.filtered_environ()
                 cls.report_to_filesystem(
                     args.logs, results, testcases if args.include_test else None
                 )
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 9deaa5bf..208348d5 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -40,6 +40,7 @@ def test_main_01(mocker, tmp_path):
     target = mocker.Mock(spec_set=Target, binary="bin", environ={}, launch_timeout=30)
     target.assets = mocker.Mock(spec_set=AssetManager)
     target.check_result.side_effect = (Result.FOUND, Result.NONE, Result.FOUND)
+    target.filtered_environ.return_value = {"ENV": "123"}
     target.save_logs = _fake_save_logs
     load_target.return_value.return_value = target
     with TestCase("test.html", None, "adpt") as src:
@@ -80,6 +81,7 @@ def test_main_01(mocker, tmp_path):
     assert serve_path.call_count == 3
     assert load_target.call_count == 1
     assert target.close.call_count == 4
+    assert target.filtered_environ.call_count == 2
     assert target.cleanup.call_count == 1
     assert target.assets.add.call_count == 0
     assert target.assets.is_empty.call_count == 1
@@ -250,10 +252,9 @@ def test_main_05(mocker, tmp_path):
         return_value=(None, ["test.html"]),  # passed to Target.check_result
     )
     # setup Target
-    target = mocker.NonCallableMock(
-        spec_set=Target, binary="bin", environ={}, launch_timeout=30
-    )
+    target = mocker.NonCallableMock(spec_set=Target, binary="bin", launch_timeout=30)
     target.check_result.return_value = Result.FOUND
+    target.filtered_environ.return_value = dict()
     target.monitor.is_healthy.return_value = False
     target.save_logs = _fake_save_logs
     mocker.patch(
@@ -299,6 +300,7 @@ def test_main_05(mocker, tmp_path):
         assert "from_cmdline" in target.assets.assets
     assert target.launch.call_count == 1
     assert target.check_result.call_count == 1
+    assert target.filtered_environ.call_count == 1
     assert serve_path.call_count == 1
     assert log_path.is_dir()
     assert any(log_path.glob("**/sample_asset"))
diff --git a/grizzly/session.py b/grizzly/session.py
index 2b93af6b..25045490 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -211,7 +211,7 @@ def run(
                 )
             current_test.duration = result.duration
             current_test.assets = self.target.assets
-            current_test.env_vars = dict(self.target.environ)
+            current_test.env_vars = self.target.filtered_environ()
             # adapter callbacks
             if result.timeout:
                 current_test.hang = True
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 30c5f0ff..7c4cce4c 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -17,11 +17,12 @@
 from time import sleep, time
 
 from ffpuppet import BrowserTimeoutError, Debugger, FFPuppet, LaunchError, Reason
+from ffpuppet.sanitizer_util import SanitizerOptions
 from prefpicker import PrefPicker
 from psutil import AccessDenied, NoSuchProcess, Process, process_iter
 
 from ..common.reporter import Report
-from ..common.utils import grz_tmp, split_sanitizer_opts
+from ..common.utils import grz_tmp
 from .target import Result, Target, TargetError, TargetLaunchError, TargetLaunchTimeout
 from .target_monitor import TargetMonitor
 
@@ -105,17 +106,35 @@ def close(self, force_close=False):
     def closed(self):
         return self._puppet.reason is not None
 
+    def create_report(self, is_hang=False):
+        logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
+        self.save_logs(logs)
+        return Report(logs, self.binary, is_hang=is_hang)
+
+    def filtered_environ(self):
+        # remove context specific entries from environment
+        filtered = dict(self.environ)
+        opts = SanitizerOptions()
+        if "ASAN_OPTIONS" in filtered:
+            opts.load_options(filtered["ASAN_OPTIONS"])
+            opts.pop("external_symbolizer_path")
+            opts.pop("strip_path_prefix")
+            opts.pop("suppressions")
+            filtered["ASAN_OPTIONS"] = opts.options
+        for san_opts in ("LSAN_OPTIONS", "TSAN_OPTIONS", "UBSAN_OPTIONS"):
+            if san_opts in filtered:
+                opts.load_options(filtered[san_opts])
+                opts.pop("suppressions")
+                filtered[san_opts] = opts.options
+        # remove empty entries
+        return {k: v for k, v in filtered.items() if v}
+
     def is_idle(self, threshold):
         for _, cpu in self._puppet.cpu_usage():
             if cpu >= threshold:
                 return False
         return True
 
-    def create_report(self, is_hang=False):
-        logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
-        self.save_logs(logs)
-        return Report(logs, self.binary, is_hang=is_hang)
-
     @property
     def monitor(self):
         if self._monitor is None:
@@ -167,7 +186,7 @@ def check_result(self, ignored):
                 LOG.debug("log size limit exceeded")
             else:
                 # crash or hang (forced SIGABRT) has been detected
-                LOG.debug("failure detected, ffpuppet %s", self._puppet.reason)
+                LOG.debug("result detected (%s)", self._puppet.reason.name)
                 result = Result.FOUND
         return result
 
@@ -318,30 +337,37 @@ def process_assets(self):
                         self._puppet.add_abort_token(line)
 
         # configure sanitizer suppressions
-        for sanitizer in ("lsan", "tsan", "ubsan"):
-            var_name = "%s_OPTIONS" % (sanitizer.upper(),)
-            # load existing sanitizer options from environment
-            if var_name in self.environ:
-                opts = split_sanitizer_opts(self.environ[var_name])
-            else:
-                opts = dict()
+        opts = SanitizerOptions()
+        for sanitizer in ["lsan", "tsan", "ubsan"]:
             asset = "%s-suppressions" % (sanitizer,)
-            supp_file = opts.pop("suppressions", "").strip("'")
+            # load existing sanitizer options from environment
+            var_name = "%s_OPTIONS" % (sanitizer.upper(),)
+            opts.load_options(self.environ.get(var_name, ""))
             if self.assets.get(asset):
                 # use suppression file if provided as asset
-                opts["suppressions"] = "%r" % (self.assets.get(asset),)
-            elif isfile(supp_file):
-                # use environment specified suppression file
-                LOG.debug("using %r from environment", asset)
-                opts["suppressions"] = "%r" % (self.assets.add(asset, supp_file),)
-            elif supp_file:
-                LOG.warning("Missing %s suppressions file %r", sanitizer, supp_file)
-            # update sanitized *SAN_OPTIONS
-            if "suppressions" in opts:
-                LOG.debug("updating suppressions in %r", var_name)
-                self.environ[var_name] = ":".join(
-                    "=".join((k, v)) for k, v in opts.items()
+                opts.add(
+                    "suppressions", "%r" % (self.assets.get(asset),), overwrite=True
                 )
+            elif opts.get("suppressions"):
+                supp_file = opts.pop("suppressions")
+                if SanitizerOptions.is_quoted(supp_file):
+                    supp_file = supp_file[1:-1]
+                if isfile(supp_file):
+                    # use environment specified suppression file
+                    LOG.debug("using %r from environment", asset)
+                    opts.add(
+                        "suppressions",
+                        "%r" % (self.assets.add(asset, supp_file),),
+                        overwrite=True,
+                    )
+                else:
+                    LOG.warning("Missing %s suppressions file %r", sanitizer, supp_file)
+            else:
+                # nothing to do
+                continue
+            # update sanitized *SAN_OPTIONS
+            LOG.debug("updating suppressions in %r", var_name)
+            self.environ[var_name] = opts.options
 
     def save_logs(self, *args, **kwargs):
         self._puppet.save_logs(*args, **kwargs)
diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 44837e00..6553d657 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -118,6 +118,10 @@ def create_report(self, is_hang=False):
     def dump_coverage(self, _timeout=0):  # pylint: disable=no-self-use
         LOG.warning("dump_coverage() is not supported!")
 
+    def filtered_environ(self):
+        """Used to collect the environment to add to a testcase"""
+        return dict(self.environ)
+
     @abstractmethod
     def handle_hang(self, ignore_idle=True):
         pass
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 0f152422..2bea116e 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -398,3 +398,20 @@ def test_puppet_target_10(tmp_path, asset, env):
                 assert assets.get("lsan-suppressions")
             else:
                 assert not assets.get("lsan-suppressions")
+
+
+def test_puppet_target_11(tmp_path):
+    """test PuppetTarget.filtered_environ()"""
+    fake_file = tmp_path / "fake"
+    fake_file.touch()
+    with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
+        target.environ = {
+            "TRACKED": "1",
+            "ASAN_OPTIONS": "external_symbolizer_path='a':no_remove='b'",
+            "LSAN_OPTIONS": "suppressions='a'",
+            "EMPTY": "",
+        }
+        assert "EMPTY" not in target.filtered_environ()
+        assert "TRACKED" in target.filtered_environ()
+        assert "ASAN_OPTIONS" in target.filtered_environ()
+        assert "LSAN_OPTIONS" not in target.filtered_environ()
diff --git a/setup.cfg b/setup.cfg
index a248b0d1..941f955c 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -22,7 +22,7 @@ include_package_data = True
 install_requires =
     cssbeautifier
     fasteners
-    ffpuppet >= 0.8.1
+    ffpuppet >= 0.8.4
     FuzzManager
     jsbeautifier
     lithium-reducer >= 0.5.3

From 44910d0688df5a3a8a2afc5a66a2225ffbdc6de8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 17 Aug 2021 12:39:17 -0700
Subject: [PATCH 308/531] Use IntEnum for Exit and Quality

---
 grizzly/common/reporter.py     |  6 +++---
 grizzly/common/utils.py        |  4 ++--
 grizzly/main.py                |  8 ++++----
 grizzly/reduce/bucket.py       |  2 +-
 grizzly/reduce/core.py         | 18 +++++++++---------
 grizzly/reduce/crash.py        |  6 +++---
 grizzly/reduce/exceptions.py   |  4 ++--
 grizzly/reduce/test_main.py    |  2 +-
 grizzly/reduce/test_main_fm.py | 16 +++++++---------
 grizzly/reduce/test_reduce.py  |  2 +-
 grizzly/replay/replay.py       | 18 ++++++++----------
 grizzly/replay/test_main.py    | 26 +++++++++++++-------------
 grizzly/test_main.py           | 10 +++++-----
 13 files changed, 59 insertions(+), 63 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index c92e61d9..d2fa7888 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -5,7 +5,7 @@
 
 from abc import ABCMeta, abstractmethod
 from collections import namedtuple
-from enum import Enum, unique
+from enum import IntEnum, unique
 from hashlib import sha1
 from json import dump, dumps, loads
 from logging import WARNING, getLogger
@@ -61,7 +61,7 @@
 
 
 @unique
-class Quality(Enum):
+class Quality(IntEnum):
     """testcase quality values"""
 
     # final reduced testcase
@@ -729,7 +729,7 @@ def _submit_report(self, report, test_cases):
                 LOG.info("Submitting new crash %r", cache_metadata["shortDescription"])
             # submit results to the FuzzManager server
             new_entry = collector.submit(
-                report.crash_info, testCase=zip_name, testCaseQuality=self.quality.value
+                report.crash_info, testCase=zip_name, testCaseQuality=self.quality
             )
         LOG.info("Logged %d (%s)", new_entry["id"], self.quality.name)
 
diff --git a/grizzly/common/utils.py b/grizzly/common/utils.py
index 9d1440c3..6d93cc8b 100644
--- a/grizzly/common/utils.py
+++ b/grizzly/common/utils.py
@@ -2,7 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from enum import Enum, unique
+from enum import IntEnum, unique
 from logging import DEBUG, basicConfig
 from os import getenv, makedirs
 from os.path import join as pathjoin
@@ -32,7 +32,7 @@ def __init__(self, message, exit_code):
 
 
 @unique
-class Exit(Enum):
+class Exit(IntEnum):
     """Exit codes"""
 
     SUCCESS = 0
diff --git a/grizzly/main.py b/grizzly/main.py
index 7511e2e6..1cff027d 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -65,7 +65,7 @@ def main(args):
         LOG.info("Using test time limit: %ds, timeout: %ds", time_limit, timeout)
         if timeout < time_limit:
             LOG.error("Timeout must be at least test time limit if not greater")
-            return Exit.ARGS.value
+            return Exit.ARGS
         if adapter.HARNESS_FILE and time_limit == timeout:
             LOG.warning(
                 "To avoid relaunches due to tests failing to close"
@@ -144,11 +144,11 @@ def main(args):
 
     except KeyboardInterrupt:
         LOG.info("Ctrl+C detected.")
-        return Exit.ABORT.value
+        return Exit.ABORT
 
     except (TargetLaunchError, TargetLaunchTimeout) as exc:
         LOG.error(str(exc))
-        return Exit.LAUNCH_FAILURE.value
+        return Exit.LAUNCH_FAILURE
 
     finally:
         LOG.info("Shutting down...")
@@ -163,4 +163,4 @@ def main(args):
             adapter.cleanup()
         LOG.info("Done.")
 
-    return Exit.SUCCESS.value
+    return Exit.SUCCESS
diff --git a/grizzly/reduce/bucket.py b/grizzly/reduce/bucket.py
index 67138ea2..8570c93d 100644
--- a/grizzly/reduce/bucket.py
+++ b/grizzly/reduce/bucket.py
@@ -47,7 +47,7 @@ def main(args):
 
     finally:
         bucket.cleanup()
-    return result.value
+    return result
 
 
 if __name__ == "__main__":
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 02a99e44..46990b7d 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -622,9 +622,9 @@ def run(self, repeat=1, min_results=1):
                         "Updating crash %d to %s (Q%d)",
                         crash_id,
                         Quality.REDUCED.name,
-                        Quality.REDUCED.value,
+                        Quality.REDUCED,
                     )
-                    CrashEntry(crash_id).testcase_quality = Quality.REDUCED.value
+                    CrashEntry(crash_id).testcase_quality = Quality.REDUCED
 
         # it's possible we made it this far without ever setting signature_desc.
         # this is only possible if --no-analysis is given
@@ -646,8 +646,8 @@ def run(self, repeat=1, min_results=1):
         )
 
         if any_success:
-            return Exit.SUCCESS.value
-        return Exit.FAILURE.value
+            return Exit.SUCCESS
+        return Exit.FAILURE
 
     def report(self, results, testcases, stats=None):
         """Report results, either to FuzzManager or to filesystem.
@@ -742,7 +742,7 @@ def main(cls, args):
                 )
             except TestCaseLoadFailure as exc:
                 LOG.error("Error: %s", str(exc))
-                return Exit.ERROR.value
+                return Exit.ERROR
 
             if args.tool is None and testcases[0].adapter_name is not None:
                 LOG.warning(
@@ -759,7 +759,7 @@ def main(cls, args):
                         "Error: '--no-harness' cannot be used with multiple "
                         "testcases. Perhaps '--test-index' can help."
                     )
-                    return Exit.ARGS.value
+                    return Exit.ARGS
                 LOG.debug("--no-harness specified relaunch set to 1")
                 args.relaunch = 1
 
@@ -826,7 +826,7 @@ def main(cls, args):
 
         except KeyboardInterrupt as exc:
             LOG.error("Exception: %r", exc)
-            return Exit.ABORT.value
+            return Exit.ABORT
 
         except (TargetLaunchError, TargetLaunchTimeout) as exc:
             LOG.error("Exception: %s", exc)
@@ -835,7 +835,7 @@ def main(cls, args):
                 LOG.error("Logs can be found here %r", path)
                 reporter = FilesystemReporter(path, major_bucket=False)
                 reporter.submit([], exc.report)
-            return Exit.LAUNCH_FAILURE.value
+            return Exit.LAUNCH_FAILURE
 
         except GrizzlyReduceBaseException as exc:
             LOG.error(exc.msg)
@@ -843,7 +843,7 @@ def main(cls, args):
 
         except Exception:  # pylint: disable=broad-except
             LOG.exception("Exception during reduction!")
-            return Exit.ERROR.value
+            return Exit.ERROR
 
         finally:
             LOG.info("Shutting down...")
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index 797d76b5..e4e63178 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -52,7 +52,7 @@ def main(args):
                 Exit.ABORT: initial_quality,
                 Exit.SUCCESS: Quality.ORIGINAL,
                 Exit.FAILURE: Quality.NOT_REPRODUCIBLE,
-            }.get(Exit(result), Quality.UNREDUCED)
+            }.get(result, Quality.UNREDUCED)
             # don't ever set things back to REDUCING, default to UNREDUCED in that case.
             # REDUCING is only used in automation, so ABORT should never happen.
             if quality == Quality.REDUCING:
@@ -61,9 +61,9 @@ def main(args):
                 "reducer finished -> exit(%d) -> %s (Q%d)",
                 result,
                 quality.name,
-                quality.value,
+                quality,
             )
-            crash.testcase_quality = quality.value
+            crash.testcase_quality = quality
     finally:
         crash.cleanup()
         if bucket is not None:
diff --git a/grizzly/reduce/exceptions.py b/grizzly/reduce/exceptions.py
index ae6709bc..9a32c729 100644
--- a/grizzly/reduce/exceptions.py
+++ b/grizzly/reduce/exceptions.py
@@ -9,7 +9,7 @@
 class GrizzlyReduceBaseException(Exception):
     """Base for other Grizzly Reducer specific exceptions."""
 
-    def __init__(self, msg, code=Exit.ERROR.value):
+    def __init__(self, msg, code=Exit.ERROR):
         super().__init__()
         self.msg = msg
         self.code = code
@@ -19,4 +19,4 @@ class NotReproducible(GrizzlyReduceBaseException):
     """Crash was not observed when expected during reduction."""
 
     def __init__(self, msg):
-        super().__init__(msg, code=Exit.FAILURE.value)
+        super().__init__(msg, code=Exit.FAILURE)
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index b50a22d9..d2ab80df 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -140,7 +140,7 @@ def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, exit_c
     )
 
     mocker.patch(patch_func, side_effect=side_effect, return_value=return_value)
-    assert ReduceManager.main(args) == exit_code.value
+    assert ReduceManager.main(args) == exit_code
 
 
 @mark.parametrize(
diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
index 4fac65e0..896b092f 100644
--- a/grizzly/reduce/test_main_fm.py
+++ b/grizzly/reduce/test_main_fm.py
@@ -35,12 +35,10 @@ def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_
     mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
     crash = mocker.patch("grizzly.reduce.crash.CrashEntry", autospec=True)
     bucket = mocker.patch("grizzly.reduce.crash.Bucket", autospec=True)
-    mocker.patch(
-        "grizzly.reduce.crash.ReduceManager.main", return_value=Exit.SUCCESS.value
-    )
+    mocker.patch("grizzly.reduce.crash.ReduceManager.main", return_value=Exit.SUCCESS)
     crash.return_value.testcase_path.return_value = "test_path.zip"
     crash.return_value.bucket = crash_bucket
-    crash.return_value.testcase_quality = 5
+    crash.return_value.testcase_quality = Quality.UNREDUCED
     crash.return_value.tool = "test-tool"
     bucket.return_value.signature_path.return_value = "test_sig.json"
 
@@ -77,15 +75,15 @@ def test_crash_main_quality(mocker, mgr_exit_code, pre_quality, post_quality):
     crash.return_value.testcase_quality = pre_quality
     crash.return_value.bucket = None
     crash.return_value.tool = "test-tool"
-    mgr.main.return_value = mgr_exit_code.value
+    mgr.main.return_value = mgr_exit_code
 
     args = mocker.Mock(
         input=12345,
         sig=None,
         tool=None,
     )
-    assert crash_main(args) == mgr_exit_code.value
-    assert crash.return_value.testcase_quality == post_quality.value
+    assert crash_main(args) == mgr_exit_code
+    assert crash.return_value.testcase_quality == post_quality
 
 
 @pytest.mark.parametrize(
@@ -117,7 +115,7 @@ def test_bucket_main(mocker, crashes, main_exit_codes, result, arg_sig, arg_tool
 
     def copy_args(args):
         call_args.append(deepcopy(args))
-        return main_exit_codes[main.call_count - 1].value
+        return main_exit_codes[main.call_count - 1]
 
     mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
     bucket = mocker.patch("grizzly.reduce.bucket.Bucket", autospec=True)
@@ -134,7 +132,7 @@ def copy_args(args):
         sig=arg_sig,
         tool=arg_tool,
     )
-    assert bucket_main(args) == result.value
+    assert bucket_main(args) == result
     assert main.call_count == len(main_exit_codes)
     for idx, (crash, _tool) in enumerate(crashes[: main.call_count]):
         assert call_args[idx].input == crash
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index b4a6abd1..441e82c0 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -795,7 +795,7 @@ def replay_run(testcases, _time_limit, **_kw):
     assert update_coll.call_count == 1
     assert update_coll.return_value.patch.call_count == 1
     assert update_coll.return_value.patch.call_args[1] == {
-        "data": {"testcase_quality": Quality.REDUCED.value},
+        "data": {"testcase_quality": Quality.REDUCED},
     }
 
 
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 3fc05408..55788889 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -127,12 +127,10 @@ def expect_hang(ignore, signature, tests):
         is_hang = any(x.hang for x in tests)
         if is_hang:
             if signature is None:
-                raise ConfigError(
-                    "Hangs require a signature to replay", Exit.ERROR.value
-                )
+                raise ConfigError("Hangs require a signature to replay", Exit.ERROR)
             if "timeout" in ignore:
                 raise ConfigError(
-                    "Cannot ignore 'timeout' when detecting hangs", Exit.ERROR.value
+                    "Cannot ignore 'timeout' when detecting hangs", Exit.ERROR
                 )
         return is_hang
 
@@ -545,7 +543,7 @@ def time_limits(cls, time_limit, timeout, tests):
             raise ConfigError(
                 "Timeout (%d) cannot be less than time limit (%d)"
                 % (timeout, time_limit),
-                Exit.ARGS.value,
+                Exit.ARGS,
             )
         return time_limit, timeout
 
@@ -580,7 +578,7 @@ def main(cls, args):
             )
         except TestCaseLoadFailure as exc:
             LOG.error("Error: %s", str(exc))
-            return Exit.ERROR.value
+            return Exit.ERROR
 
         results = None
         target = None
@@ -590,7 +588,7 @@ def main(cls, args):
                     "'--no-harness' cannot be used with multiple testcases. "
                     "Perhaps '--test-index' can help."
                 )
-                return Exit.ARGS.value
+                return Exit.ARGS
             # check if hangs are expected
             expect_hang = cls.expect_hang(args.ignore, signature, testcases)
             # check test time limit and timeout
@@ -673,14 +671,14 @@ def main(cls, args):
                     args.logs, results, testcases if args.include_test else None
                 )
             # TODO: add fuzzmanager reporting
-            return Exit.SUCCESS.value if success else Exit.FAILURE.value
+            return Exit.SUCCESS if success else Exit.FAILURE
 
         except ConfigError as exc:
             LOG.error(str(exc))
             return exc.exit_code
 
         except KeyboardInterrupt:
-            return Exit.ABORT.value
+            return Exit.ABORT
 
         except (TargetLaunchError, TargetLaunchTimeout) as exc:
             LOG.error(str(exc))
@@ -689,7 +687,7 @@ def main(cls, args):
                 LOG.error("Logs can be found here %r", path)
                 reporter = FilesystemReporter(path, major_bucket=False)
                 reporter.submit([], exc.report)
-            return Exit.LAUNCH_FAILURE.value
+            return Exit.LAUNCH_FAILURE
 
         finally:
             LOG.info("Shutting down...")
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 208348d5..ebc4e418 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -73,7 +73,7 @@ def test_main_01(mocker, tmp_path):
         timeout=None,
         valgrind=False,
     )
-    assert ReplayManager.main(args) == Exit.SUCCESS.value
+    assert ReplayManager.main(args) == Exit.SUCCESS
     assert target.reverse.call_count == 1
     assert target.launch.call_count == 3
     assert target.check_result.call_count == 3
@@ -126,7 +126,7 @@ def test_main_02(mocker, tmp_path):
         timeout=None,
         valgrind=False,
     )
-    assert ReplayManager.main(args) == Exit.FAILURE.value
+    assert ReplayManager.main(args) == Exit.FAILURE
     assert target.check_result.call_count == 1
     assert not target.environ
     assert target.close.call_count == 2
@@ -159,35 +159,35 @@ def test_main_03(mocker):
     )
     # user abort
     fake_load_target.side_effect = KeyboardInterrupt
-    assert ReplayManager.main(args) == Exit.ABORT.value
+    assert ReplayManager.main(args) == Exit.ABORT
     fake_load_target.reset_mock()
     # invalid test case
     fake_tc.load.side_effect = TestCaseLoadFailure
-    assert ReplayManager.main(args) == Exit.ERROR.value
+    assert ReplayManager.main(args) == Exit.ERROR
     assert fake_load_target.call_count == 0
     # no test cases
     fake_tc.load.side_effect = None
     fake_tc.load.return_value = list()
-    assert ReplayManager.main(args) == Exit.ERROR.value
+    assert ReplayManager.main(args) == Exit.ERROR
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
     # multiple test cases with --no-harness
     fake_tc.load.return_value = [
         mocker.Mock(spec_set=TestCase, env_vars={}, hang=False) for _ in range(2)
     ]
-    assert ReplayManager.main(args) == Exit.ARGS.value
+    assert ReplayManager.main(args) == Exit.ARGS
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
     # signature required replaying hang
     fake_tc.load.return_value = [mocker.Mock(spec_set=TestCase, env_vars={}, hang=True)]
-    assert ReplayManager.main(args) == Exit.ERROR.value
+    assert ReplayManager.main(args) == Exit.ERROR
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
     # can't ignore timeout replaying hang
     args.ignore = ["timeout"]
     args.sig = "sig"
     fake_tc.load.return_value = [mocker.Mock(spec_set=TestCase, env_vars={}, hang=True)]
-    assert ReplayManager.main(args) == Exit.ERROR.value
+    assert ReplayManager.main(args) == Exit.ERROR
     assert fake_sig.fromFile.call_count == 1
     assert fake_load_target.call_count == 0
     fake_load_target.reset_mock()
@@ -234,14 +234,14 @@ def test_main_04(mocker, tmp_path):
         "grizzly.replay.replay.ReplayManager.run",
         side_effect=TargetLaunchError("", report),
     )
-    assert ReplayManager.main(args) == Exit.LAUNCH_FAILURE.value
+    assert ReplayManager.main(args) == Exit.LAUNCH_FAILURE
     assert not fake_logs.is_dir()
     assert "fake_report_logs" in (x.name for x in fake_tmp.iterdir())
     # target launch timeout
     mocker.patch(
         "grizzly.replay.replay.ReplayManager.run", side_effect=TargetLaunchTimeout
     )
-    assert ReplayManager.main(args) == Exit.LAUNCH_FAILURE.value
+    assert ReplayManager.main(args) == Exit.LAUNCH_FAILURE
 
 
 def test_main_05(mocker, tmp_path):
@@ -296,7 +296,7 @@ def test_main_05(mocker, tmp_path):
     args.input = str(input_path)
     with AssetManager(base_path=str(tmp_path)) as assets:
         target.assets = assets
-        assert ReplayManager.main(args) == Exit.SUCCESS.value
+        assert ReplayManager.main(args) == Exit.SUCCESS
         assert "from_cmdline" in target.assets.assets
     assert target.launch.call_count == 1
     assert target.check_result.call_count == 1
@@ -369,7 +369,7 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
         timeout=arg_timeout,
         valgrind=False,
     )
-    assert ReplayManager.main(args) == result.value
+    assert ReplayManager.main(args) == result
 
 
 @mark.parametrize(
@@ -427,7 +427,7 @@ def test_main_07(mocker, tmp_path, pernosco, rr, valgrind, no_harness):
     )
     # maximum one debugger allowed at a time
     assert sum((pernosco, rr, valgrind)) < 2, "test broken!"
-    assert ReplayManager.main(args) == Exit.FAILURE.value
+    assert ReplayManager.main(args) == Exit.FAILURE
     assert target.check_result.call_count == 1
     assert target.close.call_count == 2
     assert target.cleanup.call_count == 1
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 38798642..bb774831 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -92,7 +92,7 @@ def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, verbose):
     if not verbose:
         args.log_level = 20
     args.coverage = cov
-    assert main(args) == Exit.SUCCESS.value
+    assert main(args) == Exit.SUCCESS
     assert fake_session.mock_calls[0][-1]["coverage"] == cov
     if adpt_relaunch:
         assert fake_session.mock_calls[0][-1]["relaunch"] == adpt_relaunch
@@ -139,7 +139,7 @@ def test_main_02(mocker, reporter):
         )
         fake_reporter.sanity_check.return_value = True
         args.s3_fuzzmanager = True
-    assert main(args) == Exit.SUCCESS.value
+    assert main(args) == Exit.SUCCESS
     assert fake_target.cleanup.call_count == 1
 
 
@@ -169,7 +169,7 @@ def test_main_03(mocker, exit_code, to_raise):
     args.adapter = "fake"
     args.input = "fake"
     fake_session.return_value.run.side_effect = to_raise
-    assert main(args) == exit_code.value
+    assert main(args) == exit_code
     assert fake_target.cleanup.call_count == 1
 
 
@@ -205,7 +205,7 @@ def test_main_04(mocker, arg_testlimit, arg_timeout, exit_code):
     args.adapter = "fake"
     args.time_limit = arg_testlimit
     args.timeout = arg_timeout
-    assert main(args) == exit_code.value
+    assert main(args) == exit_code
 
 
 @mark.parametrize(
@@ -241,7 +241,7 @@ def test_main_05(mocker, pernosco, rr, valgrind):
     args.pernosco = pernosco
     args.rr = rr
     args.valgrind = valgrind
-    assert main(args) == Exit.SUCCESS.value
+    assert main(args) == Exit.SUCCESS
     assert fake_target.call_args[-1]["pernosco"] == pernosco
     assert fake_target.call_args[-1]["rr"] == rr
     assert fake_target.call_args[-1]["valgrind"] == valgrind

From bfcb7cc208f143753f2c3365de2f2ad672188eb8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 17 Aug 2021 22:06:02 -0700
Subject: [PATCH 309/531] [tests] Add coverage of Target.filtered_environ()

---
 grizzly/target/test_target.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index 4391b9f6..853145c4 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -52,6 +52,7 @@ def test_target_01(tmp_path):
         target.assets = AssetManager(base_path=str(tmp_path))
         assert target.assets.path != org_path
         assert not target.environ
+        assert not target.filtered_environ()
         assert not target.is_idle(0)
         assert target.launch_timeout == 321
         assert target.log_size() == 0

From 1c686580baf6da9d73cb9d14f32b4d9d87a4b9dd Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 17 Aug 2021 22:09:22 -0700
Subject: [PATCH 310/531] Pass integer Quality value to FM

---
 grizzly/common/reporter.py     | 2 +-
 grizzly/reduce/core.py         | 2 +-
 grizzly/reduce/crash.py        | 2 +-
 grizzly/reduce/test_main_fm.py | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index d2fa7888..c8e18d6d 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -729,7 +729,7 @@ def _submit_report(self, report, test_cases):
                 LOG.info("Submitting new crash %r", cache_metadata["shortDescription"])
             # submit results to the FuzzManager server
             new_entry = collector.submit(
-                report.crash_info, testCase=zip_name, testCaseQuality=self.quality
+                report.crash_info, testCase=zip_name, testCaseQuality=self.quality.value
             )
         LOG.info("Logged %d (%s)", new_entry["id"], self.quality.name)
 
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 46990b7d..67c99af0 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -624,7 +624,7 @@ def run(self, repeat=1, min_results=1):
                         Quality.REDUCED.name,
                         Quality.REDUCED,
                     )
-                    CrashEntry(crash_id).testcase_quality = Quality.REDUCED
+                    CrashEntry(crash_id).testcase_quality = Quality.REDUCED.value
 
         # it's possible we made it this far without ever setting signature_desc.
         # this is only possible if --no-analysis is given
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index e4e63178..61d16b9e 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -63,7 +63,7 @@ def main(args):
                 quality.name,
                 quality,
             )
-            crash.testcase_quality = quality
+            crash.testcase_quality = quality.value
     finally:
         crash.cleanup()
         if bucket is not None:
diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
index 896b092f..633a8c6f 100644
--- a/grizzly/reduce/test_main_fm.py
+++ b/grizzly/reduce/test_main_fm.py
@@ -38,7 +38,7 @@ def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_
     mocker.patch("grizzly.reduce.crash.ReduceManager.main", return_value=Exit.SUCCESS)
     crash.return_value.testcase_path.return_value = "test_path.zip"
     crash.return_value.bucket = crash_bucket
-    crash.return_value.testcase_quality = Quality.UNREDUCED
+    crash.return_value.testcase_quality = 5
     crash.return_value.tool = "test-tool"
     bucket.return_value.signature_path.return_value = "test_sig.json"
 

From 74e681cd8cbe309018c36afec137856d8beb26b1 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 9 Sep 2021 16:31:40 -0700
Subject: [PATCH 311/531] Simplify filtered_environ()

---
 grizzly/target/puppet_target.py | 14 ++++++--------
 grizzly/target/test_target.py   |  4 ++++
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 7c4cce4c..3b9ffc01 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -115,17 +115,15 @@ def filtered_environ(self):
         # remove context specific entries from environment
         filtered = dict(self.environ)
         opts = SanitizerOptions()
-        if "ASAN_OPTIONS" in filtered:
-            opts.load_options(filtered["ASAN_OPTIONS"])
+        # iterate over *SAN_OPTIONS entries
+        for san in (x for x in filtered if x.endswith("SAN_OPTIONS")):
+            opts.load_options(filtered[san])
+            # remove entries specific to the current environment
             opts.pop("external_symbolizer_path")
+            opts.pop("log_path")
             opts.pop("strip_path_prefix")
             opts.pop("suppressions")
-            filtered["ASAN_OPTIONS"] = opts.options
-        for san_opts in ("LSAN_OPTIONS", "TSAN_OPTIONS", "UBSAN_OPTIONS"):
-            if san_opts in filtered:
-                opts.load_options(filtered[san_opts])
-                opts.pop("suppressions")
-                filtered[san_opts] = opts.options
+            filtered[san] = opts.options
         # remove empty entries
         return {k: v for k, v in filtered.items() if v}
 
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index 853145c4..e0c3f9f9 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -73,6 +73,10 @@ def test_target_02(mocker, tmp_path):
         assert target.environ
         assert "SKIP" not in target.environ
         assert target.environ["TEST_INC"] == "1"
+        filtered = target.filtered_environ()
+        assert filtered
+        assert "SKIP" not in filtered
+        assert filtered["TEST_INC"] == "1"
 
 
 def test_target_03():

From 5ebb2a6cdb01fe2014c3caff6ab19822ef2cca73 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 10 Sep 2021 09:55:39 -0700
Subject: [PATCH 312/531] Check signature cache before creating a signature

---
 grizzly/common/reporter.py      | 17 +++++++++++++----
 grizzly/common/test_reporter.py | 20 +++++++++++++++++++-
 2 files changed, 32 insertions(+), 5 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index c8e18d6d..ea852e7e 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -26,7 +26,7 @@
 from Collector.Collector import Collector
 from fasteners.process_lock import InterProcessLock
 from FTB.ProgramConfiguration import ProgramConfiguration
-from FTB.Signatures.CrashInfo import CrashInfo
+from FTB.Signatures.CrashInfo import CrashInfo, CrashSignature
 from psutil import disk_usage
 
 # check if boto is available for S3FuzzManager reporter
@@ -227,9 +227,18 @@ def crash_signature(self):
             CrashSignature: CrashSignature based on log data.
         """
         if self._signature is None:
-            self._signature = self.crash_info.createCrashSignature(
-                maxFrames=self.crash_signature_max_frames(self.crash_info)
-            )
+            collector = Collector()
+            with InterProcessLock(pathjoin(grz_tmp(), "fm_sigcache.lock")):
+                if collector.sigCacheDir:
+                    cache_sig, _ = collector.search(self.crash_info)
+                    if cache_sig:
+                        LOG.debug("signature loaded from cache file %r", cache_sig)
+                        self._signature = CrashSignature.fromFile(cache_sig)
+            # if cache lookup failed generate a crash signature
+            if self._signature is None:
+                self._signature = self.crash_info.createCrashSignature(
+                    maxFrames=self.crash_signature_max_frames(self.crash_info)
+                )
         return self._signature
 
     @staticmethod
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index bea3d543..0b019fa7 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -314,9 +314,27 @@ def test_report_12(tmp_path):
     assert report._crash_info is not None
 
 
-def test_report_13(mocker, tmp_path):
+@pytest.mark.parametrize(
+    "sig_data",
+    [
+        # signature exists in cache
+        '{"symptoms": [{"functionNames": ["a"],"type": "stackFrames"}]}',
+        # no signature
+        None,
+    ],
+)
+def test_report_13(mocker, tmp_path, sig_data):
     """test Report.crash_signature and Report.crash_hash"""
     mocker.patch("grizzly.common.reporter.ProgramConfiguration", autospec=True)
+    collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
+    if sig_data:
+        sig_file = tmp_path / "cache.sig"
+        sig_file.write_text(sig_data)
+        collector.return_value.search.return_value = (str(sig_file), None)
+        collector.return_value.sigCacheDir = str(sig_file)
+    else:
+        collector.return_value.sigCacheDir = None
+        collector.return_value.search.return_value = (None, None)
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     _create_crash_log(tmp_path / "log_asan_blah.txt")

From 15f6439808a9ac05a134628a736ce44c1179315b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 13 Sep 2021 12:49:01 -0700
Subject: [PATCH 313/531] Use signature hash instead of description to bucket
 and count results

---
 grizzly/common/status.py               | 53 +++++++++++++++-----------
 grizzly/common/status_reporter.py      | 16 ++++----
 grizzly/common/test_status.py          | 18 ++++-----
 grizzly/common/test_status_reporter.py | 20 +++++-----
 grizzly/replay/replay.py               | 12 +++---
 grizzly/session.py                     | 14 +++++--
 grizzly/test_session.py                | 17 +++++++--
 7 files changed, 89 insertions(+), 61 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index bab8f7f2..1e8353b8 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -3,7 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Manage Grizzly status reports."""
-from collections import defaultdict, namedtuple
+from collections import namedtuple
 from contextlib import contextmanager
 from json import dump, load
 from logging import getLogger
@@ -34,7 +34,7 @@ class Status:
         _enable_profiling (bool): Profiling support status.
         _lock (InterProcessLock): Lock used with data_file.
         _profiles (dict): Profiling data.
-        _results (dict): Results data. Used to count occurrences of a signature.
+        _results (dict): Results data. Used to count occurrences of results.
         data_file (str): File to save data to. None in read-only mode.
         ignored (int): Ignored result count.
         iteration (int): Iteration count.
@@ -75,7 +75,7 @@ def __init__(self, data_file, enable_profiling=False, start_time=None):
             self._lock = InterProcessLock(self.lock_file(data_file))
             self._enable_profiling = enable_profiling
         self._profiles = dict()
-        self._results = defaultdict(int)
+        self._results = dict()
         self.data_file = data_file
         self.ignored = 0
         self.iteration = 0
@@ -106,16 +106,26 @@ def cleanup(self):
                 pass
             self.data_file = None
 
-    def count_result(self, signature):
-        """Increment counter that matches `signature`.
+    def count_result(self, uid, description):
+        """Increment counter that matches `uid`.
 
         Args:
-            signature (str): Signature to increment.
+            uid (str): Unique identifier.
+            description (str): User friendly name (short signature).
 
         Returns:
-            None
+            int: Current count.
         """
-        self._results[signature] += 1
+        if uid not in self._results:
+            assert isinstance(uid, str)
+            assert isinstance(description, str)
+            # create result entry
+            self._results[uid] = {
+                "count": 0,
+                "desc": description,
+            }
+        self._results[uid]["count"] += 1
+        return self._results[uid]["count"]
 
     @property
     def _data(self):
@@ -312,7 +322,19 @@ def results(self):
         Returns:
             int: Total number of results.
         """
-        return sum(self._results.values())
+        return sum(x["count"] for x in self._results.values())
+
+    def result_entries(self):
+        """Provide unique result entries.
+
+        Args:
+            None
+
+        Yields:
+            dict: Result entry.
+        """
+        for uid, result in self._results.items():
+            yield uid, result
 
     @property
     def runtime(self):
@@ -329,19 +351,6 @@ def runtime(self):
             return self.timestamp - self.start_time
         return max(time() - self.start_time, 0)
 
-    def signatures(self):
-        """Provide the signature and the number of times it has been found for
-        each result.
-
-        Args:
-            None
-
-        Yields:
-            tuple: Signature and count.
-        """
-        for sig, count in self._results.items():
-            yield (sig, count)
-
     @classmethod
     def start(cls, path=PATH, enable_profiling=False):
         """Create a unique Status object.
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 617872d7..37291446 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -133,22 +133,24 @@ def print_summary(self, runtime=True, sysinfo=False, timestamp=False):
         print(self._summary(runtime=runtime, sysinfo=sysinfo, timestamp=timestamp))
 
     def _results(self, max_len=85):
-        signatures = defaultdict(int)
+        descs = dict()
+        counts = defaultdict(int)
         exp = int(time()) - self.EXP_LIMIT
         # calculate totals
         for report in self.reports:
             # filter expired reports
             if report.timestamp > exp:
                 # count results in report
-                for sig, count in report.signatures():
-                    signatures[sig] += count
+                for uid, result in report.result_entries():
+                    descs[uid] = result["desc"]
+                    counts[uid] += result["count"]
         # generate output
         txt = list()
-        for sig, count in sorted(signatures.items(), key=lambda x: x[1], reverse=True):
-            if len(sig) > max_len:
-                txt.append("%d: '%s...'\n" % (count, sig[:max_len]))
+        for uid, count in sorted(counts.items(), key=lambda x: x[1], reverse=True):
+            if len(descs[uid]) > max_len:
+                txt.append("%d: '%s...'\n" % (count, descs[uid][:max_len]))
             else:
-                txt.append("%d: %r\n" % (count, sig))
+                txt.append("%d: %r\n" % (count, descs[uid]))
         if not txt:
             txt.append("No results available\n")
         return "".join(txt)
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 02c66b50..b1bdc843 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -52,7 +52,7 @@ def test_status_02(tmp_path):
 def test_status_03(tmp_path):
     """test Status.report()"""
     status = Status.start(path=str(tmp_path))
-    status.count_result("sig1")
+    status.count_result("uid1", "sig1")
     # try to report before REPORT_FREQ elapses
     assert not status.report()
     # REPORT_FREQ elapses
@@ -85,7 +85,7 @@ def test_status_05(mocker, tmp_path):
     mocker.patch("grizzly.common.status.time", return_value=1.0)
     # create simple entry
     status = Status.start(path=str(tmp_path), enable_profiling=True)
-    status.count_result("sig1")
+    status.count_result("uid1", "sig1")
     status.record("test", 123.45)
     status.report(force=True)
     assert status.results == 1
@@ -197,16 +197,16 @@ def test_status_08(tmp_path):
 
 
 def test_status_09(tmp_path):
-    """test Status.count_result() and Status.signatures()"""
+    """test Status.count_result() and Status.result_entries()"""
     status = Status.start(path=str(tmp_path))
-    status.count_result("sig1")
-    status.count_result("sig2")
-    status.count_result("sig1")
-    status.count_result("sig3")
+    assert status.count_result("uid1", "sig1") == 1
+    assert status.count_result("uid2", "sig2") == 1
+    assert status.count_result("uid1", "sig1") == 2
+    assert status.count_result("uid3", "sig3") == 1
     assert status.results == 4
     found = dict()
-    for sig, count in status.signatures():
-        found[sig] = count
+    for _, result in status.result_entries():
+        found[result["desc"]] = result["count"]
     assert "sig1" in found
     assert found["sig1"] == 2
     assert "sig2" in found
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 48c17b78..4a008a65 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -200,7 +200,7 @@ def test_status_reporter_06(mocker, tmp_path):
     status = Status.start(path=str(tmp_path), enable_profiling=True)
     status.ignored = 1
     status.iteration = 432422
-    status._results = {"sig": 123}
+    status.count_result("uid1", "sig1")
     status.record("test1", 0.91)
     status.record("test1", 1.0)
     status.record("test1", 1.23456)
@@ -246,14 +246,14 @@ def test_status_reporter_07(tmp_path):
     # multiple reports with results
     status = Status.start(path=str(tmp_path))
     status.iteration = 1
-    status.count_result("[@ test1]")
-    status.count_result("[@ test2]")
-    status.count_result("[@ test1]")
+    status.count_result("uid1", "[@ test1]")
+    status.count_result("uid2", "[@ test2]")
+    status.count_result("uid1", "[@ test1]")
     status.report(force=True)
     status = Status.start(path=str(tmp_path))
     status.iteration = 1
-    status.count_result("[@ test1]")
-    status.count_result("[@ longsignature123]")
+    status.count_result("uid1", "[@ test1]")
+    status.count_result("uid3", "[@ longsignature123]")
     status.report(force=True)
     rptr = StatusReporter.load(str(tmp_path))
     assert rptr.has_results
@@ -331,13 +331,15 @@ def test_status_reporter_10(tmp_path):
     status.ignored = 100
     status.iteration = 1000
     status.log_size = 9999999999
-    status._results = {"sig": 123}
+    status.count_result("uid1", "[@ sig1]")
+    status._results["uid1"]["count"] = 123
     status.report(force=True)
     status = Status.start(path=str(status_path))
     status.ignored = 9
     status.iteration = 192938
     status.log_size = 0
-    status._results = {"sig": 3}
+    status.count_result("uid2", "[@ sig2]")
+    status._results["uid2"]["count"] = 3
     status.report(force=True)
     # create screenlogs with tracebacks
     for i in range(10):
@@ -554,7 +556,7 @@ def test_main_02(tmp_path):
     StatusReporter.CPU_POLL_INTERVAL = 0.01
     status = Status.start(path=str(tmp_path))
     status.iteration = 1
-    status.count_result("[@ test]")
+    status.count_result("uid", "[@ test]")
     status.report(force=True)
     assert main(["--reports", str(tmp_path)]) == 0
 
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 55788889..3083243e 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -385,18 +385,18 @@ def run(
                         self._any_crash
                         or self.check_match(self._signature, report, expect_hang)
                     ):
-                        self.status.count_result(short_sig)
+                        if sig_hash:
+                            LOG.debug("using provided signature (hash) to bucket")
+                            bucket_hash = sig_hash
+                        else:
+                            bucket_hash = report.crash_hash
+                        self.status.count_result(bucket_hash, short_sig)
                         LOG.info(
                             "Result: %s (%s:%s)",
                             short_sig,
                             report.major[:8],
                             report.minor[:8],
                         )
-                        if sig_hash:
-                            LOG.debug("using provided signature (hash) to bucket")
-                            bucket_hash = sig_hash
-                        else:
-                            bucket_hash = report.crash_hash
                         if bucket_hash not in reports:
                             reports[bucket_hash] = ReplayResult(
                                 report, served, durations, True
diff --git a/grizzly/session.py b/grizzly/session.py
index 25045490..9fa5107f 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -191,9 +191,9 @@ def run(
                         exc.report.major[:8],
                         exc.report.minor[:8],
                     )
+                    self.status.count_result(exc.report.crash_hash, short_sig)
                     self.reporter.submit([], exc.report)
                     exc.report.cleanup()
-                    self.status.count_result(short_sig)
                     raise TargetLaunchError(str(exc), None) from None
 
             # create and populate a test case
@@ -246,18 +246,24 @@ def run(
                 LOG.debug("result detected")
                 report = self.target.create_report(is_hang=result.timeout)
                 if result.timeout:
+                    report_uid = "hang"
                     short_sig = "Potential hang detected"
                 else:
+                    report_uid = report.crash_hash
                     short_sig = report.crash_info.createShortSignature()
+                seen = self.status.count_result(report_uid, short_sig)
                 LOG.info(
-                    "Result: %s (%s:%s)", short_sig, report.major[:8], report.minor[:8]
+                    "Result: %s (%s:%s) - %d",
+                    short_sig,
+                    report.major[:8],
+                    report.minor[:8],
+                    seen,
                 )
                 self.reporter.submit(self.iomanager.tests, report)
                 report.cleanup()
-                self.status.count_result(short_sig)
             elif result.status == Result.IGNORED:
                 self.status.ignored += 1
-                LOG.info("Ignored (%d)", self.status.ignored)
+                LOG.info("Ignored - %d", self.status.ignored)
 
             if startup_error:
                 raise SessionError("Please check Adapter and Target")
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index b3f5e602..0d453375 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -194,7 +194,9 @@ def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     adapter = SimpleAdapter(harness)
     reporter = mocker.Mock(spec_set=Reporter)
-    report = mocker.Mock(spec_set=Report, major="major123", minor="minor456")
+    report = mocker.Mock(
+        spec_set=Report, major="major123", minor="minor456", crash_hash="123"
+    )
     report.crash_info.createShortSignature.return_value = "[@ sig]"
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
@@ -283,7 +285,9 @@ def test_session_06(mocker, tmp_path, harness, report_size):
     """test Session - handle Target delayed failures"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     reporter = mocker.Mock(spec_set=Reporter)
-    report = mocker.Mock(spec_set=Report, major="major123", minor="minor456")
+    report = mocker.Mock(
+        spec_set=Report, major="major123", minor="minor456", crash_hash="1234"
+    )
     report.crash_info.createShortSignature.return_value = "[@ sig]"
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
@@ -327,7 +331,9 @@ def test_session_06(mocker, tmp_path, harness, report_size):
 def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, results):
     """test Session.run() - initial test case was not served"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
-    report = mocker.Mock(spec_set=Report, major="major123", minor="minor456")
+    report = mocker.Mock(
+        spec_set=Report, major="major123", minor="minor456", crash_hash="123"
+    )
     report.crash_info.createShortSignature.return_value = "[@ sig]"
     reporter = mocker.Mock(spec_set=Reporter)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
@@ -381,7 +387,10 @@ def test_session_08(tmp_path, mocker):
 def test_session_09(tmp_path, mocker):
     """test Session.run() handle TargetLaunchError"""
     mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
-    report = mocker.Mock(spec_set=Report, major="major123", minor="minor456")
+    report = mocker.Mock(
+        spec_set=Report, major="major123", minor="minor456", crash_hash="123"
+    )
+    report.crash_info.createShortSignature.return_value = "[@ sig]"
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.launch.side_effect = TargetLaunchError("test", report)
     adapter = mocker.Mock(spec_set=Adapter, remaining=None)

From cf9f3a6cd125ca62c758f086c0de86aeb02384e3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 14 Sep 2021 13:12:22 -0700
Subject: [PATCH 314/531] Move Report to a new file

---
 grizzly/common/report.py        | 419 ++++++++++++++++++++++++++++++++
 grizzly/common/reporter.py      | 405 +-----------------------------
 grizzly/common/test_report.py   | 347 ++++++++++++++++++++++++++
 grizzly/common/test_reporter.py | 339 +-------------------------
 grizzly/reduce/conftest.py      |   2 +-
 5 files changed, 776 insertions(+), 736 deletions(-)
 create mode 100644 grizzly/common/report.py
 create mode 100644 grizzly/common/test_report.py

diff --git a/grizzly/common/report.py b/grizzly/common/report.py
new file mode 100644
index 00000000..40b89844
--- /dev/null
+++ b/grizzly/common/report.py
@@ -0,0 +1,419 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from collections import namedtuple
+from hashlib import sha1
+from logging import getLogger
+from os import SEEK_END, scandir, stat, unlink
+from os.path import basename, isdir, isfile
+from os.path import join as pathjoin
+from platform import machine, system
+from re import DOTALL, VERBOSE
+from re import compile as re_compile
+from shutil import copyfileobj, move, rmtree
+from tempfile import mkstemp
+from time import strftime
+
+# import FuzzManager utilities
+from Collector.Collector import Collector
+from fasteners.process_lock import InterProcessLock
+from FTB.ProgramConfiguration import ProgramConfiguration
+from FTB.Signatures.CrashInfo import CrashInfo, CrashSignature
+
+from .stack_hasher import Stack
+from .utils import grz_tmp
+
+__all__ = ("Report",)
+__author__ = "Tyson Smith"
+__credits__ = ["Tyson Smith"]
+
+LOG = getLogger(__name__)
+
+# NOTE: order matters, aux -> stderr -> stdout
+LogMap = namedtuple("LogMap", "aux stderr stdout")
+
+
+class Report:
+    DEFAULT_MAJOR = "NO_STACK"
+    DEFAULT_MINOR = "0"
+    HANG_STACK_HEIGHT = 10
+    MAX_LOG_SIZE = 1_048_576  # 1MB
+
+    __slots__ = (
+        "_crash_info",
+        "_logs",
+        "_signature",
+        "_target_binary",
+        "is_hang",
+        "path",
+        "prefix",
+        "stack",
+    )
+
+    def __init__(self, log_path, target_binary, is_hang=False, size_limit=MAX_LOG_SIZE):
+        assert isinstance(log_path, str)
+        assert isinstance(target_binary, str)
+        self._crash_info = None
+        self._logs = self.select_logs(log_path)
+        assert self._logs is not None
+        self._signature = None
+        self._target_binary = target_binary
+        self.is_hang = is_hang
+        self.path = log_path
+        # tail files in log_path if needed
+        if size_limit < 1:
+            LOG.warning("No limit set on report log size!")
+        else:
+            for log in scandir(path=log_path):
+                if log.is_file() and log.stat().st_size > size_limit:
+                    Report.tail(log.path, size_limit)
+        # look through logs one by one until we find a stack
+        for log_file in (x for x in self._logs if x is not None):
+            with open(log_file, "rb") as log_fp:
+                stack = Stack.from_text(log_fp.read().decode("utf-8", errors="ignore"))
+            if stack.frames:
+                # limit the hash calculations to the first n frames if a hang
+                # was detected to attempt to help local bucketing
+                stack.height_limit = self.HANG_STACK_HEIGHT if is_hang else None
+                self.prefix = "%s_%s" % (stack.minor[:8], strftime("%Y-%m-%d_%H-%M-%S"))
+                self.stack = stack
+                break
+        else:
+            self.prefix = "%s_%s" % (self.DEFAULT_MINOR, strftime("%Y-%m-%d_%H-%M-%S"))
+            self.stack = None
+
+    @staticmethod
+    def calc_hash(signature):
+        """Create unique hash from a signature.
+
+        Args:
+            None
+
+        Returns:
+            str: Hash of the raw signature.
+        """
+        return sha1(signature.rawSignature.encode("utf-8")).hexdigest()[:16]
+
+    def cleanup(self):
+        """Remove Report data from filesystem.
+
+        Args:
+            None
+
+        Returns:
+            None
+        """
+        if self.path and isdir(self.path):
+            rmtree(self.path)
+        self.path = None
+
+    @property
+    def crash_hash(self):
+        """Create unique hash from a signature.
+
+        Args:
+            None
+
+        Returns:
+            str: Hash of the raw signature of the crash.
+        """
+        return self.calc_hash(self.crash_signature)
+
+    @property
+    def crash_info(self):
+        """Create CrashInfo object from logs.
+
+        Args:
+            None
+
+        Returns:
+            CrashInfo: CrashInfo based on log data.
+        """
+        if self._crash_info is None:
+            assert self.path is not None
+            # read in the log files and create a CrashInfo object
+            if self._logs.aux is not None:
+                with open(self._logs.aux, "rb") as log_fp:
+                    aux_data = (
+                        log_fp.read().decode("utf-8", errors="ignore").splitlines()
+                    )
+            else:
+                aux_data = None
+            # create ProgramConfiguration that can be reported to a FM server
+            if isfile("%s.fuzzmanagerconf" % (self._target_binary,)):
+                # attempt to use "<target_binary>.fuzzmanagerconf"
+                fm_cfg = ProgramConfiguration.fromBinary(self._target_binary)
+            else:
+                LOG.debug("'%s.fuzzmanagerconf' does not exist", self._target_binary)
+                fm_cfg = None
+            if fm_cfg is None:
+                LOG.debug("creating ProgramConfiguration")
+                cpu = machine().lower()
+                fm_cfg = ProgramConfiguration(
+                    basename(self._target_binary),
+                    "x86_64" if cpu == "amd64" else cpu,
+                    system(),
+                )
+            with open(self._logs.stderr, "rb") as err_fp, open(
+                self._logs.stdout, "rb"
+            ) as out_fp:
+                self._crash_info = CrashInfo.fromRawCrashData(
+                    out_fp.read().decode("utf-8", errors="ignore").splitlines(),
+                    err_fp.read().decode("utf-8", errors="ignore").splitlines(),
+                    fm_cfg,
+                    auxCrashData=aux_data,
+                )
+        return self._crash_info
+
+    @property
+    def crash_signature(self):
+        """Create CrashSignature object from CrashInfo.
+
+        Args:
+            None
+
+        Returns:
+            CrashSignature: CrashSignature based on log data.
+        """
+        if self._signature is None:
+            collector = Collector()
+            with InterProcessLock(pathjoin(grz_tmp(), "fm_sigcache.lock")):
+                if collector.sigCacheDir:
+                    cache_sig, _ = collector.search(self.crash_info)
+                    if cache_sig:
+                        LOG.debug("signature loaded from cache file %r", cache_sig)
+                        self._signature = CrashSignature.fromFile(cache_sig)
+            # if cache lookup failed generate a crash signature
+            if self._signature is None:
+                self._signature = self.crash_info.createCrashSignature(
+                    maxFrames=self.crash_signature_max_frames(self.crash_info)
+                )
+        return self._signature
+
+    @staticmethod
+    def crash_signature_max_frames(crash_info, suggested_frames=8):
+        if set(crash_info.backtrace) & {
+            "std::panicking::rust_panic",
+            "std::panicking::rust_panic_with_hook",
+        }:
+            # rust panic adds 5-6 frames of noise at the top of the stack
+            suggested_frames += 6
+        return suggested_frames
+
+    @staticmethod
+    def _find_ffpuppet_worker(logs):
+        """Search through list of log files for a ffpuppet worker log.
+
+        Args:
+            logs (list(str)): List of log files to search.
+
+        Returns:
+            str: The full file path if a match is found otherwise None.
+        """
+        found = None
+        for fname in (x for x in logs if "ffp_worker" in x):
+            if found is not None:
+                # we only expect one log here...
+                LOG.warning("overwriting previously selected %r", found)
+            found = fname
+        return found
+
+    @staticmethod
+    def _find_minidump(logs):
+        """Search through list of log files for a minidump log.
+
+        Args:
+            logs (list(str)): List of log files to search.
+
+        Returns:
+            str: The full file path if a match is found otherwise None.
+        """
+        re_dump_req = re_compile(
+            r"\d+\|0\|.+?\|google_breakpad::ExceptionHandler::WriteMinidump"
+        )
+        for fname in (x for x in logs if "minidump" in x):
+            with open(fname, "r") as log_fp:
+                data = log_fp.read(65536)
+                # this will select log that contains "Crash|SIGSEGV|" or
+                # the desired "DUMP_REQUESTED" log
+                # TODO: review this it may be too strict
+                # see mozilla-central/source/accessible/ipc/DocAccessibleParent.cpp#452
+                if "Crash|DUMP_REQUESTED|" not in data or re_dump_req.search(data):
+                    return fname
+        return None
+
+    @staticmethod
+    def _find_sanitizer(logs):
+        """Search through list of log files for a sanitizer (ASan, UBSan, etc...) log.
+
+        Args:
+            logs (list(str)): List of log files to search.
+
+        Returns:
+            str: The full file path if a match is found otherwise None.
+        """
+        # pattern to identify the ASan crash triggered when the parent process goes away
+        # TODO: this may no longer be required
+        re_e10s_forced = re_compile(
+            r"""
+            ==\d+==ERROR:.+?SEGV\son.+?0x[0]+\s\(.+?T2\).+?
+            #0\s+0x[0-9a-f]+\sin\s+mozilla::ipc::MessageChannel::OnChannelErrorFromLink
+            """,
+            DOTALL | VERBOSE,
+        )
+        # this is a list of Sanitizer error reports to prioritize
+        # Sanitizer reports not included below are deprioritized
+        prioritize_tokens = (
+            "use-after-",
+            "-buffer-overflow on",
+            ": data race ",
+            ": SEGV on ",
+            "access-violation on ",
+            "attempting free on ",
+            "negative-size-param",
+            "-param-overlap",
+        )
+        fallback = None
+        found = None
+        for fname in (x for x in logs if "asan" in x):
+            with open(fname, "r") as log_fp:
+                data = log_fp.read(65536)
+            # look for interesting crash info in the log
+            if "==ERROR:" in data or "WARNING:" in data:
+                # check for e10s forced crash
+                if re_e10s_forced.search(data) is not None:
+                    continue
+                # make sure there is something that looks like a stack frame
+                if "#0 " in data:
+                    found = fname
+                    if any(x in data for x in prioritize_tokens):
+                        # this is the likely cause of the crash
+                        break
+            if found is None:
+                # UBSan error (non-ASan builds)
+                if ": runtime error: " in data:
+                    found = fname
+                # catch all (choose the one with info for now)
+                elif data:
+                    fallback = fname
+        return found or fallback
+
+    @staticmethod
+    def _find_valgrind(logs):
+        """Search through list of log files for a Valgrind worker log.
+
+        Args:
+            logs (list(str)): List of log files to search.
+
+        Returns:
+            str: The full file path if a match is found otherwise None.
+        """
+        for fname in (x for x in logs if "valgrind" in x):
+            if stat(fname).st_size:
+                return fname
+        return None
+
+    @property
+    def major(self):
+        """The inclusive bucketing hash based on the stack trace
+        data found in logs.
+
+        Args:
+            None
+
+        Returns:
+            str: major hash string.
+        """
+        if self.stack and self.stack.major is not None:
+            return self.stack.major
+        return self.DEFAULT_MAJOR
+
+    @property
+    def minor(self):
+        """The specific bucketing hash based on the stack trace
+        data found in logs.
+
+        Args:
+            None
+
+        Returns:
+            str: minor hash string.
+        """
+        if self.stack and self.stack.minor is not None:
+            return self.stack.minor
+        return self.DEFAULT_MINOR
+
+    @property
+    def preferred(self):
+        """Log file containing most relevant data.
+
+        Args:
+            None
+
+        Returns:
+            str: Name of log.
+        """
+        return self._logs.aux or self._logs.stderr
+
+    @classmethod
+    def select_logs(cls, path):
+        """Scan path for file containing stderr, stdout and other (aux)
+        data and build a LogMap.
+
+        Args:
+            path (str): Path to scan for log files.
+
+        Returns:
+            LogMap: A LogMap pointing to log files or None if path is empty.
+        """
+        files = (x for x in scandir(path=path) if x.is_file())
+        # order by date hopefully the oldest log is the cause of the issue
+        to_scan = [x.path for x in sorted(files, key=lambda x: x.stat().st_mtime)]
+        if not to_scan:
+            LOG.warning("No files found in %r", path)
+            return None
+        # look for file to use as aux log
+        log_aux = cls._find_sanitizer(to_scan)
+        if log_aux is None:
+            log_aux = cls._find_valgrind(to_scan)
+        if log_aux is None:
+            log_aux = cls._find_minidump(to_scan)
+        if log_aux is None:
+            log_aux = cls._find_ffpuppet_worker(to_scan)
+        # look for stderr and stdout log files
+        log_err = None
+        log_out = None
+        for fname in to_scan:
+            if "stderr" in fname:
+                log_err = fname
+            elif "stdout" in fname:
+                log_out = fname
+        result = LogMap(log_aux, log_err, log_out)
+        return result if any(result) else None
+
+    @staticmethod
+    def tail(in_file, size_limit):
+        """Tail the given file. WARNING: This is destructive!
+
+        Args:
+            in_file (str): Path to file to work with.
+            size_limit (int): Maximum size of file after tail operation.
+
+        Returns:
+            None
+        """
+        assert size_limit > 0
+        with open(in_file, "rb") as in_fp:
+            in_fp.seek(0, SEEK_END)
+            end = in_fp.tell()
+            if end <= size_limit:
+                return
+            dump_pos = end - size_limit
+            in_fp.seek(dump_pos)
+            out_fd, out_file = mkstemp(prefix="taillog_", dir=grz_tmp())
+            with open(out_fd, "wb") as out_fp:
+                out_fp.write(b"[LOG TAILED]\n")
+                copyfileobj(in_fp, out_fp, 0x10000)  # 64KB chunks
+        unlink(in_file)
+        move(out_file, in_file)
diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index ea852e7e..e527d010 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -2,31 +2,23 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
 from abc import ABCMeta, abstractmethod
-from collections import namedtuple
 from enum import IntEnum, unique
-from hashlib import sha1
 from json import dump, dumps, loads
 from logging import WARNING, getLogger
-from os import SEEK_END, getcwd, getenv, makedirs, mkdir, scandir, stat, unlink, walk
+from os import getcwd, getenv, makedirs, mkdir, unlink, walk
 from os.path import basename, expanduser, isdir, isfile
 from os.path import join as pathjoin
 from os.path import realpath, relpath
-from platform import machine, system
-from re import DOTALL, VERBOSE
-from re import compile as re_compile
-from shutil import copyfile, copyfileobj, move, rmtree
+from shutil import copyfile, move, rmtree
 from tarfile import open as tar_open
-from tempfile import TemporaryDirectory, mkstemp
-from time import strftime
+from tempfile import TemporaryDirectory
 from zipfile import ZIP_DEFLATED, ZipFile
 
 # import FuzzManager utilities
 from Collector.Collector import Collector
 from fasteners.process_lock import InterProcessLock
 from FTB.ProgramConfiguration import ProgramConfiguration
-from FTB.Signatures.CrashInfo import CrashInfo, CrashSignature
 from psutil import disk_usage
 
 # check if boto is available for S3FuzzManager reporter
@@ -41,14 +33,13 @@
 except ImportError as err:
     _boto_import_error = err  # pylint: disable=invalid-name
 
-from .stack_hasher import Stack
+from .report import Report
 from .utils import grz_tmp
 
 __all__ = (
     "FilesystemReporter",
     "FuzzManagerReporter",
     "Quality",
-    "Report",
     "S3FuzzManagerReporter",
 )
 __author__ = "Tyson Smith"
@@ -56,9 +47,6 @@
 
 LOG = getLogger(__name__)
 
-# NOTE: order matters, aux -> stderr -> stdout
-LogMap = namedtuple("LogMap", "aux stderr stdout")
-
 
 @unique
 class Quality(IntEnum):
@@ -84,391 +72,6 @@ class Quality(IntEnum):
     NOT_REPRODUCIBLE = 10
 
 
-class Report:
-    DEFAULT_MAJOR = "NO_STACK"
-    DEFAULT_MINOR = "0"
-    HANG_STACK_HEIGHT = 10
-    MAX_LOG_SIZE = 1_048_576  # 1MB
-
-    __slots__ = (
-        "_crash_info",
-        "_logs",
-        "_signature",
-        "_target_binary",
-        "is_hang",
-        "path",
-        "prefix",
-        "stack",
-    )
-
-    def __init__(self, log_path, target_binary, is_hang=False, size_limit=MAX_LOG_SIZE):
-        assert isinstance(log_path, str)
-        assert isinstance(target_binary, str)
-        self._crash_info = None
-        self._logs = self.select_logs(log_path)
-        assert self._logs is not None
-        self._signature = None
-        self._target_binary = target_binary
-        self.is_hang = is_hang
-        self.path = log_path
-        # tail files in log_path if needed
-        if size_limit < 1:
-            LOG.warning("No limit set on report log size!")
-        else:
-            for log in scandir(path=log_path):
-                if log.is_file() and log.stat().st_size > size_limit:
-                    Report.tail(log.path, size_limit)
-        # look through logs one by one until we find a stack
-        for log_file in (x for x in self._logs if x is not None):
-            with open(log_file, "rb") as log_fp:
-                stack = Stack.from_text(log_fp.read().decode("utf-8", errors="ignore"))
-            if stack.frames:
-                # limit the hash calculations to the first n frames if a hang
-                # was detected to attempt to help local bucketing
-                stack.height_limit = self.HANG_STACK_HEIGHT if is_hang else None
-                self.prefix = "%s_%s" % (stack.minor[:8], strftime("%Y-%m-%d_%H-%M-%S"))
-                self.stack = stack
-                break
-        else:
-            self.prefix = "%s_%s" % (self.DEFAULT_MINOR, strftime("%Y-%m-%d_%H-%M-%S"))
-            self.stack = None
-
-    @staticmethod
-    def calc_hash(signature):
-        """Create unique hash from a signature.
-
-        Args:
-            None
-
-        Returns:
-            str: Hash of the raw signature.
-        """
-        return sha1(signature.rawSignature.encode("utf-8")).hexdigest()[:16]
-
-    def cleanup(self):
-        """Remove Report data from filesystem.
-
-        Args:
-            None
-
-        Returns:
-            None
-        """
-        if self.path and isdir(self.path):
-            rmtree(self.path)
-        self.path = None
-
-    @property
-    def crash_hash(self):
-        """Create unique hash from a signature.
-
-        Args:
-            None
-
-        Returns:
-            str: Hash of the raw signature of the crash.
-        """
-        return self.calc_hash(self.crash_signature)
-
-    @property
-    def crash_info(self):
-        """Create CrashInfo object from logs.
-
-        Args:
-            None
-
-        Returns:
-            CrashInfo: CrashInfo based on log data.
-        """
-        if self._crash_info is None:
-            assert self.path is not None
-            # read in the log files and create a CrashInfo object
-            if self._logs.aux is not None:
-                with open(self._logs.aux, "rb") as log_fp:
-                    aux_data = (
-                        log_fp.read().decode("utf-8", errors="ignore").splitlines()
-                    )
-            else:
-                aux_data = None
-            # create ProgramConfiguration that can be reported to a FM server
-            if isfile("%s.fuzzmanagerconf" % (self._target_binary,)):
-                # attempt to use "<target_binary>.fuzzmanagerconf"
-                fm_cfg = ProgramConfiguration.fromBinary(self._target_binary)
-            else:
-                LOG.debug("'%s.fuzzmanagerconf' does not exist", self._target_binary)
-                fm_cfg = None
-            if fm_cfg is None:
-                LOG.debug("creating ProgramConfiguration")
-                cpu = machine().lower()
-                fm_cfg = ProgramConfiguration(
-                    basename(self._target_binary),
-                    "x86_64" if cpu == "amd64" else cpu,
-                    system(),
-                )
-            with open(self._logs.stderr, "rb") as err_fp, open(
-                self._logs.stdout, "rb"
-            ) as out_fp:
-                self._crash_info = CrashInfo.fromRawCrashData(
-                    out_fp.read().decode("utf-8", errors="ignore").splitlines(),
-                    err_fp.read().decode("utf-8", errors="ignore").splitlines(),
-                    fm_cfg,
-                    auxCrashData=aux_data,
-                )
-        return self._crash_info
-
-    @property
-    def crash_signature(self):
-        """Create CrashSignature object from CrashInfo.
-
-        Args:
-            None
-
-        Returns:
-            CrashSignature: CrashSignature based on log data.
-        """
-        if self._signature is None:
-            collector = Collector()
-            with InterProcessLock(pathjoin(grz_tmp(), "fm_sigcache.lock")):
-                if collector.sigCacheDir:
-                    cache_sig, _ = collector.search(self.crash_info)
-                    if cache_sig:
-                        LOG.debug("signature loaded from cache file %r", cache_sig)
-                        self._signature = CrashSignature.fromFile(cache_sig)
-            # if cache lookup failed generate a crash signature
-            if self._signature is None:
-                self._signature = self.crash_info.createCrashSignature(
-                    maxFrames=self.crash_signature_max_frames(self.crash_info)
-                )
-        return self._signature
-
-    @staticmethod
-    def crash_signature_max_frames(crash_info, suggested_frames=8):
-        if set(crash_info.backtrace) & {
-            "std::panicking::rust_panic",
-            "std::panicking::rust_panic_with_hook",
-        }:
-            # rust panic adds 5-6 frames of noise at the top of the stack
-            suggested_frames += 6
-        return suggested_frames
-
-    @staticmethod
-    def _find_ffpuppet_worker(logs):
-        """Search through list of log files for a ffpuppet worker log.
-
-        Args:
-            logs (list(str)): List of log files to search.
-
-        Returns:
-            str: The full file path if a match is found otherwise None.
-        """
-        found = None
-        for fname in (x for x in logs if "ffp_worker" in x):
-            if found is not None:
-                # we only expect one log here...
-                LOG.warning("overwriting previously selected %r", found)
-            found = fname
-        return found
-
-    @staticmethod
-    def _find_minidump(logs):
-        """Search through list of log files for a minidump log.
-
-        Args:
-            logs (list(str)): List of log files to search.
-
-        Returns:
-            str: The full file path if a match is found otherwise None.
-        """
-        re_dump_req = re_compile(
-            r"\d+\|0\|.+?\|google_breakpad::ExceptionHandler::WriteMinidump"
-        )
-        for fname in (x for x in logs if "minidump" in x):
-            with open(fname, "r") as log_fp:
-                data = log_fp.read(65536)
-                # this will select log that contains "Crash|SIGSEGV|" or
-                # the desired "DUMP_REQUESTED" log
-                # TODO: review this it may be too strict
-                # see mozilla-central/source/accessible/ipc/DocAccessibleParent.cpp#452
-                if "Crash|DUMP_REQUESTED|" not in data or re_dump_req.search(data):
-                    return fname
-        return None
-
-    @staticmethod
-    def _find_sanitizer(logs):
-        """Search through list of log files for a sanitizer (ASan, UBSan, etc...) log.
-
-        Args:
-            logs (list(str)): List of log files to search.
-
-        Returns:
-            str: The full file path if a match is found otherwise None.
-        """
-        # pattern to identify the ASan crash triggered when the parent process goes away
-        # TODO: this may no longer be required
-        re_e10s_forced = re_compile(
-            r"""
-            ==\d+==ERROR:.+?SEGV\son.+?0x[0]+\s\(.+?T2\).+?
-            #0\s+0x[0-9a-f]+\sin\s+mozilla::ipc::MessageChannel::OnChannelErrorFromLink
-            """,
-            DOTALL | VERBOSE,
-        )
-        # this is a list of Sanitizer error reports to prioritize
-        # Sanitizer reports not included below are deprioritized
-        prioritize_tokens = (
-            "use-after-",
-            "-buffer-overflow on",
-            ": data race ",
-            ": SEGV on ",
-            "access-violation on ",
-            "attempting free on ",
-            "negative-size-param",
-            "-param-overlap",
-        )
-        fallback = None
-        found = None
-        for fname in (x for x in logs if "asan" in x):
-            with open(fname, "r") as log_fp:
-                data = log_fp.read(65536)
-            # look for interesting crash info in the log
-            if "==ERROR:" in data or "WARNING:" in data:
-                # check for e10s forced crash
-                if re_e10s_forced.search(data) is not None:
-                    continue
-                # make sure there is something that looks like a stack frame
-                if "#0 " in data:
-                    found = fname
-                    if any(x in data for x in prioritize_tokens):
-                        # this is the likely cause of the crash
-                        break
-            if found is None:
-                # UBSan error (non-ASan builds)
-                if ": runtime error: " in data:
-                    found = fname
-                # catch all (choose the one with info for now)
-                elif data:
-                    fallback = fname
-        return found or fallback
-
-    @staticmethod
-    def _find_valgrind(logs):
-        """Search through list of log files for a Valgrind worker log.
-
-        Args:
-            logs (list(str)): List of log files to search.
-
-        Returns:
-            str: The full file path if a match is found otherwise None.
-        """
-        for fname in (x for x in logs if "valgrind" in x):
-            if stat(fname).st_size:
-                return fname
-        return None
-
-    @property
-    def major(self):
-        """The inclusive bucketing hash based on the stack trace
-        data found in logs.
-
-        Args:
-            None
-
-        Returns:
-            str: major hash string.
-        """
-        if self.stack and self.stack.major is not None:
-            return self.stack.major
-        return self.DEFAULT_MAJOR
-
-    @property
-    def minor(self):
-        """The specific bucketing hash based on the stack trace
-        data found in logs.
-
-        Args:
-            None
-
-        Returns:
-            str: minor hash string.
-        """
-        if self.stack and self.stack.minor is not None:
-            return self.stack.minor
-        return self.DEFAULT_MINOR
-
-    @property
-    def preferred(self):
-        """Log file containing most relevant data.
-
-        Args:
-            None
-
-        Returns:
-            str: Name of log.
-        """
-        return self._logs.aux or self._logs.stderr
-
-    @classmethod
-    def select_logs(cls, path):
-        """Scan path for file containing stderr, stdout and other (aux)
-        data and build a LogMap.
-
-        Args:
-            path (str): Path to scan for log files.
-
-        Returns:
-            LogMap: A LogMap pointing to log files or None if path is empty.
-        """
-        files = (x for x in scandir(path=path) if x.is_file())
-        # order by date hopefully the oldest log is the cause of the issue
-        to_scan = [x.path for x in sorted(files, key=lambda x: x.stat().st_mtime)]
-        if not to_scan:
-            LOG.warning("No files found in %r", path)
-            return None
-        # look for file to use as aux log
-        log_aux = cls._find_sanitizer(to_scan)
-        if log_aux is None:
-            log_aux = cls._find_valgrind(to_scan)
-        if log_aux is None:
-            log_aux = cls._find_minidump(to_scan)
-        if log_aux is None:
-            log_aux = cls._find_ffpuppet_worker(to_scan)
-        # look for stderr and stdout log files
-        log_err = None
-        log_out = None
-        for fname in to_scan:
-            if "stderr" in fname:
-                log_err = fname
-            elif "stdout" in fname:
-                log_out = fname
-        result = LogMap(log_aux, log_err, log_out)
-        return result if any(result) else None
-
-    @staticmethod
-    def tail(in_file, size_limit):
-        """Tail the given file. WARNING: This is destructive!
-
-        Args:
-            in_file (str): Path to file to work with.
-            size_limit (int): Maximum size of file after tail operation.
-
-        Returns:
-            None
-        """
-        assert size_limit > 0
-        with open(in_file, "rb") as in_fp:
-            in_fp.seek(0, SEEK_END)
-            end = in_fp.tell()
-            if end <= size_limit:
-                return
-            dump_pos = end - size_limit
-            in_fp.seek(dump_pos)
-            out_fd, out_file = mkstemp(prefix="taillog_", dir=grz_tmp())
-            with open(out_fd, "wb") as out_fp:
-                out_fp.write(b"[LOG TAILED]\n")
-                copyfileobj(in_fp, out_fp, 0x10000)  # 64KB chunks
-        unlink(in_file)
-        move(out_file, in_file)
-
-
 class Reporter(metaclass=ABCMeta):
     @abstractmethod
     def _post_submit(self):
diff --git a/grizzly/common/test_report.py b/grizzly/common/test_report.py
new file mode 100644
index 00000000..f38ebe81
--- /dev/null
+++ b/grizzly/common/test_report.py
@@ -0,0 +1,347 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""test Grizzly Reporter"""
+# pylint: disable=protected-access
+
+import os
+from pathlib import Path
+
+import pytest
+from FTB.Signatures.CrashInfo import CrashInfo
+
+from .report import Report
+
+
+def _create_crash_log(log_path):
+    with log_path.open("w") as log_fp:
+        log_fp.write("==1==ERROR: AddressSanitizer: SEGV on unknown address 0x0")
+        log_fp.write(" (pc 0x0 bp 0x0 sp 0x0 T0)\n")
+        log_fp.write("    #0 0xbad000 in foo /file1.c:123:234\n")
+        log_fp.write("    #1 0x1337dd in bar /file2.c:1806:19")
+
+
+def test_report_01(tmp_path):
+    """test Report() with boring logs (no stack)"""
+    (tmp_path / "not_a_log.txt").touch()
+    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
+    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
+    report = Report(str(tmp_path), "a.bin", size_limit=0)
+    assert report._target_binary == "a.bin"
+    assert report.path == str(tmp_path)
+    assert report._logs.aux is None
+    assert report._logs.stderr.endswith("log_stderr.txt")
+    assert report._logs.stdout.endswith("log_stdout.txt")
+    assert report.preferred.endswith("log_stderr.txt")
+    assert report.stack is None
+    assert Report.DEFAULT_MAJOR == report.major
+    assert Report.DEFAULT_MINOR == report.minor
+    assert report.prefix is not None
+    report.cleanup()
+    assert not tmp_path.exists()
+
+
+def test_report_02(tmp_path):
+    """test Report() with crash logs"""
+    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
+    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
+    _create_crash_log(tmp_path / "log_asan_blah.txt")
+    report = Report(str(tmp_path), "bin")
+    assert report.path == str(tmp_path)
+    assert report._logs.aux.endswith("log_asan_blah.txt")
+    assert report._logs.stderr.endswith("log_stderr.txt")
+    assert report._logs.stdout.endswith("log_stdout.txt")
+    assert report.preferred.endswith("log_asan_blah.txt")
+    assert report.stack is not None
+    assert Report.DEFAULT_MAJOR != report.major
+    assert Report.DEFAULT_MINOR != report.minor
+    assert report.prefix is not None
+    report.cleanup()
+
+
+def test_report_03(tmp_path):
+    """test Report.tail()"""
+    tmp_file = tmp_path / "file.txt"
+    tmp_file.write_bytes(b"blah\ntest\n123\xEF\x00FOO")
+    length = tmp_file.stat().st_size
+    # no size limit
+    with pytest.raises(AssertionError):
+        Report.tail(str(tmp_file), 0)
+    assert tmp_file.stat().st_size == length
+    Report.tail(str(tmp_file), 3)
+    log_data = tmp_file.read_bytes()
+    assert log_data.startswith(b"[LOG TAILED]\n")
+    assert log_data[13:] == b"FOO"
+
+
+def test_report_04(tmp_path):
+    """test Report.select_logs() uninteresting data"""
+    # test with empty path
+    assert Report.select_logs(str(tmp_path)) is None
+    # empty file
+    (tmp_path / "not_a_log.txt").touch()
+    assert Report.select_logs(str(tmp_path)) is None
+
+
+def test_report_05(tmp_path):
+    """test Report.select_logs()"""
+    # small log with nothing interesting
+    with (tmp_path / "log_asan.txt.1").open("wb") as log_fp:
+        log_fp.write(b"SHORT LOG\n")
+        log_fp.write(b"filler line")
+    # crash on another thread
+    with (tmp_path / "log_asan.txt.2").open("wb") as log_fp:
+        log_fp.write(b"GOOD LOG\n")
+        log_fp.write(
+            b"==70811==ERROR: AddressSanitizer: SEGV on unknown address 0x00000BADF00D"
+        )
+        log_fp.write(
+            b" (pc 0x7f4c0bb54c67 bp 0x7f4c07bea380 sp 0x7f4c07bea360 T0)\n"
+        )  # must be 2nd line
+        # pad out to 6 lines
+        for l_no in range(4):
+            log_fp.write(b"    #%d blah...\n" % l_no)
+    # child log that should be ignored (created when parent crashes)
+    with (tmp_path / "log_asan.txt.3").open("wb") as log_fp:
+        log_fp.write(b"BAD LOG\n")
+        log_fp.write(
+            b"==70811==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000"
+        )
+        log_fp.write(
+            b" (pc 0x7f4c0bb54c67 bp 0x7f4c07bea380 sp 0x7f4c07bea360 T2)\n"
+        )  # must be 2nd line
+        # pad out to 6 lines
+        for l_no in range(4):
+            log_fp.write(b"    #%d blah...\n" % l_no)
+    (tmp_path / "log_mindump_blah.txt").write_bytes(b"minidump log")
+    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
+    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
+    # should be ignored in favor of "GOOD LOG"
+    (tmp_path / "log_ffp_worker_blah.txt").write_bytes(b"worker log")
+    log_map = Report.select_logs(str(tmp_path))
+    assert "GOOD LOG" in (tmp_path / log_map.aux).read_text()
+    assert "STDERR" in (tmp_path / log_map.stderr).read_text()
+    assert "STDOUT" in (tmp_path / log_map.stdout).read_text()
+
+
+def test_report_06(tmp_path):
+    """test minidump with Report.select_logs()"""
+    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
+    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
+    with (tmp_path / "log_minidump_01.txt").open("wb") as log_fp:
+        log_fp.write(b"GPU|||\n")
+        log_fp.write(b"Crash|SIGSEGV|0x0|0\n")
+        log_fp.write(b"minidump log\n")
+    (tmp_path / "log_ffp_worker_blah.txt").write_bytes(b"worker log")
+    log_map = Report.select_logs(str(tmp_path))
+    assert (tmp_path / log_map.stderr).is_file()
+    assert (tmp_path / log_map.stdout).is_file()
+    assert "minidump log" in (tmp_path / log_map.aux).read_text()
+
+
+def test_report_07(tmp_path):
+    """test selecting preferred DUMP_REQUESTED minidump with Report.select_logs()"""
+    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
+    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
+    with (tmp_path / "log_minidump_01.txt").open("wb") as log_fp:
+        log_fp.write(b"GPU|||\n")
+        log_fp.write(b"Crash|DUMP_REQUESTED|0x7f9518665d18|0\n")
+        log_fp.write(b"0|0|bar.so|sadf|a.cc:739484451a63|3066|0x0\n")
+        log_fp.write(b"0|1|gar.so|fdsa|b.cc:739484451a63|1644|0x12\n")
+    with (tmp_path / "log_minidump_02.txt").open("wb") as log_fp:
+        log_fp.write(b"GPU|||\n")
+        log_fp.write(b"Crash|DUMP_REQUESTED|0x7f57ac9e2e14|0\n")
+        log_fp.write(
+            b"0|0|foo.so|google_breakpad::ExceptionHandler::WriteMinidump|"
+            b"bar.cc:234|674|0xc\n"
+        )
+        log_fp.write(
+            b"0|1|foo.so|google_breakpad::ExceptionHandler::WriteMinidump|"
+            b"bar.cc:4a2|645|0x8\n"
+        )
+    with (tmp_path / "log_minidump_03.txt").open("wb") as log_fp:
+        log_fp.write(b"GPU|||\n")
+        log_fp.write(b"Crash|DUMP_REQUESTED|0x7f9518665d18|0\n")
+        log_fp.write(b"0|0|bar.so|sadf|a.cc:1234|3066|0x0\n")
+        log_fp.write(b"0|1|gar.so|fdsa|b.cc:4323|1644|0x12\n")
+    log_map = Report.select_logs(str(tmp_path))
+    assert (tmp_path / log_map.stderr).is_file()
+    assert (tmp_path / log_map.stdout).is_file()
+    assert (
+        "google_breakpad::ExceptionHandler::WriteMinidump"
+        in (tmp_path / log_map.aux).read_text()
+    )
+
+
+def test_report_08(tmp_path):
+    """test selecting worker logs with Report.select_logs()"""
+    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
+    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
+    (tmp_path / "log_ffp_worker_1.txt").write_bytes(b"worker log")
+    # we should only ever see one but if we see multiple we warn, so test that.
+    (tmp_path / "log_ffp_worker_2.txt").write_bytes(b"worker log")
+    log_map = Report.select_logs(str(tmp_path))
+    assert (tmp_path / log_map.stderr).is_file()
+    assert (tmp_path / log_map.stdout).is_file()
+    assert "worker log" in (tmp_path / log_map.aux).read_text()
+
+
+def test_report_09(tmp_path):
+    """test prioritizing sanitizer logs with Report._find_sanitizer()"""
+    # NOTE: ordered by selection priority in order to use previously added logs
+    # test empty
+    (tmp_path / "log_asan.txt.0").touch()
+    assert Report._find_sanitizer([str(x) for x in tmp_path.iterdir()]) is None
+    # test *San log with data
+    (tmp_path / "log_asan.txt.1").write_text("test")
+    selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
+    assert selected is not None
+    assert "test" in Path(selected).read_text()
+    # test UBSan log
+    (tmp_path / "log_asan.txt.1").write_text(
+        "test.cc:3:5: runtime error: signed integer overflow: ..."
+    )
+    selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
+    assert selected is not None
+    assert "runtime error: signed integer overflow" in Path(selected).read_text()
+    # test selecting ASan report
+    with (tmp_path / "log_asan.txt.2").open("wb") as log_fp:
+        # missing stack
+        log_fp.write(b"==1184==ERROR: AddressSanitizer: BUS on ... blah\n")
+    with (tmp_path / "log_asan.txt.3").open("wb") as log_fp:
+        log_fp.write(b"==9482==ERROR: AddressSanitizer: stack-overflow on ...\n")
+        for l_no in range(4):
+            log_fp.write(b"    #%d blah...\n" % (l_no,))
+    selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
+    assert selected is not None
+    assert "AddressSanitizer: stack-overflow" in Path(selected).read_text()
+    # test selecting prioritized
+    with (tmp_path / "log_asan.txt.4").open("wb") as log_fp:
+        log_fp.write(
+            b"==1942==ERROR: AddressSanitizer: heap-use-after-free on ... blah\n"
+        )
+        for l_no in range(4):
+            log_fp.write(b"    #%d blah...\n" % (l_no,))
+    with (tmp_path / "log_asan.txt.5").open("wb") as log_fp:
+        log_fp.write(b"==1984==ERROR: AddressSanitizer: SEGV on ... blah\n")
+        log_fp.write(b"missing trace...\n")
+    with (tmp_path / "log_asan.txt.6").open("wb") as log_fp:
+        log_fp.write(b"ERROR: Failed to mmap\n")
+    selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
+    assert selected is not None
+    assert "heap-use-after-free" in Path(selected).read_text()
+    # test selecting TSan reports
+    tsan_path = tmp_path / "tsan"
+    tsan_path.mkdir()
+    (tsan_path / "log_asan_benign.txt").write_text(
+        "==27531==WARNING: Symbolizer buffer too small\n"
+        "==27531==WARNING: Symbolizer buffer too small"
+    )
+    tsan_report = tsan_path / "log_asan_report.txt"
+    tsan_report.write_text(
+        "WARNING: ThreadSanitizer: data race (pid=26919)\n"
+        "  Write of size 8 at 0x7f0ca2fc3400 by thread T51:\n"
+        "    #0 memcpy /sanitizer_common_interceptors.inc:810:5 (lib+0x6656e)\n"
+    )
+    selected = Report._find_sanitizer([str(x) for x in tsan_path.iterdir()])
+    assert selected is not None
+    assert selected == str(tsan_report)
+
+
+def test_report_10(tmp_path):
+    """test Report() size_limit"""
+    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log\n" * 200)
+    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log\n" * 200)
+    (tmp_path / "unrelated.txt").write_bytes(b"nothing burger\n" * 200)
+    (tmp_path / "rr-trace").mkdir()
+    size_limit = len("STDERR log\n")
+    report = Report(str(tmp_path), "bin", size_limit=size_limit)
+    assert report.path == str(tmp_path)
+    assert report._logs.aux is None
+    assert report._logs.stderr.endswith("log_stderr.txt")
+    assert report._logs.stdout.endswith("log_stdout.txt")
+    assert report.preferred.endswith("log_stderr.txt")
+    assert report.stack is None
+    size_limit += len("[LOG TAILED]\n")
+    assert os.stat(os.path.join(report.path, report._logs.stderr)).st_size == size_limit
+    assert os.stat(os.path.join(report.path, report._logs.stdout)).st_size == size_limit
+    assert os.stat(os.path.join(report.path, "unrelated.txt")).st_size == size_limit
+    report.cleanup()
+    assert not tmp_path.is_dir()
+
+
+def test_report_11(tmp_path):
+    """test selecting Valgrind logs with Report.select_logs()"""
+    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
+    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
+    (tmp_path / "log_valgrind.txt").write_bytes(b"valgrind log")
+    log_map = Report.select_logs(str(tmp_path))
+    assert (tmp_path / log_map.stderr).is_file()
+    assert (tmp_path / log_map.stdout).is_file()
+    assert "valgrind log" in (tmp_path / log_map.aux).read_text()
+
+
+def test_report_12(tmp_path):
+    """test Report.crash_info"""
+    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
+    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
+    _create_crash_log(tmp_path / "log_asan_blah.txt")
+    # no binary.fuzzmanagerconf
+    report = Report(str(tmp_path), target_binary="fake_bin")
+    assert report._crash_info is None
+    assert report.crash_info is not None
+    assert report._crash_info is not None
+    # with binary.fuzzmanagerconf
+    with (tmp_path / "fake_bin.fuzzmanagerconf").open("wb") as conf:
+        conf.write(b"[Main]\n")
+        conf.write(b"platform = x86-64\n")
+        conf.write(b"product = mozilla-central\n")
+        conf.write(b"os = linux\n")
+    report = Report(str(tmp_path), target_binary=str(tmp_path / "fake_bin"))
+    assert report._crash_info is None
+    assert report.crash_info is not None
+    assert report._crash_info is not None
+
+
+@pytest.mark.parametrize(
+    "sig_data",
+    [
+        # signature exists in cache
+        '{"symptoms": [{"functionNames": ["a"],"type": "stackFrames"}]}',
+        # no signature
+        None,
+    ],
+)
+def test_report_13(mocker, tmp_path, sig_data):
+    """test Report.crash_signature and Report.crash_hash"""
+    mocker.patch("grizzly.common.reporter.ProgramConfiguration", autospec=True)
+    collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
+    if sig_data:
+        sig_file = tmp_path / "cache.sig"
+        sig_file.write_text(sig_data)
+        collector.return_value.search.return_value = (str(sig_file), None)
+        collector.return_value.sigCacheDir = str(sig_file)
+    else:
+        collector.return_value.sigCacheDir = None
+        collector.return_value.search.return_value = (None, None)
+    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
+    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
+    _create_crash_log(tmp_path / "log_asan_blah.txt")
+    report = Report(str(tmp_path), "bin")
+    assert report._signature is None
+    assert report.crash_signature
+    assert report.crash_info.createShortSignature() == "[@ foo]"
+    assert report.crash_hash
+
+
+def test_report_14(mocker):
+    """test Report.crash_signature_max_frames()"""
+    info = mocker.Mock(spec=CrashInfo)
+    info.backtrace = ("blah",)
+    assert Report.crash_signature_max_frames(info) == 8
+    info.backtrace = (
+        "std::panicking::rust_panic",
+        "std::panicking::rust_panic_with_hook",
+    )
+    assert Report.crash_signature_max_frames(info) == 14
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 0b019fa7..8ef1bf25 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -4,20 +4,16 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """test Grizzly Reporter"""
 # pylint: disable=protected-access
-
-import os
 import sys
 import tarfile
-from pathlib import Path
 
 import pytest
 from FTB.ProgramConfiguration import ProgramConfiguration
-from FTB.Signatures.CrashInfo import CrashInfo
 
+from .report import Report
 from .reporter import (
     FilesystemReporter,
     FuzzManagerReporter,
-    Report,
     Reporter,
     S3FuzzManagerReporter,
 )
@@ -32,331 +28,6 @@ def _create_crash_log(log_path):
         log_fp.write("    #1 0x1337dd in bar /file2.c:1806:19")
 
 
-def test_report_01(tmp_path):
-    """test Report() with boring logs (no stack)"""
-    (tmp_path / "not_a_log.txt").touch()
-    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
-    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    report = Report(str(tmp_path), "a.bin", size_limit=0)
-    assert report._target_binary == "a.bin"
-    assert report.path == str(tmp_path)
-    assert report._logs.aux is None
-    assert report._logs.stderr.endswith("log_stderr.txt")
-    assert report._logs.stdout.endswith("log_stdout.txt")
-    assert report.preferred.endswith("log_stderr.txt")
-    assert report.stack is None
-    assert Report.DEFAULT_MAJOR == report.major
-    assert Report.DEFAULT_MINOR == report.minor
-    assert report.prefix is not None
-    report.cleanup()
-    assert not tmp_path.exists()
-
-
-def test_report_02(tmp_path):
-    """test Report() with crash logs"""
-    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
-    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    _create_crash_log(tmp_path / "log_asan_blah.txt")
-    report = Report(str(tmp_path), "bin")
-    assert report.path == str(tmp_path)
-    assert report._logs.aux.endswith("log_asan_blah.txt")
-    assert report._logs.stderr.endswith("log_stderr.txt")
-    assert report._logs.stdout.endswith("log_stdout.txt")
-    assert report.preferred.endswith("log_asan_blah.txt")
-    assert report.stack is not None
-    assert Report.DEFAULT_MAJOR != report.major
-    assert Report.DEFAULT_MINOR != report.minor
-    assert report.prefix is not None
-    report.cleanup()
-
-
-def test_report_03(tmp_path):
-    """test Report.tail()"""
-    tmp_file = tmp_path / "file.txt"
-    tmp_file.write_bytes(b"blah\ntest\n123\xEF\x00FOO")
-    length = tmp_file.stat().st_size
-    # no size limit
-    with pytest.raises(AssertionError):
-        Report.tail(str(tmp_file), 0)
-    assert tmp_file.stat().st_size == length
-    Report.tail(str(tmp_file), 3)
-    log_data = tmp_file.read_bytes()
-    assert log_data.startswith(b"[LOG TAILED]\n")
-    assert log_data[13:] == b"FOO"
-
-
-def test_report_04(tmp_path):
-    """test Report.select_logs() uninteresting data"""
-    # test with empty path
-    assert Report.select_logs(str(tmp_path)) is None
-    # empty file
-    (tmp_path / "not_a_log.txt").touch()
-    assert Report.select_logs(str(tmp_path)) is None
-
-
-def test_report_05(tmp_path):
-    """test Report.select_logs()"""
-    # small log with nothing interesting
-    with (tmp_path / "log_asan.txt.1").open("wb") as log_fp:
-        log_fp.write(b"SHORT LOG\n")
-        log_fp.write(b"filler line")
-    # crash on another thread
-    with (tmp_path / "log_asan.txt.2").open("wb") as log_fp:
-        log_fp.write(b"GOOD LOG\n")
-        log_fp.write(
-            b"==70811==ERROR: AddressSanitizer: SEGV on unknown address 0x00000BADF00D"
-        )
-        log_fp.write(
-            b" (pc 0x7f4c0bb54c67 bp 0x7f4c07bea380 sp 0x7f4c07bea360 T0)\n"
-        )  # must be 2nd line
-        # pad out to 6 lines
-        for l_no in range(4):
-            log_fp.write(b"    #%d blah...\n" % l_no)
-    # child log that should be ignored (created when parent crashes)
-    with (tmp_path / "log_asan.txt.3").open("wb") as log_fp:
-        log_fp.write(b"BAD LOG\n")
-        log_fp.write(
-            b"==70811==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000"
-        )
-        log_fp.write(
-            b" (pc 0x7f4c0bb54c67 bp 0x7f4c07bea380 sp 0x7f4c07bea360 T2)\n"
-        )  # must be 2nd line
-        # pad out to 6 lines
-        for l_no in range(4):
-            log_fp.write(b"    #%d blah...\n" % l_no)
-    (tmp_path / "log_mindump_blah.txt").write_bytes(b"minidump log")
-    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
-    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    # should be ignored in favor of "GOOD LOG"
-    (tmp_path / "log_ffp_worker_blah.txt").write_bytes(b"worker log")
-    log_map = Report.select_logs(str(tmp_path))
-    assert "GOOD LOG" in (tmp_path / log_map.aux).read_text()
-    assert "STDERR" in (tmp_path / log_map.stderr).read_text()
-    assert "STDOUT" in (tmp_path / log_map.stdout).read_text()
-
-
-def test_report_06(tmp_path):
-    """test minidump with Report.select_logs()"""
-    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
-    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    with (tmp_path / "log_minidump_01.txt").open("wb") as log_fp:
-        log_fp.write(b"GPU|||\n")
-        log_fp.write(b"Crash|SIGSEGV|0x0|0\n")
-        log_fp.write(b"minidump log\n")
-    (tmp_path / "log_ffp_worker_blah.txt").write_bytes(b"worker log")
-    log_map = Report.select_logs(str(tmp_path))
-    assert (tmp_path / log_map.stderr).is_file()
-    assert (tmp_path / log_map.stdout).is_file()
-    assert "minidump log" in (tmp_path / log_map.aux).read_text()
-
-
-def test_report_07(tmp_path):
-    """test selecting preferred DUMP_REQUESTED minidump with Report.select_logs()"""
-    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
-    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    with (tmp_path / "log_minidump_01.txt").open("wb") as log_fp:
-        log_fp.write(b"GPU|||\n")
-        log_fp.write(b"Crash|DUMP_REQUESTED|0x7f9518665d18|0\n")
-        log_fp.write(b"0|0|bar.so|sadf|a.cc:739484451a63|3066|0x0\n")
-        log_fp.write(b"0|1|gar.so|fdsa|b.cc:739484451a63|1644|0x12\n")
-    with (tmp_path / "log_minidump_02.txt").open("wb") as log_fp:
-        log_fp.write(b"GPU|||\n")
-        log_fp.write(b"Crash|DUMP_REQUESTED|0x7f57ac9e2e14|0\n")
-        log_fp.write(
-            b"0|0|foo.so|google_breakpad::ExceptionHandler::WriteMinidump|"
-            b"bar.cc:234|674|0xc\n"
-        )
-        log_fp.write(
-            b"0|1|foo.so|google_breakpad::ExceptionHandler::WriteMinidump|"
-            b"bar.cc:4a2|645|0x8\n"
-        )
-    with (tmp_path / "log_minidump_03.txt").open("wb") as log_fp:
-        log_fp.write(b"GPU|||\n")
-        log_fp.write(b"Crash|DUMP_REQUESTED|0x7f9518665d18|0\n")
-        log_fp.write(b"0|0|bar.so|sadf|a.cc:1234|3066|0x0\n")
-        log_fp.write(b"0|1|gar.so|fdsa|b.cc:4323|1644|0x12\n")
-    log_map = Report.select_logs(str(tmp_path))
-    assert (tmp_path / log_map.stderr).is_file()
-    assert (tmp_path / log_map.stdout).is_file()
-    assert (
-        "google_breakpad::ExceptionHandler::WriteMinidump"
-        in (tmp_path / log_map.aux).read_text()
-    )
-
-
-def test_report_08(tmp_path):
-    """test selecting worker logs with Report.select_logs()"""
-    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
-    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    (tmp_path / "log_ffp_worker_1.txt").write_bytes(b"worker log")
-    # we should only ever see one but if we see multiple we warn, so test that.
-    (tmp_path / "log_ffp_worker_2.txt").write_bytes(b"worker log")
-    log_map = Report.select_logs(str(tmp_path))
-    assert (tmp_path / log_map.stderr).is_file()
-    assert (tmp_path / log_map.stdout).is_file()
-    assert "worker log" in (tmp_path / log_map.aux).read_text()
-
-
-def test_report_09(tmp_path):
-    """test prioritizing sanitizer logs with Report._find_sanitizer()"""
-    # NOTE: ordered by selection priority in order to use previously added logs
-    # test empty
-    (tmp_path / "log_asan.txt.0").touch()
-    assert Report._find_sanitizer([str(x) for x in tmp_path.iterdir()]) is None
-    # test *San log with data
-    (tmp_path / "log_asan.txt.1").write_text("test")
-    selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
-    assert selected is not None
-    assert "test" in Path(selected).read_text()
-    # test UBSan log
-    (tmp_path / "log_asan.txt.1").write_text(
-        "test.cc:3:5: runtime error: signed integer overflow: ..."
-    )
-    selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
-    assert selected is not None
-    assert "runtime error: signed integer overflow" in Path(selected).read_text()
-    # test selecting ASan report
-    with (tmp_path / "log_asan.txt.2").open("wb") as log_fp:
-        # missing stack
-        log_fp.write(b"==1184==ERROR: AddressSanitizer: BUS on ... blah\n")
-    with (tmp_path / "log_asan.txt.3").open("wb") as log_fp:
-        log_fp.write(b"==9482==ERROR: AddressSanitizer: stack-overflow on ...\n")
-        for l_no in range(4):
-            log_fp.write(b"    #%d blah...\n" % (l_no,))
-    selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
-    assert selected is not None
-    assert "AddressSanitizer: stack-overflow" in Path(selected).read_text()
-    # test selecting prioritized
-    with (tmp_path / "log_asan.txt.4").open("wb") as log_fp:
-        log_fp.write(
-            b"==1942==ERROR: AddressSanitizer: heap-use-after-free on ... blah\n"
-        )
-        for l_no in range(4):
-            log_fp.write(b"    #%d blah...\n" % (l_no,))
-    with (tmp_path / "log_asan.txt.5").open("wb") as log_fp:
-        log_fp.write(b"==1984==ERROR: AddressSanitizer: SEGV on ... blah\n")
-        log_fp.write(b"missing trace...\n")
-    with (tmp_path / "log_asan.txt.6").open("wb") as log_fp:
-        log_fp.write(b"ERROR: Failed to mmap\n")
-    selected = Report._find_sanitizer([str(x) for x in tmp_path.iterdir()])
-    assert selected is not None
-    assert "heap-use-after-free" in Path(selected).read_text()
-    # test selecting TSan reports
-    tsan_path = tmp_path / "tsan"
-    tsan_path.mkdir()
-    (tsan_path / "log_asan_benign.txt").write_text(
-        "==27531==WARNING: Symbolizer buffer too small\n"
-        "==27531==WARNING: Symbolizer buffer too small"
-    )
-    tsan_report = tsan_path / "log_asan_report.txt"
-    tsan_report.write_text(
-        "WARNING: ThreadSanitizer: data race (pid=26919)\n"
-        "  Write of size 8 at 0x7f0ca2fc3400 by thread T51:\n"
-        "    #0 memcpy /sanitizer_common_interceptors.inc:810:5 (lib+0x6656e)\n"
-    )
-    selected = Report._find_sanitizer([str(x) for x in tsan_path.iterdir()])
-    assert selected is not None
-    assert selected == str(tsan_report)
-
-
-def test_report_10(tmp_path):
-    """test Report() size_limit"""
-    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log\n" * 200)
-    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log\n" * 200)
-    (tmp_path / "unrelated.txt").write_bytes(b"nothing burger\n" * 200)
-    (tmp_path / "rr-trace").mkdir()
-    size_limit = len("STDERR log\n")
-    report = Report(str(tmp_path), "bin", size_limit=size_limit)
-    assert report.path == str(tmp_path)
-    assert report._logs.aux is None
-    assert report._logs.stderr.endswith("log_stderr.txt")
-    assert report._logs.stdout.endswith("log_stdout.txt")
-    assert report.preferred.endswith("log_stderr.txt")
-    assert report.stack is None
-    size_limit += len("[LOG TAILED]\n")
-    assert os.stat(os.path.join(report.path, report._logs.stderr)).st_size == size_limit
-    assert os.stat(os.path.join(report.path, report._logs.stdout)).st_size == size_limit
-    assert os.stat(os.path.join(report.path, "unrelated.txt")).st_size == size_limit
-    report.cleanup()
-    assert not tmp_path.is_dir()
-
-
-def test_report_11(tmp_path):
-    """test selecting Valgrind logs with Report.select_logs()"""
-    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
-    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    (tmp_path / "log_valgrind.txt").write_bytes(b"valgrind log")
-    log_map = Report.select_logs(str(tmp_path))
-    assert (tmp_path / log_map.stderr).is_file()
-    assert (tmp_path / log_map.stdout).is_file()
-    assert "valgrind log" in (tmp_path / log_map.aux).read_text()
-
-
-def test_report_12(tmp_path):
-    """test Report.crash_info"""
-    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
-    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    _create_crash_log(tmp_path / "log_asan_blah.txt")
-    # no binary.fuzzmanagerconf
-    report = Report(str(tmp_path), target_binary="fake_bin")
-    assert report._crash_info is None
-    assert report.crash_info is not None
-    assert report._crash_info is not None
-    # with binary.fuzzmanagerconf
-    with (tmp_path / "fake_bin.fuzzmanagerconf").open("wb") as conf:
-        conf.write(b"[Main]\n")
-        conf.write(b"platform = x86-64\n")
-        conf.write(b"product = mozilla-central\n")
-        conf.write(b"os = linux\n")
-    report = Report(str(tmp_path), target_binary=str(tmp_path / "fake_bin"))
-    assert report._crash_info is None
-    assert report.crash_info is not None
-    assert report._crash_info is not None
-
-
-@pytest.mark.parametrize(
-    "sig_data",
-    [
-        # signature exists in cache
-        '{"symptoms": [{"functionNames": ["a"],"type": "stackFrames"}]}',
-        # no signature
-        None,
-    ],
-)
-def test_report_13(mocker, tmp_path, sig_data):
-    """test Report.crash_signature and Report.crash_hash"""
-    mocker.patch("grizzly.common.reporter.ProgramConfiguration", autospec=True)
-    collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
-    if sig_data:
-        sig_file = tmp_path / "cache.sig"
-        sig_file.write_text(sig_data)
-        collector.return_value.search.return_value = (str(sig_file), None)
-        collector.return_value.sigCacheDir = str(sig_file)
-    else:
-        collector.return_value.sigCacheDir = None
-        collector.return_value.search.return_value = (None, None)
-    (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
-    (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    _create_crash_log(tmp_path / "log_asan_blah.txt")
-    report = Report(str(tmp_path), "bin")
-    assert report._signature is None
-    assert report.crash_signature
-    assert report.crash_info.createShortSignature() == "[@ foo]"
-    assert report.crash_hash
-
-
-def test_report_14(mocker):
-    """test Report.crash_signature_max_frames()"""
-    info = mocker.Mock(spec=CrashInfo)
-    info.backtrace = ("blah",)
-    assert Report.crash_signature_max_frames(info) == 8
-    info.backtrace = (
-        "std::panicking::rust_panic",
-        "std::panicking::rust_panic_with_hook",
-    )
-    assert Report.crash_signature_max_frames(info) == 14
-
-
 def test_reporter_01(mocker):
     """test creating a simple Reporter"""
 
@@ -475,7 +146,7 @@ def test_fuzzmanager_reporter_02(mocker, tmp_path):
         "grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path)
     )
     mocker.patch("grizzly.common.reporter.getenv", autospec=True, return_value="0")
-    fake_crashinfo = mocker.patch("grizzly.common.reporter.CrashInfo", autospec=True)
+    fake_crashinfo = mocker.patch("grizzly.common.report.CrashInfo", autospec=True)
     fake_crashinfo.fromRawCrashData.return_value.createShortSignature.return_value = (
         "test [@ test]"
     )
@@ -513,7 +184,7 @@ def test_fuzzmanager_reporter_03(mocker, tmp_path):
     mocker.patch(
         "grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path)
     )
-    fake_crashinfo = mocker.patch("grizzly.common.reporter.CrashInfo", autospec=True)
+    fake_crashinfo = mocker.patch("grizzly.common.report.CrashInfo", autospec=True)
     fake_crashinfo.fromRawCrashData.return_value.createShortSignature.return_value = (
         "test [@ test]"
     )
@@ -538,7 +209,7 @@ def test_fuzzmanager_reporter_03(mocker, tmp_path):
 
 def test_fuzzmanager_reporter_04(mocker, tmp_path):
     """test FuzzManagerReporter.submit() hit frequent crash"""
-    mocker.patch("grizzly.common.reporter.CrashInfo", autospec=True)
+    mocker.patch("grizzly.common.report.CrashInfo", autospec=True)
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     fake_collector.return_value.search.return_value = (
         None,
@@ -555,7 +226,7 @@ def test_fuzzmanager_reporter_04(mocker, tmp_path):
 
 def test_fuzzmanager_reporter_05(mocker, tmp_path):
     """test FuzzManagerReporter.submit() hit existing crash"""
-    mocker.patch("grizzly.common.reporter.CrashInfo", autospec=True)
+    mocker.patch("grizzly.common.report.CrashInfo", autospec=True)
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     fake_collector.return_value.search.return_value = (
         None,
diff --git a/grizzly/reduce/conftest.py b/grizzly/reduce/conftest.py
index 971caf05..2679facf 100644
--- a/grizzly/reduce/conftest.py
+++ b/grizzly/reduce/conftest.py
@@ -26,7 +26,7 @@ def reporter_sequential_strftime(mocker):
     """Make `strftime` in `FilesystemReporter` return sequential values.
     This ensures ever report gets a unique folder and won't overwrite another.
     """
-    prefix = mocker.patch("grizzly.common.reporter.strftime")
+    prefix = mocker.patch("grizzly.common.report.strftime")
 
     def report_prefix(_):
         return "%04d" % (prefix.call_count,)

From c4dab64f2a61e5fa7564a4cd2905cbb59a82c2ed Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 20 Sep 2021 14:58:24 -0700
Subject: [PATCH 315/531] Use sqlite database to store status data

---
 grizzly/common/status.py               | 297 ++++++++++++++-----------
 grizzly/common/status_reporter.py      | 106 +++------
 grizzly/common/test_status.py          | 130 ++++-------
 grizzly/common/test_status_reporter.py | 126 ++++-------
 grizzly/conftest.py                    |  14 ++
 grizzly/replay/conftest.py             |  30 +++
 grizzly/replay/replay.py               |   9 +-
 grizzly/replay/test_main.py            |   2 +
 grizzly/replay/test_replay.py          |  87 ++------
 grizzly/session.py                     |  10 +-
 grizzly/test_session.py                |  34 +--
 11 files changed, 380 insertions(+), 465 deletions(-)
 create mode 100644 grizzly/conftest.py
 create mode 100644 grizzly/replay/conftest.py

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 1e8353b8..13897a83 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -5,17 +5,12 @@
 """Manage Grizzly status reports."""
 from collections import namedtuple
 from contextlib import contextmanager
-from json import dump, load
+from json import dumps, loads
 from logging import getLogger
-from os import close, getpid, scandir, unlink
-from os.path import isdir, isfile
-from tempfile import mkstemp
+from os import getpid
+from sqlite3 import connect
 from time import time
 
-from fasteners.process_lock import InterProcessLock
-
-from .utils import grz_tmp
-
 __all__ = ("Status",)
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
@@ -27,33 +22,33 @@
 
 class Status:
     """Status holds status information for the Grizzly session.
-    There can be multiple readers (read-only) but only a single writer of data.
-    Read-only mode is implied if `data_file` is None.
+    Read-only mode is implied if `_db_file` is None.
 
     Attributes:
+        _db_file (str): Database file containing data. None in read-only mode.
         _enable_profiling (bool): Profiling support status.
-        _lock (InterProcessLock): Lock used with data_file.
         _profiles (dict): Profiling data.
         _results (dict): Results data. Used to count occurrences of results.
-        data_file (str): File to save data to. None in read-only mode.
         ignored (int): Ignored result count.
         iteration (int): Iteration count.
         log_size (int): Log size in bytes.
         pid (int): Python process ID.
         start_time (float): Start time of session.
         test_name (str): Current test name.
-        timestamp (float): Last time data was saved to data_file. Set by report().
+        timestamp (float): Last time data was saved to database.
     """
 
-    PATH = grz_tmp("status")
+    DB_VERSION = 1
+    # entries older than 'EXP_LIMIT' seconds will be removed.
+    EXP_LIMIT = 86400
+    # database will be updated no more than every 'REPORT_FREQ' seconds.
     REPORT_FREQ = 60
 
     __slots__ = (
+        "_db_file",
         "_enable_profiling",
-        "_lock",
         "_profiles",
         "_results",
-        "data_file",
         "ignored",
         "iteration",
         "log_size",
@@ -63,20 +58,19 @@ class Status:
         "timestamp",
     )
 
-    def __init__(self, data_file, enable_profiling=False, start_time=None):
-        if data_file is None:
+    def __init__(
+        self, db_file=None, enable_profiling=False, start_time=None, exp_limit=EXP_LIMIT
+    ):
+        if db_file is None:
             # read-only mode
             assert start_time is None
-            self._lock = None
             self._enable_profiling = False
         else:
-            assert data_file.endswith(".json")
             assert isinstance(start_time, float)
-            self._lock = InterProcessLock(self.lock_file(data_file))
             self._enable_profiling = enable_profiling
         self._profiles = dict()
         self._results = dict()
-        self.data_file = data_file
+        self._db_file = db_file
         self.ignored = 0
         self.iteration = 0
         self.log_size = 0
@@ -85,26 +79,44 @@ def __init__(self, data_file, enable_profiling=False, start_time=None):
         self.test_name = None
         self.timestamp = start_time
 
-    def cleanup(self):
-        """Remove data and lock files from disk.
-
-        Args:
-            None
-
-        Returns:
-            None
-        """
-        if self.data_file is not None:
+        # prepare database
+        if self._db_file:
+            LOG.debug("using status db %r", self._db_file)
+            con = connect(self._db_file)
             try:
-                with self._lock:
-                    unlink(self.data_file)
-            except OSError:  # pragma: no cover
-                LOG.warning("Failed to delete %r", self.data_file)
-            try:
-                unlink(self.lock_file(self.data_file))
-            except OSError:  # pragma: no cover
-                pass
-            self.data_file = None
+                cur = con.cursor()
+                # check db version
+                cur.execute("PRAGMA user_version;")
+                version = cur.fetchone()[0]
+                if version < self.DB_VERSION:
+                    LOG.debug("db version %d < %d", version, self.DB_VERSION)
+                    cur.execute("DROP TABLE IF EXISTS status;")
+                    cur.execute("PRAGMA user_version = %d;" % (self.DB_VERSION,))
+                    con.commit()
+                else:
+                    assert version == self.DB_VERSION
+                # create tables if needed
+                con.execute(
+                    """CREATE TABLE IF NOT EXISTS status (
+                       _profiles TEXT NOT NULL,
+                       _results TEXT NOT NULL,
+                       ignored INTEGER NOT NULL,
+                       iteration INTEGER NOT NULL,
+                       log_size INTEGER NOT NULL,
+                       pid INTEGER UNIQUE NOT NULL,
+                       start_time REAL NOT NULL,
+                       timestamp REAL NOT NULL);"""
+                )
+                con.commit()
+                # remove inactive status data
+                if exp_limit > 0:
+                    con.execute(
+                        """DELETE FROM status WHERE timestamp <= ?;""",
+                        (time() - exp_limit,),
+                    )
+                con.commit()
+            finally:
+                con.close()
 
     def count_result(self, uid, description):
         """Increment counter that matches `uid`.
@@ -127,89 +139,64 @@ def count_result(self, uid, description):
         self._results[uid]["count"] += 1
         return self._results[uid]["count"]
 
-    @property
-    def _data(self):
-        return {
-            "_profiles": self._profiles,
-            "_results": self._results,
-            "ignored": self.ignored,
-            "iteration": self.iteration,
-            "log_size": self.log_size,
-            "pid": self.pid,
-            "start_time": self.start_time,
-            "test_name": self.test_name,
-            "timestamp": self.timestamp,
-        }
-
-    @classmethod
-    def load(cls, data_file):
-        """Load status report from a file. This will create a read-only status report.
-
-        Args:
-            data_file (str): JSON file that contains status data.
-
-        Returns:
-            Status: Loaded status object (read-only) or None
-        """
-        assert data_file
-        status = cls(None)
-        data = None
-        try:
-            with InterProcessLock(cls.lock_file(data_file)):
-                with open(data_file, "r") as out_fp:
-                    data = load(out_fp)
-        except OSError:
-            LOG.debug("failed to open %r", data_file)
-            # if data_file exists the lock will be removed by the active session
-            if not isfile(data_file):
-                # attempt to remove potentially leaked lock file
-                try:
-                    unlink(cls.lock_file(data_file))
-                except OSError:  # pragma: no cover
-                    pass
-        except ValueError:
-            LOG.debug("failed to load json data from %r", data_file)
-        else:
-            LOG.debug("no such file %r", data_file)
-        if data is None:
-            return None
-        if "start_time" not in data:
-            LOG.debug("invalid status json file")
-            return None
-        for attr, value in data.items():
-            setattr(status, attr, value)
-        assert status.start_time <= status.timestamp
-        assert status.data_file is None
-        return status
-
     @classmethod
-    def loadall(cls, path):
-        """Load all status reports found in `path`.
+    def loadall(cls, db_file, time_limit=300):
+        """Load all status reports found in `db_file`.
 
         Args:
-            path (str): Path to scan for files containing status data.
+            db_file (str): Path to database containing status data.
+            time_limit (int): Only include entries with a timestamp that is within the
+                              given number of seconds.
 
         Yields:
             Status: Successfully loaded read-only status objects.
         """
-        if isdir(path):
-            for entry in scandir(path):
-                if entry.is_file() and entry.name.endswith(".json"):
-                    status = cls.load(entry.path)
-                    if status is not None:
-                        yield status
-
-    @staticmethod
-    def lock_file(data_file):
-        """Name of lock file to use with data_file.
-
-        Args:
-            data_file (str): Name of data file.
-
-        Returns:
-            str: Lock file name.
-        """
-        return "%s.lock" % (data_file,)
+        assert time_limit >= 0
+        con = connect(db_file)
+        try:
+            cur = con.cursor()
+            # check db version
+            cur.execute("PRAGMA user_version;")
+            assert cur.fetchone()[0] <= cls.DB_VERSION
+            # check table exists
+            cur.execute(
+                """SELECT name
+                           FROM sqlite_master
+                           WHERE type='table'
+                           AND name='status';"""
+            )
+            if cur.fetchone():
+                # collect entries
+                cur.execute(
+                    """SELECT pid,
+                             _profiles,
+                             _results,
+                             ignored,
+                             iteration,
+                             log_size,
+                             start_time,
+                             timestamp
+                       FROM status
+                       WHERE timestamp > ?;""",
+                    (time() - time_limit,),
+                )
+                entries = cur.fetchall()
+            else:
+                entries = ()
+        finally:
+            con.close()
+
+        for entry in entries:
+            status = cls()
+            status.pid = entry[0]
+            status._profiles = loads(entry[1])
+            status._results = loads(entry[2])
+            status.ignored = entry[3]
+            status.iteration = entry[4]
+            status.log_size = entry[5]
+            status.start_time = entry[6]
+            status.timestamp = entry[7]
+            yield status
 
     @contextmanager
     def measure(self, name):
@@ -290,7 +277,7 @@ def record(self, name, duration):
                 }
 
     def report(self, force=False, report_freq=REPORT_FREQ):
-        """Write status report to disk. Reports are only written periodically.
+        """Write status report to database. Reports are only written periodically.
         It is limited by `report_freq`. The specified number of seconds must
         elapse before another write will be performed unless `force` is True.
 
@@ -301,15 +288,66 @@ def report(self, force=False, report_freq=REPORT_FREQ):
         Returns:
             bool: Returns true if the report was successful otherwise false.
         """
-        assert self.data_file is not None
         now = time()
         if not force and now < (self.timestamp + report_freq):
             return False
+        assert self._db_file
         assert self.start_time <= now
         self.timestamp = now
-        with self._lock:
-            with open(self.data_file, "w") as out_fp:
-                dump(self._data, out_fp)
+
+        profiles = dumps(self._profiles)
+        results = dumps(self._results)
+        con = connect(self._db_file)
+        try:
+            cur = con.cursor()
+            cur.execute(
+                """UPDATE status
+                   SET _profiles = ?,
+                       _results = ?,
+                       ignored = ?,
+                       iteration = ?,
+                       log_size = ?,
+                       start_time = ?,
+                       timestamp = ?
+                   WHERE pid = ?;""",
+                (
+                    profiles,
+                    results,
+                    self.ignored,
+                    self.iteration,
+                    self.log_size,
+                    self.start_time,
+                    self.timestamp,
+                    self.pid,
+                ),
+            )
+            if cur.rowcount < 1:
+                cur.execute(
+                    """INSERT INTO status(
+                       pid,
+                       _profiles,
+                       _results,
+                       ignored,
+                       iteration,
+                       log_size,
+                       start_time,
+                       timestamp)
+                       VALUES (?, ?, ?, ?, ?, ?, ?, ?);""",
+                    (
+                        self.pid,
+                        profiles,
+                        results,
+                        self.ignored,
+                        self.iteration,
+                        self.log_size,
+                        self.start_time,
+                        self.timestamp,
+                    ),
+                )
+            con.commit()
+        finally:
+            con.close()
+
         return True
 
     @property
@@ -347,29 +385,26 @@ def runtime(self):
         Returns:
             int: Total runtime in seconds.
         """
-        if self.data_file is None:
+        if self._db_file is None:
             return self.timestamp - self.start_time
         return max(time() - self.start_time, 0)
 
     @classmethod
-    def start(cls, path=PATH, enable_profiling=False):
+    def start(cls, db_file, enable_profiling=False):
         """Create a unique Status object.
 
         Args:
-            path (str): Location to save files containing status data.
+            db_file (str): Path to database containing status data.
             enable_profiling (bool): Record profiling data.
 
         Returns:
             Status: Active status report.
         """
+        assert db_file
         pid = getpid()
-        tfd, filepath = mkstemp(
-            dir=path,
-            prefix="grzstatus_%d_" % (pid,),
-            suffix=".json",
+        status = cls(
+            db_file=db_file, enable_profiling=enable_profiling, start_time=time()
         )
-        close(tfd)
-        status = cls(filepath, enable_profiling=enable_profiling, start_time=time())
         status.pid = pid
         status.report(force=True)
         return status
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 37291446..67e718da 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -15,13 +15,14 @@
 except ImportError:  # pragma: no cover
     # os.getloadavg() is not available on all platforms
     getloadavg = None
-from os import SEEK_CUR, getenv, remove, scandir
+from os import SEEK_CUR, getenv, scandir
 from os.path import isdir
 from re import match
-from time import gmtime, strftime, time
+from time import gmtime, strftime
 
 from psutil import cpu_count, cpu_percent, disk_usage, virtual_memory
 
+from ..session import Session
 from .status import Status
 
 __all__ = ("StatusReporter",)
@@ -36,46 +37,14 @@ class StatusReporter:
 
     CPU_POLL_INTERVAL = 1
     DISPLAY_LIMIT_LOG = 10  # don't include log results unless size exceeds 10MBs
-    EXP_LIMIT = 600  # expiration limit, ignore older reports
     READ_BUF_SIZE = 0x10000  # 64KB
     SUMMARY_LIMIT = 4095  # summary output must be no more than 4KB
+    TIME_LIMIT = 600  # ignore older reports
 
     def __init__(self, reports, tracebacks=None):
-        assert all(x.data_file is None for x in reports)
         self.reports = reports
         self.tracebacks = tracebacks
 
-    @staticmethod
-    def delete_expired(path, exp_limit=EXP_LIMIT):
-        """Remove expired reports from the filesystem.
-
-        Args:
-            path (str): Path to scan for status report files.
-            exp_limit (int): Age limit of report in seconds before it is considered
-                             expired.
-
-        Returns:
-            None
-        """
-        exp = int(time()) - exp_limit
-        expired = 0
-        for entry in scandir(path):
-            if entry.name.endswith(".json") and entry.is_file():
-                report = Status.load(entry.path)
-                if report and report.timestamp <= exp:
-                    # remove lock file
-                    try:
-                        remove(Status.lock_file(entry.path))
-                    except OSError:  # pragma: no cover
-                        pass
-                    # remove data file
-                    try:
-                        remove(entry.path)
-                        expired += 1
-                    except OSError:  # pragma: no cover
-                        pass
-        print("%d expired report(s) removed" % (expired,))
-
     def dump_specific(self, filename):
         """Write out merged reports.
 
@@ -110,18 +79,23 @@ def has_results(self):
         return any(x.results for x in self.reports)
 
     @classmethod
-    def load(cls, path, tb_path=None):
+    def load(cls, db_file, tb_path=None, time_limit=TIME_LIMIT):
         """Read Grizzly status reports and create a StatusReporter object.
 
         Args:
             path (str): Path to scan for status data files.
             tb_path (str): Directory to scan for files containing Python tracebacks.
+            time_limit (int): Only include entries with a timestamp that is within the
+                              given number of seconds.
 
         Returns:
             StatusReporter: Contains available status reports and traceback reports.
         """
         tracebacks = None if tb_path is None else cls._tracebacks(tb_path)
-        return cls(list(Status.loadall(path)), tracebacks=tracebacks)
+        return cls(
+            list(Status.loadall(db_file=db_file, time_limit=time_limit)),
+            tracebacks=tracebacks,
+        )
 
     def print_results(self):
         print(self._results())
@@ -135,15 +109,12 @@ def print_summary(self, runtime=True, sysinfo=False, timestamp=False):
     def _results(self, max_len=85):
         descs = dict()
         counts = defaultdict(int)
-        exp = int(time()) - self.EXP_LIMIT
         # calculate totals
         for report in self.reports:
-            # filter expired reports
-            if report.timestamp > exp:
-                # count results in report
-                for uid, result in report.result_entries():
-                    descs[uid] = result["desc"]
-                    counts[uid] += result["count"]
+            # count results in report
+            for uid, result in report.result_entries():
+                descs[uid] = result["desc"]
+                counts[uid] += result["count"]
         # generate output
         txt = list()
         for uid, count in sorted(counts.items(), key=lambda x: x[1], reverse=True):
@@ -176,15 +147,10 @@ def _specific(self):
         """
         if not self.reports:
             return "No status reports available"
-        exp = int(time()) - self.EXP_LIMIT
         self.reports.sort(key=lambda x: x.runtime, reverse=True)
-        self.reports.sort(key=lambda x: x.timestamp < exp)
         txt = list()
         for num, report in enumerate(self.reports, start=1):
             txt.append("#%02d - %d -" % (num, report.pid))
-            if report.timestamp < exp:
-                txt.append(" (EXPIRED)\n")
-                continue
             txt.append(" Runtime %s\n" % (timedelta(seconds=int(report.runtime)),))
             txt.append(" * Iterations: %d" % (report.iteration,))
             txt.append(" @ %0.2f," % (round(report.rate, 2),))
@@ -224,16 +190,14 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
         """
         txt = list()
         # Job specific status
-        exp = int(time()) - self.EXP_LIMIT
-        reports = tuple(x for x in self.reports if x.timestamp > exp)
-        if reports:
+        if self.reports:
             # calculate totals
-            iterations = tuple(x.iteration for x in reports)
-            log_sizes = tuple(x.log_size for x in reports)
-            rates = tuple(x.rate for x in reports)
-            results = tuple(x.results for x in reports)
-            count = len(reports)
-            total_ignored = sum(x.ignored for x in reports)
+            iterations = tuple(x.iteration for x in self.reports)
+            log_sizes = tuple(x.log_size for x in self.reports)
+            rates = tuple(x.rate for x in self.reports)
+            results = tuple(x.results for x in self.reports)
+            count = len(self.reports)
+            total_ignored = sum(x.ignored for x in self.reports)
             total_iters = sum(iterations)
             # Iterations
             txt.append("Iterations : %d" % (total_iters,))
@@ -257,7 +221,7 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
             # Runtime
             if runtime:
                 txt.append("\n")
-                total_runtime = sum(x.runtime for x in reports)
+                total_runtime = sum(x.runtime for x in self.reports)
                 txt.append("   Runtime : %s" % (timedelta(seconds=int(total_runtime)),))
             # Log size
             log_usage = sum(log_sizes) / 1_048_576.0
@@ -464,7 +428,7 @@ def __str__(self):
         return "\n".join(["Log: %r" % self.file_name] + self.prev_lines + self.lines)
 
 
-def main(args=None):
+def main(args=None, modes=None):
     """Merge Grizzly status files into a single report (main entrypoint).
 
     Args:
@@ -481,19 +445,14 @@ def main(args=None):
         log_fmt = "[%(asctime)s] %(message)s"
     basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
 
-    modes = ("status", "cleanup")
+    if not modes:
+        modes = {"fuzz": Session.STATUS_DB}
     parser = ArgumentParser(description="Grizzly status report generator")
     parser.add_argument("--dump", help="File to write report to")
     parser.add_argument(
         "--mode",
-        default="status",
-        help="Report mode. Available modes: %s (default: 'status')"
-        % (", ".join(modes),),
-    )
-    parser.add_argument(
-        "--reports",
-        default=Status.PATH,
-        help="Scan path for status report json files (default: %(default)s)",
+        default="fuzz",
+        help="Report mode. Available modes: %s (default: 'fuzz')" % (", ".join(modes),),
     )
     parser.add_argument(
         "--system-report",
@@ -510,15 +469,12 @@ def main(args=None):
     if args.tracebacks and not isdir(args.tracebacks):
         parser.error("--tracebacks must be a directory")
 
-    if args.mode == "cleanup":
-        print("Removing expired reports from disk...")
-        StatusReporter.delete_expired(args.reports)
-        return 0
-
-    reporter = StatusReporter.load(args.reports, tb_path=args.tracebacks)
+    status_db = modes.get(args.mode)
+    reporter = StatusReporter.load(db_file=status_db, tb_path=args.tracebacks)
     if args.dump:
         reporter.dump_summary(args.dump)
         return 0
+
     if not reporter.reports:
         print("Grizzly Status - No status reports to display")
         return 0
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index b1bdc843..a1bb8207 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -6,8 +6,6 @@
 # pylint: disable=protected-access
 
 from multiprocessing import Event, Process
-from os import remove, stat
-from os.path import isfile
 from time import sleep, time
 
 from .status import Status
@@ -16,11 +14,9 @@
 def test_status_01(mocker, tmp_path):
     """test Status.start()"""
     mocker.patch("grizzly.common.status.time", return_value=1.0)
-    status = Status.start(path=str(tmp_path))
+    status = Status.start(db_file=str(tmp_path / "status.db"))
     assert status is not None
-    assert status.data_file is not None
-    assert isfile(status.data_file)
-    assert stat(status.data_file).st_size > 0
+    assert status._db_file is not None
     assert status.start_time > 0
     assert status.timestamp >= status.start_time
     assert status.ignored == 0
@@ -35,23 +31,8 @@ def test_status_01(mocker, tmp_path):
 
 
 def test_status_02(tmp_path):
-    """test Status.cleanup()"""
-    status = Status.start(path=str(tmp_path))
-    dfile = status.data_file
-    status.cleanup()
-    assert status.data_file is None
-    assert not isfile(dfile)
-    # call 2nd time
-    status.cleanup()
-    # missing data file
-    status = Status.start(path=str(tmp_path))
-    remove(status.data_file)
-    status.cleanup()
-
-
-def test_status_03(tmp_path):
     """test Status.report()"""
-    status = Status.start(path=str(tmp_path))
+    status = Status.start(db_file=str(tmp_path / "status.db"))
     status.count_result("uid1", "sig1")
     # try to report before REPORT_FREQ elapses
     assert not status.report()
@@ -64,33 +45,19 @@ def test_status_03(tmp_path):
     status.timestamp = future
     assert status.report(force=True)
     assert status.timestamp < future
-    status.cleanup()
-
-
-def test_status_04(tmp_path):
-    """test Status.load() failure paths"""
-    # load no db
-    assert Status.load(str(tmp_path / "missing.json")) is None
-    # load empty
-    bad = tmp_path / "bad.json"
-    bad.touch()
-    assert Status.load(str(bad)) is None
-    # load invalid/incomplete json
-    bad.write_bytes(b"{}")
-    assert Status.load(str(bad)) is None
 
 
-def test_status_05(mocker, tmp_path):
+def test_status_03(mocker, tmp_path):
     """test Status.load()"""
     mocker.patch("grizzly.common.status.time", return_value=1.0)
+    db_file = str(tmp_path / "status.db")
     # create simple entry
-    status = Status.start(path=str(tmp_path), enable_profiling=True)
+    status = Status.start(db_file=db_file, enable_profiling=True)
     status.count_result("uid1", "sig1")
     status.record("test", 123.45)
     status.report(force=True)
     assert status.results == 1
-    loaded = Status.load(status.data_file)
-    assert loaded.data_file is None
+    loaded = next(Status.loadall(db_file=db_file))
     assert status.start_time == loaded.start_time
     assert status.timestamp == loaded.timestamp
     assert status.runtime == loaded.runtime
@@ -101,33 +68,36 @@ def test_status_05(mocker, tmp_path):
     assert status.results == loaded.results
     assert not loaded._enable_profiling
     assert "test" in loaded._profiles
-    loaded.cleanup()
-    assert isfile(status.data_file)
-    data_file = status.data_file
-    status.cleanup()
-    assert not isfile(data_file)
 
 
-def test_status_06(tmp_path):
+def test_status_04(mocker, tmp_path):
     """test Status.loadall()"""
-    # missing path
-    assert not any(Status.loadall("missing"))
-    # no status data
-    assert not any(Status.loadall(str(tmp_path)))
-    # add more entries
-    for _ in range(5):
-        Status.start(path=str(tmp_path))
-    (tmp_path / "empty.json").touch()
-    assert len(tuple(Status.loadall(str(tmp_path)))) == 5
+    getpid = mocker.patch("grizzly.common.status.getpid")
+    db_file = str(tmp_path / "status.db")
+    for pid in range(5):
+        getpid.return_value = pid
+        Status.start(db_file=db_file)
+    assert len(tuple(Status.loadall(db_file=db_file))) == 5
 
 
-def test_status_07(mocker, tmp_path):
+def test_status_05(mocker, tmp_path):
     """test Status.runtime and Status.rate calculations"""
     mocker.patch(
-        "grizzly.common.status.time", side_effect=(1.0, 1.0, 3.0, 3.0, 5.0, 5.0, 5.0)
+        "grizzly.common.status.time",
+        side_effect=(
+            1.0,
+            1.0,
+            3.0,
+            3.0,
+            5.0,
+            5.0,
+            5.0,
+            5.0,
+            5.0,
+        ),
     )
-    status = Status.start(path=str(tmp_path))
-    assert status.data_file is not None
+    db_file = str(tmp_path / "status.db")
+    status = Status.start(db_file=db_file)
     assert status.start_time == 1
     # test no iterations
     assert status.runtime == 2.0
@@ -140,7 +110,7 @@ def test_status_07(mocker, tmp_path):
     assert status.rate == 0.25
     # test loaded
     status.report(force=True)
-    loaded = Status.load(status.data_file)
+    loaded = next(Status.loadall(db_file=db_file))
     assert loaded.runtime == 4.0
     assert loaded.rate == 0.25
     # timestamp should be used when calculating rate and runtime on loaded object
@@ -149,42 +119,38 @@ def test_status_07(mocker, tmp_path):
     assert loaded.rate == 1.0
 
 
-def _client_writer(done, reported, working_path):
+def _client_writer(done, reported, db_file):
     """Used by test_status_08"""
     # NOTE: this must be at the top level to work on Windows
-    status = Status.start(path=working_path)
-    try:
-        while not done.is_set():
-            status.iteration += 1
-            status.report(force=True)
-            # perform two reports before setting flag
-            if not reported.is_set() and status.iteration > 1:
-                reported.set()
-            sleep(0.01)
-    finally:
-        status.cleanup()
+    status = Status.start(db_file=db_file)
+    while not done.is_set():
+        status.iteration += 1
+        status.report(force=True)
+        # perform two reports before setting flag
+        if not reported.is_set() and status.iteration > 1:
+            reported.set()
+        sleep(0.01)
 
 
 def test_status_08(tmp_path):
     """test Status.loadall() with multiple active reporters"""
+    db_file = str(tmp_path / "status.db")
     done = Event()
     procs = list()
     report_events = list()
     try:
         # launch processes
-        for _ in range(5):
+        for _ in range(10):
             report_events.append(Event())
             procs.append(
-                Process(
-                    target=_client_writer, args=(done, report_events[-1], str(tmp_path))
-                )
+                Process(target=_client_writer, args=(done, report_events[-1], db_file))
             )
             procs[-1].start()
         # wait for processes to launch and report
         for has_reported in report_events:
             assert has_reported.wait(timeout=60)
         # collect reports
-        reports = tuple(Status.loadall(str(tmp_path)))
+        reports = tuple(Status.loadall(db_file))
         assert len(reports) == len(procs)
         assert max(x.rate for x in reports) > 0
     finally:
@@ -192,13 +158,11 @@ def test_status_08(tmp_path):
         for proc in procs:
             if proc.pid is not None:
                 proc.join()
-    # verify cleanup
-    assert not any(Status.loadall(str(tmp_path)))
 
 
 def test_status_09(tmp_path):
     """test Status.count_result() and Status.result_entries()"""
-    status = Status.start(path=str(tmp_path))
+    status = Status.start(db_file=str(tmp_path / "status.db"))
     assert status.count_result("uid1", "sig1") == 1
     assert status.count_result("uid2", "sig2") == 1
     assert status.count_result("uid1", "sig1") == 2
@@ -217,16 +181,16 @@ def test_status_09(tmp_path):
 
 def test_status_10(tmp_path):
     """test Status.measure() and Status.record() - profiling support"""
+    db_file = str(tmp_path / "status.db")
     # profiling disabled
-    status = Status.start(path=str(tmp_path), enable_profiling=False)
+    status = Status.start(db_file=db_file, enable_profiling=False)
     status.record("x", 10.1)
     assert not status._profiles
     with status.measure("x"):
         pass
     assert not status._profiles
-    status.cleanup()
     # profiling enabled
-    status = Status.start(path=str(tmp_path), enable_profiling=True)
+    status = Status.start(db_file=db_file, enable_profiling=True)
     assert not status._profiles
     # initial entry
     status.record("test1", 10.1)
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 4a008a65..72b50462 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -6,7 +6,6 @@
 # pylint: disable=protected-access
 
 from itertools import count
-from os.path import isfile
 from re import match
 from unittest.mock import Mock
 
@@ -45,10 +44,10 @@ def test_status_reporter_01(tmp_path):
 def test_status_reporter_02(tmp_path):
     """test StatusReporter.load()"""
     # missing reports path
-    st_rpt = StatusReporter.load(str(tmp_path / "missing"))
+    st_rpt = StatusReporter.load(str(tmp_path / "status.db"))
     assert not st_rpt.reports
     # empty reports and tb paths
-    st_rpt = StatusReporter.load(str(tmp_path), tb_path=str(tmp_path))
+    st_rpt = StatusReporter.load(str(tmp_path / "status.db"), tb_path=str(tmp_path))
     assert isinstance(st_rpt.reports, list)
     assert not st_rpt.reports
     assert isinstance(st_rpt.tracebacks, list)
@@ -127,15 +126,16 @@ def test_status_reporter_04(tmp_path):
 
 def test_status_reporter_05(mocker, tmp_path):
     """test StatusReporter._summary()"""
+    mocker.patch("grizzly.common.status.getpid", side_effect=(1, 2))
     mocker.patch("grizzly.common.status.time", side_effect=count(start=1.0, step=1.0))
-    mocker.patch("grizzly.common.status_reporter.time", side_effect=(1.0, 2.0))
+    db_file = str(tmp_path / "status.db")
     # single report
-    status = Status.start(path=str(tmp_path))
+    status = Status.start(db_file=db_file)
     status.ignored = 0
     status.iteration = 1
     status.log_size = 0
     status.report(force=True)
-    rptr = StatusReporter.load(str(tmp_path))
+    rptr = StatusReporter.load(db_file)
     rptr._sys_info = _fake_sys_info
     assert rptr.reports is not None
     assert len(rptr.reports) == 1
@@ -149,12 +149,12 @@ def test_status_reporter_05(mocker, tmp_path):
     assert "Timestamp" not in output
     assert len(output.split("\n")) == 3
     # multiple reports
-    status = Status.start(path=str(tmp_path))
+    status = Status.start(db_file=db_file)
     status.ignored = 1
     status.iteration = 8
     status.log_size = 86900000
     status.report(force=True)
-    rptr = StatusReporter.load(str(tmp_path))
+    rptr = StatusReporter.load(db_file)
     rptr._sys_info = _fake_sys_info
     assert len(rptr.reports) == 2
     output = rptr._summary(sysinfo=True, timestamp=True)
@@ -175,29 +175,23 @@ def test_status_reporter_05(mocker, tmp_path):
 
 def test_status_reporter_06(mocker, tmp_path):
     """test StatusReporter._specific()"""
-    mocker.patch("grizzly.common.status_reporter.time", return_value=3661.0)
+    mocker.patch("grizzly.common.status.getpid", side_effect=(1, 2))
+    db_file = str(tmp_path / "status.db")
     # single report
-    mocker.patch(
-        "grizzly.common.status.time", side_effect=count(start=0.0, step=3600.0)
-    )
-    status = Status.start(path=str(tmp_path))
+    status = Status.start(db_file=db_file)
     status.ignored = 0
     status.iteration = 1
     status.log_size = 0
     status.report(force=True)
-    rptr = StatusReporter.load(str(tmp_path))
+    rptr = StatusReporter.load(db_file)
     assert rptr.reports is not None
     output = rptr._specific()
     assert len(output.split("\n")[:-1]) == 2
     assert "Ignored" in output
     assert "Iteration" in output
     assert "Results" in output
-    assert "EXPIRED" not in output
     # multiple reports
-    mocker.patch(
-        "grizzly.common.status.time", side_effect=count(start=0.0, step=3661.0)
-    )
-    status = Status.start(path=str(tmp_path), enable_profiling=True)
+    status = Status.start(db_file=db_file, enable_profiling=True)
     status.ignored = 1
     status.iteration = 432422
     status.count_result("uid1", "sig1")
@@ -206,7 +200,7 @@ def test_status_reporter_06(mocker, tmp_path):
     status.record("test1", 1.23456)
     status.record("test2", 1201.1)
     status.report(force=True)
-    rptr = StatusReporter.load(str(tmp_path))
+    rptr = StatusReporter.load(db_file)
     assert len(rptr.reports) == 2
     output = rptr._specific()
     assert len(output.split("\n")[:-1]) == 7
@@ -216,46 +210,36 @@ def test_status_reporter_06(mocker, tmp_path):
     assert "Profiling entries" in output
     assert "> test1:" in output
     assert "> test2:" in output
-    assert "EXPIRED" not in output
-    # expired report
-    mocker.patch("grizzly.common.status.time", return_value=1.0)
-    status = Status.start(path=str(tmp_path))
-    status.ignored = 1
-    status.iteration = 1
-    status.report(force=True)
-    rptr = StatusReporter.load(str(tmp_path))
-    assert len(rptr.reports) == 3
-    output = rptr._specific()
-    assert len(output.split("\n")[:-1]) == 8
-    assert "EXPIRED" in output
 
 
-def test_status_reporter_07(tmp_path):
+def test_status_reporter_07(mocker, tmp_path):
     """test StatusReporter._results()"""
+    mocker.patch("grizzly.common.status.getpid", side_effect=(1, 2, 3))
+    db_file = str(tmp_path / "status.db")
     # single report without results
-    status = Status.start(path=str(tmp_path))
+    status = Status.start(db_file=db_file)
     status.ignored = 0
     status.iteration = 1
     status.log_size = 0
     status.report(force=True)
-    rptr = StatusReporter.load(str(tmp_path))
+    rptr = StatusReporter.load(db_file)
     assert rptr.reports is not None
     assert len(rptr.reports) == 1
     assert not rptr.has_results
     assert rptr._results() == "No results available\n"
     # multiple reports with results
-    status = Status.start(path=str(tmp_path))
+    status = Status.start(db_file=db_file)
     status.iteration = 1
     status.count_result("uid1", "[@ test1]")
     status.count_result("uid2", "[@ test2]")
     status.count_result("uid1", "[@ test1]")
     status.report(force=True)
-    status = Status.start(path=str(tmp_path))
+    status = Status.start(db_file=db_file)
     status.iteration = 1
     status.count_result("uid1", "[@ test1]")
     status.count_result("uid3", "[@ longsignature123]")
     status.report(force=True)
-    rptr = StatusReporter.load(str(tmp_path))
+    rptr = StatusReporter.load(db_file)
     assert rptr.has_results
     assert len(rptr.reports) == 3
     output = rptr._results(max_len=16)
@@ -267,9 +251,8 @@ def test_status_reporter_07(tmp_path):
 
 def test_status_reporter_08(tmp_path):
     """test StatusReporter.load() with traceback"""
-    status_path = tmp_path / "status"
-    status_path.mkdir()
-    status = Status.start(path=str(status_path))
+    db_file = str(tmp_path / "status.db")
+    status = Status.start(db_file=db_file)
     status.ignored = 0
     status.iteration = 1
     status.log_size = 0
@@ -281,21 +264,21 @@ def test_status_reporter_08(tmp_path):
         test_fp.write(b"Traceback (most recent call last):\n")
         test_fp.write(b"  blah\n")
         test_fp.write(b"IndexError: list index out of range\n")
-    rptr = StatusReporter.load(str(status_path), tb_path=str(tmp_path))
+    rptr = StatusReporter.load(db_file, tb_path=str(tmp_path))
     assert len(rptr.tracebacks) == 1
     # create second screenlog
     with (tmp_path / "screenlog.1234").open("wb") as test_fp:
         test_fp.write(b"Traceback (most recent call last):\n")
         test_fp.write(b"  blah\n")
         test_fp.write(b"foo.bar.error: blah\n")
-    rptr = StatusReporter.load(str(status_path), tb_path=str(tmp_path))
+    rptr = StatusReporter.load(db_file, tb_path=str(tmp_path))
     assert len(rptr.tracebacks) == 2
     # create third screenlog
     with (tmp_path / "screenlog.3").open("wb") as test_fp:
         test_fp.write(b"Traceback (most recent call last):\n")
         test_fp.write(b"  blah\n")
         test_fp.write(b"KeyboardInterrupt\n")
-    rptr = StatusReporter.load(str(status_path), tb_path=str(tmp_path))
+    rptr = StatusReporter.load(db_file, tb_path=str(tmp_path))
     assert len(rptr.tracebacks) == 2
     merged_log = rptr._summary()
     assert len(merged_log.splitlines()) == 14
@@ -313,7 +296,7 @@ def test_status_reporter_09(tmp_path):
         test_fp.write(b"Traceback (most recent call last):\n")
         test_fp.write(b"  blah\n")
         test_fp.write(b"IndexError: list index out of range\n")
-    rptr = StatusReporter.load(str(tmp_path), tb_path=str(tmp_path))
+    rptr = StatusReporter.load(str(tmp_path / "status.db"), tb_path=str(tmp_path))
     rptr._sys_info = _fake_sys_info
     assert len(rptr.tracebacks) == 1
     output = rptr._summary()
@@ -322,19 +305,19 @@ def test_status_reporter_09(tmp_path):
     assert "IndexError" in output
 
 
-def test_status_reporter_10(tmp_path):
+def test_status_reporter_10(mocker, tmp_path):
     """test StatusReporter.summary() limit with traceback"""
-    status_path = tmp_path / "status"
-    status_path.mkdir()
+    mocker.patch("grizzly.common.status.getpid", side_effect=(1, 2))
+    db_file = str(tmp_path / "status.db")
     # create reports
-    status = Status.start(path=str(status_path))
+    status = Status.start(db_file=db_file)
     status.ignored = 100
     status.iteration = 1000
     status.log_size = 9999999999
     status.count_result("uid1", "[@ sig1]")
     status._results["uid1"]["count"] = 123
     status.report(force=True)
-    status = Status.start(path=str(status_path))
+    status = Status.start(db_file=db_file)
     status.ignored = 9
     status.iteration = 192938
     status.log_size = 0
@@ -351,29 +334,13 @@ def test_status_reporter_10(tmp_path):
                 )
                 test_fp.write(b"    some_long_name_for_a_func_%04d()\n" % (j,))
             test_fp.write(b"IndexError: list index out of range\n")
-    rptr = StatusReporter.load(str(status_path), tb_path=str(tmp_path))
+    rptr = StatusReporter.load(db_file, tb_path=str(tmp_path))
     rptr._sys_info = _fake_sys_info
     assert len(rptr.tracebacks) == 10
     merged_log = rptr._summary(runtime=True, sysinfo=True, timestamp=True)
     assert len(merged_log) < StatusReporter.SUMMARY_LIMIT
 
 
-def test_status_reporter_11(mocker, tmp_path):
-    """test StatusReporter.delete_expired()"""
-    # test not expired
-    mocker.patch("grizzly.common.status.time", return_value=1.0)
-    mocker.patch("grizzly.common.status_reporter.time", return_value=1.0)
-    status = Status.start(path=str(tmp_path))
-    status.report(force=True)
-    StatusReporter.delete_expired(str(tmp_path))
-    assert isfile(status.data_file)
-    # test expired
-    mocker.patch("grizzly.common.status_reporter.time", return_value=2.0)
-    status.report(force=True)
-    StatusReporter.delete_expired(str(tmp_path), exp_limit=1)
-    assert not isfile(status.data_file)
-
-
 def test_traceback_report_01():
     """test simple TracebackReport"""
     tbr = TracebackReport("log.txt", ["0", "1", "2"], prev_lines=["-2", "-1"])
@@ -547,41 +514,40 @@ def test_traceback_report_08(tmp_path):
 
 def test_main_01(tmp_path):
     """test main() with no reports"""
+    db_file = str(tmp_path / "status.db")
     StatusReporter.CPU_POLL_INTERVAL = 0.01
-    assert main(["--reports", str(tmp_path)]) == 0
+    assert main([], modes={"fuzz": db_file}) == 0
 
 
 def test_main_02(tmp_path):
     """test main() with a report"""
+    db_file = str(tmp_path / "status.db")
     StatusReporter.CPU_POLL_INTERVAL = 0.01
-    status = Status.start(path=str(tmp_path))
+    status = Status.start(db_file=db_file)
     status.iteration = 1
     status.count_result("uid", "[@ test]")
     status.report(force=True)
-    assert main(["--reports", str(tmp_path)]) == 0
+    assert main([], modes={"fuzz": db_file}) == 0
 
 
 def test_main_03(tmp_path):
     """test main() --dump"""
+    db_file = str(tmp_path / "status.db")
     StatusReporter.CPU_POLL_INTERVAL = 0.01
-    status = Status.start(path=str(tmp_path))
+    status = Status.start(db_file=db_file)
     status.iteration = 1
     status.report(force=True)
     dump_file = tmp_path / "output.txt"
-    assert main(["--dump", str(dump_file), "--reports", str(tmp_path)]) == 0
+    assert main(["--dump", str(dump_file)], modes={"fuzz": db_file}) == 0
     assert dump_file.is_file()
     assert b"Runtime" not in dump_file.read_bytes()
     # assert False, dump_file.read_bytes()
 
 
-def test_main_04():
+def test_main_04(tmp_path):
     """test main() with invalid args"""
+    db_file = str(tmp_path / "status.db")
     with raises(SystemExit):
-        main(["--mode", "invalid"])
+        main(["--mode", "invalid"], modes={"fuzz": db_file})
     with raises(SystemExit):
-        main(["--tracebacks", "missing"])
-
-
-def test_main_05(tmp_path):
-    """test main() cleanup mode"""
-    assert main(["--mode", "cleanup", "--reports", str(tmp_path)]) == 0
+        main(["--tracebacks", "missing"], modes={"fuzz": db_file})
diff --git a/grizzly/conftest.py b/grizzly/conftest.py
new file mode 100644
index 00000000..9eca8c5c
--- /dev/null
+++ b/grizzly/conftest.py
@@ -0,0 +1,14 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Common unit test fixtures for `grizzly`.
+"""
+
+from pytest import fixture
+
+
+@fixture
+def tmp_path_status_db(tmp_path, mocker):
+    """Use a temporary database file for testing."""
+    mocker.patch("grizzly.session.Session.STATUS_DB", new=str(tmp_path / "tmp.db"))
diff --git a/grizzly/replay/conftest.py b/grizzly/replay/conftest.py
new file mode 100644
index 00000000..0abd719b
--- /dev/null
+++ b/grizzly/replay/conftest.py
@@ -0,0 +1,30 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Common unit test fixtures for `grizzly.replay`.
+"""
+
+from pathlib import Path
+
+from pytest import fixture
+
+
+@fixture
+def tmp_path_grz_tmp(tmp_path, mocker):
+    """Provide an alternate working directory for testing."""
+
+    def _grz_tmp(*subdir):
+        path = Path(tmp_path, "grizzly", *subdir)
+        path.mkdir(parents=True, exist_ok=True)
+        return str(path)
+
+    mocker.patch("grizzly.replay.replay.grz_tmp", _grz_tmp)
+
+
+@fixture
+def tmp_path_status_db(tmp_path, mocker):
+    """Use a temporary database file for testing."""
+    mocker.patch(
+        "grizzly.replay.replay.ReplayManager.STATUS_DB", new=str(tmp_path / "tmp.db")
+    )
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 3083243e..9651209f 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -41,6 +41,7 @@ def __init__(self, report, served, durations, expected):
 class ReplayManager:
     HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
     DEFAULT_TIME_LIMIT = 30
+    STATUS_DB = pathjoin(grz_tmp(), "replay-status.db")
 
     __slots__ = (
         "ignore",
@@ -107,8 +108,7 @@ def cleanup(self):
         Returns:
             None
         """
-        if self.status is not None:
-            self.status.cleanup()
+        # TODO: Do we need this anymore?
 
     @staticmethod
     def expect_hang(ignore, signature, tests):
@@ -253,10 +253,7 @@ def run(
         assert self._harness is not None or len(testcases) == 1
         assert not expect_hang or self._signature is not None
 
-        if self.status is not None:
-            LOG.debug("clearing previous status data")
-            self.status.cleanup()
-        self.status = Status.start()
+        self.status = Status.start(db_file=self.STATUS_DB)
 
         server_map = ServerMap()
         if self._harness is not None:
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index ebc4e418..3bd98431 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -22,6 +22,8 @@
 from .replay import ReplayManager
 from .test_replay import _fake_save_logs
 
+pytestmark = mark.usefixtures("tmp_path_grz_tmp", "tmp_path_status_db")
+
 
 def test_main_01(mocker, tmp_path):
     """test ReplayManager.main()"""
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 28d8f551..807c1289 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -14,11 +14,12 @@
 from sapphire import Sapphire, Served
 
 from ..common.reporter import Report
-from ..common.status import Status
 from ..common.storage import TestCase, TestCaseLoadFailure
 from ..target import AssetManager, Result, Target
 from .replay import ReplayManager, ReplayResult
 
+pytestmark = mark.usefixtures("tmp_path_grz_tmp", "tmp_path_status_db")
+
 
 def _fake_save_logs(result_logs, _meta=False):
     """write fake log data to disk"""
@@ -34,21 +35,7 @@ def _fake_save_logs(result_logs, _meta=False):
 
 
 def test_replay_01(mocker):
-    """test ReplayManager.cleanup()"""
-    replay = ReplayManager(
-        [],
-        mocker.Mock(spec_set=Sapphire),
-        mocker.Mock(spec_set=Target),
-        [mocker.Mock()],
-    )
-    replay.status = mocker.Mock(spec_set=Status)
-    replay.cleanup()
-    assert replay.status.cleanup.call_count == 1
-
-
-def test_replay_02(mocker, tmp_path):
     """test ReplayManager.run() - no repro"""
-    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
@@ -65,10 +52,9 @@ def test_replay_02(mocker, tmp_path):
             assert target.close.call_count == 2
             assert target.close.mock_calls[0] == mocker.call()
             assert target.close.mock_calls[1] == mocker.call(force_close=True)
-        assert not any(tmp_path.iterdir())
 
 
-def test_replay_03(mocker):
+def test_replay_02(mocker):
     """test ReplayManager.run() - no repro - with repeats"""
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["index.html"])
@@ -89,7 +75,7 @@ def test_replay_03(mocker):
             assert target.close.call_count == 2
 
 
-def test_replay_04(mocker):
+def test_replay_03(mocker):
     """test ReplayManager.run() - exit - skip shutdown in runner"""
     # this will make runner appear to have just relaunched the target
     # and skip the expected shutdown
@@ -115,9 +101,8 @@ def test_replay_04(mocker):
             assert target.close.call_count == 1
 
 
-def test_replay_05(mocker, tmp_path):
+def test_replay_04(mocker):
     """test ReplayManager.run() - successful repro"""
-    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     served = ["index.html"]
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, served)
@@ -144,12 +129,10 @@ def test_replay_05(mocker, tmp_path):
         assert results[0].served[0] == served
         assert len(results[0].durations) == 1
         results[0].report.cleanup()
-        assert not any(tmp_path.iterdir())
 
 
-def test_replay_06(mocker, tmp_path):
+def test_replay_05(mocker):
     """test ReplayManager.run() - error - landing page not requested"""
-    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(spec_set=Target, binary="bin", closed=True, launch_timeout=30)
     testcases = [
@@ -182,10 +165,9 @@ def test_replay_06(mocker, tmp_path):
     assert not results[0].expected
 
 
-def test_replay_07(mocker, tmp_path):
+def test_replay_06(mocker):
     """test ReplayManager.run()
     delayed failure - following test landing page not requested"""
-    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     target = mocker.Mock(spec_set=Target, binary="bin", launch_timeout=30)
     type(target).closed = mocker.PropertyMock(side_effect=(True, False, True))
@@ -208,9 +190,8 @@ def test_replay_07(mocker, tmp_path):
         assert target.close.call_count == 2
 
 
-def test_replay_08(mocker, tmp_path):
+def test_replay_07(mocker):
     """test ReplayManager.run() - ignored"""
-    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
@@ -226,13 +207,11 @@ def test_replay_08(mocker, tmp_path):
         assert replay.status.ignored == 1
         assert replay.status.iteration == 1
         assert replay.status.results == 0
-    assert not any(tmp_path.iterdir())
 
 
-def test_replay_09(mocker, tmp_path):
+def test_replay_08(mocker):
     """test ReplayManager.run() - early exit"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="path/fake_bin", launch_timeout=30)
@@ -295,12 +274,9 @@ def test_replay_09(mocker, tmp_path):
     assert sum(x.count for x in results) == 4
 
 
-def test_replay_10(mocker, tmp_path):
+def test_replay_09(mocker):
     """test ReplayManager.run() - test signatures - fail to meet minimum"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    mocker.patch(
-        "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
-    )
     report_0 = mocker.Mock(spec_set=Report)
     report_0.crash_info.createShortSignature.return_value = "No crash detected"
     report_1 = mocker.Mock(
@@ -347,11 +323,8 @@ def test_replay_10(mocker, tmp_path):
     assert signature.matches.call_count == 3
 
 
-def test_replay_11(mocker, tmp_path):
+def test_replay_10(mocker):
     """test ReplayManager.run() - test signatures - multiple matches"""
-    mocker.patch(
-        "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
-    )
     report_0 = mocker.Mock(
         spec_set=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
     )
@@ -391,11 +364,8 @@ def test_replay_11(mocker, tmp_path):
     assert signature.matches.call_count == 2
 
 
-def test_replay_12(mocker, tmp_path):
+def test_replay_11(mocker):
     """test ReplayManager.run() - any crash - success"""
-    mocker.patch(
-        "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
-    )
     report_0 = mocker.Mock(spec_set=Report)
     report_0.crash_info.createShortSignature.return_value = "No crash detected"
     report_1 = mocker.Mock(
@@ -432,11 +402,8 @@ def test_replay_12(mocker, tmp_path):
     assert report_2.cleanup.call_count == 0
 
 
-def test_replay_13(mocker, tmp_path):
+def test_replay_12(mocker):
     """test ReplayManager.run() - any crash - fail to meet minimum"""
-    mocker.patch(
-        "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
-    )
     report_0 = mocker.Mock(spec_set=Report)
     report_0.crash_info.createShortSignature.return_value = "No crash detected"
     report_1 = mocker.Mock(
@@ -473,11 +440,8 @@ def test_replay_13(mocker, tmp_path):
     assert report_3.cleanup.call_count == 1
 
 
-def test_replay_14(mocker, tmp_path):
+def test_replay_13(mocker):
     """test ReplayManager.run() - no signature - use first crash"""
-    mocker.patch(
-        "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
-    )
     report_1 = mocker.Mock(
         spec_set=Report, crash_hash="hash1", major="0123", minor="9999"
     )
@@ -519,11 +483,8 @@ def test_replay_14(mocker, tmp_path):
     assert report_3.cleanup.call_count == 1
 
 
-def test_replay_15(mocker, tmp_path):
+def test_replay_14(mocker):
     """test ReplayManager.run() - unexpected exception"""
-    mocker.patch(
-        "grizzly.replay.replay.mkdtemp", autospec=True, return_value=str(tmp_path)
-    )
     report_0 = mocker.Mock(
         spec_set=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
     )
@@ -552,7 +513,7 @@ def test_replay_15(mocker, tmp_path):
     assert report_0.cleanup.call_count == 1
 
 
-def test_replay_16(mocker):
+def test_replay_15(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
@@ -572,7 +533,7 @@ def test_replay_16(mocker):
     assert all(x.dump.call_count == 1 for x in testcases)
 
 
-def test_replay_17(mocker):
+def test_replay_16(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
@@ -597,9 +558,8 @@ def test_replay_17(mocker):
     assert all(x.dump.call_count == 1 for x in testcases)
 
 
-def test_replay_18(mocker, tmp_path):
+def test_replay_17(mocker):
     """test ReplayManager.run() - multiple TestCases - successful repro"""
-    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.side_effect = (
         (Served.ALL, ["a.html"]),
@@ -634,10 +594,9 @@ def test_replay_18(mocker, tmp_path):
     assert all(x.dump.call_count == 1 for x in testcases)
 
 
-def test_replay_19(mocker, tmp_path):
+def test_replay_18(mocker):
     """test ReplayManager.run() - multiple calls"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["index.html"])
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
@@ -653,7 +612,7 @@ def test_replay_19(mocker, tmp_path):
     assert server.serve_path.call_count == 3
 
 
-def test_replay_20(mocker, tmp_path):
+def test_replay_19(mocker, tmp_path):
     """test ReplayManager.report_to_filesystem()"""
     # no reports
     ReplayManager.report_to_filesystem(str(tmp_path), [])
@@ -705,7 +664,7 @@ def test_replay_20(mocker, tmp_path):
     assert (path / "reports" / "expected_logs").is_dir()
 
 
-def test_replay_21(mocker, tmp_path):
+def test_replay_20(mocker, tmp_path):
     """test ReplayManager.load_testcases()"""
     fake_load = mocker.patch("grizzly.replay.replay.TestCase.load")
     test0 = mocker.Mock(spec_set=TestCase, env_vars={"env": "var"})
@@ -769,9 +728,8 @@ def test_replay_21(mocker, tmp_path):
         (False, False, False, 1, 0),
     ],
 )
-def test_replay_22(mocker, tmp_path, is_hang, use_sig, match_sig, ignored, results):
+def test_replay_21(mocker, is_hang, use_sig, match_sig, ignored, results):
     """test ReplayManager.run() - detect hangs"""
-    mocker.patch("grizzly.replay.replay.grz_tmp", return_value=str(tmp_path))
     served = ["index.html"]
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.TIMEOUT, served)
@@ -807,4 +765,3 @@ def test_replay_22(mocker, tmp_path, is_hang, use_sig, match_sig, ignored, resul
         assert len(found[0].durations) == 1
         assert testcase.hang == is_hang
         found[0].report.cleanup()
-        assert not any(tmp_path.iterdir())
diff --git a/grizzly/session.py b/grizzly/session.py
index 9fa5107f..22a9b145 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -3,11 +3,13 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
+from pathlib import Path
 from time import time
 
 from .common.iomanager import IOManager
 from .common.runner import Runner
 from .common.status import Status
+from .common.utils import grz_tmp
 from .target import Result, TargetLaunchError
 
 __all__ = ("SessionError", "LogOutputLimiter", "Session")
@@ -61,6 +63,7 @@ def ready(self, cur_iter, launches):
 class Session:
     DISPLAY_VERBOSE = 0  # display status every iteration
     DISPLAY_NORMAL = 1  # quickly reduce the amount of output
+    STATUS_DB = str(Path(grz_tmp()) / "fuzz-status.db")
 
     # display warning when target log files exceed limit (25MB)
     TARGET_LOG_SIZE_WARN = 0x1900000
@@ -99,7 +102,10 @@ def __init__(
         self.target = target
         self.status = None
         self.iomanager = IOManager(report_size=report_size)
-        self.status = Status.start(enable_profiling=enable_profiling)
+        self.status = Status.start(
+            db_file=self.STATUS_DB,
+            enable_profiling=enable_profiling,
+        )
 
     def __enter__(self):
         return self
@@ -110,8 +116,6 @@ def __exit__(self, *exc):
     def close(self):
         if self.iomanager is not None:
             self.iomanager.cleanup()
-        if self.status is not None:
-            self.status.cleanup()
 
     def display_status(self, log_limiter):
         if self.adapter.remaining is not None:
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 0d453375..80bdf9ab 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -18,6 +18,8 @@
 from .session import LogOutputLimiter, Session, SessionError
 from .target import AssetManager, Result, Target, TargetLaunchError
 
+pytestmark = mark.usefixtures("tmp_path_status_db")
+
 
 class SimpleAdapter(Adapter):
     def __init__(self, use_harness, remaining=None):
@@ -62,11 +64,8 @@ def generate(self, testcase, _server_map):
         (True, False, False, 1, 0, 1),
     ],
 )
-def test_session_01(
-    mocker, tmp_path, harness, profiling, coverage, relaunch, iters, runtime
-):
+def test_session_01(mocker, harness, profiling, coverage, relaunch, iters, runtime):
     """test Session with typical fuzzer Adapter"""
-    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     mocker.patch("grizzly.common.status.time", side_effect=count(start=1.0, step=1.0))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
@@ -136,9 +135,8 @@ def test_session_01(
         (True, 10, 10),
     ],
 )
-def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
+def test_session_02(mocker, harness, relaunch, remaining):
     """test Session with playback Adapter"""
-    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
         spec_set=Target,
@@ -189,9 +187,8 @@ def test_session_02(tmp_path, mocker, harness, relaunch, remaining):
         (False, 1, 1, 3),
     ],
 )
-def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
+def test_session_03(mocker, harness, report_size, relaunch, iters):
     """test Session - detecting failure"""
-    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     adapter = SimpleAdapter(harness)
     reporter = mocker.Mock(spec_set=Reporter)
     report = mocker.Mock(
@@ -231,14 +228,13 @@ def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters):
         assert reporter.submit.call_args[0][1].major == "major123"
 
 
-def test_session_04(mocker, tmp_path):
+def test_session_04(mocker):
     """test Adapter creating invalid test case"""
 
     class FuzzAdapter(Adapter):
         def generate(self, _testcase, _server_map):
             pass
 
-    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.NONE, [])
     target = mocker.Mock(
@@ -253,9 +249,8 @@ def generate(self, _testcase, _server_map):
             session.run([], 10)
 
 
-def test_session_05(mocker, tmp_path):
+def test_session_05(mocker):
     """test Target not requesting landing page"""
-    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.TIMEOUT, [])
     target = mocker.Mock(
@@ -281,9 +276,8 @@ def test_session_05(mocker, tmp_path):
         (False, 1),
     ],
 )
-def test_session_06(mocker, tmp_path, harness, report_size):
+def test_session_06(mocker, harness, report_size):
     """test Session - handle Target delayed failures"""
-    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     reporter = mocker.Mock(spec_set=Reporter)
     report = mocker.Mock(
         spec_set=Report, major="major123", minor="minor456", crash_hash="1234"
@@ -328,9 +322,8 @@ def test_session_06(mocker, tmp_path, harness, report_size):
         (Served.TIMEOUT, Result.NONE, 1, 0),
     ],
 )
-def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, results):
+def test_session_07(mocker, srv_results, target_result, ignored, results):
     """test Session.run() - initial test case was not served"""
-    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     report = mocker.Mock(
         spec_set=Report, major="major123", minor="minor456", crash_hash="123"
     )
@@ -359,9 +352,8 @@ def test_session_07(mocker, tmp_path, srv_results, target_result, ignored, resul
         assert target.handle_hang.call_count == ignored
 
 
-def test_session_08(tmp_path, mocker):
+def test_session_08(mocker):
     """test Session.run() ignoring failures"""
-    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     result = RunResult([], 0.1, status=Result.IGNORED)
     result.attempted = True
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
@@ -384,9 +376,8 @@ def test_session_08(tmp_path, mocker):
         assert session.status.ignored == 1
 
 
-def test_session_09(tmp_path, mocker):
+def test_session_09(mocker):
     """test Session.run() handle TargetLaunchError"""
-    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     report = mocker.Mock(
         spec_set=Report, major="major123", minor="minor456", crash_hash="123"
     )
@@ -405,9 +396,8 @@ def test_session_09(tmp_path, mocker):
         assert session.status.ignored == 0
 
 
-def test_session_10(tmp_path, mocker):
+def test_session_10(mocker):
     """test Session.run() report hang"""
-    mocker.patch("grizzly.session.Status.PATH", return_value=str(tmp_path))
     result = RunResult([], 60.0, status=Result.FOUND, timeout=True)
     result.attempted = True
     runner = mocker.patch("grizzly.session.Runner", autospec=True)

From 4eaa389853a9c72090b245f336ff2bd7214db674 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 23 Sep 2021 10:44:04 -0700
Subject: [PATCH 316/531] Use ResultCounter in Status to count results that
 have been found

---
 grizzly/common/status.py               | 358 +++++++++++++++++++------
 grizzly/common/status_reporter.py      |  25 +-
 grizzly/common/test_status.py          | 220 +++++++++++----
 grizzly/common/test_status_reporter.py |  22 +-
 grizzly/replay/replay.py               |  12 +-
 grizzly/replay/test_replay.py          |  44 +--
 grizzly/session.py                     |  14 +-
 grizzly/test_session.py                |   8 +-
 8 files changed, 503 insertions(+), 200 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 13897a83..595a3407 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -3,7 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Manage Grizzly status reports."""
-from collections import namedtuple
+from collections import defaultdict, namedtuple
 from contextlib import contextmanager
 from json import dumps, loads
 from logging import getLogger
@@ -15,6 +15,10 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
+# used to track changes to the database layout
+DB_VERSION = 1
+# default expiration limit for entries in the database
+EXP_LIMIT = 86400
 LOG = getLogger(__name__)
 
 ProfileEntry = namedtuple("ProfileEntry", "count max min name total")
@@ -38,9 +42,6 @@ class Status:
         timestamp (float): Last time data was saved to database.
     """
 
-    DB_VERSION = 1
-    # entries older than 'EXP_LIMIT' seconds will be removed.
-    EXP_LIMIT = 86400
     # database will be updated no more than every 'REPORT_FREQ' seconds.
     REPORT_FREQ = 60
 
@@ -48,7 +49,7 @@ class Status:
         "_db_file",
         "_enable_profiling",
         "_profiles",
-        "_results",
+        "results",
         "ignored",
         "iteration",
         "log_size",
@@ -59,47 +60,54 @@ class Status:
     )
 
     def __init__(
-        self, db_file=None, enable_profiling=False, start_time=None, exp_limit=EXP_LIMIT
+        self,
+        db_file=None,
+        enable_profiling=False,
+        start_time=None,
+        exp_limit=EXP_LIMIT,
+        pid=None,
     ):
         if db_file is None:
             # read-only mode
             assert start_time is None
             self._enable_profiling = False
+            self.results = None
         else:
             assert isinstance(start_time, float)
+            assert exp_limit >= 0
+            assert pid >= 0
             self._enable_profiling = enable_profiling
+            self.results = ResultCounter(pid, db_file=db_file, exp_limit=EXP_LIMIT)
         self._profiles = dict()
-        self._results = dict()
         self._db_file = db_file
         self.ignored = 0
         self.iteration = 0
         self.log_size = 0
-        self.pid = None
+        self.pid = pid
         self.start_time = start_time
         self.test_name = None
         self.timestamp = start_time
 
         # prepare database
         if self._db_file:
-            LOG.debug("using status db %r", self._db_file)
+            LOG.debug("status using db %r", self._db_file)
             con = connect(self._db_file)
             try:
                 cur = con.cursor()
                 # check db version
                 cur.execute("PRAGMA user_version;")
                 version = cur.fetchone()[0]
-                if version < self.DB_VERSION:
-                    LOG.debug("db version %d < %d", version, self.DB_VERSION)
+                if version < DB_VERSION:
+                    LOG.debug("db version %d < %d", version, DB_VERSION)
                     cur.execute("DROP TABLE IF EXISTS status;")
-                    cur.execute("PRAGMA user_version = %d;" % (self.DB_VERSION,))
+                    cur.execute("PRAGMA user_version = %d;" % (DB_VERSION,))
                     con.commit()
                 else:
-                    assert version == self.DB_VERSION
+                    assert version == DB_VERSION
                 # create tables if needed
                 con.execute(
                     """CREATE TABLE IF NOT EXISTS status (
                        _profiles TEXT NOT NULL,
-                       _results TEXT NOT NULL,
                        ignored INTEGER NOT NULL,
                        iteration INTEGER NOT NULL,
                        log_size INTEGER NOT NULL,
@@ -108,7 +116,7 @@ def __init__(
                        timestamp REAL NOT NULL);"""
                 )
                 con.commit()
-                # remove inactive status data
+                # remove expired status data
                 if exp_limit > 0:
                     con.execute(
                         """DELETE FROM status WHERE timestamp <= ?;""",
@@ -118,27 +126,6 @@ def __init__(
             finally:
                 con.close()
 
-    def count_result(self, uid, description):
-        """Increment counter that matches `uid`.
-
-        Args:
-            uid (str): Unique identifier.
-            description (str): User friendly name (short signature).
-
-        Returns:
-            int: Current count.
-        """
-        if uid not in self._results:
-            assert isinstance(uid, str)
-            assert isinstance(description, str)
-            # create result entry
-            self._results[uid] = {
-                "count": 0,
-                "desc": description,
-            }
-        self._results[uid]["count"] += 1
-        return self._results[uid]["count"]
-
     @classmethod
     def loadall(cls, db_file, time_limit=300):
         """Load all status reports found in `db_file`.
@@ -151,26 +138,26 @@ def loadall(cls, db_file, time_limit=300):
         Yields:
             Status: Successfully loaded read-only status objects.
         """
+        assert db_file
         assert time_limit >= 0
         con = connect(db_file)
         try:
             cur = con.cursor()
             # check db version
             cur.execute("PRAGMA user_version;")
-            assert cur.fetchone()[0] <= cls.DB_VERSION
+            assert cur.fetchone()[0] <= DB_VERSION
             # check table exists
             cur.execute(
                 """SELECT name
-                           FROM sqlite_master
-                           WHERE type='table'
-                           AND name='status';"""
+                   FROM sqlite_master
+                   WHERE type='table'
+                   AND name='status';"""
             )
             if cur.fetchone():
                 # collect entries
                 cur.execute(
                     """SELECT pid,
                              _profiles,
-                             _results,
                              ignored,
                              iteration,
                              log_size,
@@ -190,12 +177,12 @@ def loadall(cls, db_file, time_limit=300):
             status = cls()
             status.pid = entry[0]
             status._profiles = loads(entry[1])
-            status._results = loads(entry[2])
-            status.ignored = entry[3]
-            status.iteration = entry[4]
-            status.log_size = entry[5]
-            status.start_time = entry[6]
-            status.timestamp = entry[7]
+            status.ignored = entry[2]
+            status.iteration = entry[3]
+            status.log_size = entry[4]
+            status.start_time = entry[5]
+            status.timestamp = entry[6]
+            status.results = ResultCounter.load(db_file, status.pid, time_limit)
             yield status
 
     @contextmanager
@@ -296,14 +283,12 @@ def report(self, force=False, report_freq=REPORT_FREQ):
         self.timestamp = now
 
         profiles = dumps(self._profiles)
-        results = dumps(self._results)
         con = connect(self._db_file)
         try:
             cur = con.cursor()
             cur.execute(
                 """UPDATE status
                    SET _profiles = ?,
-                       _results = ?,
                        ignored = ?,
                        iteration = ?,
                        log_size = ?,
@@ -312,7 +297,6 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                    WHERE pid = ?;""",
                 (
                     profiles,
-                    results,
                     self.ignored,
                     self.iteration,
                     self.log_size,
@@ -326,17 +310,15 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                     """INSERT INTO status(
                        pid,
                        _profiles,
-                       _results,
                        ignored,
                        iteration,
                        log_size,
                        start_time,
                        timestamp)
-                       VALUES (?, ?, ?, ?, ?, ?, ?, ?);""",
+                       VALUES (?, ?, ?, ?, ?, ?, ?);""",
                     (
                         self.pid,
                         profiles,
-                        results,
                         self.ignored,
                         self.iteration,
                         self.log_size,
@@ -350,30 +332,6 @@ def report(self, force=False, report_freq=REPORT_FREQ):
 
         return True
 
-    @property
-    def results(self):
-        """Calculate the total number of results.
-
-        Args:
-            None
-
-        Returns:
-            int: Total number of results.
-        """
-        return sum(x["count"] for x in self._results.values())
-
-    def result_entries(self):
-        """Provide unique result entries.
-
-        Args:
-            None
-
-        Yields:
-            dict: Result entry.
-        """
-        for uid, result in self._results.items():
-            yield uid, result
-
     @property
     def runtime(self):
         """Calculate the number of seconds since start() was called. Value is
@@ -401,10 +359,250 @@ def start(cls, db_file, enable_profiling=False):
             Status: Active status report.
         """
         assert db_file
-        pid = getpid()
         status = cls(
-            db_file=db_file, enable_profiling=enable_profiling, start_time=time()
+            db_file=db_file,
+            enable_profiling=enable_profiling,
+            start_time=time(),
+            pid=getpid(),
         )
-        status.pid = pid
         status.report(force=True)
         return status
+
+
+class ResultCounter:
+    __slots__ = (
+        "_count",
+        "_desc",
+        "_db_file",
+        "_frequent",
+        "_limit",
+        "_pid",
+    )
+
+    def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=5):
+        assert exp_limit >= 0
+        assert freq_limit >= 0
+        assert pid >= 0
+        self._count = defaultdict(int)
+        self._desc = dict()
+        self._db_file = db_file
+        self._frequent = set()
+        self._limit = freq_limit
+        self._pid = pid
+
+        # prepare database
+        if self._db_file:
+            LOG.debug("resultcounter using db %r", self._db_file)
+            con = connect(self._db_file)
+            try:
+                cur = con.cursor()
+                cur.execute("PRAGMA user_version;")
+                version = cur.fetchone()[0]
+                if version < DB_VERSION:
+                    LOG.debug("db version %d < %d", version, DB_VERSION)
+                    cur.execute("DROP TABLE IF EXISTS results;")
+                    cur.execute("PRAGMA user_version = %d;" % (DB_VERSION,))
+                    con.commit()
+                else:
+                    assert version == DB_VERSION
+                # create tables if needed
+                con.execute(
+                    """CREATE TABLE IF NOT EXISTS results (
+                       count INTEGER NOT NULL,
+                       description TEXT NOT NULL,
+                       pid INTEGER NOT NULL,
+                       result_id TEXT NOT NULL,
+                       timestamp INTEGER NOT NULL);"""
+                )
+                con.commit()
+                # remove expired entries
+                if exp_limit > 0:
+                    con.execute(
+                        """DELETE FROM results WHERE timestamp <= ?;""",
+                        (int(time() - exp_limit),),
+                    )
+                con.commit()
+            finally:
+                con.close()
+
+    def all(self):
+        """Yield all result data.
+
+        Args:
+            None
+
+        Yields:
+            tuple: Contains result_id, count and description for each entry.
+        """
+        for result_id, count in self._count.items():
+            if count > 0:
+                yield (result_id, count, self._desc.get(result_id, None))
+
+    def count(self, result_id, desc):
+        """
+
+        Args:
+            result_id (str): Result ID.
+            desc (str): User friendly description.
+
+        Returns:
+            int: Current count for given result_id.
+        """
+        assert isinstance(result_id, str)
+        self._count[result_id] += 1
+        if result_id not in self._desc:
+            self._desc[result_id] = desc
+        if self._db_file:
+            con = connect(self._db_file)
+            try:
+                timestamp = int(time())
+                cur = con.cursor()
+                cur.execute(
+                    """UPDATE results
+                       SET timestamp = ?,
+                           count = ?
+                       WHERE pid = ?
+                       AND result_id = ?;""",
+                    (timestamp, self._count[result_id], self._pid, result_id),
+                )
+                if cur.rowcount < 1:
+                    cur.execute(
+                        """INSERT INTO results(
+                           pid,
+                           result_id,
+                           description,
+                           timestamp,
+                           count)
+                           VALUES (?, ?, ?, ?, ?);""",
+                        (
+                            self._pid,
+                            result_id,
+                            desc,
+                            timestamp,
+                            self._count[result_id],
+                        ),
+                    )
+                con.commit()
+            finally:
+                con.close()
+        return self._count[result_id]
+
+    @classmethod
+    def load(cls, db_file, pid, time_limit):
+        """Load existing entries for database and populate a ResultCounter.
+
+        Args:
+            db_file (str): Database file.
+            pid (int): PID of process that created the entries.
+            time_limit (int): Used to filter older entries.
+
+        Returns:
+            ResultCounter: ResultCounter loaded with data that matches given pid.
+        """
+        assert db_file
+        assert pid >= 0
+        assert time_limit >= 0
+        con = connect(db_file)
+        try:
+            cur = con.cursor()
+            # check db version
+            cur.execute("PRAGMA user_version;")
+            assert cur.fetchone()[0] <= DB_VERSION
+            # check table exists
+            cur.execute(
+                """SELECT name
+                   FROM sqlite_master
+                   WHERE type='table'
+                   AND name='results';"""
+            )
+            if cur.fetchone():
+                # collect entries
+                cur.execute(
+                    """SELECT result_id,
+                              description,
+                              count
+                       FROM results
+                       WHERE pid = ?
+                       AND timestamp > ?;""",
+                    (pid, int(time()) - time_limit),
+                )
+                entries = cur.fetchall()
+            else:
+                entries = ()
+        finally:
+            con.close()
+
+        loaded = cls(pid)
+        for result_id, desc, count in entries:
+            loaded._desc[result_id] = desc
+            loaded._count[result_id] = count
+        return loaded
+
+    def get(self, result_id):
+        """Get count and description for given result id.
+
+        Args:
+            result_id (str): Result ID.
+
+        Returns:
+            tuple: Count and description.
+        """
+        assert isinstance(result_id, str)
+        return (self._count.get(result_id, 0), self._desc.get(result_id, None))
+
+    def is_frequent(self, result_id):
+        """Scan all results including results from other running instances
+        to determine if the results limit has been reached.
+
+        Args:
+            result_id (str): Result ID.
+
+        Returns:
+            bool: True if limit has been reached otherwise False.
+        """
+        assert isinstance(result_id, str)
+        if result_id in self._frequent:
+            return True
+        if self._db_file:
+            # look up count from all sources
+            con = connect(self._db_file)
+            try:
+                cur = con.cursor()
+                cur.execute(
+                    """SELECT SUM(count) FROM results WHERE result_id = ?;""",
+                    (result_id,),
+                )
+                total = cur.fetchone()[0] or 0
+            finally:
+                con.close()
+        else:
+            total = self._count.get(result_id, 0)
+        if total >= self._limit:
+            self._frequent.add(result_id)
+            return True
+        return False
+
+    def mark_frequent(self, result_id):
+        """Mark given results ID as frequent locally.
+
+        Args:
+            result_id (str): Result ID.
+
+        Returns:
+            None
+        """
+        assert isinstance(result_id, str)
+        if result_id not in self._frequent:
+            self._frequent.add(result_id)
+
+    @property
+    def total(self):
+        """Get total count of all results.
+
+        Args:
+            None
+
+        Returns:
+            int: Total result count.
+        """
+        return sum(x for x in self._count.values())
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 67e718da..81424b78 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -39,7 +39,7 @@ class StatusReporter:
     DISPLAY_LIMIT_LOG = 10  # don't include log results unless size exceeds 10MBs
     READ_BUF_SIZE = 0x10000  # 64KB
     SUMMARY_LIMIT = 4095  # summary output must be no more than 4KB
-    TIME_LIMIT = 600  # ignore older reports
+    TIME_LIMIT = 120  # ignore older reports
 
     def __init__(self, reports, tracebacks=None):
         self.reports = reports
@@ -76,7 +76,7 @@ def dump_summary(self, filename, runtime=False, sysinfo=True, timestamp=True):
 
     @property
     def has_results(self):
-        return any(x.results for x in self.reports)
+        return any(x.results.total for x in self.reports)
 
     @classmethod
     def load(cls, db_file, tb_path=None, time_limit=TIME_LIMIT):
@@ -110,18 +110,17 @@ def _results(self, max_len=85):
         descs = dict()
         counts = defaultdict(int)
         # calculate totals
-        for report in self.reports:
-            # count results in report
-            for uid, result in report.result_entries():
-                descs[uid] = result["desc"]
-                counts[uid] += result["count"]
+        for entry in self.reports:
+            for rid, count, desc in entry.results.all():
+                descs[rid] = desc
+                counts[rid] += count
         # generate output
         txt = list()
-        for uid, count in sorted(counts.items(), key=lambda x: x[1], reverse=True):
-            if len(descs[uid]) > max_len:
-                txt.append("%d: '%s...'\n" % (count, descs[uid][:max_len]))
+        for rid, count in sorted(counts.items(), key=lambda x: x[1], reverse=True):
+            if len(descs[rid]) > max_len:
+                txt.append("%d: '%s...'\n" % (count, descs[rid][:max_len]))
             else:
-                txt.append("%d: %r\n" % (count, descs[uid]))
+                txt.append("%d: %r\n" % (count, descs[rid]))
         if not txt:
             txt.append("No results available\n")
         return "".join(txt)
@@ -155,7 +154,7 @@ def _specific(self):
             txt.append(" * Iterations: %d" % (report.iteration,))
             txt.append(" @ %0.2f," % (round(report.rate, 2),))
             txt.append(" Ignored: %d," % (report.ignored,))
-            txt.append(" Results: %d" % (report.results,))
+            txt.append(" Results: %d" % (report.results.total,))
             txt.append("\n")
             # add profiling data if it exists
             if any(report.profile_entries()):
@@ -195,7 +194,7 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
             iterations = tuple(x.iteration for x in self.reports)
             log_sizes = tuple(x.log_size for x in self.reports)
             rates = tuple(x.rate for x in self.reports)
-            results = tuple(x.results for x in self.reports)
+            results = tuple(x.results.total for x in self.reports)
             count = len(self.reports)
             total_ignored = sum(x.ignored for x in self.reports)
             total_iters = sum(iterations)
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index a1bb8207..6ffcad46 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -8,13 +8,15 @@
 from multiprocessing import Event, Process
 from time import sleep, time
 
-from .status import Status
+from pytest import mark
+
+from .status import ResultCounter, Status
 
 
 def test_status_01(mocker, tmp_path):
     """test Status.start()"""
-    mocker.patch("grizzly.common.status.time", return_value=1.0)
-    status = Status.start(db_file=str(tmp_path / "status.db"))
+    mocker.patch("grizzly.common.status.time", autospec=True, return_value=1.0)
+    status = Status.start(str(tmp_path / "status.db"))
     assert status is not None
     assert status._db_file is not None
     assert status.start_time > 0
@@ -23,7 +25,7 @@ def test_status_01(mocker, tmp_path):
     assert status.iteration == 0
     assert status.log_size == 0
     assert status.rate == 0
-    assert status.results == 0
+    assert status.results.total == 0
     assert int(status.runtime) == 0
     assert status.pid is not None
     assert not status._enable_profiling
@@ -32,8 +34,8 @@ def test_status_01(mocker, tmp_path):
 
 def test_status_02(tmp_path):
     """test Status.report()"""
-    status = Status.start(db_file=str(tmp_path / "status.db"))
-    status.count_result("uid1", "sig1")
+    status = Status.start(str(tmp_path / "status.db"))
+    status.results.count("uid1", "sig1")
     # try to report before REPORT_FREQ elapses
     assert not status.report()
     # REPORT_FREQ elapses
@@ -47,70 +49,59 @@ def test_status_02(tmp_path):
     assert status.timestamp < future
 
 
-def test_status_03(mocker, tmp_path):
+def test_status_03(tmp_path):
     """test Status.load()"""
-    mocker.patch("grizzly.common.status.time", return_value=1.0)
     db_file = str(tmp_path / "status.db")
     # create simple entry
-    status = Status.start(db_file=db_file, enable_profiling=True)
-    status.count_result("uid1", "sig1")
+    status = Status.start(db_file, enable_profiling=True)
+    status.results.count("uid1", "sig1")
     status.record("test", 123.45)
     status.report(force=True)
-    assert status.results == 1
-    loaded = next(Status.loadall(db_file=db_file))
+    assert status.results.total == 1
+    loaded = next(Status.loadall(db_file))
     assert status.start_time == loaded.start_time
     assert status.timestamp == loaded.timestamp
-    assert status.runtime == loaded.runtime
+    assert status.runtime >= loaded.runtime
     assert status.ignored == loaded.ignored
     assert status.iteration == loaded.iteration
     assert status.log_size == loaded.log_size
     assert status.pid == loaded.pid
-    assert status.results == loaded.results
+    assert loaded.results.get("uid1") == (1, "sig1")
     assert not loaded._enable_profiling
     assert "test" in loaded._profiles
 
 
 def test_status_04(mocker, tmp_path):
     """test Status.loadall()"""
-    getpid = mocker.patch("grizzly.common.status.getpid")
+    getpid = mocker.patch("grizzly.common.status.getpid", autospec=True)
     db_file = str(tmp_path / "status.db")
     for pid in range(5):
         getpid.return_value = pid
-        Status.start(db_file=db_file)
-    assert len(tuple(Status.loadall(db_file=db_file))) == 5
+        Status.start(db_file)
+    assert len(tuple(Status.loadall(db_file))) == 5
 
 
 def test_status_05(mocker, tmp_path):
     """test Status.runtime and Status.rate calculations"""
-    mocker.patch(
-        "grizzly.common.status.time",
-        side_effect=(
-            1.0,
-            1.0,
-            3.0,
-            3.0,
-            5.0,
-            5.0,
-            5.0,
-            5.0,
-            5.0,
-        ),
-    )
+    fake_time = mocker.patch("grizzly.common.status.time", autospec=True)
+    fake_time.return_value = 1.0
     db_file = str(tmp_path / "status.db")
-    status = Status.start(db_file=db_file)
+    status = Status.start(db_file)
     assert status.start_time == 1
     # test no iterations
+    fake_time.return_value = 3.0
     assert status.runtime == 2.0
     assert status.rate == 0
     # test one iteration
     status.iteration = 1
     # timestamp should be ignored when calculating rate and runtime on active object
+    fake_time.return_value = 5.0
     status.timestamp = 100
     assert status.runtime == 4.0
     assert status.rate == 0.25
     # test loaded
     status.report(force=True)
-    loaded = next(Status.loadall(db_file=db_file))
+    loaded = next(Status.loadall(db_file))
     assert loaded.runtime == 4.0
     assert loaded.rate == 0.25
     # timestamp should be used when calculating rate and runtime on loaded object
@@ -122,7 +113,7 @@ def test_status_05(mocker, tmp_path):
 def _client_writer(done, reported, db_file):
     """Used by test_status_08"""
     # NOTE: this must be at the top level to work on Windows
-    status = Status.start(db_file=db_file)
+    status = Status.start(db_file)
     while not done.is_set():
         status.iteration += 1
         status.report(force=True)
@@ -132,7 +123,7 @@ def _client_writer(done, reported, db_file):
         sleep(0.01)
 
 
-def test_status_08(tmp_path):
+def test_status_06(tmp_path):
     """test Status.loadall() with multiple active reporters"""
     db_file = str(tmp_path / "status.db")
     done = Event()
@@ -160,37 +151,18 @@ def test_status_08(tmp_path):
                 proc.join()
 
 
-def test_status_09(tmp_path):
-    """test Status.count_result() and Status.result_entries()"""
-    status = Status.start(db_file=str(tmp_path / "status.db"))
-    assert status.count_result("uid1", "sig1") == 1
-    assert status.count_result("uid2", "sig2") == 1
-    assert status.count_result("uid1", "sig1") == 2
-    assert status.count_result("uid3", "sig3") == 1
-    assert status.results == 4
-    found = dict()
-    for _, result in status.result_entries():
-        found[result["desc"]] = result["count"]
-    assert "sig1" in found
-    assert found["sig1"] == 2
-    assert "sig2" in found
-    assert found["sig2"] == 1
-    assert "sig3" in found
-    assert found["sig3"] == 1
-
-
-def test_status_10(tmp_path):
+def test_status_07(tmp_path):
     """test Status.measure() and Status.record() - profiling support"""
     db_file = str(tmp_path / "status.db")
     # profiling disabled
-    status = Status.start(db_file=db_file, enable_profiling=False)
+    status = Status.start(db_file, enable_profiling=False)
     status.record("x", 10.1)
     assert not status._profiles
     with status.measure("x"):
         pass
     assert not status._profiles
     # profiling enabled
-    status = Status.start(db_file=db_file, enable_profiling=True)
+    status = Status.start(db_file, enable_profiling=True)
     assert not status._profiles
     # initial entry
     status.record("test1", 10.1)
@@ -245,3 +217,137 @@ def test_status_10(tmp_path):
     assert len(status._profiles) == 3
     assert "no-op" in status._profiles
     assert len(tuple(status.profile_entries())) == 3
+
+
+@mark.parametrize(
+    "keys, counts, limit, local_only",
+    [
+        # no records
+        (["a"], [0], 1, True),
+        (["a"], [0], 1, False),
+        # single record (not frequent)
+        (["a"], [1], 2, True),
+        (["a"], [1], 2, False),
+        # single record (frequent)
+        (["a"], [1], 1, True),
+        (["a"], [1], 1, False),
+        # multiple records
+        (["a", "b", "c"], [1, 2, 10], 5, True),
+        (["a", "b", "c"], [1, 2, 10], 5, False),
+    ],
+)
+def test_report_counter_01(tmp_path, keys, counts, limit, local_only):
+    """test ResultCounter local functionality"""
+    db_path = None if local_only else str(tmp_path / "storage.db")
+    counter = ResultCounter(1, db_file=db_path, freq_limit=limit)
+    for report_id, count in zip(keys, counts):
+        assert counter.get(report_id) == (0, None)
+        assert not counter.is_frequent(report_id)
+        # call count() with report_id 'count' times
+        for current in range(1, count + 1):
+            assert counter.count(report_id, "desc") == current
+        if sum(counts) > 0:
+            assert counter.get(report_id) == (count, "desc")
+        else:
+            assert counter.get(report_id) == (count, None)
+        if count >= limit:
+            assert counter.is_frequent(report_id)
+        else:
+            assert not counter.is_frequent(report_id)
+            counter.mark_frequent(report_id)
+            assert counter.is_frequent(report_id)
+    for _report_id, count, _desc in counter.all():
+        assert count > 0
+    assert counter.total == sum(counts)
+
+
+def test_report_counter_02(mocker, tmp_path):
+    """test ResultCounter multi instance functionality"""
+    mocker.patch("grizzly.common.status.time", autospec=True, return_value=1)
+    db_path = str(tmp_path / "storage.db")
+    counter_a = ResultCounter(1, db_file=db_path, freq_limit=2)
+    counter_b = ResultCounter(2, db_file=db_path, freq_limit=2)
+    counter_c = ResultCounter(3, db_file=db_path, freq_limit=2)
+    # local (counter_a, bucket a) count is 0, global (all counters) count is 0
+    assert not counter_a.is_frequent("a")
+    assert not counter_b.is_frequent("a")
+    assert not counter_c.is_frequent("a")
+    assert counter_a.count("a", "desc") == 1
+    # local (counter_a, bucket a) count is 1, global (all counters) count is 1
+    assert not counter_a.is_frequent("a")
+    assert not counter_b.is_frequent("a")
+    assert not counter_c.is_frequent("a")
+    assert counter_b.count("a", "desc") == 1
+    # local (counter_b, bucket a) count is 1, global (all counters) count is 2
+    assert counter_a.is_frequent("a")
+    assert counter_b.is_frequent("a")
+    assert counter_c.is_frequent("a")
+    assert counter_c.count("a", "desc") == 1
+    # local (counter_c, bucket a) count is 1, global (all counters) count is 3
+    assert counter_a.is_frequent("a")
+    assert counter_b.is_frequent("a")
+    assert counter_c.is_frequent("a")
+    # local (counter_a, bucket x) count is 0, global (all counters) count is 0
+    assert not counter_a.is_frequent("x")
+    # remove 'expired' reports
+    mocker.patch("grizzly.common.status.time", autospec=True, return_value=1000)
+    counter_d = ResultCounter(4, db_file=db_path, freq_limit=2, exp_limit=10)
+    # local (counter_d, bucket a) count is 0, global (all counters) count is 0
+    assert not counter_d.is_frequent("a")
+    assert counter_a.total == 1
+    assert counter_b.total == 1
+    assert counter_c.total == 1
+    assert counter_d.total == 0
+
+
+def test_report_counter_03(mocker, tmp_path):
+    """test ResultCounter.load()"""
+    fake_time = mocker.patch("grizzly.common.status.time", autospec=True)
+    fake_time.return_value = 1
+    db_path = str(tmp_path / "storage.db")
+    counter = ResultCounter(123, db_file=db_path, exp_limit=1)
+    counter.count("a", "desc_a")
+    fake_time.return_value = 2
+    counter.count("a", "desc_a")
+    fake_time.return_value = 3
+    counter.count("b", "desc_b")
+    # filter out reports by time
+    fake_time.return_value = 4
+    # last 1 second
+    loaded = ResultCounter.load(db_path, counter._pid, 1)
+    assert loaded.total == 0
+    # last 2 seconds
+    loaded = ResultCounter.load(db_path, counter._pid, 2)
+    assert loaded.total == 1
+    assert loaded.get("b") == (1, "desc_b")
+    # last 3 seconds
+    loaded = ResultCounter.load(db_path, counter._pid, 3)
+    assert loaded.get("a") == (2, "desc_a")
+    assert loaded.total == 3
+    # increase time limit
+    fake_time.return_value = 4
+    loaded = ResultCounter.load(db_path, counter._pid, 10)
+    assert loaded.total == counter.total == 3
+    assert loaded.get("a") == (2, "desc_a")
+    assert loaded.get("b") == (1, "desc_b")
+
+
+def test_report_counter_04(mocker, tmp_path):
+    """test ResultCounter remove old entries"""
+    fake_time = mocker.patch("grizzly.common.status.time", autospec=True)
+    fake_time.return_value = 1
+    db_path = str(tmp_path / "storage.db")
+    counter = ResultCounter(123, db_file=db_path, exp_limit=0)
+    counter.count("a", "desc_a")
+    fake_time.return_value = 100
+    counter.count("b", "desc_b")
+    loaded = ResultCounter.load(db_path, counter._pid, 100)
+    assert loaded.total == 2
+    # set exp_limit to zero to skip removing expired results
+    ResultCounter(123, db_file=db_path, exp_limit=0)
+    loaded = ResultCounter.load(db_path, counter._pid, 100)
+    assert loaded.total == 2
+    # clear expired records from database by setting exp_limit
+    ResultCounter(123, db_file=db_path, exp_limit=10)
+    loaded = ResultCounter.load(db_path, counter._pid, 100)
+    assert loaded.total == 1
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 72b50462..f342c256 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -194,7 +194,7 @@ def test_status_reporter_06(mocker, tmp_path):
     status = Status.start(db_file=db_file, enable_profiling=True)
     status.ignored = 1
     status.iteration = 432422
-    status.count_result("uid1", "sig1")
+    status.results.count("uid1", "sig1")
     status.record("test1", 0.91)
     status.record("test1", 1.0)
     status.record("test1", 1.23456)
@@ -230,14 +230,14 @@ def test_status_reporter_07(mocker, tmp_path):
     # multiple reports with results
     status = Status.start(db_file=db_file)
     status.iteration = 1
-    status.count_result("uid1", "[@ test1]")
-    status.count_result("uid2", "[@ test2]")
-    status.count_result("uid1", "[@ test1]")
+    status.results.count("uid1", "[@ test1]")
+    status.results.count("uid2", "[@ test2]")
+    status.results.count("uid1", "[@ test1]")
     status.report(force=True)
     status = Status.start(db_file=db_file)
     status.iteration = 1
-    status.count_result("uid1", "[@ test1]")
-    status.count_result("uid3", "[@ longsignature123]")
+    status.results.count("uid1", "[@ test1]")
+    status.results.count("uid3", "[@ longsignature123]")
     status.report(force=True)
     rptr = StatusReporter.load(db_file)
     assert rptr.has_results
@@ -314,15 +314,15 @@ def test_status_reporter_10(mocker, tmp_path):
     status.ignored = 100
     status.iteration = 1000
     status.log_size = 9999999999
-    status.count_result("uid1", "[@ sig1]")
-    status._results["uid1"]["count"] = 123
+    status.results.count("uid1", "[@ sig1]")
+    status.results._count["uid1"] = 123
     status.report(force=True)
     status = Status.start(db_file=db_file)
     status.ignored = 9
     status.iteration = 192938
     status.log_size = 0
-    status.count_result("uid2", "[@ sig2]")
-    status._results["uid2"]["count"] = 3
+    status.results.count("uid2", "[@ sig2]")
+    status.results._count["uid2"] = 3
     status.report(force=True)
     # create screenlogs with tracebacks
     for i in range(10):
@@ -525,7 +525,7 @@ def test_main_02(tmp_path):
     StatusReporter.CPU_POLL_INTERVAL = 0.01
     status = Status.start(db_file=db_file)
     status.iteration = 1
-    status.count_result("uid", "[@ test]")
+    status.results.count("uid", "[@ test]")
     status.report(force=True)
     assert main([], modes={"fuzz": db_file}) == 0
 
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 9651209f..27ff2bc2 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -387,7 +387,7 @@ def run(
                             bucket_hash = sig_hash
                         else:
                             bucket_hash = report.crash_hash
-                        self.status.count_result(bucket_hash, short_sig)
+                        self.status.results.count(bucket_hash, short_sig)
                         LOG.info(
                             "Result: %s (%s:%s)",
                             short_sig,
@@ -431,7 +431,7 @@ def run(
                 if exit_early:
                     # failed to meet minimum number of results
                     if (
-                        repeat - self.status.iteration + self.status.results
+                        repeat - self.status.iteration + self.status.results.total
                         < min_results
                     ):
                         if self.status.iteration < repeat:
@@ -439,7 +439,7 @@ def run(
                         # failed to reproduce issue
                         LOG.debug(
                             "results (%d) < minimum (%d), after %d attempts",
-                            self.status.results,
+                            self.status.results.total,
                             min_results,
                             self.status.iteration,
                         )
@@ -448,8 +448,8 @@ def run(
                         # is an issue for now use relaunch=1
                         break
                     # check if complete (minimum number of results found)
-                    if self.status.results >= min_results:
-                        assert self.status.results == min_results
+                    if self.status.results.total >= min_results:
+                        assert self.status.results.total == min_results
                         assert (
                             sum(x.count for x in reports.values() if x.expected)
                             >= min_results
@@ -472,7 +472,7 @@ def run(
                 else:
                     LOG.debug(
                         "%d (any_crash) less than minimum %d",
-                        self.status.results,
+                        self.status.results.total,
                         min_results,
                     )
                     for report in reports.values():
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 807c1289..b50c2579 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -47,7 +47,7 @@ def test_replay_01(mocker):
             assert replay.signature is None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
-            assert replay.status.results == 0
+            assert replay.status.results.total == 0
             assert target.monitor.is_healthy.call_count == 1
             assert target.close.call_count == 2
             assert target.close.mock_calls[0] == mocker.call()
@@ -69,7 +69,7 @@ def test_replay_02(mocker):
             assert replay.signature is None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 10
-            assert replay.status.results == 0
+            assert replay.status.results.total == 0
             assert target.handle_hang.call_count == 0
             assert target.monitor.is_healthy.call_count == 1
             assert target.close.call_count == 2
@@ -95,7 +95,7 @@ def test_replay_03(mocker):
             assert not replay.run([testcase], 10, repeat=10, min_results=1)
             assert replay.status.ignored == 0
             assert replay.status.iteration == 10
-            assert replay.status.results == 0
+            assert replay.status.results.total == 0
             assert target.handle_hang.call_count == 0
             assert target.monitor.is_healthy.call_count == 0
             assert target.close.call_count == 1
@@ -117,7 +117,7 @@ def test_replay_04(mocker):
             assert replay.signature is not None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
-            assert replay.status.results == 1
+            assert replay.status.results.total == 1
             assert target.handle_hang.call_count == 0
             assert target.monitor.is_healthy.call_count == 1
             assert target.close.call_count == 2
@@ -145,7 +145,7 @@ def test_replay_05(mocker):
         assert not replay.run(testcases, 10, repeat=1)
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
-        assert replay.status.results == 0
+        assert replay.status.results.total == 0
         # target.close() called once in runner and once by ReplayManager.run()
         assert target.close.call_count == 2
     target.reset_mock()
@@ -156,7 +156,7 @@ def test_replay_05(mocker):
         results = replay.run(testcases, 10, repeat=1)
         assert replay.status.ignored == 1
         assert replay.status.iteration == 1
-        assert replay.status.results == 0
+        assert replay.status.results.total == 0
         assert replay._signature is None
         # target.close() called once in runner and once by ReplayManager.run()
         assert target.close.call_count == 2
@@ -185,7 +185,7 @@ def test_replay_06(mocker):
         assert replay.run(testcases, 10, repeat=2)
         assert replay.status.ignored == 0
         assert replay.status.iteration == 2
-        assert replay.status.results == 1
+        assert replay.status.results.total == 1
         # target.close() called once in runner and once by ReplayManager.run()
         assert target.close.call_count == 2
 
@@ -206,7 +206,7 @@ def test_replay_07(mocker):
         assert target.close.call_count == 2
         assert replay.status.ignored == 1
         assert replay.status.iteration == 1
-        assert replay.status.results == 0
+        assert replay.status.results.total == 0
 
 
 def test_replay_08(mocker):
@@ -230,7 +230,7 @@ def test_replay_08(mocker):
         assert not replay.run(testcases, 10, repeat=4, min_results=3)
         assert target.close.call_count == 4
         assert replay.status.iteration == 3
-        assert replay.status.results == 1
+        assert replay.status.results.total == 1
         assert replay.status.ignored == 1
     # early success
     target.reset_mock()
@@ -244,7 +244,7 @@ def test_replay_08(mocker):
         results = replay.run(testcases, 10, repeat=4, min_results=2)
         assert target.close.call_count == 4
         assert replay.status.iteration == 3
-        assert replay.status.results == 2
+        assert replay.status.results.total == 2
         assert replay.status.ignored == 1
     assert len(results) == 1
     assert sum(x.count for x in results) == 2
@@ -258,7 +258,7 @@ def test_replay_08(mocker):
         assert not replay.run(testcases, 10, repeat=4, min_results=4, exit_early=False)
         assert target.close.call_count == 5
         assert replay.status.iteration == 4
-        assert replay.status.results == 0
+        assert replay.status.results.total == 0
         assert replay.status.ignored == 0
     target.reset_mock()
     # ignore early success (perform all repeats)
@@ -268,7 +268,7 @@ def test_replay_08(mocker):
         results = replay.run(testcases, 10, repeat=4, min_results=1, exit_early=False)
         assert target.close.call_count == 5
         assert replay.status.iteration == 4
-        assert replay.status.results == 4
+        assert replay.status.results.total == 4
         assert replay.status.ignored == 0
     assert len(results) == 1
     assert sum(x.count for x in results) == 4
@@ -310,7 +310,7 @@ def test_replay_09(mocker):
         assert target.close.call_count == 5
         assert replay.signature == signature
         assert replay.status.iteration == 4
-        assert replay.status.results == 1
+        assert replay.status.results.total == 1
         assert replay.status.ignored == 2
     assert fake_report.call_count == 4
     assert len(results) == 1
@@ -353,7 +353,7 @@ def test_replay_10(mocker):
         assert target.close.call_count == 3
         assert replay.signature == signature
         assert replay.status.iteration == 2
-        assert replay.status.results == 2
+        assert replay.status.results.total == 2
         assert replay.status.ignored == 0
     assert fake_report.call_count == 2
     assert len(results) == 1
@@ -391,7 +391,7 @@ def test_replay_11(mocker):
         assert target.close.call_count == 4
         assert replay.signature is None
         assert replay.status.iteration == 3
-        assert replay.status.results == 2
+        assert replay.status.results.total == 2
         assert replay.status.ignored == 0
     assert fake_report.call_count == 3
     assert len(results) == 2
@@ -431,7 +431,7 @@ def test_replay_12(mocker):
         assert target.close.call_count == 5
         assert replay.signature is None
         assert replay.status.iteration == 4
-        assert replay.status.results == 2
+        assert replay.status.results.total == 2
         assert replay.status.ignored == 0
     assert fake_report.call_count == 4
     assert report_0.cleanup.call_count == 1
@@ -472,7 +472,7 @@ def test_replay_13(mocker):
         assert target.close.call_count == 4
         assert replay.signature == auto_sig
         assert replay.status.iteration == 3
-        assert replay.status.results == 2
+        assert replay.status.results.total == 2
         assert replay.status.ignored == 1
     assert fake_report.call_count == 3
     assert len(results) == 2
@@ -505,7 +505,7 @@ def test_replay_14(mocker):
             replay.run(testcases, 10, repeat=3, min_results=2)
         assert replay.signature is None
         assert replay.status.iteration == 2
-        assert replay.status.results == 1
+        assert replay.status.results.total == 1
         assert replay.status.ignored == 0
     assert target.close.call_count == 1
     assert target.monitor.is_healthy.call_count == 0
@@ -528,7 +528,7 @@ def test_replay_15(mocker):
         assert not replay.run(testcases, 10)
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
-        assert replay.status.results == 0
+        assert replay.status.results.total == 0
     assert target.close.call_count == 2
     assert all(x.dump.call_count == 1 for x in testcases)
 
@@ -553,7 +553,7 @@ def test_replay_16(mocker):
         assert target.launch.call_count == 5
         assert replay.status.ignored == 0
         assert replay.status.iteration == 10
-        assert replay.status.results == 0
+        assert replay.status.results.total == 0
     assert target.monitor.is_healthy.call_count == 5
     assert all(x.dump.call_count == 1 for x in testcases)
 
@@ -584,7 +584,7 @@ def test_replay_17(mocker):
         assert target.close.call_count == 2
         assert replay.status.ignored == 0
         assert replay.status.iteration == 1
-        assert replay.status.results == 1
+        assert replay.status.results.total == 1
     assert len(results) == 1
     assert len(results[0].served) == len(testcases)
     assert results[0].served[0][0] == "a.html"
@@ -751,7 +751,7 @@ def test_replay_21(mocker, is_hang, use_sig, match_sig, ignored, results):
             found = replay.run([testcase], 10, expect_hang=is_hang)
             assert replay.status.iteration == 1
             assert replay.status.ignored == ignored
-            assert replay.status.results == results
+            assert replay.status.results.total == results
             assert target.handle_hang.call_count == 1
             assert target.monitor.is_healthy.call_count == 0
             assert target.close.call_count == 1
diff --git a/grizzly/session.py b/grizzly/session.py
index 22a9b145..cfddc8f8 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -123,11 +123,11 @@ def display_status(self, log_limiter):
                 "[I%04d-L%02d-R%02d] %s",
                 self.status.iteration,
                 self.adapter.remaining,
-                self.status.results,
+                self.status.results.total,
                 self.status.test_name,
             )
         elif log_limiter.ready(self.status.iteration, self.target.monitor.launches):
-            LOG.info("I%04d-R%02d ", self.status.iteration, self.status.results)
+            LOG.info("I%04d-R%02d ", self.status.iteration, self.status.results.total)
 
     def generate_testcase(self, time_limit):
         LOG.debug("calling iomanager.create_testcase()")
@@ -195,7 +195,7 @@ def run(
                         exc.report.major[:8],
                         exc.report.minor[:8],
                     )
-                    self.status.count_result(exc.report.crash_hash, short_sig)
+                    self.status.results.count(exc.report.crash_hash, short_sig)
                     self.reporter.submit([], exc.report)
                     exc.report.cleanup()
                     raise TargetLaunchError(str(exc), None) from None
@@ -204,7 +204,6 @@ def run(
             current_test = self.generate_testcase(time_limit)
             # display status
             self.display_status(log_limiter=log_limiter)
-
             # run test case
             with self.status.measure("execute"):
                 result = runner.run(
@@ -250,12 +249,13 @@ def run(
                 LOG.debug("result detected")
                 report = self.target.create_report(is_hang=result.timeout)
                 if result.timeout:
-                    report_uid = "hang"
+                    # TODO: we cannot create a unique bucket hash for hangs atm
+                    bucket_hash = "hang"
                     short_sig = "Potential hang detected"
                 else:
-                    report_uid = report.crash_hash
+                    bucket_hash = report.crash_hash
                     short_sig = report.crash_info.createShortSignature()
-                seen = self.status.count_result(report_uid, short_sig)
+                seen = self.status.results.count(bucket_hash, short_sig)
                 LOG.info(
                     "Result: %s (%s:%s) - %d",
                     short_sig,
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 80bdf9ab..0f4b6e77 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -345,7 +345,7 @@ def test_session_07(mocker, srv_results, target_result, ignored, results):
         with raises(SessionError, match="Please check Adapter and Target"):
             session.run([], 10, iteration_limit=2)
         assert session.status.iteration == 1
-        assert session.status.results == results
+        assert session.status.results.total == results
         assert session.status.ignored == ignored
         assert reporter.submit.call_count == results
         assert target.check_result.call_count == results
@@ -372,7 +372,7 @@ def test_session_08(mocker):
         assert adapter.on_timeout.call_count == 0
         assert target.create_report.call_count == 0
         assert session.status.iteration == 1
-        assert session.status.results == 0
+        assert session.status.results.total == 0
         assert session.status.ignored == 1
 
 
@@ -392,7 +392,7 @@ def test_session_09(mocker):
         with raises(TargetLaunchError, match="test"):
             session.run([], 10, iteration_limit=2)
         assert session.status.iteration == 1
-        assert session.status.results == 1
+        assert session.status.results.total == 1
         assert session.status.ignored == 0
 
 
@@ -421,7 +421,7 @@ def test_session_10(mocker):
         assert target.create_report.call_count == 1
         assert reporter.submit.call_count == 1
         assert session.status.iteration == 1
-        assert session.status.results == 1
+        assert session.status.results.total == 1
         assert session.status.ignored == 0
 
 

From 82a19c42cd27634fdc314e786e1055ad8767bbd2 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 28 Sep 2021 12:27:12 -0700
Subject: [PATCH 317/531] Move db version checking to a function

---
 grizzly/common/status.py      | 119 +++++++++++++++++-----------------
 grizzly/common/test_status.py |  32 +++++++--
 2 files changed, 87 insertions(+), 64 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 595a3407..5cfefecd 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -24,6 +24,40 @@
 ProfileEntry = namedtuple("ProfileEntry", "count max min name total")
 
 
+def _db_version_check(db_file, expected=DB_VERSION):
+    """Perform version check and remove obsolete tables if required.
+
+    Args:
+        db_file (str): Database file containing data.
+        expected (int): The latest database version.
+
+    Returns:
+        None
+    """
+    assert expected > 0
+    with connect(db_file, isolation_level=None) as con:
+        cur = con.cursor()
+        cur.execute("BEGIN")
+        # check db version
+        cur.execute("PRAGMA user_version;")
+        version = cur.fetchone()[0]
+        if version < expected:
+            LOG.debug("db version %d < %d", version, expected)
+            # remove ALL tables from the database
+            cur.execute("SELECT name FROM sqlite_master WHERE type='table';")
+            for entry in cur.fetchall():
+                LOG.debug("dropping table %r", entry[0])
+                cur.execute("DROP TABLE IF EXISTS %s;" % (entry[0],))
+            # try to detect if there is a race
+            cur.execute("PRAGMA user_version;")
+            assert version == cur.fetchone()[0]
+            # update db version number
+            cur.execute("PRAGMA user_version = %d;" % (expected,))
+            con.commit()
+        else:
+            cur.execute("ROLLBACK")
+
+
 class Status:
     """Status holds status information for the Grizzly session.
     Read-only mode is implied if `_db_file` is None.
@@ -66,24 +100,25 @@ def __init__(
         start_time=None,
         exp_limit=EXP_LIMIT,
         pid=None,
+        report_limit=0,
     ):
         if db_file is None:
             # read-only mode
             assert start_time is None
             self._enable_profiling = False
-            self.results = None
         else:
             assert isinstance(start_time, float)
             assert exp_limit >= 0
+            assert report_limit >= 0
             assert pid >= 0
             self._enable_profiling = enable_profiling
-            self.results = ResultCounter(pid, db_file=db_file, exp_limit=EXP_LIMIT)
         self._profiles = dict()
         self._db_file = db_file
         self.ignored = 0
         self.iteration = 0
         self.log_size = 0
         self.pid = pid
+        self.results = None
         self.start_time = start_time
         self.test_name = None
         self.timestamp = start_time
@@ -91,20 +126,9 @@ def __init__(
         # prepare database
         if self._db_file:
             LOG.debug("status using db %r", self._db_file)
-            con = connect(self._db_file)
-            try:
-                cur = con.cursor()
-                # check db version
-                cur.execute("PRAGMA user_version;")
-                version = cur.fetchone()[0]
-                if version < DB_VERSION:
-                    LOG.debug("db version %d < %d", version, DB_VERSION)
-                    cur.execute("DROP TABLE IF EXISTS status;")
-                    cur.execute("PRAGMA user_version = %d;" % (DB_VERSION,))
-                    con.commit()
-                else:
-                    assert version == DB_VERSION
-                # create tables if needed
+            _db_version_check(self._db_file)
+            with connect(self._db_file) as con:
+                # create table if needed
                 con.execute(
                     """CREATE TABLE IF NOT EXISTS status (
                        _profiles TEXT NOT NULL,
@@ -115,7 +139,6 @@ def __init__(
                        start_time REAL NOT NULL,
                        timestamp REAL NOT NULL);"""
                 )
-                con.commit()
                 # remove expired status data
                 if exp_limit > 0:
                     con.execute(
@@ -123,8 +146,13 @@ def __init__(
                         (time() - exp_limit,),
                     )
                 con.commit()
-            finally:
-                con.close()
+
+            self.results = ResultCounter(
+                pid,
+                db_file=db_file,
+                exp_limit=EXP_LIMIT,
+                freq_limit=report_limit,
+            )
 
     @classmethod
     def loadall(cls, db_file, time_limit=300):
@@ -140,8 +168,7 @@ def loadall(cls, db_file, time_limit=300):
         """
         assert db_file
         assert time_limit >= 0
-        con = connect(db_file)
-        try:
+        with connect(db_file) as con:
             cur = con.cursor()
             # check db version
             cur.execute("PRAGMA user_version;")
@@ -170,8 +197,6 @@ def loadall(cls, db_file, time_limit=300):
                 entries = cur.fetchall()
             else:
                 entries = ()
-        finally:
-            con.close()
 
         for entry in entries:
             status = cls()
@@ -283,8 +308,7 @@ def report(self, force=False, report_freq=REPORT_FREQ):
         self.timestamp = now
 
         profiles = dumps(self._profiles)
-        con = connect(self._db_file)
-        try:
+        with connect(self._db_file) as con:
             cur = con.cursor()
             cur.execute(
                 """UPDATE status
@@ -327,8 +351,6 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                     ),
                 )
             con.commit()
-        finally:
-            con.close()
 
         return True
 
@@ -348,7 +370,7 @@ def runtime(self):
         return max(time() - self.start_time, 0)
 
     @classmethod
-    def start(cls, db_file, enable_profiling=False):
+    def start(cls, db_file, enable_profiling=False, report_limit=0):
         """Create a unique Status object.
 
         Args:
@@ -364,6 +386,7 @@ def start(cls, db_file, enable_profiling=False):
             enable_profiling=enable_profiling,
             start_time=time(),
             pid=getpid(),
+            report_limit=report_limit,
         )
         status.report(force=True)
         return status
@@ -372,14 +395,14 @@ def start(cls, db_file, enable_profiling=False):
 class ResultCounter:
     __slots__ = (
         "_count",
-        "_desc",
         "_db_file",
+        "_desc",
         "_frequent",
         "_limit",
         "_pid",
     )
 
-    def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=5):
+    def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=0):
         assert exp_limit >= 0
         assert freq_limit >= 0
         assert pid >= 0
@@ -393,19 +416,9 @@ def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=5):
         # prepare database
         if self._db_file:
             LOG.debug("resultcounter using db %r", self._db_file)
-            con = connect(self._db_file)
-            try:
-                cur = con.cursor()
-                cur.execute("PRAGMA user_version;")
-                version = cur.fetchone()[0]
-                if version < DB_VERSION:
-                    LOG.debug("db version %d < %d", version, DB_VERSION)
-                    cur.execute("DROP TABLE IF EXISTS results;")
-                    cur.execute("PRAGMA user_version = %d;" % (DB_VERSION,))
-                    con.commit()
-                else:
-                    assert version == DB_VERSION
-                # create tables if needed
+            _db_version_check(self._db_file)
+            with connect(self._db_file) as con:
+                # create table if needed
                 con.execute(
                     """CREATE TABLE IF NOT EXISTS results (
                        count INTEGER NOT NULL,
@@ -414,7 +427,6 @@ def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=5):
                        result_id TEXT NOT NULL,
                        timestamp INTEGER NOT NULL);"""
                 )
-                con.commit()
                 # remove expired entries
                 if exp_limit > 0:
                     con.execute(
@@ -422,8 +434,6 @@ def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=5):
                         (int(time() - exp_limit),),
                     )
                 con.commit()
-            finally:
-                con.close()
 
     def all(self):
         """Yield all result data.
@@ -453,8 +463,7 @@ def count(self, result_id, desc):
         if result_id not in self._desc:
             self._desc[result_id] = desc
         if self._db_file:
-            con = connect(self._db_file)
-            try:
+            with connect(self._db_file) as con:
                 timestamp = int(time())
                 cur = con.cursor()
                 cur.execute(
@@ -483,8 +492,6 @@ def count(self, result_id, desc):
                         ),
                     )
                 con.commit()
-            finally:
-                con.close()
         return self._count[result_id]
 
     @classmethod
@@ -502,8 +509,7 @@ def load(cls, db_file, pid, time_limit):
         assert db_file
         assert pid >= 0
         assert time_limit >= 0
-        con = connect(db_file)
-        try:
+        with connect(db_file) as con:
             cur = con.cursor()
             # check db version
             cur.execute("PRAGMA user_version;")
@@ -529,8 +535,6 @@ def load(cls, db_file, pid, time_limit):
                 entries = cur.fetchall()
             else:
                 entries = ()
-        finally:
-            con.close()
 
         loaded = cls(pid)
         for result_id, desc, count in entries:
@@ -561,20 +565,19 @@ def is_frequent(self, result_id):
             bool: True if limit has been reached otherwise False.
         """
         assert isinstance(result_id, str)
+        if self._limit < 1:
+            return False
         if result_id in self._frequent:
             return True
         if self._db_file:
             # look up count from all sources
-            con = connect(self._db_file)
-            try:
+            with connect(self._db_file) as con:
                 cur = con.cursor()
                 cur.execute(
                     """SELECT SUM(count) FROM results WHERE result_id = ?;""",
                     (result_id,),
                 )
                 total = cur.fetchone()[0] or 0
-            finally:
-                con.close()
         else:
             total = self._count.get(result_id, 0)
         if total >= self._limit:
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 6ffcad46..50040c48 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -10,7 +10,7 @@
 
 from pytest import mark
 
-from .status import ResultCounter, Status
+from .status import ResultCounter, Status, _db_version_check
 
 
 def test_status_01(mocker, tmp_path):
@@ -111,7 +111,7 @@ def test_status_05(mocker, tmp_path):
 
 
 def _client_writer(done, reported, db_file):
-    """Used by test_status_08"""
+    """Used by test_status_06"""
     # NOTE: this must be at the top level to work on Windows
     status = Status.start(db_file)
     while not done.is_set():
@@ -138,8 +138,8 @@ def test_status_06(tmp_path):
             )
             procs[-1].start()
         # wait for processes to launch and report
-        for has_reported in report_events:
-            assert has_reported.wait(timeout=60)
+        for event in report_events:
+            assert event.wait(timeout=60)
         # collect reports
         reports = tuple(Status.loadall(db_file))
         assert len(reports) == len(procs)
@@ -231,6 +231,9 @@ def test_status_07(tmp_path):
         # single record (frequent)
         (["a"], [1], 1, True),
         (["a"], [1], 1, False),
+        # single record no limit
+        (["a"], [1], 0, True),
+        (["a"], [1], 0, False),
         # multiple records
         (["a", "b", "c"], [1, 2, 10], 5, True),
         (["a", "b", "c"], [1, 2, 10], 5, False),
@@ -250,12 +253,12 @@ def test_report_counter_01(tmp_path, keys, counts, limit, local_only):
             assert counter.get(report_id) == (count, "desc")
         else:
             assert counter.get(report_id) == (count, None)
-        if count >= limit:
+        if count >= limit > 0:
             assert counter.is_frequent(report_id)
         else:
             assert not counter.is_frequent(report_id)
             counter.mark_frequent(report_id)
-            assert counter.is_frequent(report_id)
+            assert counter.is_frequent(report_id) or limit == 0
     for _report_id, count, _desc in counter.all():
         assert count > 0
     assert counter.total == sum(counts)
@@ -305,6 +308,9 @@ def test_report_counter_03(mocker, tmp_path):
     fake_time = mocker.patch("grizzly.common.status.time", autospec=True)
     fake_time.return_value = 1
     db_path = str(tmp_path / "storage.db")
+    # load empty db
+    ResultCounter.load(db_path, 123, 10)
+    # create counter
     counter = ResultCounter(123, db_file=db_path, exp_limit=1)
     counter.count("a", "desc_a")
     fake_time.return_value = 2
@@ -351,3 +357,17 @@ def test_report_counter_04(mocker, tmp_path):
     ResultCounter(123, db_file=db_path, exp_limit=10)
     loaded = ResultCounter.load(db_path, counter._pid, 100)
     assert loaded.total == 1
+
+
+def test_db_version_check_01(tmp_path):
+    """test _db_version_check()"""
+    db_path = str(tmp_path / "storage.db")
+    # empty db
+    _db_version_check(db_path, expected=1)
+    # no update needed
+    Status.start(db_path)
+    _db_version_check(db_path, expected=1)
+    # force update
+    _db_version_check(db_path, expected=2)
+    # verify everything works after update
+    Status.start(db_path)

From dbca0b4f94554b43320ba34991cef6264dd858c8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 28 Sep 2021 18:09:21 -0700
Subject: [PATCH 318/531] Require minimum two local results before
 is_frequent() can return True

---
 grizzly/common/status.py      | 13 +++++-----
 grizzly/common/test_status.py | 47 ++++++++++++++++++++++++-----------
 2 files changed, 39 insertions(+), 21 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 5cfefecd..ca3fd76b 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -556,20 +556,23 @@ def get(self, result_id):
 
     def is_frequent(self, result_id):
         """Scan all results including results from other running instances
-        to determine if the results limit has been reached.
+        to determine if the limit has been exceeded. Local count must be >1 before
+        limit is checked.
 
         Args:
             result_id (str): Result ID.
 
         Returns:
-            bool: True if limit has been reached otherwise False.
+            bool: True if limit has been exceeded otherwise False.
         """
         assert isinstance(result_id, str)
         if self._limit < 1:
             return False
         if result_id in self._frequent:
             return True
-        if self._db_file:
+        total = self._count.get(result_id, 0)
+        # only count for parallel results if more than 1 local result has been found
+        if total > 1 and self._db_file:
             # look up count from all sources
             with connect(self._db_file) as con:
                 cur = con.cursor()
@@ -578,9 +581,7 @@ def is_frequent(self, result_id):
                     (result_id,),
                 )
                 total = cur.fetchone()[0] or 0
-        else:
-            total = self._count.get(result_id, 0)
-        if total >= self._limit:
+        if total > self._limit:
             self._frequent.add(result_id)
             return True
         return False
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 50040c48..55ab7fd3 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -249,16 +249,21 @@ def test_report_counter_01(tmp_path, keys, counts, limit, local_only):
         # call count() with report_id 'count' times
         for current in range(1, count + 1):
             assert counter.count(report_id, "desc") == current
+        # test get()
         if sum(counts) > 0:
             assert counter.get(report_id) == (count, "desc")
         else:
             assert counter.get(report_id) == (count, None)
-        if count >= limit > 0:
+        # test is_frequent()
+        if count > limit > 0:
             assert counter.is_frequent(report_id)
-        else:
+        elif limit > 0:
             assert not counter.is_frequent(report_id)
+            # test mark_frequent()
             counter.mark_frequent(report_id)
-            assert counter.is_frequent(report_id) or limit == 0
+            assert counter.is_frequent(report_id)
+        else:
+            assert limit == 0
     for _report_id, count, _desc in counter.all():
         assert count > 0
     assert counter.total == sum(counts)
@@ -268,27 +273,39 @@ def test_report_counter_02(mocker, tmp_path):
     """test ResultCounter multi instance functionality"""
     mocker.patch("grizzly.common.status.time", autospec=True, return_value=1)
     db_path = str(tmp_path / "storage.db")
-    counter_a = ResultCounter(1, db_file=db_path, freq_limit=2)
-    counter_b = ResultCounter(2, db_file=db_path, freq_limit=2)
+    counter_a = ResultCounter(1, db_file=db_path, freq_limit=0)
+    counter_b = ResultCounter(2, db_file=db_path, freq_limit=1)
     counter_c = ResultCounter(3, db_file=db_path, freq_limit=2)
-    # local (counter_a, bucket a) count is 0, global (all counters) count is 0
+    # local counts are 0, global (all counters) count is 0
     assert not counter_a.is_frequent("a")
     assert not counter_b.is_frequent("a")
     assert not counter_c.is_frequent("a")
-    assert counter_a.count("a", "desc") == 1
     # local (counter_a, bucket a) count is 1, global (all counters) count is 1
+    assert counter_a.count("a", "desc") == 1
     assert not counter_a.is_frequent("a")
     assert not counter_b.is_frequent("a")
     assert not counter_c.is_frequent("a")
-    assert counter_b.count("a", "desc") == 1
     # local (counter_b, bucket a) count is 1, global (all counters) count is 2
-    assert counter_a.is_frequent("a")
+    assert counter_b.count("a", "desc") == 1
+    assert not counter_a.is_frequent("a")
+    assert not counter_b.is_frequent("a")
+    assert not counter_c.is_frequent("a")
+    # local (counter_b, bucket a) count is 2, global (all counters) count is 3
+    # locally exceeded
+    assert counter_b.count("a", "desc") == 2
     assert counter_b.is_frequent("a")
-    assert counter_c.is_frequent("a")
+    # local (counter_c, bucket a) count is 1, global (all counters) count is 4
     assert counter_c.count("a", "desc") == 1
-    # local (counter_c, bucket a) count is 1, global (all counters) count is 3
-    assert counter_a.is_frequent("a")
+    assert not counter_a.is_frequent("a")
     assert counter_b.is_frequent("a")
+    assert not counter_c.is_frequent("a")
+    # local (counter_a, bucket a) count is 2, global (all counters) count is 5
+    # no limit
+    assert counter_a.count("a", "desc") == 2
+    assert not counter_a.is_frequent("a")
+    # local (counter_c, bucket a) count is 2, global (all counters) count is 6
+    # locally not exceeded, globally exceeded
+    assert counter_c.count("a", "desc") == 2
     assert counter_c.is_frequent("a")
     # local (counter_a, bucket x) count is 0, global (all counters) count is 0
     assert not counter_a.is_frequent("x")
@@ -297,9 +314,9 @@ def test_report_counter_02(mocker, tmp_path):
     counter_d = ResultCounter(4, db_file=db_path, freq_limit=2, exp_limit=10)
     # local (counter_d, bucket a) count is 0, global (all counters) count is 0
     assert not counter_d.is_frequent("a")
-    assert counter_a.total == 1
-    assert counter_b.total == 1
-    assert counter_c.total == 1
+    assert counter_a.total == 2
+    assert counter_b.total == 2
+    assert counter_c.total == 2
     assert counter_d.total == 0
 
 

From 963575289d2f6ddca5d6e8125e909d4cfb95a66a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 30 Sep 2021 11:12:49 -0700
Subject: [PATCH 319/531] Add '--limit-reports' command line argument

---
 grizzly/args.py         | 13 ++++++++++++
 grizzly/main.py         |  1 +
 grizzly/session.py      | 16 ++++++++++-----
 grizzly/test_args.py    |  2 ++
 grizzly/test_main.py    |  1 +
 grizzly/test_session.py | 45 +++++++++++++++++++++++++++++++++++++++++
 6 files changed, 73 insertions(+), 5 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index d373cf64..74d6a0ee 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -310,6 +310,16 @@ def __init__(self):
             help="Maximum number of test cases to include in the report."
             " (default: %(default)s)",
         )
+        self.reporter_grp.add_argument(
+            "--limit-reports",
+            type=int,
+            default=0,
+            help="Maximum number of times a unique result will be submitted."
+            " This includes results submitted by parallel and previously run"
+            " (within 24h) processes. This can help avoid spamming duplicate results."
+            " The first time a result is seen it will always be submitted."
+            " (default: %(default)s) - Use 0 for 'no limit'",
+        )
         self.reporter_grp.add_argument(
             "--s3-fuzzmanager",
             action="store_true",
@@ -340,6 +350,9 @@ def sanity_check(self, args):
         if args.limit < 0:
             self.parser.error("--limit must be >= 0")
 
+        if args.limit_reports < 0:
+            self.parser.error("--limit-reports must be >= 0")
+
         if args.runtime < 0:
             self.parser.error("--runtime must be >= 0")
 
diff --git a/grizzly/main.py b/grizzly/main.py
index 1cff027d..20fad42b 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -127,6 +127,7 @@ def main(args):
                 coverage=args.coverage,
                 enable_profiling=args.enable_profiling,
                 relaunch=relaunch,
+                report_limit=args.limit_reports,
                 report_size=args.collect,
             )
             if args.log_level == DEBUG or args.verbose:
diff --git a/grizzly/session.py b/grizzly/session.py
index cfddc8f8..d9e85111 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -89,23 +89,24 @@ def __init__(
         coverage=False,
         enable_profiling=False,
         relaunch=1,
+        report_limit=0,
         report_size=1,
     ):
         assert relaunch > 0
+        assert report_limit >= 0
         assert report_size > 0
         self._coverage = coverage
         self._relaunch = relaunch
         self.adapter = adapter
-        self.iomanager = None
+        self.iomanager = IOManager(report_size=report_size)
         self.reporter = reporter
         self.server = server
-        self.target = target
-        self.status = None
-        self.iomanager = IOManager(report_size=report_size)
         self.status = Status.start(
             db_file=self.STATUS_DB,
             enable_profiling=enable_profiling,
+            report_limit=report_limit,
         )
+        self.target = target
 
     def __enter__(self):
         return self
@@ -263,7 +264,12 @@ def run(
                     report.minor[:8],
                     seen,
                 )
-                self.reporter.submit(self.iomanager.tests, report)
+                if not self.status.results.is_frequent(bucket_hash):
+                    self.reporter.submit(self.iomanager.tests, report)
+                else:
+                    # we should always submit the first instance of a result
+                    assert seen > 1
+                    LOG.info("Result is frequent, skipping submission")
                 report.cleanup()
             elif result.status == Result.IGNORED:
                 self.status.ignored += 1
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index 1a81676f..cdbe595f 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -155,6 +155,8 @@ def test_grizzly_args_03(capsys, mocker, tmp_path):
         (["--input", "missing"], "error: 'missing' does not exist"),
         # test invalid limit value
         (["--limit", "-1"], "error: --limit must be >= 0"),
+        # test invalid limit value
+        (["--limit-reports", "-1"], "error: --limit-reports must be >= 0"),
         # test runtime limit value
         (["--runtime", "-1"], "error: --runtime must be >= 0"),
         # test tool
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index bb774831..af2bf0b6 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -27,6 +27,7 @@ def __init__(self):
         self.ignore = list()
         self.launch_timeout = 300
         self.limit = 0
+        self.limit_reports = 0
         self.log_level = 10  # 10 = DEBUG, 20 = INFO
         self.log_limit = 0
         self.memory = 0
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 0f4b6e77..ad34f908 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -425,6 +425,51 @@ def test_session_10(mocker):
         assert session.status.ignored == 0
 
 
+@mark.parametrize(
+    "harness, report_size, relaunch, iters, report_limit",
+    [
+        # no limit, always submit reports
+        (True, 1, 1, 10, 0),
+        # limit, only submit initial reports
+        (True, 1, 1, 10, 5),
+    ],
+)
+def test_session_11(mocker, harness, report_size, relaunch, iters, report_limit):
+    """test Session - limit result submission"""
+    adapter = SimpleAdapter(harness)
+    reporter = mocker.Mock(spec_set=Reporter)
+    report = mocker.Mock(spec_set=Report, major="abc", minor="def", crash_hash="123")
+    report.crash_info.createShortSignature.return_value = "[@ sig]"
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
+    target = mocker.Mock(
+        spec_set=Target,
+        assets=mocker.Mock(spec_set=AssetManager),
+        environ=dict(),
+        launch_timeout=30,
+    )
+    target.monitor.launches = 1
+    # avoid shutdown delay
+    target.monitor.is_healthy.return_value = False
+    type(target).closed = mocker.PropertyMock(return_value=True)
+    target.check_result.return_value = Result.FOUND
+    target.log_size.return_value = 1
+    target.create_report.return_value = report
+    with Session(
+        adapter, reporter, server, target, report_limit=report_limit, relaunch=1
+    ) as session:
+        server.serve_path = lambda *a, **kv: (
+            Served.ALL,
+            [session.iomanager.page_name(offset=-1)],
+        )
+        session.run([], 10, input_path="file.bin", iteration_limit=iters)
+        if report_limit > 0:
+            assert reporter.submit.call_count == report_limit
+        else:
+            assert reporter.submit.call_count == iters
+        assert len(reporter.submit.call_args[0][0]) == min(report_size, relaunch)
+        assert reporter.submit.call_args[0][1].major == "abc"
+
+
 def test_log_output_limiter_01(mocker):
     """test LogOutputLimiter.ready() not ready"""
     fake_time = mocker.patch("grizzly.session.time", autospec=True)

From d3a727a3f1424b8a01fa612e377925c917d001cf Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 30 Sep 2021 17:17:49 -0700
Subject: [PATCH 320/531] Remove report limiting from FuzzManagerReporter

---
 grizzly/common/reporter.py      |  80 ++++-----------
 grizzly/common/test_reporter.py | 176 +++++++++-----------------------
 grizzly/reduce/core.py          |   2 -
 3 files changed, 67 insertions(+), 191 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index e527d010..1f7a5ab8 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -4,7 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from abc import ABCMeta, abstractmethod
 from enum import IntEnum, unique
-from json import dump, dumps, loads
+from json import dumps, loads
 from logging import WARNING, getLogger
 from os import getcwd, getenv, makedirs, mkdir, unlink, walk
 from os.path import basename, expanduser, isdir, isfile
@@ -153,13 +153,11 @@ def _submit_report(self, report, test_cases):
 
 class FuzzManagerReporter(Reporter):
     FM_CONFIG = pathjoin(expanduser("~"), ".fuzzmanagerconf")
-    # max number of times to report a non-frequent signature to FuzzManager
-    MAX_REPORTS = 10
+
+    __slots__ = ("_extra_metadata", "quality", "tool")
 
     def __init__(self, tool=None):
         self._extra_metadata = {}
-        self.force_report = False
-        self.max_reports = FuzzManagerReporter.MAX_REPORTS
         self.quality = Quality.UNREDUCED
         self.tool = tool  # optional tool name
 
@@ -234,56 +232,22 @@ def _ignored(report):
         return False
 
     def _submit_report(self, report, test_cases):
-        # search for a cached signature match and if the signature
-        # is already in the cache and marked as frequent, don't bother submitting
+        # search for a cached signature match
         with InterProcessLock(pathjoin(grz_tmp(), "fm_sigcache.lock")):
             collector = Collector()
-            cache_sig_file, cache_metadata = collector.search(report.crash_info)
-            if cache_metadata is not None:
-                if cache_metadata["frequent"]:
-                    LOG.info(
-                        "Frequent crash matched existing signature: %s",
-                        cache_metadata["shortDescription"],
-                    )
-                    if not self.force_report:
-                        return None
-                elif "bug__id" in cache_metadata:
-                    LOG.info(
-                        "Crash matched existing signature (bug %s): %s",
-                        cache_metadata["bug__id"],
-                        cache_metadata["shortDescription"],
-                    )
-                    # we will still report this one, but no more
-                    cache_metadata["frequent"] = True
-                # there is already a signature, initialize count
-                cache_metadata.setdefault("_grizzly_seen_count", 0)
-            else:
-                # there is no signature, create one locally so we can count
-                # the number of times we've seen it
-                max_frames = report.crash_signature_max_frames(report.crash_info)
-                cache_sig_file = collector.generate(
-                    report.crash_info, numFrames=max_frames
-                )
-                cache_metadata = {
-                    "_grizzly_seen_count": 0,
-                    "frequent": False,
-                    "shortDescription": report.crash_info.createShortSignature(),
-                }
-            if cache_sig_file is None:
-                if self._ignored(report):
-                    LOG.info("Report is unsupported and is in ignore list")
-                    return None
-                LOG.warning("Report is unsupported by FM, saved to %r", report.path)
-                # TODO: we should check if stackhasher failed too
-                raise RuntimeError("Failed to create FM signature")
-            # limit the number of times we report per cycle
-            cache_metadata["_grizzly_seen_count"] += 1
-            if cache_metadata["_grizzly_seen_count"] >= self.max_reports:
-                # we will still report this one, but no more
-                cache_metadata["frequent"] = True
-            metadata_file = cache_sig_file.replace(".signature", ".metadata")
-            with open(metadata_file, "w") as meta_fp:
-                dump(cache_metadata, meta_fp)
+            _, cache_metadata = collector.search(report.crash_info)
+
+        # check if signature has been marked as frequent in FM
+        if cache_metadata is not None and cache_metadata["frequent"]:
+            LOG.info(
+                "Frequent crash matched existing signature: %s",
+                cache_metadata["shortDescription"],
+            )
+            return None
+
+        if self._ignored(report):
+            LOG.info("Report is in ignore list")
+            return None
 
         if report.is_hang:
             self.add_extra_metadata("is_hang", True)
@@ -310,9 +274,10 @@ def _submit_report(self, report, test_cases):
             self.quality = Quality.NO_TESTCASE
         report.crash_info.configuration.addMetadata(self._extra_metadata)
 
+        # TODO: this should likely move to ffpuppet
         # grab screen log (used in automation)
         if getenv("WINDOW") is not None:
-            screen_log = pathjoin(getcwd(), ".".join(["screenlog", getenv("WINDOW")]))
+            screen_log = pathjoin(getcwd(), "screenlog.%s" % (getenv("WINDOW"),))
             if isfile(screen_log):
                 target_log = pathjoin(report.path, "screenlog.txt")
                 copyfile(screen_log, target_log)
@@ -333,12 +298,7 @@ def _submit_report(self, report, test_cases):
             # override tool name if specified
             if self.tool is not None:
                 collector.tool = self.tool
-            # announce shortDescription if crash is not in a bucket
-            if (
-                cache_metadata["_grizzly_seen_count"] == 1
-                and not cache_metadata["frequent"]
-            ):
-                LOG.info("Submitting new crash %r", cache_metadata["shortDescription"])
+
             # submit results to the FuzzManager server
             new_entry = collector.submit(
                 report.crash_info, testCase=zip_name, testCaseQuality=self.quality.value
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 8ef1bf25..043ad134 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -4,11 +4,11 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """test Grizzly Reporter"""
 # pylint: disable=protected-access
-import sys
-import tarfile
+from sys import platform
+from tarfile import open as tar_open
 
-import pytest
 from FTB.ProgramConfiguration import ProgramConfiguration
+from pytest import importorskip, mark, raises
 
 from .report import Report
 from .reporter import (
@@ -102,7 +102,7 @@ def test_filesystem_reporter_03(tmp_path):
     (log_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     reporter = FilesystemReporter(str(tmp_path / "reports"))
     reporter.min_space = 2 ** 50
-    with pytest.raises(RuntimeError, match="Running low on disk space"):
+    with raises(RuntimeError, match="Running low on disk space"):
         reporter.submit([], Report(str(log_path), "fake_bin"))
 
 
@@ -124,7 +124,7 @@ def test_fuzzmanager_reporter_01(mocker, tmp_path):
     fake_reporter.fromBinary.return_value = mocker.Mock(spec_set=ProgramConfiguration)
     # missing global FM config file
     FuzzManagerReporter.FM_CONFIG = "no_file"
-    with pytest.raises(IOError, match="Missing: no_file"):
+    with raises(IOError, match="Missing: no_file"):
         FuzzManagerReporter.sanity_check("fake")
     # missing binary FM config file
     fake_fmc = tmp_path / ".fuzzmanagerconf"
@@ -132,7 +132,7 @@ def test_fuzzmanager_reporter_01(mocker, tmp_path):
     fake_bin = tmp_path / "bin"
     fake_bin.touch()
     FuzzManagerReporter.FM_CONFIG = str(fake_fmc)
-    with pytest.raises(IOError, match="bin.fuzzmanagerconf"):
+    with raises(IOError, match="bin.fuzzmanagerconf"):
         FuzzManagerReporter.sanity_check(str(fake_bin))
     # success
     (tmp_path / "bin.fuzzmanagerconf").touch()
@@ -140,20 +140,29 @@ def test_fuzzmanager_reporter_01(mocker, tmp_path):
     assert fake_reporter.fromBinary.call_count == 1
 
 
-def test_fuzzmanager_reporter_02(mocker, tmp_path):
+@mark.parametrize(
+    "tests, frequent, ignored",
+    [
+        # report - without test
+        (False, False, False),
+        # report - with test
+        (True, False, False),
+        # report - frequent
+        (True, True, False),
+        # report - ignored
+        (True, False, True),
+    ],
+)
+def test_fuzzmanager_reporter_02(mocker, tmp_path, tests, frequent, ignored):
     """test FuzzManagerReporter.submit()"""
     mocker.patch(
         "grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path)
     )
     mocker.patch("grizzly.common.reporter.getenv", autospec=True, return_value="0")
-    fake_crashinfo = mocker.patch("grizzly.common.report.CrashInfo", autospec=True)
-    fake_crashinfo.fromRawCrashData.return_value.createShortSignature.return_value = (
-        "test [@ test]"
-    )
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
-    fake_collector.return_value.search.return_value = (None, None)
-    fake_collector.return_value.generate.return_value = str(
-        tmp_path / "fm_file.signature"
+    fake_collector.return_value.search.return_value = (
+        None,
+        {"frequent": frequent, "shortDescription": "[@ test]"},
     )
     log_path = tmp_path / "log_path"
     log_path.mkdir()
@@ -162,116 +171,29 @@ def test_fuzzmanager_reporter_02(mocker, tmp_path):
     (log_path / "log_stdout.txt").touch()
     (log_path / "rr-traces").mkdir()
     (tmp_path / "screenlog.0").touch()
-    fake_test = mocker.Mock(
-        spec_set=TestCase,
-        adapter_name="adapter",
-        env_vars={"TEST": "1"},
-        input_fname="input",
-    )
+    test_cases = list()
+    if tests:
+        fake_test = mocker.Mock(
+            spec_set=TestCase,
+            adapter_name="adapter",
+            env_vars={"TEST": "1"},
+            input_fname="input",
+        )
+        test_cases.append(fake_test)
     reporter = FuzzManagerReporter("fake_bin")
-    reporter.submit([fake_test], Report(str(log_path), "fake_bin", is_hang=True))
+    reporter._ignored = lambda x: ignored
+    reporter.submit(test_cases, Report(str(log_path), "fake_bin", is_hang=True))
     assert not log_path.is_dir()
-    assert fake_test.dump.call_count == 1
-    assert fake_collector.return_value.submit.call_count == 1
-    meta_data = (tmp_path / "fm_file.metadata").read_text()
-    assert '"frequent": false' in meta_data
-    assert '"_grizzly_seen_count": 1' in meta_data
-    assert '"shortDescription": "test [@ test]"' in meta_data
+    if frequent or ignored:
+        assert fake_collector.return_value.submit.call_count == 0
+        assert fake_test.dump.call_count == 0
+    else:
+        assert fake_collector.return_value.submit.call_count == 1
+        if tests:
+            assert fake_test.dump.call_count == 1
 
 
 def test_fuzzmanager_reporter_03(mocker, tmp_path):
-    """test FuzzManagerReporter.submit() - no test / mark as frequent"""
-    mocker.patch(
-        "grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path)
-    )
-    fake_crashinfo = mocker.patch("grizzly.common.report.CrashInfo", autospec=True)
-    fake_crashinfo.fromRawCrashData.return_value.createShortSignature.return_value = (
-        "test [@ test]"
-    )
-    fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
-    fake_collector.return_value.search.return_value = (None, None)
-    fake_collector.return_value.generate.return_value = str(
-        tmp_path / "fm_file.signature"
-    )
-    log_path = tmp_path / "log_path"
-    log_path.mkdir()
-    (log_path / "log_stderr.txt").touch()
-    (log_path / "log_stdout.txt").touch()
-    reporter = FuzzManagerReporter("fake_bin")
-    reporter.max_reports = 1
-    reporter.submit([], Report(str(log_path), "fake_bin"))
-    assert fake_collector.return_value.submit.call_count == 1
-    meta_data = (tmp_path / "fm_file.metadata").read_text()
-    assert '"frequent": true' in meta_data
-    assert '"_grizzly_seen_count": 1' in meta_data
-    assert '"shortDescription": "test [@ test]"' in meta_data
-
-
-def test_fuzzmanager_reporter_04(mocker, tmp_path):
-    """test FuzzManagerReporter.submit() hit frequent crash"""
-    mocker.patch("grizzly.common.report.CrashInfo", autospec=True)
-    fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
-    fake_collector.return_value.search.return_value = (
-        None,
-        {"frequent": True, "shortDescription": "[@ test]"},
-    )
-    log_path = tmp_path / "log_path"
-    log_path.mkdir()
-    (log_path / "log_stderr.txt").touch()
-    (log_path / "log_stdout.txt").touch()
-    reporter = FuzzManagerReporter("fake_bin")
-    reporter.submit([], Report(str(log_path), "fake_bin"))
-    fake_collector.return_value.submit.assert_not_called()
-
-
-def test_fuzzmanager_reporter_05(mocker, tmp_path):
-    """test FuzzManagerReporter.submit() hit existing crash"""
-    mocker.patch("grizzly.common.report.CrashInfo", autospec=True)
-    fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
-    fake_collector.return_value.search.return_value = (
-        None,
-        {"bug__id": 1, "frequent": False, "shortDescription": "[@ test]"},
-    )
-    log_path = tmp_path / "log_path"
-    log_path.mkdir()
-    (log_path / "log_stderr.txt").touch()
-    (log_path / "log_stdout.txt").touch()
-    reporter = FuzzManagerReporter("fake_bin")
-    reporter._ignored = lambda x: True
-    reporter.submit([], Report(str(log_path), "fake_bin"))
-    fake_collector.return_value.submit.assert_not_called()
-
-
-def test_fuzzmanager_reporter_06(mocker, tmp_path):
-    """test FuzzManagerReporter.submit() no signature"""
-    fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
-    fake_collector.return_value.search.return_value = (None, None)
-    fake_collector.return_value.generate.return_value = None
-    log_path = tmp_path / "log_path"
-    log_path.mkdir()
-    (log_path / "log_stderr.txt").touch()
-    (log_path / "log_stdout.txt").touch()
-    reporter = FuzzManagerReporter("fake_bin")
-    with pytest.raises(RuntimeError, match="Failed to create FM signature"):
-        reporter.submit([], Report(str(log_path), "fake_bin"))
-
-
-def test_fuzzmanager_reporter_07(mocker, tmp_path):
-    """test FuzzManagerReporter.submit() unsymbolized crash"""
-    fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
-    fake_collector.return_value.search.return_value = (None, None)
-    fake_collector.return_value.generate.return_value = None
-    log_path = tmp_path / "log_path"
-    log_path.mkdir()
-    (log_path / "log_stderr.txt").touch()
-    (log_path / "log_stdout.txt").touch()
-    reporter = FuzzManagerReporter("fake_bin")
-    reporter._ignored = lambda x: True
-    reporter.submit([], Report(str(log_path), "fake_bin"))
-    fake_collector.return_value.submit.assert_not_called()
-
-
-def test_fuzzmanager_reporter_08(mocker, tmp_path):
     """test FuzzManagerReporter._ignored()"""
     log_file = tmp_path / "test.log"
     log_file.touch()
@@ -296,20 +218,18 @@ def test_s3fuzzmanager_reporter_01(mocker, tmp_path):
     mocker.patch("grizzly.common.reporter.FuzzManagerReporter", autospec=True)
     fake_bin = tmp_path / "bin"
     # test GRZ_S3_BUCKET missing
-    with pytest.raises(
-        EnvironmentError, match="'GRZ_S3_BUCKET' is not set in environment"
-    ):
+    with raises(EnvironmentError, match="'GRZ_S3_BUCKET' is not set in environment"):
         S3FuzzManagerReporter.sanity_check(str(fake_bin))
     # test GRZ_S3_BUCKET set
-    pytest.importorskip("boto3")
+    importorskip("boto3")
     mocker.patch("grizzly.common.reporter.getenv", autospec=True, return_value="test")
     S3FuzzManagerReporter.sanity_check(str(fake_bin))
 
 
 def test_s3fuzzmanager_reporter_02(mocker, tmp_path):
     """test S3FuzzManagerReporter._pre_submit()"""
-    pytest.importorskip("boto3")
-    pytest.importorskip("botocore")
+    importorskip("boto3")
+    importorskip("botocore")
     mocker.patch("grizzly.common.reporter.getenv", autospec=True, return_value="test")
     fake_resource = mocker.patch("grizzly.common.reporter.resource", autospec=True)
 
@@ -352,9 +272,7 @@ def __init__(self, message, response):
     assert fake_resource.return_value.meta.client.upload_file.call_count == 1
 
 
-@pytest.mark.skipif(
-    not sys.platform.startswith("linux"), reason="RR only supported on Linux"
-)
+@mark.skipif(not platform.startswith("linux"), reason="RR only supported on Linux")
 def test_s3fuzzmanager_reporter_03(tmp_path):
     """test S3FuzzManagerReporter.compress_rr_trace()"""
     # create fake trace
@@ -378,7 +296,7 @@ def test_s3fuzzmanager_reporter_03(tmp_path):
     S3FuzzManagerReporter.compress_rr_trace(str(src), str(dest))
     assert not src.is_dir()
     assert (dest / "rr.tar.bz2").is_file()
-    with tarfile.open(str(dest / "rr.tar.bz2"), "r:bz2") as arc_fp:
+    with tar_open(str(dest / "rr.tar.bz2"), "r:bz2") as arc_fp:
         entries = arc_fp.getnames()
     assert "echo-1" in entries
     assert "echo-0" not in entries
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 67c99af0..bde1a5af 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -665,8 +665,6 @@ def report(self, results, testcases, stats=None):
         for result in results:
             if self._report_to_fuzzmanager:
                 reporter = FuzzManagerReporter(self._report_tool)
-                if result.expected:
-                    reporter.force_report = True
             else:
                 report_dir = "reports" if result.expected else "other_reports"
                 reporter = FilesystemReporter(

From c55502e8db53412aec63f516ca4d0998439b3af0 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 30 Sep 2021 17:18:53 -0700
Subject: [PATCH 321/531] Set default report limit to 5

---
 grizzly/args.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 74d6a0ee..130e47ad 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -313,7 +313,7 @@ def __init__(self):
         self.reporter_grp.add_argument(
             "--limit-reports",
             type=int,
-            default=0,
+            default=5,
             help="Maximum number of times a unique result will be submitted."
             " This includes results submitted by parallel and previously run"
             " (within 24h) processes. This can help avoid spamming duplicate results."

From 03a9a20aa6937ea720335523ec86cbc7d87c07b6 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 1 Oct 2021 15:40:33 -0700
Subject: [PATCH 322/531] Automate layout of summary status reports

---
 grizzly/common/status_reporter.py      | 114 ++++++++++++++++---------
 grizzly/common/test_status_reporter.py |  33 ++++---
 2 files changed, 88 insertions(+), 59 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 81424b78..827ae13c 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -179,7 +179,6 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
         """Merge and generate a summary of status reports.
 
         Args:
-            filename (str): Path where output should be written.
             runtime (bool): Include total runtime in output
             sysinfo (bool): Include system info (CPU, disk, RAM... etc) in output
             timestamp (bool): Include time stamp in output
@@ -187,7 +186,7 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
         Returns:
             str: A summary of merged reports
         """
-        txt = list()
+        entries = list()
         # Job specific status
         if self.reports:
             # calculate totals
@@ -198,49 +197,73 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
             count = len(self.reports)
             total_ignored = sum(x.ignored for x in self.reports)
             total_iters = sum(iterations)
+
             # Iterations
-            txt.append("Iterations : %d" % (total_iters,))
+            disp = list()
+            disp.append(str(total_iters))
             if count > 1:
-                txt.append(" (%d, %d)" % (max(iterations), min(iterations)))
-            txt.append("\n")
+                disp.append(" (%d, %d)" % (max(iterations), min(iterations)))
+            entries.append(("Iterations", "".join(disp)))
+
             # Rate
-            txt.append("      Rate : %d @ %0.2f" % (count, round(sum(rates), 2)))
+            disp = list()
+            disp.append("%d @ %0.2f" % (count, round(sum(rates), 2)))
             if count > 1:
-                txt.append(
+                disp.append(
                     " (%0.2f, %0.2f)" % (round(max(rates), 2), round(min(rates), 2))
                 )
-            txt.append("\n")
-            # Results / Signature mismatch
-            txt.append("   Results : %d" % (sum(results),))
+            entries.append(("Rate", "".join(disp)))
+
+            # Results
+            disp = list()
+            disp.append(str(sum(results)))
             if total_ignored:
                 ignore_pct = total_ignored / float(total_iters) * 100
-                txt.append(
+                disp.append(
                     " (%d ignored @ %0.2f%%)" % (total_ignored, round(ignore_pct, 2))
                 )
+            entries.append(("Results", "".join(disp)))
+
             # Runtime
             if runtime:
-                txt.append("\n")
                 total_runtime = sum(x.runtime for x in self.reports)
-                txt.append("   Runtime : %s" % (timedelta(seconds=int(total_runtime)),))
+                entries.append(("Runtime", str(timedelta(seconds=int(total_runtime)))))
+
             # Log size
             log_usage = sum(log_sizes) / 1_048_576.0
             if log_usage > self.DISPLAY_LIMIT_LOG:
-                txt.append("\n")
-                txt.append("      Logs : %0.1fMB" % (log_usage,))
+                disp = list()
+                disp.append("%0.1fMB" % (log_usage,))
                 if count > 1:
-                    txt.append(
+                    disp.append(
                         " (%0.2fMB, %0.2fMB)"
                         % (max(log_sizes) / 1_048_576.0, min(log_sizes) / 1_048_576.0)
                     )
+                entries.append(("Logs", "".join(disp)))
         else:
-            txt.append("No status reports available")
+            entries.append(("No status reports available", None))
+
+        # System information
         if sysinfo:
-            txt.append("\n")
-            txt.append(self._sys_info())
+            entries.extend(self._sys_info())
+
+        # Timestamp
         if timestamp:
-            txt.append("\n")
-            txt.append(strftime(" Timestamp : %Y/%m/%d %X %z", gmtime()))
-        msg = "".join(txt)
+            entries.append(("Timestamp", strftime("%Y/%m/%d %X %z", gmtime())))
+
+        # Format output
+        label_lengths = tuple(len(x[0]) for x in entries if x[1])
+        max_len = max(label_lengths) if label_lengths else 0
+        msg = list()
+        for label, body in entries:
+            if body:
+                msg.append(
+                    "%s%s : %s" % ((" " * max(max_len - len(label), 0), label, body))
+                )
+            else:
+                msg.append(label)
+        msg = "\n".join(msg)
+
         if self.tracebacks:
             txt = self._merge_tracebacks(self.tracebacks, self.SUMMARY_LIMIT - len(msg))
             msg = "".join((msg, txt))
@@ -269,41 +292,50 @@ def _merge_tracebacks(tracebacks, size_limit):
 
     @staticmethod
     def _sys_info():
-        """Collect and format system information.
+        """Collect system information.
 
         Args:
             None
 
         Returns:
-            str: System information formatted to match output from _summary()
+            list(tuple): System information in tuples (label, display data).
         """
-        txt = list()
-        txt.append(
-            "CPU & Load : %d @ %0.1f%%"
+        entries = list()
+
+        # CPU and load
+        disp = list()
+        disp.append(
+            "%d @ %d%%"
             % (
-                cpu_count(),
-                cpu_percent(interval=StatusReporter.CPU_POLL_INTERVAL),
+                cpu_count(logical=False),
+                round(cpu_percent(interval=StatusReporter.CPU_POLL_INTERVAL)),
             )
         )
         if getloadavg is not None:
-            txt.append(" %s\n" % (str(getloadavg()),))
-        else:
-            txt.append("\n")
+            disp.append(" %s" % (str(getloadavg()),))
+        entries.append(("CPU & Load", "".join(disp)))
+
+        # memory usage
+        disp = list()
         mem_usage = virtual_memory()
-        txt.append("    Memory : ")
         if mem_usage.available < 1_073_741_824:  # < 1GB
-            txt.append("%dMB" % (mem_usage.available / 1_048_576,))
+            disp.append("%dMB" % (mem_usage.available / 1_048_576,))
         else:
-            txt.append("%0.1fGB" % (mem_usage.available / 1_073_741_824.0,))
-        txt.append(" of %0.1fGB free\n" % (mem_usage.total / 1_073_741_824.0,))
+            disp.append("%0.1fGB" % (mem_usage.available / 1_073_741_824.0,))
+        disp.append(" of %0.1fGB free" % (mem_usage.total / 1_073_741_824.0,))
+        entries.append(("Memory", "".join(disp)))
+
+        # disk usage
+        disp = list()
         usage = disk_usage("/")
-        txt.append("      Disk : ")
         if usage.free < 1_073_741_824:  # < 1GB
-            txt.append("%dMB" % (usage.free / 1_048_576,))
+            disp.append("%dMB" % (usage.free / 1_048_576,))
         else:
-            txt.append("%0.1fGB" % (usage.free / 1_073_741_824.0,))
-        txt.append(" of %0.1fGB free" % (usage.total / 1_073_741_824.0,))
-        return "".join(txt)
+            disp.append("%0.1fGB" % (usage.free / 1_073_741_824.0,))
+        disp.append(" of %0.1fGB free" % (usage.total / 1_073_741_824.0,))
+        entries.append(("Disk", "".join(disp)))
+
+        return entries
 
     @staticmethod
     def _tracebacks(path, ignore_kbi=True, max_preceeding=5):
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index f342c256..561e247a 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -17,11 +17,11 @@
 
 
 def _fake_sys_info():
-    return (
-        "CPU & Load : 64 @ 93.1% (85.25, 76.21, 51.06)\n"
-        "    Memory : 183.9GB of 251.9GB free\n"
-        "      Disk : 22.2GB of 28.7GB free"
-    )
+    return [
+        ("CPU & Load", "64 @ 93.1% (85.25, 76.21, 51.06)"),
+        ("Memory", "183.9GB of 251.9GB free"),
+        ("Disk", "22.2GB of 28.7GB free"),
+    ]
 
 
 def test_status_reporter_01(tmp_path):
@@ -94,21 +94,18 @@ def test_status_reporter_03(mocker, disk, memory, getloadavg):
             "grizzly.common.status_reporter.getloadavg", side_effect=getloadavg
         )
     sysinfo = StatusReporter._sys_info()
+    assert len(sysinfo) == 3
+    assert sysinfo[0][0] == "CPU & Load"
+    assert sysinfo[1][0] == "Memory"
+    assert sysinfo[2][0] == "Disk"
+    if getloadavg is not None:
+        assert sysinfo[0][-1].endswith("(0.12, 0.34, 0.56)")
     if disk.free < GBYTES or memory.available < GBYTES:
-        assert "MB" in sysinfo
+        assert "MB" in sysinfo[1][-1]
+        assert "MB" in sysinfo[2][-1]
     else:
-        assert "MB" not in sysinfo
-    lines = sysinfo.split("\n")
-    assert len(lines) == 3
-    assert "CPU & Load : " in lines[0]
-    if getloadavg is not None:
-        assert lines[0].endswith("(0.12, 0.34, 0.56)")
-    assert "Memory : " in lines[1]
-    assert "Disk : " in lines[2]
-    # verify alignment
-    position = len(lines[0].split(":")[0])
-    for line in lines:
-        assert line[position] == ":"
+        assert "MB" not in sysinfo[1][-1]
+        assert "MB" not in sysinfo[2][-1]
 
 
 def test_status_reporter_04(tmp_path):

From ba80e6351d51d150b17dd8a7e826891fe72a698a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 1 Oct 2021 17:39:23 -0700
Subject: [PATCH 323/531] Add ability to detect potential blocking results

---
 grizzly/common/status.py      | 16 ++++++++++++++++
 grizzly/common/test_status.py | 20 +++++++++++++++++++-
 2 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index ca3fd76b..fde27b4d 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -154,6 +154,22 @@ def __init__(
                 freq_limit=report_limit,
             )
 
+    def blockers(self, iters_per_result=100):
+        """Any result with an iterations-per-result ratio of less than or equal the
+        given limit are considered 'blockers'.
+
+        Args:
+            iters_per_result (int): Iterations-per-result threshold.
+
+        Yields:
+            tuple(int, str): Count and description of result.
+        """
+        assert iters_per_result > 0
+        if self.results:
+            for _, count, desc in self.results.all():
+                if self.iteration / count <= iters_per_result:
+                    yield count, desc
+
     @classmethod
     def loadall(cls, db_file, time_limit=300):
         """Load all status reports found in `db_file`.
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 55ab7fd3..db03e9d6 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -30,6 +30,7 @@ def test_status_01(mocker, tmp_path):
     assert status.pid is not None
     assert not status._enable_profiling
     assert not status._profiles
+    assert not any(status.blockers())
 
 
 def test_status_02(tmp_path):
@@ -50,7 +51,7 @@ def test_status_02(tmp_path):
 
 
 def test_status_03(tmp_path):
-    """test Status.load()"""
+    """test Status.loadall()"""
     db_file = str(tmp_path / "status.db")
     # create simple entry
     status = Status.start(db_file, enable_profiling=True)
@@ -219,6 +220,23 @@ def test_status_07(tmp_path):
     assert len(tuple(status.profile_entries())) == 3
 
 
+def test_status_08(tmp_path):
+    """test Status.blockers()"""
+    status = Status.start(str(tmp_path / "status.db"))
+    status.iteration = 10
+    assert not any(status.blockers())
+    status.results.count("uid1", "sig1")
+    assert not any(status.blockers(iters_per_result=3))
+    status.results.count("uid2", "sig2")
+    status.results.count("uid2", "sig2")
+    assert not any(status.blockers(iters_per_result=2))
+    blockers = tuple(status.blockers(iters_per_result=5))
+    assert len(blockers) == 1
+    assert blockers[0] == (2, "sig2")
+    blockers = tuple(status.blockers(iters_per_result=10))
+    assert len(blockers) == 2
+
+
 @mark.parametrize(
     "keys, counts, limit, local_only",
     [

From 10f72b3e8e67655ee589fe707251daf5fb46903d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 1 Oct 2021 17:48:07 -0700
Subject: [PATCH 324/531] Warn in summary report if potential blockers are
 detected

---
 grizzly/common/status_reporter.py      | 24 ++++++++++++++++++------
 grizzly/common/test_status_reporter.py | 12 +++++++-----
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 827ae13c..619d49e8 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -175,13 +175,16 @@ def _specific(self):
                 txt.append("\n")
         return "".join(txt)
 
-    def _summary(self, runtime=True, sysinfo=False, timestamp=False):
+    def _summary(
+        self, runtime=True, sysinfo=False, timestamp=False, iters_per_result=100
+    ):
         """Merge and generate a summary of status reports.
 
         Args:
             runtime (bool): Include total runtime in output
             sysinfo (bool): Include system info (CPU, disk, RAM... etc) in output
             timestamp (bool): Include time stamp in output
+            iters_per_result (int): Threshold for warning of potential blockers
 
         Returns:
             str: A summary of merged reports
@@ -215,14 +218,23 @@ def _summary(self, runtime=True, sysinfo=False, timestamp=False):
             entries.append(("Rate", "".join(disp)))
 
             # Results
-            disp = list()
-            disp.append(str(sum(results)))
+            if total_iters:
+                total_results = sum(results)
+                result_pct = total_results / float(total_iters) * 100
+                disp = list()
+                disp.append("%d @ %0.1f%%" % (total_results, round(result_pct, 1)))
+                if any(
+                    x.blockers(iters_per_result=iters_per_result) for x in self.reports
+                ):
+                    disp.append(" (Blockers)")
+                entries.append(("Results", "".join(disp)))
+
+            # Ignored
             if total_ignored:
                 ignore_pct = total_ignored / float(total_iters) * 100
-                disp.append(
-                    " (%d ignored @ %0.2f%%)" % (total_ignored, round(ignore_pct, 2))
+                entries.append(
+                    ("Ignored", "%d @ %0.1f%%" % (total_ignored, round(ignore_pct, 1)))
                 )
-            entries.append(("Results", "".join(disp)))
 
             # Runtime
             if runtime:
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 561e247a..917e0bfd 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -18,7 +18,7 @@
 
 def _fake_sys_info():
     return [
-        ("CPU & Load", "64 @ 93.1% (85.25, 76.21, 51.06)"),
+        ("CPU & Load", "64 @ 93% (85.25, 76.21, 51.06)"),
         ("Memory", "183.9GB of 251.9GB free"),
         ("Disk", "22.2GB of 28.7GB free"),
     ]
@@ -140,7 +140,7 @@ def test_status_reporter_05(mocker, tmp_path):
     assert "Iteration" in output
     assert "Rate" in output
     assert "Results" in output
-    assert "ignored" not in output
+    assert "Ignored" not in output
     assert "Logs" not in output
     assert "Runtime" not in output
     assert "Timestamp" not in output
@@ -158,12 +158,12 @@ def test_status_reporter_05(mocker, tmp_path):
     assert "Iteration" in output
     assert "Rate" in output
     assert "Results" in output
-    assert "ignored" in output
+    assert "Ignored" in output
     assert "Logs" in output
     assert "Runtime" in output
     assert "Timestamp" in output
     lines = output.split("\n")
-    assert len(lines) == 9
+    assert len(lines) == 10
     # verify alignment
     position = len(lines[0].split(":")[0])
     for line in lines:
@@ -334,7 +334,9 @@ def test_status_reporter_10(mocker, tmp_path):
     rptr = StatusReporter.load(db_file, tb_path=str(tmp_path))
     rptr._sys_info = _fake_sys_info
     assert len(rptr.tracebacks) == 10
-    merged_log = rptr._summary(runtime=True, sysinfo=True, timestamp=True)
+    merged_log = rptr._summary(
+        runtime=True, sysinfo=True, timestamp=True, iters_per_result=1
+    )
     assert len(merged_log) < StatusReporter.SUMMARY_LIMIT
 
 

From 00ace68d3d13675018f62b84a856e022bbe1af15 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 4 Oct 2021 17:00:27 -0700
Subject: [PATCH 325/531] Fix status db update race

---
 grizzly/common/status.py      | 10 ++++----
 grizzly/common/test_status.py | 44 +++++++++++++++++++----------------
 2 files changed, 28 insertions(+), 26 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index fde27b4d..c57beb73 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -37,7 +37,7 @@ def _db_version_check(db_file, expected=DB_VERSION):
     assert expected > 0
     with connect(db_file, isolation_level=None) as con:
         cur = con.cursor()
-        cur.execute("BEGIN")
+        cur.execute("BEGIN EXCLUSIVE;")
         # check db version
         cur.execute("PRAGMA user_version;")
         version = cur.fetchone()[0]
@@ -48,14 +48,12 @@ def _db_version_check(db_file, expected=DB_VERSION):
             for entry in cur.fetchall():
                 LOG.debug("dropping table %r", entry[0])
                 cur.execute("DROP TABLE IF EXISTS %s;" % (entry[0],))
-            # try to detect if there is a race
-            cur.execute("PRAGMA user_version;")
-            assert version == cur.fetchone()[0]
             # update db version number
             cur.execute("PRAGMA user_version = %d;" % (expected,))
             con.commit()
-        else:
-            cur.execute("ROLLBACK")
+        elif version > expected:
+            # this can only happen is old code is run after a db update
+            LOG.error("db version %d > expected %d", version, expected)
 
 
 class Status:
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index db03e9d6..f2d90436 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -111,45 +111,49 @@ def test_status_05(mocker, tmp_path):
     assert loaded.rate == 1.0
 
 
-def _client_writer(done, reported, db_file):
+# NOTE: this function must be at the top level to work on Windows
+def _client_writer(db_file, begin, count):
     """Used by test_status_06"""
-    # NOTE: this must be at the top level to work on Windows
+    begin.wait(timeout=45)
     status = Status.start(db_file)
-    while not done.is_set():
+    for _ in range(count):
         status.iteration += 1
         status.report(force=True)
-        # perform two reports before setting flag
-        if not reported.is_set() and status.iteration > 1:
-            reported.set()
         sleep(0.01)
 
 
 def test_status_06(tmp_path):
-    """test Status.loadall() with multiple active reporters"""
+    """test Status.loadall() with multiple active clients in parallel"""
+    begin = Event()
+    clients = 10
     db_file = str(tmp_path / "status.db")
-    done = Event()
+    iter_count = 2
     procs = list()
-    report_events = list()
     try:
-        # launch processes
-        for _ in range(10):
-            report_events.append(Event())
+        # create and launch client processes
+        for _ in range(clients):
             procs.append(
-                Process(target=_client_writer, args=(done, report_events[-1], db_file))
+                Process(target=_client_writer, args=(db_file, begin, iter_count))
             )
             procs[-1].start()
-        # wait for processes to launch and report
-        for event in report_events:
-            assert event.wait(timeout=60)
+        # synchronize client processes (not perfect but good enough)
+        begin.set()
+        # wait for processes to report and exit
+        for proc in procs:
+            proc.join(timeout=60)
+            assert proc.exitcode == 0
         # collect reports
         reports = tuple(Status.loadall(db_file))
-        assert len(reports) == len(procs)
+        # check that each process created a report
+        assert len(reports) == clients
+        # check reported data
         assert max(x.rate for x in reports) > 0
+        assert sum(x.iteration for x in reports) == iter_count * clients
     finally:
-        done.set()
         for proc in procs:
-            if proc.pid is not None:
-                proc.join()
+            if proc.exitcode is None:
+                proc.terminate()
+            proc.join()
 
 
 def test_status_07(tmp_path):

From 99be7e2662d92ce1fb3b260b7ccce3633af697a3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 4 Oct 2021 17:58:50 -0700
Subject: [PATCH 326/531] Tighten up db version check assertions

---
 grizzly/common/status.py      | 20 ++++++++++----------
 grizzly/common/test_status.py | 11 +++++------
 2 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index c57beb73..6481eeed 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -32,7 +32,7 @@ def _db_version_check(db_file, expected=DB_VERSION):
         expected (int): The latest database version.
 
     Returns:
-        None
+        bool: True if database was reset other False.
     """
     assert expected > 0
     with connect(db_file, isolation_level=None) as con:
@@ -51,9 +51,9 @@ def _db_version_check(db_file, expected=DB_VERSION):
             # update db version number
             cur.execute("PRAGMA user_version = %d;" % (expected,))
             con.commit()
-        elif version > expected:
-            # this can only happen is old code is run after a db update
-            LOG.error("db version %d > expected %d", version, expected)
+            return True
+        assert version == expected, "code out of date?"
+        return False
 
 
 class Status:
@@ -184,9 +184,6 @@ def loadall(cls, db_file, time_limit=300):
         assert time_limit >= 0
         with connect(db_file) as con:
             cur = con.cursor()
-            # check db version
-            cur.execute("PRAGMA user_version;")
-            assert cur.fetchone()[0] <= DB_VERSION
             # check table exists
             cur.execute(
                 """SELECT name
@@ -195,6 +192,9 @@ def loadall(cls, db_file, time_limit=300):
                    AND name='status';"""
             )
             if cur.fetchone():
+                # check db version
+                cur.execute("PRAGMA user_version;")
+                assert cur.fetchone()[0] == DB_VERSION, "code out of date?"
                 # collect entries
                 cur.execute(
                     """SELECT pid,
@@ -525,9 +525,6 @@ def load(cls, db_file, pid, time_limit):
         assert time_limit >= 0
         with connect(db_file) as con:
             cur = con.cursor()
-            # check db version
-            cur.execute("PRAGMA user_version;")
-            assert cur.fetchone()[0] <= DB_VERSION
             # check table exists
             cur.execute(
                 """SELECT name
@@ -536,6 +533,9 @@ def load(cls, db_file, pid, time_limit):
                    AND name='results';"""
             )
             if cur.fetchone():
+                # check db version
+                cur.execute("PRAGMA user_version;")
+                assert cur.fetchone()[0] == DB_VERSION, "code out of date?"
                 # collect entries
                 cur.execute(
                     """SELECT result_id,
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index f2d90436..5cde183e 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -10,7 +10,7 @@
 
 from pytest import mark
 
-from .status import ResultCounter, Status, _db_version_check
+from .status import DB_VERSION, ResultCounter, Status, _db_version_check
 
 
 def test_status_01(mocker, tmp_path):
@@ -402,11 +402,10 @@ def test_db_version_check_01(tmp_path):
     """test _db_version_check()"""
     db_path = str(tmp_path / "storage.db")
     # empty db
-    _db_version_check(db_path, expected=1)
+    assert _db_version_check(db_path, expected=DB_VERSION)
     # no update needed
+    assert not _db_version_check(db_path, expected=DB_VERSION)
+    # add db contents
     Status.start(db_path)
-    _db_version_check(db_path, expected=1)
     # force update
-    _db_version_check(db_path, expected=2)
-    # verify everything works after update
-    Status.start(db_path)
+    assert _db_version_check(db_path, expected=DB_VERSION + 1)

From c6ac56502a3e77186383d68659d5161387d0b900 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 5 Oct 2021 16:56:34 -0700
Subject: [PATCH 327/531] Update status reporter command line flags

---
 grizzly/common/status_reporter.py      | 61 ++++++++++++++++++++------
 grizzly/common/test_status_reporter.py | 52 +++++++++++++++-------
 2 files changed, 82 insertions(+), 31 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 619d49e8..18cecc5d 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -222,9 +222,12 @@ def _summary(
                 total_results = sum(results)
                 result_pct = total_results / float(total_iters) * 100
                 disp = list()
-                disp.append("%d @ %0.1f%%" % (total_results, round(result_pct, 1)))
+                disp.append("%d" % (total_results,))
+                if total_results:
+                    disp.append(" @ %0.1f%%" % (round(result_pct, 1),))
                 if any(
-                    x.blockers(iters_per_result=iters_per_result) for x in self.reports
+                    any(x.blockers(iters_per_result=iters_per_result))
+                    for x in self.reports
                 ):
                     disp.append(" (Blockers)")
                 entries.append(("Results", "".join(disp)))
@@ -471,7 +474,7 @@ def __str__(self):
         return "\n".join(["Log: %r" % self.file_name] + self.prev_lines + self.lines)
 
 
-def main(args=None, modes=None):
+def main(args=None):
     """Merge Grizzly status files into a single report (main entrypoint).
 
     Args:
@@ -488,14 +491,34 @@ def main(args=None, modes=None):
         log_fmt = "[%(asctime)s] %(message)s"
     basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
 
-    if not modes:
-        modes = {"fuzz": Session.STATUS_DB}
+    # TODO: add support for reducer
+    modes = {"fuzzing": Session.STATUS_DB}
+
+    # report types: define name and time range of scan
+    report_types = {
+        # include status reports from the last 2 minutes
+        "active": 120,
+        # include status reports from the last 8 hours
+        "complete": 28800,
+    }
+
     parser = ArgumentParser(description="Grizzly status report generator")
-    parser.add_argument("--dump", help="File to write report to")
     parser.add_argument(
-        "--mode",
-        default="fuzz",
-        help="Report mode. Available modes: %s (default: 'fuzz')" % (", ".join(modes),),
+        "--dump", help="File to write report to, existing files will be overwritten."
+    )
+    parser.add_argument(
+        "--type",
+        choices=report_types.keys(),
+        default="active",
+        help="Report type. active: Current snapshot of activity, complete: "
+        "Aggregate summary of all jobs over a longer duration (8h). "
+        "(default: active)",
+    )
+    parser.add_argument(
+        "--scan-mode",
+        choices=modes.keys(),
+        default="fuzzing",
+        help="Report mode. (default: fuzzing)",
     )
     parser.add_argument(
         "--system-report",
@@ -507,20 +530,30 @@ def main(args=None, modes=None):
         help="Scan path for Python tracebacks found in screenlog.# files",
     )
     args = parser.parse_args(args)
-    if args.mode not in modes:
-        parser.error("Invalid mode %r" % args.mode)
     if args.tracebacks and not isdir(args.tracebacks):
         parser.error("--tracebacks must be a directory")
 
-    status_db = modes.get(args.mode)
-    reporter = StatusReporter.load(db_file=status_db, tb_path=args.tracebacks)
+    status_db = modes.get(args.scan_mode)
+    reporter = StatusReporter.load(
+        db_file=status_db,
+        tb_path=args.tracebacks,
+        time_limit=report_types[args.type],
+    )
     if args.dump:
-        reporter.dump_summary(args.dump)
+        if args.type == "active":
+            reporter.dump_summary(
+                args.dump, runtime=False, sysinfo=True, timestamp=True
+            )
+        else:
+            reporter.dump_summary(
+                args.dump, runtime=True, sysinfo=False, timestamp=False
+            )
         return 0
 
     if not reporter.reports:
         print("Grizzly Status - No status reports to display")
         return 0
+
     print(
         "Grizzly Status - %s - Instance report frequency: %ds\n"
         % (strftime("%Y/%m/%d %X"), Status.REPORT_FREQ)
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 917e0bfd..7a29f32c 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -140,6 +140,7 @@ def test_status_reporter_05(mocker, tmp_path):
     assert "Iteration" in output
     assert "Rate" in output
     assert "Results" in output
+    assert "Blockers" not in output
     assert "Ignored" not in output
     assert "Logs" not in output
     assert "Runtime" not in output
@@ -511,42 +512,59 @@ def test_traceback_report_08(tmp_path):
     assert "AssertionError" in output
 
 
-def test_main_01(tmp_path):
+def test_main_01(mocker, tmp_path):
     """test main() with no reports"""
-    db_file = str(tmp_path / "status.db")
-    StatusReporter.CPU_POLL_INTERVAL = 0.01
-    assert main([], modes={"fuzz": db_file}) == 0
+    mocker.patch("grizzly.session.Session.STATUS_DB", str(tmp_path / "status.db"))
+    mocker.patch(
+        "grizzly.common.status_reporter.StatusReporter.CPU_POLL_INTERVAL", 0.01
+    )
+    assert main([]) == 0
 
 
-def test_main_02(tmp_path):
+def test_main_02(mocker, tmp_path):
     """test main() with a report"""
     db_file = str(tmp_path / "status.db")
-    StatusReporter.CPU_POLL_INTERVAL = 0.01
+    mocker.patch("grizzly.session.Session.STATUS_DB", db_file)
+    mocker.patch(
+        "grizzly.common.status_reporter.StatusReporter.CPU_POLL_INTERVAL", 0.01
+    )
     status = Status.start(db_file=db_file)
     status.iteration = 1
     status.results.count("uid", "[@ test]")
     status.report(force=True)
-    assert main([], modes={"fuzz": db_file}) == 0
+    assert main([]) == 0
 
 
-def test_main_03(tmp_path):
+@mark.parametrize(
+    "report_type",
+    [
+        "active",
+        "complete",
+    ],
+)
+def test_main_03(mocker, tmp_path, report_type):
     """test main() --dump"""
     db_file = str(tmp_path / "status.db")
-    StatusReporter.CPU_POLL_INTERVAL = 0.01
+    mocker.patch("grizzly.session.Session.STATUS_DB", db_file)
+    mocker.patch(
+        "grizzly.common.status_reporter.StatusReporter.CPU_POLL_INTERVAL", 0.01
+    )
     status = Status.start(db_file=db_file)
     status.iteration = 1
     status.report(force=True)
     dump_file = tmp_path / "output.txt"
-    assert main(["--dump", str(dump_file)], modes={"fuzz": db_file}) == 0
+    assert main(["--dump", str(dump_file), "--type", report_type]) == 0
     assert dump_file.is_file()
-    assert b"Runtime" not in dump_file.read_bytes()
-    # assert False, dump_file.read_bytes()
+    if report_type == "active":
+        assert b"Runtime" not in dump_file.read_bytes()
+    else:
+        assert b"Timestamp" not in dump_file.read_bytes()
 
 
-def test_main_04(tmp_path):
+def test_main_04(capsys, mocker, tmp_path):
     """test main() with invalid args"""
-    db_file = str(tmp_path / "status.db")
-    with raises(SystemExit):
-        main(["--mode", "invalid"], modes={"fuzz": db_file})
+    mocker.patch("grizzly.session.Session.STATUS_DB", str(tmp_path / "status.db"))
+
     with raises(SystemExit):
-        main(["--tracebacks", "missing"], modes={"fuzz": db_file})
+        main(["--tracebacks", "missing"])
+    assert "--tracebacks must be a directory" in capsys.readouterr()[-1]

From aeb86ea0907881f44b67714ea0557a16dbade5cb Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 7 Oct 2021 13:27:56 -0700
Subject: [PATCH 328/531] Only lock db when update is required

Don't lock db to perform initial version check.
---
 grizzly/common/status.py      | 33 +++++++++++++++++++--------------
 grizzly/common/test_status.py | 16 ++++++++++++++--
 2 files changed, 33 insertions(+), 16 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 6481eeed..f3138a03 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -37,23 +37,28 @@ def _db_version_check(db_file, expected=DB_VERSION):
     assert expected > 0
     with connect(db_file, isolation_level=None) as con:
         cur = con.cursor()
-        cur.execute("BEGIN EXCLUSIVE;")
-        # check db version
+        # collect db version
         cur.execute("PRAGMA user_version;")
         version = cur.fetchone()[0]
+        # check if an update is required
         if version < expected:
-            LOG.debug("db version %d < %d", version, expected)
-            # remove ALL tables from the database
-            cur.execute("SELECT name FROM sqlite_master WHERE type='table';")
-            for entry in cur.fetchall():
-                LOG.debug("dropping table %r", entry[0])
-                cur.execute("DROP TABLE IF EXISTS %s;" % (entry[0],))
-            # update db version number
-            cur.execute("PRAGMA user_version = %d;" % (expected,))
-            con.commit()
-            return True
-        assert version == expected, "code out of date?"
-        return False
+            cur.execute("BEGIN EXCLUSIVE;")
+            # check db version while locked to avoid race
+            cur.execute("PRAGMA user_version;")
+            version = cur.fetchone()[0]
+            if version < expected:
+                LOG.debug("db version %d < %d", version, expected)
+                # remove ALL tables from the database
+                cur.execute("SELECT name FROM sqlite_master WHERE type='table';")
+                for entry in cur.fetchall():
+                    LOG.debug("dropping table %r", entry[0])
+                    cur.execute("DROP TABLE IF EXISTS %s;" % (entry[0],))
+                # update db version number
+                cur.execute("PRAGMA user_version = %d;" % (expected,))
+                con.commit()
+                return True
+    assert version == expected, "code out of date?"
+    return False
 
 
 class Status:
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 5cde183e..aaea3005 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -122,12 +122,21 @@ def _client_writer(db_file, begin, count):
         sleep(0.01)
 
 
-def test_status_06(tmp_path):
+@mark.parametrize(
+    "loads_in_parallel",
+    [
+        # only test reporting in parallel
+        0,
+        # test reporting and loading in parallel
+        5,
+    ],
+)
+def test_status_06(tmp_path, loads_in_parallel):
     """test Status.loadall() with multiple active clients in parallel"""
     begin = Event()
     clients = 10
     db_file = str(tmp_path / "status.db")
-    iter_count = 2
+    iter_count = 5
     procs = list()
     try:
         # create and launch client processes
@@ -138,6 +147,9 @@ def test_status_06(tmp_path):
             procs[-1].start()
         # synchronize client processes (not perfect but good enough)
         begin.set()
+        # attempt parallel loads
+        for _ in range(loads_in_parallel):
+            tuple(Status.loadall(db_file))
         # wait for processes to report and exit
         for proc in procs:
             proc.join(timeout=60)

From 10f21caef3bc4ab59d8e7af10afddcf853dee2a9 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 7 Oct 2021 13:34:50 -0700
Subject: [PATCH 329/531] Include both logical and physical cores in summary
 status report

---
 grizzly/common/status_reporter.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 18cecc5d..66f908e7 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -320,8 +320,9 @@ def _sys_info():
         # CPU and load
         disp = list()
         disp.append(
-            "%d @ %d%%"
+            "%d (%d) @ %d%%"
             % (
+                cpu_count(logical=True),
                 cpu_count(logical=False),
                 round(cpu_percent(interval=StatusReporter.CPU_POLL_INTERVAL)),
             )

From 6cd48583092df5866ea0046792e7326d054d768d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 8 Oct 2021 14:44:50 -0700
Subject: [PATCH 330/531] Handle FM signature creation failures

---
 grizzly/common/report.py      |   4 ++
 grizzly/common/test_report.py |  23 ++++---
 grizzly/replay/replay.py      |  27 ++++----
 grizzly/replay/test_replay.py | 118 ++++++++++++++++++++--------------
 grizzly/session.py            |   6 +-
 grizzly/test_session.py       |  35 ++++++----
 6 files changed, 127 insertions(+), 86 deletions(-)

diff --git a/grizzly/common/report.py b/grizzly/common/report.py
index 40b89844..efa8e07c 100644
--- a/grizzly/common/report.py
+++ b/grizzly/common/report.py
@@ -93,6 +93,8 @@ def calc_hash(signature):
         Returns:
             str: Hash of the raw signature.
         """
+        if signature is None:
+            return "NO_SIGNATURE"
         return sha1(signature.rawSignature.encode("utf-8")).hexdigest()[:16]
 
     def cleanup(self):
@@ -189,6 +191,8 @@ def crash_signature(self):
                 self._signature = self.crash_info.createCrashSignature(
                     maxFrames=self.crash_signature_max_frames(self.crash_info)
                 )
+            if self._signature is None:
+                LOG.debug("failed to create FM signature")
         return self._signature
 
     @staticmethod
diff --git a/grizzly/common/test_report.py b/grizzly/common/test_report.py
index f38ebe81..8abf78fb 100644
--- a/grizzly/common/test_report.py
+++ b/grizzly/common/test_report.py
@@ -305,21 +305,22 @@ def test_report_12(tmp_path):
 
 
 @pytest.mark.parametrize(
-    "sig_data",
+    "sig_cache, has_sig",
     [
         # signature exists in cache
-        '{"symptoms": [{"functionNames": ["a"],"type": "stackFrames"}]}',
+        ('{"symptoms": [{"functionNames": ["a"],"type": "stackFrames"}]}', True),
         # no signature
-        None,
+        (None, True),
+        (None, False),
     ],
 )
-def test_report_13(mocker, tmp_path, sig_data):
+def test_report_13(mocker, tmp_path, sig_cache, has_sig):
     """test Report.crash_signature and Report.crash_hash"""
     mocker.patch("grizzly.common.reporter.ProgramConfiguration", autospec=True)
     collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
-    if sig_data:
+    if sig_cache:
         sig_file = tmp_path / "cache.sig"
-        sig_file.write_text(sig_data)
+        sig_file.write_text(sig_cache)
         collector.return_value.search.return_value = (str(sig_file), None)
         collector.return_value.sigCacheDir = str(sig_file)
     else:
@@ -327,11 +328,15 @@ def test_report_13(mocker, tmp_path, sig_data):
         collector.return_value.search.return_value = (None, None)
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    _create_crash_log(tmp_path / "log_asan_blah.txt")
+    if has_sig:
+        _create_crash_log(tmp_path / "log_asan_blah.txt")
     report = Report(str(tmp_path), "bin")
     assert report._signature is None
-    assert report.crash_signature
-    assert report.crash_info.createShortSignature() == "[@ foo]"
+    if has_sig:
+        assert report.crash_signature
+        assert report.crash_info.createShortSignature() == "[@ foo]"
+    else:
+        assert not report.crash_signature
     assert report.crash_hash
 
 
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 27ff2bc2..27ad3ab0 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -93,7 +93,8 @@ def signature(self):
     @staticmethod
     def check_match(signature, report, expect_hang):
         if signature is None:
-            return False
+            # Treat 'None' signature as a bucket if it's not a hang
+            return not report.is_hang
         if expect_hang and not report.is_hang:
             # avoid catching other crashes with forgiving hang signatures
             return False
@@ -359,30 +360,29 @@ def run(
                     # check signatures
                     if run_result.timeout:
                         short_sig = "Potential hang detected"
-                    else:
+                    elif report.crash_signature is not None:
                         short_sig = report.crash_info.createShortSignature()
+                    else:
+                        # FM crash signature creation failed
+                        short_sig = "Signature creation failed"
+
                     # set active signature
                     if (
                         not startup_error
                         and not self._any_crash
                         and not run_result.timeout
                         and self._signature is None
-                        and short_sig != "No crash detected"
                     ):
                         assert not expect_hang
                         LOG.debug("no signature given, using %r", short_sig)
                         self._signature = report.crash_signature
+
                     # bucket result
-                    if short_sig == "No crash detected":
-                        # TODO: verify report.major == "NO_STACK"
-                        # otherwise FM failed to parse the logs
-                        # TODO: change this to support hangs/timeouts, etc
-                        LOG.info("Result: No crash detected")
-                    elif not startup_error and (
+                    if not startup_error and (
                         self._any_crash
                         or self.check_match(self._signature, report, expect_hang)
                     ):
-                        if sig_hash:
+                        if sig_hash is not None:
                             LOG.debug("using provided signature (hash) to bucket")
                             bucket_hash = sig_hash
                         else:
@@ -428,15 +428,14 @@ def run(
                     self.status.ignored += 1
                     LOG.info("Result: Ignored (%d)", self.status.ignored)
 
-                if exit_early:
-                    # failed to meet minimum number of results
+                if exit_early and self.status.iteration < repeat:
+                    # check if failed to meet minimum number of results
                     if (
                         repeat - self.status.iteration + self.status.results.total
                         < min_results
                     ):
-                        if self.status.iteration < repeat:
-                            LOG.debug("skipping remaining attempts")
                         # failed to reproduce issue
+                        LOG.debug("skipping remaining attempts")
                         LOG.debug(
                             "results (%d) < minimum (%d), after %d attempts",
                             self.status.results.total,
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index b50c2579..35943d8f 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -7,7 +7,7 @@
 unit tests for grizzly.replay
 """
 from itertools import cycle
-from os.path import join as pathjoin
+from pathlib import Path
 
 from pytest import mark, raises
 
@@ -23,11 +23,10 @@
 
 def _fake_save_logs(result_logs, _meta=False):
     """write fake log data to disk"""
-    with open(pathjoin(result_logs, "log_stderr.txt"), "w") as log_fp:
-        log_fp.write("STDERR log\n")
-    with open(pathjoin(result_logs, "log_stdout.txt"), "w") as log_fp:
-        log_fp.write("STDOUT log\n")
-    with open(pathjoin(result_logs, "log_asan_blah.txt"), "w") as log_fp:
+    log_path = Path(result_logs)
+    (log_path / "log_stderr.txt").write_text("STDERR log\n")
+    (log_path / "log_stdout.txt").write_text("STDOUT log\n")
+    with (log_path / "log_asan_blah.txt").open("w") as log_fp:
         log_fp.write("==1==ERROR: AddressSanitizer: ")
         log_fp.write("SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n")
         log_fp.write("    #0 0xbad000 in foo /file1.c:123:234\n")
@@ -101,7 +100,16 @@ def test_replay_03(mocker):
             assert target.close.call_count == 1
 
 
-def test_replay_04(mocker):
+@mark.parametrize(
+    "good_sig",
+    [
+        # success - FM parsed signature
+        True,
+        # signature could not be parsed
+        False,
+    ],
+)
+def test_replay_04(mocker, good_sig):
     """test ReplayManager.run() - successful repro"""
     served = ["index.html"]
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
@@ -109,12 +117,25 @@ def test_replay_04(mocker):
     target = mocker.Mock(spec_set=Target, binary="C:\\fake_bin", launch_timeout=30)
     target.check_result.return_value = Result.FOUND
     target.monitor.is_healthy.return_value = False
-    target.save_logs = _fake_save_logs
+    if good_sig:
+        target.save_logs = _fake_save_logs
+    else:
+
+        def _save_logs(result_logs, _meta=False):
+            """create uninteresting logs"""
+            log_path = Path(result_logs)
+            (log_path / "log_stderr.txt").write_text("STDERR log\n")
+            (log_path / "log_stdout.txt").write_text("STDOUT log\n")
+
+        target.save_logs = _save_logs
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, relaunch=10) as replay:
             assert replay.signature is None
             results = replay.run([testcase], 10)
-            assert replay.signature is not None
+            if good_sig:
+                assert replay.signature is not None
+            else:
+                assert replay.signature is None
             assert replay.status.ignored == 0
             assert replay.status.iteration == 1
             assert replay.status.results.total == 1
@@ -277,8 +298,6 @@ def test_replay_08(mocker):
 def test_replay_09(mocker):
     """test ReplayManager.run() - test signatures - fail to meet minimum"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
-    report_0 = mocker.Mock(spec_set=Report)
-    report_0.crash_info.createShortSignature.return_value = "No crash detected"
     report_1 = mocker.Mock(
         spec_set=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
     )
@@ -292,7 +311,7 @@ def test_replay_09(mocker):
     )
     report_3.crash_info.createShortSignature.return_value = "[@ test2]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
-    fake_report.side_effect = (report_0, report_1, report_2, report_3)
+    fake_report.side_effect = (report_1, report_2, report_3)
     fake_report.calc_hash.return_value = "bucketHASH"
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
@@ -306,17 +325,16 @@ def test_replay_09(mocker):
     with ReplayManager(
         [], server, target, signature=signature, use_harness=False
     ) as replay:
-        results = replay.run(testcases, 10, repeat=4, min_results=2)
-        assert target.close.call_count == 5
+        results = replay.run(testcases, 10, repeat=3, min_results=2)
+        assert target.close.call_count == 4
         assert replay.signature == signature
-        assert replay.status.iteration == 4
+        assert replay.status.iteration == 3
         assert replay.status.results.total == 1
         assert replay.status.ignored == 2
-    assert fake_report.call_count == 4
+    assert fake_report.call_count == 3
     assert len(results) == 1
     assert not results[0].expected
     assert results[0].count == 2
-    assert report_0.cleanup.call_count == 1
     assert report_1.cleanup.call_count == 1
     assert report_2.cleanup.call_count == 0
     assert report_3.cleanup.call_count == 1
@@ -366,8 +384,6 @@ def test_replay_10(mocker):
 
 def test_replay_11(mocker):
     """test ReplayManager.run() - any crash - success"""
-    report_0 = mocker.Mock(spec_set=Report)
-    report_0.crash_info.createShortSignature.return_value = "No crash detected"
     report_1 = mocker.Mock(
         spec_set=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
     )
@@ -377,7 +393,7 @@ def test_replay_11(mocker):
     )
     report_2.crash_info.createShortSignature.return_value = "[@ test2]"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
-    fake_report.side_effect = (report_0, report_1, report_2)
+    fake_report.side_effect = (report_1, report_2)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
@@ -387,25 +403,22 @@ def test_replay_11(mocker):
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
     ]
     with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
-        results = replay.run(testcases, 10, repeat=3, min_results=2)
-        assert target.close.call_count == 4
+        results = replay.run(testcases, 10, repeat=2, min_results=2)
+        assert target.close.call_count == 3
         assert replay.signature is None
-        assert replay.status.iteration == 3
+        assert replay.status.iteration == 2
         assert replay.status.results.total == 2
         assert replay.status.ignored == 0
-    assert fake_report.call_count == 3
+    assert fake_report.call_count == 2
     assert len(results) == 2
     assert all(x.expected for x in results)
     assert sum(x.count for x in results if x.expected) == 2
-    assert report_0.cleanup.call_count == 1
     assert report_1.cleanup.call_count == 0
     assert report_2.cleanup.call_count == 0
 
 
 def test_replay_12(mocker):
     """test ReplayManager.run() - any crash - fail to meet minimum"""
-    report_0 = mocker.Mock(spec_set=Report)
-    report_0.crash_info.createShortSignature.return_value = "No crash detected"
     report_1 = mocker.Mock(
         spec_set=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
     )
@@ -414,14 +427,17 @@ def test_replay_12(mocker):
         spec_set=Report, crash_hash="hash2", major="0123abcd", minor="abcd9876"
     )
     report_2.crash_info.createShortSignature.return_value = "[@ test2]"
-    report_3 = mocker.Mock(spec_set=Report)
-    report_3.crash_info.createShortSignature.return_value = "No crash detected"
     fake_report = mocker.patch("grizzly.replay.replay.Report", autospec=True)
-    fake_report.side_effect = (report_0, report_1, report_2, report_3)
+    fake_report.side_effect = (report_1, report_2)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
     target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
-    target.check_result.return_value = Result.FOUND
+    target.check_result.side_effect = (
+        Result.NONE,
+        Result.FOUND,
+        Result.FOUND,
+        Result.NONE,
+    )
     target.monitor.is_healthy.return_value = False
     testcases = [
         mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
@@ -433,11 +449,9 @@ def test_replay_12(mocker):
         assert replay.status.iteration == 4
         assert replay.status.results.total == 2
         assert replay.status.ignored == 0
-    assert fake_report.call_count == 4
-    assert report_0.cleanup.call_count == 1
+    assert fake_report.call_count == 2
     assert report_1.cleanup.call_count == 1
     assert report_2.cleanup.call_count == 1
-    assert report_3.cleanup.call_count == 1
 
 
 def test_replay_13(mocker):
@@ -714,25 +728,30 @@ def test_replay_20(mocker, tmp_path):
 
 
 @mark.parametrize(
-    "is_hang, use_sig, match_sig, ignored, results",
+    "expect_hang, is_hang, use_sig, match_sig, ignored, results",
     [
         # reproduce expected hang
-        (True, True, True, 0, 1),
-        # expected hang (signature, no match)
-        (True, True, False, 1, 0),
-        # unexpected hang (signature, match)
-        (False, True, True, 0, 1),
+        (True, True, True, True, 0, 1),
+        # expected hang (signature, hang - no match)
+        (True, True, True, False, 1, 0),
+        # expected hang got crash (signature)
+        (True, False, True, False, 1, 0),
         # unexpected hang (signature, no match)
-        (False, True, False, 1, 0),
+        (False, True, True, False, 1, 0),
         # unexpected hang (no signature)
-        (False, False, False, 1, 0),
+        (False, True, False, False, 1, 0),
+        # unexpected crash (signature)
+        (False, False, True, False, 1, 0),
     ],
 )
-def test_replay_21(mocker, is_hang, use_sig, match_sig, ignored, results):
+def test_replay_21(mocker, expect_hang, is_hang, use_sig, match_sig, ignored, results):
     """test ReplayManager.run() - detect hangs"""
     served = ["index.html"]
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
-    server.serve_path.return_value = (Served.TIMEOUT, served)
+    server.serve_path.return_value = (
+        Served.TIMEOUT if is_hang else Served.ALL,
+        served,
+    )
     if use_sig:
         signature = mocker.Mock()
         signature.matches.return_value = match_sig
@@ -743,23 +762,24 @@ def test_replay_21(mocker, is_hang, use_sig, match_sig, ignored, results):
     target.check_result.return_value = Result.FOUND
     target.handle_hang.return_value = False
     target.save_logs = _fake_save_logs
+    target.monitor.is_healthy.return_value = False
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         testcase.hang = is_hang
         with ReplayManager(
             [], server, target, signature=signature, relaunch=10
         ) as replay:
-            found = replay.run([testcase], 10, expect_hang=is_hang)
+            found = replay.run([testcase], 10, expect_hang=expect_hang)
             assert replay.status.iteration == 1
             assert replay.status.ignored == ignored
             assert replay.status.results.total == results
-            assert target.handle_hang.call_count == 1
-            assert target.monitor.is_healthy.call_count == 0
-            assert target.close.call_count == 1
+            assert target.handle_hang.call_count == (1 if is_hang else 0)
+            assert target.monitor.is_healthy.call_count == (0 if is_hang else 1)
+            assert target.close.call_count == (1 if is_hang else 2)
         assert len(found) == 1
         assert found[0].count == 1
         assert found[0].expected == results
         assert found[0].report
-        assert found[0].report.is_hang
+        assert found[0].report.is_hang == is_hang
         assert len(found[0].served) == 1
         assert found[0].served[0] == served
         assert len(found[0].durations) == 1
diff --git a/grizzly/session.py b/grizzly/session.py
index d9e85111..31de12e8 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -255,7 +255,11 @@ def run(
                     short_sig = "Potential hang detected"
                 else:
                     bucket_hash = report.crash_hash
-                    short_sig = report.crash_info.createShortSignature()
+                    if report.crash_signature is not None:
+                        short_sig = report.crash_info.createShortSignature()
+                    else:
+                        # FM crash signature creation failed
+                        short_sig = "Signature creation failed"
                 seen = self.status.results.count(bucket_hash, short_sig)
                 LOG.info(
                     "Result: %s (%s:%s) - %d",
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index ad34f908..552b228f 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -171,30 +171,28 @@ def test_session_02(mocker, harness, relaunch, remaining):
 
 
 @mark.parametrize(
-    "harness, report_size, relaunch, iters",
+    "harness, report_size, relaunch, iters, has_sig",
     [
         # with harness, collect 1 test case
-        (True, 1, 1, 1),
+        (True, 1, 1, 1, True),
         # with harness, collect 2 test cases
-        (True, 2, 2, 2),
+        (True, 2, 2, 2, True),
         # with harness, collect 2 test cases,
-        (True, 2, 3, 3),
+        (True, 2, 3, 3, True),
         # with harness, collect 3 test cases, relaunch 1
-        (True, 3, 1, 3),
+        (True, 3, 1, 3, True),
         # without harness, collect 1 test case
-        (False, 1, 1, 1),
+        (False, 1, 1, 1, True),
         # without harness, collect 1 test case, 3 iterations
-        (False, 1, 1, 3),
+        (False, 1, 1, 3, True),
+        # with harness, collect 1 test case, failed to generate FM signature
+        (True, 1, 1, 1, False),
     ],
 )
-def test_session_03(mocker, harness, report_size, relaunch, iters):
+def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters, has_sig):
     """test Session - detecting failure"""
     adapter = SimpleAdapter(harness)
     reporter = mocker.Mock(spec_set=Reporter)
-    report = mocker.Mock(
-        spec_set=Report, major="major123", minor="minor456", crash_hash="123"
-    )
-    report.crash_info.createShortSignature.return_value = "[@ sig]"
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(
         spec_set=Target,
@@ -214,6 +212,18 @@ def test_session_03(mocker, harness, report_size, relaunch, iters):
         Result.FOUND
     ]
     target.log_size.return_value = 1
+    # create Report
+    log_path = tmp_path / "logs"
+    log_path.mkdir()
+    (log_path / "log_stderr.txt").write_bytes(b"STDERR log")
+    (log_path / "log_stdout.txt").write_bytes(b"STDOUT log")
+    if has_sig:
+        with (log_path / "log_asan_blah.txt").open("w") as log_fp:
+            log_fp.write("==1==ERROR: AddressSanitizer: ")
+            log_fp.write("SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n")
+            log_fp.write("    #0 0xbad000 in foo /file1.c:123:234\n")
+            log_fp.write("    #1 0x1337dd in bar /file2.c:1806:19\n")
+    report = Report(str(log_path), "bin")
     target.create_report.return_value = report
     with Session(
         adapter, reporter, server, target, relaunch=relaunch, report_size=report_size
@@ -225,7 +235,6 @@ def test_session_03(mocker, harness, report_size, relaunch, iters):
         session.run([], 10, input_path="file.bin", iteration_limit=iters)
         assert reporter.submit.call_count == 1
         assert len(reporter.submit.call_args[0][0]) == min(report_size, relaunch)
-        assert reporter.submit.call_args[0][1].major == "major123"
 
 
 def test_session_04(mocker):

From 0f52440a4dfe42cf6485977851ded1c9c326cc38 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 8 Oct 2021 15:05:07 -0700
Subject: [PATCH 331/531] [tests] Update patch missed when splitting file

---
 grizzly/common/test_report.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/grizzly/common/test_report.py b/grizzly/common/test_report.py
index 8abf78fb..edc408ea 100644
--- a/grizzly/common/test_report.py
+++ b/grizzly/common/test_report.py
@@ -2,7 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-"""test Grizzly Reporter"""
+"""test Grizzly Report"""
 # pylint: disable=protected-access
 
 import os
@@ -311,21 +311,21 @@ def test_report_12(tmp_path):
         ('{"symptoms": [{"functionNames": ["a"],"type": "stackFrames"}]}', True),
         # no signature
         (None, True),
+        # FM failed to generate signature
         (None, False),
     ],
 )
 def test_report_13(mocker, tmp_path, sig_cache, has_sig):
     """test Report.crash_signature and Report.crash_hash"""
-    mocker.patch("grizzly.common.reporter.ProgramConfiguration", autospec=True)
-    collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
+    mocker.patch("grizzly.common.report.ProgramConfiguration", autospec=True)
+    collector = mocker.patch("grizzly.common.report.Collector", autospec=True)
     if sig_cache:
         sig_file = tmp_path / "cache.sig"
         sig_file.write_text(sig_cache)
         collector.return_value.search.return_value = (str(sig_file), None)
-        collector.return_value.sigCacheDir = str(sig_file)
+        collector.return_value.sigCacheDir = str(tmp_path)
     else:
         collector.return_value.sigCacheDir = None
-        collector.return_value.search.return_value = (None, None)
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     if has_sig:

From a2673d6f2ceb810137592b6ab3d817878073ce5f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 11 Oct 2021 19:04:59 -0700
Subject: [PATCH 332/531] Make ResultCounter.load() batch load from db

---
 grizzly/common/status.py      | 48 ++++++++++++++++++++---------------
 grizzly/common/test_status.py | 21 ++++++++-------
 2 files changed, 38 insertions(+), 31 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index f3138a03..0e369712 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -217,16 +217,23 @@ def loadall(cls, db_file, time_limit=300):
             else:
                 entries = ()
 
+        results = ResultCounter.load(db_file, time_limit)
+
         for entry in entries:
-            status = cls()
-            status.pid = entry[0]
+            status = cls(pid=entry[0])
             status._profiles = loads(entry[1])
             status.ignored = entry[2]
             status.iteration = entry[3]
             status.log_size = entry[4]
             status.start_time = entry[5]
             status.timestamp = entry[6]
-            status.results = ResultCounter.load(db_file, status.pid, time_limit)
+            for counter in results:
+                if counter.pid == status.pid:
+                    status.results = counter
+                    break
+            else:
+                # no existing ResultCounter with matching pid found
+                status.results = ResultCounter(status.pid)
             yield status
 
     @contextmanager
@@ -418,7 +425,7 @@ class ResultCounter:
         "_desc",
         "_frequent",
         "_limit",
-        "_pid",
+        "pid",
     )
 
     def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=0):
@@ -430,7 +437,7 @@ def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=0):
         self._db_file = db_file
         self._frequent = set()
         self._limit = freq_limit
-        self._pid = pid
+        self.pid = pid
 
         # prepare database
         if self._db_file:
@@ -491,7 +498,7 @@ def count(self, result_id, desc):
                            count = ?
                        WHERE pid = ?
                        AND result_id = ?;""",
-                    (timestamp, self._count[result_id], self._pid, result_id),
+                    (timestamp, self._count[result_id], self.pid, result_id),
                 )
                 if cur.rowcount < 1:
                     cur.execute(
@@ -503,7 +510,7 @@ def count(self, result_id, desc):
                            count)
                            VALUES (?, ?, ?, ?, ?);""",
                         (
-                            self._pid,
+                            self.pid,
                             result_id,
                             desc,
                             timestamp,
@@ -514,19 +521,17 @@ def count(self, result_id, desc):
         return self._count[result_id]
 
     @classmethod
-    def load(cls, db_file, pid, time_limit):
+    def load(cls, db_file, time_limit):
         """Load existing entries for database and populate a ResultCounter.
 
         Args:
             db_file (str): Database file.
-            pid (int): PID of process that created the entries.
             time_limit (int): Used to filter older entries.
 
         Returns:
-            ResultCounter: ResultCounter loaded with data that matches given pid.
+            list: Loaded ResultCounters.
         """
         assert db_file
-        assert pid >= 0
         assert time_limit >= 0
         with connect(db_file) as con:
             cur = con.cursor()
@@ -543,23 +548,26 @@ def load(cls, db_file, pid, time_limit):
                 assert cur.fetchone()[0] == DB_VERSION, "code out of date?"
                 # collect entries
                 cur.execute(
-                    """SELECT result_id,
+                    """SELECT pid,
+                              result_id,
                               description,
                               count
                        FROM results
-                       WHERE pid = ?
-                       AND timestamp > ?;""",
-                    (pid, int(time()) - time_limit),
+                       WHERE timestamp > ?;""",
+                    (int(time()) - time_limit,),
                 )
                 entries = cur.fetchall()
             else:
                 entries = ()
 
-        loaded = cls(pid)
-        for result_id, desc, count in entries:
-            loaded._desc[result_id] = desc
-            loaded._count[result_id] = count
-        return loaded
+        loaded = dict()
+        for pid, result_id, desc, count in entries:
+            if pid not in loaded:
+                loaded[pid] = cls(pid)
+            loaded[pid]._desc[result_id] = desc
+            loaded[pid]._count[result_id] = count
+
+        return list(loaded.values())
 
     def get(self, result_id):
         """Get count and description for given result id.
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index aaea3005..388a9267 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -360,7 +360,7 @@ def test_report_counter_03(mocker, tmp_path):
     fake_time.return_value = 1
     db_path = str(tmp_path / "storage.db")
     # load empty db
-    ResultCounter.load(db_path, 123, 10)
+    assert not ResultCounter.load(db_path, 10)
     # create counter
     counter = ResultCounter(123, db_file=db_path, exp_limit=1)
     counter.count("a", "desc_a")
@@ -371,19 +371,18 @@ def test_report_counter_03(mocker, tmp_path):
     # filter out reports by time
     fake_time.return_value = 4
     # last 1 second
-    loaded = ResultCounter.load(db_path, counter._pid, 1)
-    assert loaded.total == 0
+    assert not ResultCounter.load(db_path, 1)
     # last 2 seconds
-    loaded = ResultCounter.load(db_path, counter._pid, 2)
+    loaded = ResultCounter.load(db_path, 2)[0]
     assert loaded.total == 1
     assert loaded.get("b") == (1, "desc_b")
     # last 3 seconds
-    loaded = ResultCounter.load(db_path, counter._pid, 3)
+    loaded = ResultCounter.load(db_path, 3)[0]
     assert loaded.get("a") == (2, "desc_a")
     assert loaded.total == 3
     # increase time limit
     fake_time.return_value = 4
-    loaded = ResultCounter.load(db_path, counter._pid, 10)
+    loaded = ResultCounter.load(db_path, 10)[0]
     assert loaded.total == counter.total == 3
     assert loaded.get("a") == (2, "desc_a")
     assert loaded.get("b") == (1, "desc_b")
@@ -398,15 +397,15 @@ def test_report_counter_04(mocker, tmp_path):
     counter.count("a", "desc_a")
     fake_time.return_value = 100
     counter.count("b", "desc_b")
-    loaded = ResultCounter.load(db_path, counter._pid, 100)
+    loaded = ResultCounter.load(db_path, 100)[0]
     assert loaded.total == 2
     # set exp_limit to zero to skip removing expired results
-    ResultCounter(123, db_file=db_path, exp_limit=0)
-    loaded = ResultCounter.load(db_path, counter._pid, 100)
+    ResultCounter(124, db_file=db_path, exp_limit=0)
+    loaded = ResultCounter.load(db_path, 100)[0]
     assert loaded.total == 2
     # clear expired records from database by setting exp_limit
-    ResultCounter(123, db_file=db_path, exp_limit=10)
-    loaded = ResultCounter.load(db_path, counter._pid, 100)
+    ResultCounter(125, db_file=db_path, exp_limit=10)
+    loaded = ResultCounter.load(db_path, 100)[0]
     assert loaded.total == 1
 
 

From ea0216fbdb147e627361f715f68175aa4bec5e7f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 11 Oct 2021 19:07:24 -0700
Subject: [PATCH 333/531] Avoid status data pid reuse

---
 grizzly/common/status.py      | 6 +++++-
 grizzly/common/test_status.py | 3 +++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 0e369712..1fa20129 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -32,7 +32,7 @@ def _db_version_check(db_file, expected=DB_VERSION):
         expected (int): The latest database version.
 
     Returns:
-        bool: True if database was reset other False.
+        bool: True if database was reset otherwise False.
     """
     assert expected > 0
     with connect(db_file, isolation_level=None) as con:
@@ -148,6 +148,8 @@ def __init__(
                         """DELETE FROM status WHERE timestamp <= ?;""",
                         (time() - exp_limit,),
                     )
+                # avoid (unlikely) pid reuse collision
+                con.execute("""DELETE FROM status WHERE pid = ?;""", (pid,))
                 con.commit()
 
             self.results = ResultCounter(
@@ -459,6 +461,8 @@ def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=0):
                         """DELETE FROM results WHERE timestamp <= ?;""",
                         (int(time() - exp_limit),),
                     )
+                # avoid (unlikely) pid reuse collision
+                con.execute("""DELETE FROM results WHERE pid = ?;""", (pid,))
                 con.commit()
 
     def all(self):
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 388a9267..1b3cd291 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -407,6 +407,9 @@ def test_report_counter_04(mocker, tmp_path):
     ResultCounter(125, db_file=db_path, exp_limit=10)
     loaded = ResultCounter.load(db_path, 100)[0]
     assert loaded.total == 1
+    # clear expired records from database by using duplicate pid
+    ResultCounter(123, db_file=db_path, exp_limit=1000)
+    assert not ResultCounter.load(db_path, 100)
 
 
 def test_db_version_check_01(tmp_path):

From 78943bca596c73dd7cc797c6a9d8a52a5a57acfc Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 12 Oct 2021 10:08:24 -0700
Subject: [PATCH 334/531] Properly close status db connection

---
 grizzly/common/status.py | 240 ++++++++++++++++++++++-----------------
 1 file changed, 133 insertions(+), 107 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 1fa20129..307cfa9d 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -35,7 +35,8 @@ def _db_version_check(db_file, expected=DB_VERSION):
         bool: True if database was reset otherwise False.
     """
     assert expected > 0
-    with connect(db_file, isolation_level=None) as con:
+    try:
+        con = connect(db_file)
         cur = con.cursor()
         # collect db version
         cur.execute("PRAGMA user_version;")
@@ -50,13 +51,15 @@ def _db_version_check(db_file, expected=DB_VERSION):
                 LOG.debug("db version %d < %d", version, expected)
                 # remove ALL tables from the database
                 cur.execute("SELECT name FROM sqlite_master WHERE type='table';")
-                for entry in cur.fetchall():
-                    LOG.debug("dropping table %r", entry[0])
-                    cur.execute("DROP TABLE IF EXISTS %s;" % (entry[0],))
-                # update db version number
-                cur.execute("PRAGMA user_version = %d;" % (expected,))
-                con.commit()
+                with con:
+                    for entry in cur.fetchall():
+                        LOG.debug("dropping table %r", entry[0])
+                        cur.execute("DROP TABLE IF EXISTS %s;" % (entry[0],))
+                    # update db version number
+                    cur.execute("PRAGMA user_version = %d;" % (expected,))
                 return True
+    finally:
+        con.close()
     assert version == expected, "code out of date?"
     return False
 
@@ -130,27 +133,31 @@ def __init__(
         if self._db_file:
             LOG.debug("status using db %r", self._db_file)
             _db_version_check(self._db_file)
-            with connect(self._db_file) as con:
-                # create table if needed
-                con.execute(
-                    """CREATE TABLE IF NOT EXISTS status (
-                       _profiles TEXT NOT NULL,
-                       ignored INTEGER NOT NULL,
-                       iteration INTEGER NOT NULL,
-                       log_size INTEGER NOT NULL,
-                       pid INTEGER UNIQUE NOT NULL,
-                       start_time REAL NOT NULL,
-                       timestamp REAL NOT NULL);"""
-                )
-                # remove expired status data
-                if exp_limit > 0:
-                    con.execute(
-                        """DELETE FROM status WHERE timestamp <= ?;""",
-                        (time() - exp_limit,),
+            try:
+                con = connect(self._db_file)
+                cur = con.cursor()
+                with con:
+                    # create table if needed
+                    cur.execute(
+                        """CREATE TABLE IF NOT EXISTS status (
+                           _profiles TEXT NOT NULL,
+                           ignored INTEGER NOT NULL,
+                           iteration INTEGER NOT NULL,
+                           log_size INTEGER NOT NULL,
+                           pid INTEGER UNIQUE NOT NULL,
+                           start_time REAL NOT NULL,
+                           timestamp REAL NOT NULL);"""
                     )
-                # avoid (unlikely) pid reuse collision
-                con.execute("""DELETE FROM status WHERE pid = ?;""", (pid,))
-                con.commit()
+                    # remove expired status data
+                    if exp_limit > 0:
+                        cur.execute(
+                            """DELETE FROM status WHERE timestamp <= ?;""",
+                            (time() - exp_limit,),
+                        )
+                    # avoid (unlikely) pid reuse collision
+                    cur.execute("""DELETE FROM status WHERE pid = ?;""", (pid,))
+            finally:
+                con.close()
 
             self.results = ResultCounter(
                 pid,
@@ -189,7 +196,8 @@ def loadall(cls, db_file, time_limit=300):
         """
         assert db_file
         assert time_limit >= 0
-        with connect(db_file) as con:
+        try:
+            con = connect(db_file)
             cur = con.cursor()
             # check table exists
             cur.execute(
@@ -218,6 +226,8 @@ def loadall(cls, db_file, time_limit=300):
                 entries = cur.fetchall()
             else:
                 entries = ()
+        finally:
+            con.close()
 
         results = ResultCounter.load(db_file, time_limit)
 
@@ -336,49 +346,52 @@ def report(self, force=False, report_freq=REPORT_FREQ):
         self.timestamp = now
 
         profiles = dumps(self._profiles)
-        with connect(self._db_file) as con:
+        try:
+            con = connect(self._db_file)
             cur = con.cursor()
-            cur.execute(
-                """UPDATE status
-                   SET _profiles = ?,
-                       ignored = ?,
-                       iteration = ?,
-                       log_size = ?,
-                       start_time = ?,
-                       timestamp = ?
-                   WHERE pid = ?;""",
-                (
-                    profiles,
-                    self.ignored,
-                    self.iteration,
-                    self.log_size,
-                    self.start_time,
-                    self.timestamp,
-                    self.pid,
-                ),
-            )
-            if cur.rowcount < 1:
+            with con:
                 cur.execute(
-                    """INSERT INTO status(
-                       pid,
-                       _profiles,
-                       ignored,
-                       iteration,
-                       log_size,
-                       start_time,
-                       timestamp)
-                       VALUES (?, ?, ?, ?, ?, ?, ?);""",
+                    """UPDATE status
+                       SET _profiles = ?,
+                           ignored = ?,
+                           iteration = ?,
+                           log_size = ?,
+                           start_time = ?,
+                           timestamp = ?
+                       WHERE pid = ?;""",
                     (
-                        self.pid,
                         profiles,
                         self.ignored,
                         self.iteration,
                         self.log_size,
                         self.start_time,
                         self.timestamp,
+                        self.pid,
                     ),
                 )
-            con.commit()
+                if cur.rowcount < 1:
+                    cur.execute(
+                        """INSERT INTO status(
+                               pid,
+                               _profiles,
+                               ignored,
+                               iteration,
+                               log_size,
+                               start_time,
+                               timestamp)
+                           VALUES (?, ?, ?, ?, ?, ?, ?);""",
+                        (
+                            self.pid,
+                            profiles,
+                            self.ignored,
+                            self.iteration,
+                            self.log_size,
+                            self.start_time,
+                            self.timestamp,
+                        ),
+                    )
+        finally:
+            con.close()
 
         return True
 
@@ -445,25 +458,29 @@ def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=0):
         if self._db_file:
             LOG.debug("resultcounter using db %r", self._db_file)
             _db_version_check(self._db_file)
-            with connect(self._db_file) as con:
-                # create table if needed
-                con.execute(
-                    """CREATE TABLE IF NOT EXISTS results (
-                       count INTEGER NOT NULL,
-                       description TEXT NOT NULL,
-                       pid INTEGER NOT NULL,
-                       result_id TEXT NOT NULL,
-                       timestamp INTEGER NOT NULL);"""
-                )
-                # remove expired entries
-                if exp_limit > 0:
-                    con.execute(
-                        """DELETE FROM results WHERE timestamp <= ?;""",
-                        (int(time() - exp_limit),),
+            try:
+                con = connect(self._db_file)
+                cur = con.cursor()
+                with con:
+                    # create table if needed
+                    cur.execute(
+                        """CREATE TABLE IF NOT EXISTS results (
+                           count INTEGER NOT NULL,
+                           description TEXT NOT NULL,
+                           pid INTEGER NOT NULL,
+                           result_id TEXT NOT NULL,
+                           timestamp INTEGER NOT NULL);"""
                     )
-                # avoid (unlikely) pid reuse collision
-                con.execute("""DELETE FROM results WHERE pid = ?;""", (pid,))
-                con.commit()
+                    # remove expired entries
+                    if exp_limit > 0:
+                        cur.execute(
+                            """DELETE FROM results WHERE timestamp <= ?;""",
+                            (int(time() - exp_limit),),
+                        )
+                    # avoid (unlikely) pid reuse collision
+                    cur.execute("""DELETE FROM results WHERE pid = ?;""", (pid,))
+            finally:
+                con.close()
 
     def all(self):
         """Yield all result data.
@@ -493,35 +510,38 @@ def count(self, result_id, desc):
         if result_id not in self._desc:
             self._desc[result_id] = desc
         if self._db_file:
-            with connect(self._db_file) as con:
-                timestamp = int(time())
+            try:
+                con = connect(self._db_file)
                 cur = con.cursor()
-                cur.execute(
-                    """UPDATE results
-                       SET timestamp = ?,
-                           count = ?
-                       WHERE pid = ?
-                       AND result_id = ?;""",
-                    (timestamp, self._count[result_id], self.pid, result_id),
-                )
-                if cur.rowcount < 1:
+                timestamp = int(time())
+                with con:
                     cur.execute(
-                        """INSERT INTO results(
-                           pid,
-                           result_id,
-                           description,
-                           timestamp,
-                           count)
-                           VALUES (?, ?, ?, ?, ?);""",
-                        (
-                            self.pid,
-                            result_id,
-                            desc,
-                            timestamp,
-                            self._count[result_id],
-                        ),
+                        """UPDATE results
+                           SET timestamp = ?,
+                               count = ?
+                           WHERE pid = ?
+                           AND result_id = ?;""",
+                        (timestamp, self._count[result_id], self.pid, result_id),
                     )
-                con.commit()
+                    if cur.rowcount < 1:
+                        cur.execute(
+                            """INSERT INTO results(
+                                   pid,
+                                   result_id,
+                                   description,
+                                   timestamp,
+                                   count)
+                               VALUES (?, ?, ?, ?, ?);""",
+                            (
+                                self.pid,
+                                result_id,
+                                desc,
+                                timestamp,
+                                self._count[result_id],
+                            ),
+                        )
+            finally:
+                con.close()
         return self._count[result_id]
 
     @classmethod
@@ -537,7 +557,8 @@ def load(cls, db_file, time_limit):
         """
         assert db_file
         assert time_limit >= 0
-        with connect(db_file) as con:
+        try:
+            con = connect(db_file)
             cur = con.cursor()
             # check table exists
             cur.execute(
@@ -563,6 +584,8 @@ def load(cls, db_file, time_limit):
                 entries = cur.fetchall()
             else:
                 entries = ()
+        finally:
+            con.close()
 
         loaded = dict()
         for pid, result_id, desc, count in entries:
@@ -604,14 +627,17 @@ def is_frequent(self, result_id):
         total = self._count.get(result_id, 0)
         # only count for parallel results if more than 1 local result has been found
         if total > 1 and self._db_file:
-            # look up count from all sources
-            with connect(self._db_file) as con:
+            try:
+                con = connect(self._db_file)
                 cur = con.cursor()
+                # look up count from all sources
                 cur.execute(
                     """SELECT SUM(count) FROM results WHERE result_id = ?;""",
                     (result_id,),
                 )
                 total = cur.fetchone()[0] or 0
+            finally:
+                con.close()
         if total > self._limit:
             self._frequent.add(result_id)
             return True

From 81b32f7ab34872a829bfb3e4565180709d6e4e68 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 12 Oct 2021 10:32:05 -0700
Subject: [PATCH 335/531] Reuse existing db connection in _db_version_check()

---
 grizzly/common/status.py      | 47 ++++++++++++++++-------------------
 grizzly/common/test_status.py | 21 ++++++++++------
 2 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 307cfa9d..5a6a9a2e 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -24,42 +24,37 @@
 ProfileEntry = namedtuple("ProfileEntry", "count max min name total")
 
 
-def _db_version_check(db_file, expected=DB_VERSION):
+def _db_version_check(con, expected=DB_VERSION):
     """Perform version check and remove obsolete tables if required.
 
     Args:
-        db_file (str): Database file containing data.
+        con (sqlite3.Connection): An open database connection.
         expected (int): The latest database version.
 
     Returns:
         bool: True if database was reset otherwise False.
     """
     assert expected > 0
-    try:
-        con = connect(db_file)
-        cur = con.cursor()
-        # collect db version
+    cur = con.cursor()
+    # collect db version and check if an update is required
+    cur.execute("PRAGMA user_version;")
+    version = cur.fetchone()[0]
+    if version < expected:
+        cur.execute("BEGIN EXCLUSIVE;")
+        # check db version again while locked to avoid race
         cur.execute("PRAGMA user_version;")
         version = cur.fetchone()[0]
-        # check if an update is required
         if version < expected:
-            cur.execute("BEGIN EXCLUSIVE;")
-            # check db version while locked to avoid race
-            cur.execute("PRAGMA user_version;")
-            version = cur.fetchone()[0]
-            if version < expected:
-                LOG.debug("db version %d < %d", version, expected)
-                # remove ALL tables from the database
-                cur.execute("SELECT name FROM sqlite_master WHERE type='table';")
-                with con:
-                    for entry in cur.fetchall():
-                        LOG.debug("dropping table %r", entry[0])
-                        cur.execute("DROP TABLE IF EXISTS %s;" % (entry[0],))
-                    # update db version number
-                    cur.execute("PRAGMA user_version = %d;" % (expected,))
-                return True
-    finally:
-        con.close()
+            LOG.debug("db version %d < %d", version, expected)
+            # remove ALL tables from the database
+            cur.execute("SELECT name FROM sqlite_master WHERE type='table';")
+            with con:
+                for entry in cur.fetchall():
+                    LOG.debug("dropping table %r", entry[0])
+                    cur.execute("DROP TABLE IF EXISTS %s;" % (entry[0],))
+                # update db version number
+                cur.execute("PRAGMA user_version = %d;" % (expected,))
+            return True
     assert version == expected, "code out of date?"
     return False
 
@@ -132,9 +127,9 @@ def __init__(
         # prepare database
         if self._db_file:
             LOG.debug("status using db %r", self._db_file)
-            _db_version_check(self._db_file)
             try:
                 con = connect(self._db_file)
+                _db_version_check(con)
                 cur = con.cursor()
                 with con:
                     # create table if needed
@@ -457,9 +452,9 @@ def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=0):
         # prepare database
         if self._db_file:
             LOG.debug("resultcounter using db %r", self._db_file)
-            _db_version_check(self._db_file)
             try:
                 con = connect(self._db_file)
+                _db_version_check(con)
                 cur = con.cursor()
                 with con:
                     # create table if needed
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 1b3cd291..280bf8a4 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -6,6 +6,7 @@
 # pylint: disable=protected-access
 
 from multiprocessing import Event, Process
+from sqlite3 import connect
 from time import sleep, time
 
 from pytest import mark
@@ -415,11 +416,15 @@ def test_report_counter_04(mocker, tmp_path):
 def test_db_version_check_01(tmp_path):
     """test _db_version_check()"""
     db_path = str(tmp_path / "storage.db")
-    # empty db
-    assert _db_version_check(db_path, expected=DB_VERSION)
-    # no update needed
-    assert not _db_version_check(db_path, expected=DB_VERSION)
-    # add db contents
-    Status.start(db_path)
-    # force update
-    assert _db_version_check(db_path, expected=DB_VERSION + 1)
+    try:
+        con = connect(db_path)
+        # empty db
+        assert _db_version_check(con, expected=DB_VERSION)
+        # no update needed
+        assert not _db_version_check(con, expected=DB_VERSION)
+        # add db contents
+        Status.start(db_path)
+        # force update
+        assert _db_version_check(con, expected=DB_VERSION + 1)
+    finally:
+        con.close()

From e047fa06f364b55e09c4911fafc28c2fd7003158 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 12 Oct 2021 10:38:09 -0700
Subject: [PATCH 336/531] Add 'PRIMARY KEY's to tables in status db

---
 grizzly/common/status.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 5a6a9a2e..a0732e75 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -139,7 +139,7 @@ def __init__(
                            ignored INTEGER NOT NULL,
                            iteration INTEGER NOT NULL,
                            log_size INTEGER NOT NULL,
-                           pid INTEGER UNIQUE NOT NULL,
+                           pid INTEGER NOT NULL PRIMARY KEY,
                            start_time REAL NOT NULL,
                            timestamp REAL NOT NULL);"""
                     )
@@ -464,7 +464,8 @@ def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=0):
                            description TEXT NOT NULL,
                            pid INTEGER NOT NULL,
                            result_id TEXT NOT NULL,
-                           timestamp INTEGER NOT NULL);"""
+                           timestamp INTEGER NOT NULL,
+                           PRIMARY KEY(pid, result_id));"""
                     )
                     # remove expired entries
                     if exp_limit > 0:

From 063be3f188fb0ce0692d2b2004b646cef292ad30 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 12 Oct 2021 14:15:56 -0700
Subject: [PATCH 337/531] A result must be seen more than once before it can be
 considered a blocker

---
 grizzly/common/status.py      |  9 ++++----
 grizzly/common/test_status.py | 42 ++++++++++++++++++++++++-----------
 2 files changed, 34 insertions(+), 17 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index a0732e75..7484c2ad 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -163,7 +163,8 @@ def __init__(
 
     def blockers(self, iters_per_result=100):
         """Any result with an iterations-per-result ratio of less than or equal the
-        given limit are considered 'blockers'.
+        given limit are considered 'blockers'. Results with a count <= 1 are not
+        included.
 
         Args:
             iters_per_result (int): Iterations-per-result threshold.
@@ -174,7 +175,7 @@ def blockers(self, iters_per_result=100):
         assert iters_per_result > 0
         if self.results:
             for _, count, desc in self.results.all():
-                if self.iteration / count <= iters_per_result:
+                if count > 1 and self.iteration / count <= iters_per_result:
                     yield count, desc
 
     @classmethod
@@ -587,8 +588,8 @@ def load(cls, db_file, time_limit):
         for pid, result_id, desc, count in entries:
             if pid not in loaded:
                 loaded[pid] = cls(pid)
-            loaded[pid]._desc[result_id] = desc
-            loaded[pid]._count[result_id] = count
+            loaded[pid]._desc[result_id] = desc  # pylint: disable=protected-access
+            loaded[pid]._count[result_id] = count  # pylint: disable=protected-access
 
         return list(loaded.values())
 
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 280bf8a4..49745374 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -237,21 +237,37 @@ def test_status_07(tmp_path):
     assert len(tuple(status.profile_entries())) == 3
 
 
-def test_status_08(tmp_path):
+@mark.parametrize(
+    "buckets, ratio, iterations, blockers",
+    [
+        # no results
+        ([], 1, 1, 0),
+        # one result seen once (not blocker since count == 1)
+        ([("uid1", "sig1", 1)], 1, 1, 0),
+        # one result seen 10x (not blocker)
+        ([("uid1", "sig1", 10)], 100, 10000, 0),
+        # one result seen 10x (blocker)
+        ([("uid1", "sig1", 10)], 100, 1000, 1),
+        # one result seen 95x (blocker)
+        ([("uid1", "sig1", 95)], 100, 1000, 1),
+        # multiple results seen once (not blocker since count == 1)
+        ([("uid1", "sig1", 1), ("uid2", "sig2", 1)], 1, 1, 0),
+        # multiple results seen once (one blockers)
+        ([("uid1", "sig1", 1), ("uid2", "sig2", 10)], 1000, 100, 1),
+        # multiple results seen once (two blockers)
+        ([("uid1", "sig1", 99), ("uid2", "sig2", 10)], 1000, 100, 2),
+    ],
+)
+def test_status_08(tmp_path, buckets, ratio, iterations, blockers):
     """test Status.blockers()"""
     status = Status.start(str(tmp_path / "status.db"))
-    status.iteration = 10
-    assert not any(status.blockers())
-    status.results.count("uid1", "sig1")
-    assert not any(status.blockers(iters_per_result=3))
-    status.results.count("uid2", "sig2")
-    status.results.count("uid2", "sig2")
-    assert not any(status.blockers(iters_per_result=2))
-    blockers = tuple(status.blockers(iters_per_result=5))
-    assert len(blockers) == 1
-    assert blockers[0] == (2, "sig2")
-    blockers = tuple(status.blockers(iters_per_result=10))
-    assert len(blockers) == 2
+    status.iteration = iterations
+    # populate counter
+    for report_id, desc, count in buckets:
+        for _ in range(count):
+            status.results.count(report_id, desc)
+    # check for blockers
+    assert len(tuple(status.blockers(iters_per_result=ratio))) == blockers
 
 
 @mark.parametrize(

From a902d842e49eb1bf5f9d3bbe67e5f1a77c259d61 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 13 Oct 2021 13:17:08 -0700
Subject: [PATCH 338/531] [tests] Add missing StatusReporter._summary()
 coverage

---
 grizzly/common/test_status_reporter.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 7a29f32c..e052c1a4 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -151,6 +151,8 @@ def test_status_reporter_05(mocker, tmp_path):
     status.ignored = 1
     status.iteration = 8
     status.log_size = 86900000
+    status.results.count("test", "test")
+    status.results.count("test", "test")
     status.report(force=True)
     rptr = StatusReporter.load(db_file)
     rptr._sys_info = _fake_sys_info

From b6c027aaec0711f05a540353057c3464b67d0931 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 14 Oct 2021 18:10:31 -0700
Subject: [PATCH 339/531] Reintroduce FuzzManagerReporter.force_crash

---
 grizzly/common/fuzzmanager.py   |  2 ++
 grizzly/common/reporter.py      | 29 ++++++++++++++++-------------
 grizzly/common/test_reporter.py | 17 ++++++++++-------
 grizzly/reduce/core.py          |  6 +++++-
 grizzly/reduce/test_reduce.py   |  1 +
 5 files changed, 34 insertions(+), 21 deletions(-)

diff --git a/grizzly/common/fuzzmanager.py b/grizzly/common/fuzzmanager.py
index 410b9f3c..8a73568b 100644
--- a/grizzly/common/fuzzmanager.py
+++ b/grizzly/common/fuzzmanager.py
@@ -26,6 +26,7 @@ def __init__(self, bucket_id):
         Arguments:
             bucket_id (int): ID of the requested bucket on the server side
         """
+        assert isinstance(bucket_id, int)
         self._bucket_id = bucket_id
         self._sig_filename = None
         self._coll = Collector()
@@ -198,6 +199,7 @@ def __init__(self, crash_id):
         Arguments:
             crash_id (int): ID of the requested crash on the server side
         """
+        assert isinstance(crash_id, int)
         self._crash_id = crash_id
         self._coll = Collector()
         self._url = "%s://%s:%d/crashmanager/rest/crashes/%d/" % (
diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 1f7a5ab8..2b7537c9 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -154,10 +154,11 @@ def _submit_report(self, report, test_cases):
 class FuzzManagerReporter(Reporter):
     FM_CONFIG = pathjoin(expanduser("~"), ".fuzzmanagerconf")
 
-    __slots__ = ("_extra_metadata", "quality", "tool")
+    __slots__ = ("_extra_metadata", "force_report", "quality", "tool")
 
     def __init__(self, tool=None):
         self._extra_metadata = {}
+        self.force_report = False
         self.quality = Quality.UNREDUCED
         self.tool = tool  # optional tool name
 
@@ -232,18 +233,20 @@ def _ignored(report):
         return False
 
     def _submit_report(self, report, test_cases):
-        # search for a cached signature match
-        with InterProcessLock(pathjoin(grz_tmp(), "fm_sigcache.lock")):
-            collector = Collector()
-            _, cache_metadata = collector.search(report.crash_info)
-
-        # check if signature has been marked as frequent in FM
-        if cache_metadata is not None and cache_metadata["frequent"]:
-            LOG.info(
-                "Frequent crash matched existing signature: %s",
-                cache_metadata["shortDescription"],
-            )
-            return None
+        collector = Collector()
+
+        if not self.force_report:
+            # search for a cached signature match
+            with InterProcessLock(pathjoin(grz_tmp(), "fm_sigcache.lock")):
+                _, cache_metadata = collector.search(report.crash_info)
+
+            # check if signature has been marked as frequent in FM
+            if cache_metadata is not None and cache_metadata["frequent"]:
+                LOG.info(
+                    "Frequent crash matched existing signature: %s",
+                    cache_metadata["shortDescription"],
+                )
+                return None
 
         if self._ignored(report):
             LOG.info("Report is in ignore list")
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 043ad134..d67df445 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -141,19 +141,21 @@ def test_fuzzmanager_reporter_01(mocker, tmp_path):
 
 
 @mark.parametrize(
-    "tests, frequent, ignored",
+    "tests, frequent, ignored, force",
     [
         # report - without test
-        (False, False, False),
+        (False, False, False, False),
         # report - with test
-        (True, False, False),
+        (True, False, False, False),
         # report - frequent
-        (True, True, False),
+        (True, True, False, False),
+        # report - forced frequent
+        (True, True, False, True),
         # report - ignored
-        (True, False, True),
+        (True, False, True, False),
     ],
 )
-def test_fuzzmanager_reporter_02(mocker, tmp_path, tests, frequent, ignored):
+def test_fuzzmanager_reporter_02(mocker, tmp_path, tests, frequent, ignored, force):
     """test FuzzManagerReporter.submit()"""
     mocker.patch(
         "grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path)
@@ -181,10 +183,11 @@ def test_fuzzmanager_reporter_02(mocker, tmp_path, tests, frequent, ignored):
         )
         test_cases.append(fake_test)
     reporter = FuzzManagerReporter("fake_bin")
+    reporter.force_report = force
     reporter._ignored = lambda x: ignored
     reporter.submit(test_cases, Report(str(log_path), "fake_bin", is_hang=True))
     assert not log_path.is_dir()
-    if frequent or ignored:
+    if (frequent and not force) or ignored:
         assert fake_collector.return_value.submit.call_count == 0
         assert fake_test.dump.call_count == 0
     else:
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index bde1a5af..97bc1ff5 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -665,6 +665,8 @@ def report(self, results, testcases, stats=None):
         for result in results:
             if self._report_to_fuzzmanager:
                 reporter = FuzzManagerReporter(self._report_tool)
+                if result.expected:
+                    reporter.force_report = True
             else:
                 report_dir = "reports" if result.expected else "other_reports"
                 reporter = FilesystemReporter(
@@ -686,7 +688,9 @@ def report(self, results, testcases, stats=None):
                 if result.served is not None:
                     for clone, served in zip(clones, result.served):
                         clone.purge_optional(served)
-                ret_values.append(reporter.submit(clones, result.report))
+                result = reporter.submit(clones, result.report)
+                if result is not None:
+                    ret_values.append(result)
             finally:
                 for clone in clones:
                     clone.cleanup()
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 441e82c0..7d664669 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -765,6 +765,7 @@ def replay_run(testcases, _time_limit, **_kw):
 
     mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     reporter = mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
+    reporter.return_value.submit.return_value = 1234
     update_coll = mocker.patch("grizzly.common.fuzzmanager.Collector")
     target = mocker.Mock(spec_set=Target)
     target.filtered_environ.return_value = dict()

From 949d35d5ca7c11f59f901159310d0259cb54bd47 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 14 Oct 2021 18:11:11 -0700
Subject: [PATCH 340/531] Set DB_TIMEOUT=30 to avoid 'database is locked'
 exception on busy system

---
 grizzly/common/status.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 7484c2ad..7d4fbfdf 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -15,6 +15,8 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
+# time in seconds for db connection to wait before raising an exception
+DB_TIMEOUT = 30
 # used to track changes to the database layout
 DB_VERSION = 1
 # default expiration limit for entries in the database
@@ -128,7 +130,7 @@ def __init__(
         if self._db_file:
             LOG.debug("status using db %r", self._db_file)
             try:
-                con = connect(self._db_file)
+                con = connect(self._db_file, timeout=DB_TIMEOUT)
                 _db_version_check(con)
                 cur = con.cursor()
                 with con:
@@ -193,7 +195,7 @@ def loadall(cls, db_file, time_limit=300):
         assert db_file
         assert time_limit >= 0
         try:
-            con = connect(db_file)
+            con = connect(db_file, timeout=DB_TIMEOUT)
             cur = con.cursor()
             # check table exists
             cur.execute(
@@ -343,7 +345,7 @@ def report(self, force=False, report_freq=REPORT_FREQ):
 
         profiles = dumps(self._profiles)
         try:
-            con = connect(self._db_file)
+            con = connect(self._db_file, timeout=DB_TIMEOUT)
             cur = con.cursor()
             with con:
                 cur.execute(
@@ -454,7 +456,7 @@ def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=0):
         if self._db_file:
             LOG.debug("resultcounter using db %r", self._db_file)
             try:
-                con = connect(self._db_file)
+                con = connect(self._db_file, timeout=DB_TIMEOUT)
                 _db_version_check(con)
                 cur = con.cursor()
                 with con:
@@ -508,7 +510,7 @@ def count(self, result_id, desc):
             self._desc[result_id] = desc
         if self._db_file:
             try:
-                con = connect(self._db_file)
+                con = connect(self._db_file, timeout=DB_TIMEOUT)
                 cur = con.cursor()
                 timestamp = int(time())
                 with con:
@@ -555,7 +557,7 @@ def load(cls, db_file, time_limit):
         assert db_file
         assert time_limit >= 0
         try:
-            con = connect(db_file)
+            con = connect(db_file, timeout=DB_TIMEOUT)
             cur = con.cursor()
             # check table exists
             cur.execute(
@@ -625,7 +627,7 @@ def is_frequent(self, result_id):
         # only count for parallel results if more than 1 local result has been found
         if total > 1 and self._db_file:
             try:
-                con = connect(self._db_file)
+                con = connect(self._db_file, timeout=DB_TIMEOUT)
                 cur = con.cursor()
                 # look up count from all sources
                 cur.execute(

From bc0ce0e5408b72859e2400b4aa1b7ac5436ec479 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 14 Oct 2021 18:11:49 -0700
Subject: [PATCH 341/531] Use contextlib.closing() with sqlite3.connect()

---
 grizzly/common/status.py | 37 ++++++++-----------------------------
 1 file changed, 8 insertions(+), 29 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 7d4fbfdf..f9882813 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -4,7 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Manage Grizzly status reports."""
 from collections import defaultdict, namedtuple
-from contextlib import contextmanager
+from contextlib import closing, contextmanager
 from json import dumps, loads
 from logging import getLogger
 from os import getpid
@@ -129,8 +129,7 @@ def __init__(
         # prepare database
         if self._db_file:
             LOG.debug("status using db %r", self._db_file)
-            try:
-                con = connect(self._db_file, timeout=DB_TIMEOUT)
+            with closing(connect(self._db_file, timeout=DB_TIMEOUT)) as con:
                 _db_version_check(con)
                 cur = con.cursor()
                 with con:
@@ -153,8 +152,6 @@ def __init__(
                         )
                     # avoid (unlikely) pid reuse collision
                     cur.execute("""DELETE FROM status WHERE pid = ?;""", (pid,))
-            finally:
-                con.close()
 
             self.results = ResultCounter(
                 pid,
@@ -194,8 +191,7 @@ def loadall(cls, db_file, time_limit=300):
         """
         assert db_file
         assert time_limit >= 0
-        try:
-            con = connect(db_file, timeout=DB_TIMEOUT)
+        with closing(connect(db_file, timeout=DB_TIMEOUT)) as con:
             cur = con.cursor()
             # check table exists
             cur.execute(
@@ -224,8 +220,6 @@ def loadall(cls, db_file, time_limit=300):
                 entries = cur.fetchall()
             else:
                 entries = ()
-        finally:
-            con.close()
 
         results = ResultCounter.load(db_file, time_limit)
 
@@ -344,8 +338,7 @@ def report(self, force=False, report_freq=REPORT_FREQ):
         self.timestamp = now
 
         profiles = dumps(self._profiles)
-        try:
-            con = connect(self._db_file, timeout=DB_TIMEOUT)
+        with closing(connect(self._db_file, timeout=DB_TIMEOUT)) as con:
             cur = con.cursor()
             with con:
                 cur.execute(
@@ -388,8 +381,6 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                             self.timestamp,
                         ),
                     )
-        finally:
-            con.close()
 
         return True
 
@@ -455,8 +446,7 @@ def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=0):
         # prepare database
         if self._db_file:
             LOG.debug("resultcounter using db %r", self._db_file)
-            try:
-                con = connect(self._db_file, timeout=DB_TIMEOUT)
+            with closing(connect(self._db_file, timeout=DB_TIMEOUT)) as con:
                 _db_version_check(con)
                 cur = con.cursor()
                 with con:
@@ -478,8 +468,6 @@ def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=0):
                         )
                     # avoid (unlikely) pid reuse collision
                     cur.execute("""DELETE FROM results WHERE pid = ?;""", (pid,))
-            finally:
-                con.close()
 
     def all(self):
         """Yield all result data.
@@ -509,8 +497,7 @@ def count(self, result_id, desc):
         if result_id not in self._desc:
             self._desc[result_id] = desc
         if self._db_file:
-            try:
-                con = connect(self._db_file, timeout=DB_TIMEOUT)
+            with closing(connect(self._db_file, timeout=DB_TIMEOUT)) as con:
                 cur = con.cursor()
                 timestamp = int(time())
                 with con:
@@ -539,8 +526,6 @@ def count(self, result_id, desc):
                                 self._count[result_id],
                             ),
                         )
-            finally:
-                con.close()
         return self._count[result_id]
 
     @classmethod
@@ -556,8 +541,7 @@ def load(cls, db_file, time_limit):
         """
         assert db_file
         assert time_limit >= 0
-        try:
-            con = connect(db_file, timeout=DB_TIMEOUT)
+        with closing(connect(db_file, timeout=DB_TIMEOUT)) as con:
             cur = con.cursor()
             # check table exists
             cur.execute(
@@ -583,8 +567,6 @@ def load(cls, db_file, time_limit):
                 entries = cur.fetchall()
             else:
                 entries = ()
-        finally:
-            con.close()
 
         loaded = dict()
         for pid, result_id, desc, count in entries:
@@ -626,8 +608,7 @@ def is_frequent(self, result_id):
         total = self._count.get(result_id, 0)
         # only count for parallel results if more than 1 local result has been found
         if total > 1 and self._db_file:
-            try:
-                con = connect(self._db_file, timeout=DB_TIMEOUT)
+            with closing(connect(self._db_file, timeout=DB_TIMEOUT)) as con:
                 cur = con.cursor()
                 # look up count from all sources
                 cur.execute(
@@ -635,8 +616,6 @@ def is_frequent(self, result_id):
                     (result_id,),
                 )
                 total = cur.fetchone()[0] or 0
-            finally:
-                con.close()
         if total > self._limit:
             self._frequent.add(result_id)
             return True

From ae48fc08f7b0b2d56cc3fdcf3b118d79aff7907d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Sun, 17 Oct 2021 19:42:40 -0700
Subject: [PATCH 342/531] Remove unnecessary db checks when loading status data

---
 grizzly/common/status.py | 36 ++++++++++--------------------------
 1 file changed, 10 insertions(+), 26 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index f9882813..164cc1e9 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -8,7 +8,7 @@
 from json import dumps, loads
 from logging import getLogger
 from os import getpid
-from sqlite3 import connect
+from sqlite3 import OperationalError, connect
 from time import time
 
 __all__ = ("Status",)
@@ -193,18 +193,8 @@ def loadall(cls, db_file, time_limit=300):
         assert time_limit >= 0
         with closing(connect(db_file, timeout=DB_TIMEOUT)) as con:
             cur = con.cursor()
-            # check table exists
-            cur.execute(
-                """SELECT name
-                   FROM sqlite_master
-                   WHERE type='table'
-                   AND name='status';"""
-            )
-            if cur.fetchone():
-                # check db version
-                cur.execute("PRAGMA user_version;")
-                assert cur.fetchone()[0] == DB_VERSION, "code out of date?"
-                # collect entries
+            # collect entries
+            try:
                 cur.execute(
                     """SELECT pid,
                              _profiles,
@@ -218,7 +208,9 @@ def loadall(cls, db_file, time_limit=300):
                     (time() - time_limit,),
                 )
                 entries = cur.fetchall()
-            else:
+            except OperationalError as exc:
+                if not str(exc).startswith("no such table:"):
+                    raise  # pragma: no cover
                 entries = ()
 
         results = ResultCounter.load(db_file, time_limit)
@@ -543,17 +535,7 @@ def load(cls, db_file, time_limit):
         assert time_limit >= 0
         with closing(connect(db_file, timeout=DB_TIMEOUT)) as con:
             cur = con.cursor()
-            # check table exists
-            cur.execute(
-                """SELECT name
-                   FROM sqlite_master
-                   WHERE type='table'
-                   AND name='results';"""
-            )
-            if cur.fetchone():
-                # check db version
-                cur.execute("PRAGMA user_version;")
-                assert cur.fetchone()[0] == DB_VERSION, "code out of date?"
+            try:
                 # collect entries
                 cur.execute(
                     """SELECT pid,
@@ -565,7 +547,9 @@ def load(cls, db_file, time_limit):
                     (int(time()) - time_limit,),
                 )
                 entries = cur.fetchall()
-            else:
+            except OperationalError as exc:
+                if not str(exc).startswith("no such table:"):
+                    raise  # pragma: no cover
                 entries = ()
 
         loaded = dict()

From 07ed52794ebb0d5e208c099d19ab9cf97cc3637c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Sun, 17 Oct 2021 19:52:00 -0700
Subject: [PATCH 343/531] Avoid db lookup if local result is frequent

---
 grizzly/common/status.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 164cc1e9..466b14c8 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -589,12 +589,16 @@ def is_frequent(self, result_id):
             return False
         if result_id in self._frequent:
             return True
+        # get local total
         total = self._count.get(result_id, 0)
-        # only count for parallel results if more than 1 local result has been found
-        if total > 1 and self._db_file:
+        # only check the db for parallel results if
+        # - result has been found locally more than once
+        # - limit has not been exceeded locally
+        # - a db file is given
+        if self._limit >= total > 1 and self._db_file:
             with closing(connect(self._db_file, timeout=DB_TIMEOUT)) as con:
                 cur = con.cursor()
-                # look up count from all sources
+                # look up total count from all processes
                 cur.execute(
                     """SELECT SUM(count) FROM results WHERE result_id = ?;""",
                     (result_id,),

From 34990a4b3011f42dd09c0fd5bf84bc0bac37ff27 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Sun, 17 Oct 2021 19:52:24 -0700
Subject: [PATCH 344/531] Call status.report() when session is complete

---
 grizzly/session.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/grizzly/session.py b/grizzly/session.py
index 31de12e8..985adee9 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -166,9 +166,9 @@ def run(
         runner = Runner(self.server, self.target, relaunch=relaunch)
         startup_error = False
         while True:
-            LOG.debug("- iteration %d -", self.status.iteration + 1)
             self.status.report()
             self.status.iteration += 1
+            LOG.debug("- iteration %d -", self.status.iteration)
 
             if self.target.closed:
                 # (re-)launch target
@@ -301,3 +301,6 @@ def run(
                 LOG.warning(
                     "Large browser logs: %dMBs", (self.status.log_size / 0x100000)
                 )
+
+        # perform final status report
+        self.status.report(force=True)

From b0b3551647c74ad6b1a2e20901ae5e643e1861e4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 19 Oct 2021 10:24:02 -0700
Subject: [PATCH 345/531] Update full status report output

---
 grizzly/common/status.py               | 10 ++---
 grizzly/common/status_reporter.py      | 56 +++++++++++++++++---------
 grizzly/common/test_status_reporter.py | 27 +++++++------
 3 files changed, 57 insertions(+), 36 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 466b14c8..47c5c2be 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -169,13 +169,13 @@ def blockers(self, iters_per_result=100):
             iters_per_result (int): Iterations-per-result threshold.
 
         Yields:
-            tuple(int, str): Count and description of result.
+            3-tuple(str, int, str): ID, count and description of blocking result.
         """
         assert iters_per_result > 0
         if self.results:
-            for _, count, desc in self.results.all():
+            for result_id, count, desc in self.results.all():
                 if count > 1 and self.iteration / count <= iters_per_result:
-                    yield count, desc
+                    yield result_id, count, desc
 
     @classmethod
     def loadall(cls, db_file, time_limit=300):
@@ -468,7 +468,7 @@ def all(self):
             None
 
         Yields:
-            tuple: Contains result_id, count and description for each entry.
+            3-tuple: Contains ID, count and description for each result entry.
         """
         for result_id, count in self._count.items():
             if count > 0:
@@ -568,7 +568,7 @@ def get(self, result_id):
             result_id (str): Result ID.
 
         Returns:
-            tuple: Count and description.
+            2-tuple: Count and description.
         """
         assert isinstance(result_id, str)
         return (self._count.get(result_id, 0), self._desc.get(result_id, None))
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 66f908e7..3c968637 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -18,7 +18,7 @@
 from os import SEEK_CUR, getenv, scandir
 from os.path import isdir
 from re import match
-from time import gmtime, strftime
+from time import gmtime, localtime, strftime
 
 from psutil import cpu_count, cpu_percent, disk_usage, virtual_memory
 
@@ -101,26 +101,32 @@ def print_results(self):
         print(self._results())
 
     def print_specific(self):
-        print(self._specific())
+        print(self._specific(), end="")
 
     def print_summary(self, runtime=True, sysinfo=False, timestamp=False):
         print(self._summary(runtime=runtime, sysinfo=sysinfo, timestamp=timestamp))
 
     def _results(self, max_len=85):
-        descs = dict()
+        blockers = set()
         counts = defaultdict(int)
+        descs = dict()
         # calculate totals
         for entry in self.reports:
             for rid, count, desc in entry.results.all():
                 descs[rid] = desc
                 counts[rid] += count
+            blockers.update(x[0] for x in entry.blockers())
         # generate output
         txt = list()
         for rid, count in sorted(counts.items(), key=lambda x: x[1], reverse=True):
+            desc = descs[rid]
+            # trim long descriptions
             if len(descs[rid]) > max_len:
-                txt.append("%d: '%s...'\n" % (count, descs[rid][:max_len]))
-            else:
-                txt.append("%d: %r\n" % (count, descs[rid]))
+                desc = "%s..." % (desc[:max_len],)
+            blocker = "*" if rid in blockers else ""
+            txt.append("%s%d: %r\n" % (blocker, count, desc))
+        if blockers:
+            txt.append("(* = Blocker)\n")
         if not txt:
             txt.append("No results available\n")
         return "".join(txt)
@@ -135,35 +141,46 @@ def _scan(path, fname_pattern):
             if entry.stat().st_size:
                 yield entry.path
 
-    def _specific(self):
+    def _specific(self, iters_per_result=100):
         """Merged and generate formatted output of status reports.
 
         Args:
-            None
+            iters_per_result (int): Threshold for warning of potential blockers.
 
         Returns:
-            str: A formatted report
+            str: A formatted report.
         """
         if not self.reports:
             return "No status reports available"
-        self.reports.sort(key=lambda x: x.runtime, reverse=True)
+        self.reports.sort(key=lambda x: x.start_time)
         txt = list()
-        for num, report in enumerate(self.reports, start=1):
-            txt.append("#%02d - %d -" % (num, report.pid))
-            txt.append(" Runtime %s\n" % (timedelta(seconds=int(report.runtime)),))
-            txt.append(" * Iterations: %d" % (report.iteration,))
-            txt.append(" @ %0.2f," % (round(report.rate, 2),))
-            txt.append(" Ignored: %d," % (report.ignored,))
-            txt.append(" Results: %d" % (report.results.total,))
+        for report in self.reports:
+            txt.append(strftime("%Y/%m/%d %X", localtime(report.start_time)))
+            txt.append(" - %d\n" % (report.pid,))
+            txt.append("  Iterations: %d" % (report.iteration,))
+            txt.append(" @ %0.2f\n" % (round(report.rate, 2),))
+            if report.ignored:
+                ignore_pct = report.ignored / float(report.iteration) * 100
+                txt.append(
+                    "  Ignored: %d @ %0.1f%%\n" % (report.ignored, round(ignore_pct, 1))
+                )
+            txt.append("  Results: %d" % (report.results.total,))
+            if report.results.total:
+                result_pct = report.results.total / float(report.iteration) * 100
+                txt.append(" @ %0.1f%%" % (round(result_pct, 1),))
+                if any(report.blockers(iters_per_result=iters_per_result)):
+                    txt.append(" (Blockers)")
             txt.append("\n")
+            txt.append("  Runtime: %s\n" % (timedelta(seconds=int(report.runtime)),))
+
             # add profiling data if it exists
             if any(report.profile_entries()):
-                txt.append(" * Profiling entries *\n")
+                txt.append("  Profiling entries:\n")
             for entry in sorted(
                 report.profile_entries(), key=lambda x: x.total, reverse=True
             ):
                 avg = entry.total / float(entry.count)
-                txt.append(" > %s: %dx " % (entry.name, entry.count))
+                txt.append("    %s: %dx " % (entry.name, entry.count))
                 if entry.total > 300:
                     txt.append(str(timedelta(seconds=int(entry.total))))
                 else:
@@ -173,6 +190,7 @@ def _specific(self):
                 txt.append(" %0.3f max," % (round(entry.max, 3),))
                 txt.append(" %0.3f min)" % (round(entry.min, 3),))
                 txt.append("\n")
+            txt.append("\n")
         return "".join(txt)
 
     def _summary(
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index e052c1a4..c24f00a3 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -186,10 +186,11 @@ def test_status_reporter_06(mocker, tmp_path):
     rptr = StatusReporter.load(db_file)
     assert rptr.reports is not None
     output = rptr._specific()
-    assert len(output.split("\n")[:-1]) == 2
-    assert "Ignored" in output
-    assert "Iteration" in output
-    assert "Results" in output
+    assert len(output.strip().split("\n")) == 4
+    assert "Ignored:" not in output
+    assert "Iterations:" in output
+    assert "Results:" in output
+    assert "Runtime:" in output
     # multiple reports
     status = Status.start(db_file=db_file, enable_profiling=True)
     status.ignored = 1
@@ -203,13 +204,14 @@ def test_status_reporter_06(mocker, tmp_path):
     rptr = StatusReporter.load(db_file)
     assert len(rptr.reports) == 2
     output = rptr._specific()
-    assert len(output.split("\n")[:-1]) == 7
-    assert "Ignored" in output
-    assert "Iteration" in output
-    assert "Results" in output
-    assert "Profiling entries" in output
-    assert "> test1:" in output
-    assert "> test2:" in output
+    assert len(output.strip().split("\n")) == 13
+    assert "Ignored:" in output
+    assert "Iterations:" in output
+    assert "Results:" in output
+    assert "Runtime:" in output
+    assert "Profiling entries:" in output
+    assert "test1:" in output
+    assert "test2:" in output
 
 
 def test_status_reporter_07(mocker, tmp_path):
@@ -246,7 +248,8 @@ def test_status_reporter_07(mocker, tmp_path):
     assert "3: '[@ test1]'" in output
     assert "1: '[@ test2]'" in output
     assert "1: '[@ longsignature...'" in output
-    assert len(output.split("\n")[:-1]) == 3
+    assert "(* = Blocker)" in output
+    assert len(output.strip().split("\n")) == 4
 
 
 def test_status_reporter_08(tmp_path):

From ba2092855b202821574d67a9bb8c8076bc7639e4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 19 Oct 2021 10:37:50 -0700
Subject: [PATCH 346/531] Add ResultEntry

---
 grizzly/common/status.py          | 20 ++++++++++++--------
 grizzly/common/status_reporter.py | 10 +++++-----
 grizzly/common/test_status.py     | 16 ++++++++--------
 3 files changed, 25 insertions(+), 21 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 47c5c2be..46fdf79e 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -25,6 +25,8 @@
 
 ProfileEntry = namedtuple("ProfileEntry", "count max min name total")
 
+ResultEntry = namedtuple("ResultEntry", "rid count desc")
+
 
 def _db_version_check(con, expected=DB_VERSION):
     """Perform version check and remove obsolete tables if required.
@@ -169,13 +171,13 @@ def blockers(self, iters_per_result=100):
             iters_per_result (int): Iterations-per-result threshold.
 
         Yields:
-            3-tuple(str, int, str): ID, count and description of blocking result.
+            ResultEntry: ID, count and description of blocking result.
         """
         assert iters_per_result > 0
         if self.results:
-            for result_id, count, desc in self.results.all():
-                if count > 1 and self.iteration / count <= iters_per_result:
-                    yield result_id, count, desc
+            for entry in self.results.all():
+                if entry.count > 1 and self.iteration / entry.count <= iters_per_result:
+                    yield entry
 
     @classmethod
     def loadall(cls, db_file, time_limit=300):
@@ -468,11 +470,11 @@ def all(self):
             None
 
         Yields:
-            3-tuple: Contains ID, count and description for each result entry.
+            ResultEntry: Contains ID, count and description for each result entry.
         """
         for result_id, count in self._count.items():
             if count > 0:
-                yield (result_id, count, self._desc.get(result_id, None))
+                yield ResultEntry(result_id, count, self._desc.get(result_id, None))
 
     def count(self, result_id, desc):
         """
@@ -568,10 +570,12 @@ def get(self, result_id):
             result_id (str): Result ID.
 
         Returns:
-            2-tuple: Count and description.
+            ResultEntry: Count and description.
         """
         assert isinstance(result_id, str)
-        return (self._count.get(result_id, 0), self._desc.get(result_id, None))
+        return ResultEntry(
+            result_id, self._count.get(result_id, 0), self._desc.get(result_id, None)
+        )
 
     def is_frequent(self, result_id):
         """Scan all results including results from other running instances
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 3c968637..23fbfc9a 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -111,11 +111,11 @@ def _results(self, max_len=85):
         counts = defaultdict(int)
         descs = dict()
         # calculate totals
-        for entry in self.reports:
-            for rid, count, desc in entry.results.all():
-                descs[rid] = desc
-                counts[rid] += count
-            blockers.update(x[0] for x in entry.blockers())
+        for report in self.reports:
+            for result in report.results.all():
+                descs[result.rid] = result.desc
+                counts[result.rid] += result.count
+            blockers.update(x.rid for x in report.blockers())
         # generate output
         txt = list()
         for rid, count in sorted(counts.items(), key=lambda x: x[1], reverse=True):
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 49745374..c179e6d5 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -68,7 +68,7 @@ def test_status_03(tmp_path):
     assert status.iteration == loaded.iteration
     assert status.log_size == loaded.log_size
     assert status.pid == loaded.pid
-    assert loaded.results.get("uid1") == (1, "sig1")
+    assert loaded.results.get("uid1") == ("uid1", 1, "sig1")
     assert not loaded._enable_profiling
     assert "test" in loaded._profiles
 
@@ -295,16 +295,16 @@ def test_report_counter_01(tmp_path, keys, counts, limit, local_only):
     db_path = None if local_only else str(tmp_path / "storage.db")
     counter = ResultCounter(1, db_file=db_path, freq_limit=limit)
     for report_id, count in zip(keys, counts):
-        assert counter.get(report_id) == (0, None)
+        assert counter.get(report_id) == (report_id, 0, None)
         assert not counter.is_frequent(report_id)
         # call count() with report_id 'count' times
         for current in range(1, count + 1):
             assert counter.count(report_id, "desc") == current
         # test get()
         if sum(counts) > 0:
-            assert counter.get(report_id) == (count, "desc")
+            assert counter.get(report_id) == (report_id, count, "desc")
         else:
-            assert counter.get(report_id) == (count, None)
+            assert counter.get(report_id) == (report_id, count, None)
         # test is_frequent()
         if count > limit > 0:
             assert counter.is_frequent(report_id)
@@ -392,17 +392,17 @@ def test_report_counter_03(mocker, tmp_path):
     # last 2 seconds
     loaded = ResultCounter.load(db_path, 2)[0]
     assert loaded.total == 1
-    assert loaded.get("b") == (1, "desc_b")
+    assert loaded.get("b") == ("b", 1, "desc_b")
     # last 3 seconds
     loaded = ResultCounter.load(db_path, 3)[0]
-    assert loaded.get("a") == (2, "desc_a")
+    assert loaded.get("a") == ("a", 2, "desc_a")
     assert loaded.total == 3
     # increase time limit
     fake_time.return_value = 4
     loaded = ResultCounter.load(db_path, 10)[0]
     assert loaded.total == counter.total == 3
-    assert loaded.get("a") == (2, "desc_a")
-    assert loaded.get("b") == (1, "desc_b")
+    assert loaded.get("a") == ("a", 2, "desc_a")
+    assert loaded.get("b") == ("b", 1, "desc_b")
 
 
 def test_report_counter_04(mocker, tmp_path):

From c433295b95dee1b00e5bd63be2a88feb2c4ce878 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 19 Oct 2021 13:16:03 -0700
Subject: [PATCH 347/531] Remove unnecessary wrapper functions from status
 reporter

---
 grizzly/common/status_reporter.py      | 84 +++++++++-----------------
 grizzly/common/test_status_reporter.py | 44 ++++++--------
 2 files changed, 47 insertions(+), 81 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 23fbfc9a..2181293c 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -45,35 +45,6 @@ def __init__(self, reports, tracebacks=None):
         self.reports = reports
         self.tracebacks = tracebacks
 
-    def dump_specific(self, filename):
-        """Write out merged reports.
-
-        Args:
-            filename (str): Path where output should be written.
-
-        Returns:
-            None
-        """
-        with open(filename, "w") as ofp:
-            ofp.write(self._specific())
-
-    def dump_summary(self, filename, runtime=False, sysinfo=True, timestamp=True):
-        """Write out summary merged reports.
-
-        Args:
-            filename (str): Path where output should be written.
-            runtime (bool): Include total runtime in output
-            sysinfo (bool): Include system info (CPU, disk, RAM... etc) in output
-            timestamp (bool): Include time stamp in output
-
-        Returns:
-            None
-        """
-        with open(filename, "w") as ofp:
-            ofp.write(
-                self._summary(runtime=runtime, sysinfo=sysinfo, timestamp=timestamp)
-            )
-
     @property
     def has_results(self):
         return any(x.results.total for x in self.reports)
@@ -97,16 +68,15 @@ def load(cls, db_file, tb_path=None, time_limit=TIME_LIMIT):
             tracebacks=tracebacks,
         )
 
-    def print_results(self):
-        print(self._results())
-
-    def print_specific(self):
-        print(self._specific(), end="")
+    def results(self, max_len=85):
+        """Merged and generate formatted output from results.
 
-    def print_summary(self, runtime=True, sysinfo=False, timestamp=False):
-        print(self._summary(runtime=runtime, sysinfo=sysinfo, timestamp=timestamp))
+        Args:
+            max_len (int): Maximum length of result description.
 
-    def _results(self, max_len=85):
+        Returns:
+            str: A formatted report.
+        """
         blockers = set()
         counts = defaultdict(int)
         descs = dict()
@@ -141,8 +111,8 @@ def _scan(path, fname_pattern):
             if entry.stat().st_size:
                 yield entry.path
 
-    def _specific(self, iters_per_result=100):
-        """Merged and generate formatted output of status reports.
+    def specific(self, iters_per_result=100):
+        """Merged and generate formatted output from status reports.
 
         Args:
             iters_per_result (int): Threshold for warning of potential blockers.
@@ -193,19 +163,19 @@ def _specific(self, iters_per_result=100):
             txt.append("\n")
         return "".join(txt)
 
-    def _summary(
+    def summary(
         self, runtime=True, sysinfo=False, timestamp=False, iters_per_result=100
     ):
-        """Merge and generate a summary of status reports.
+        """Merge and generate a summary from status reports.
 
         Args:
-            runtime (bool): Include total runtime in output
-            sysinfo (bool): Include system info (CPU, disk, RAM... etc) in output
-            timestamp (bool): Include time stamp in output
-            iters_per_result (int): Threshold for warning of potential blockers
+            runtime (bool): Include total runtime in output.
+            sysinfo (bool): Include system info (CPU, disk, RAM... etc) in output.
+            timestamp (bool): Include time stamp in output.
+            iters_per_result (int): Threshold for warning of potential blockers.
 
         Returns:
-            str: A summary of merged reports
+            str: A summary of merged reports.
         """
         entries = list()
         # Job specific status
@@ -558,15 +528,15 @@ def main(args=None):
         tb_path=args.tracebacks,
         time_limit=report_types[args.type],
     )
+
     if args.dump:
-        if args.type == "active":
-            reporter.dump_summary(
-                args.dump, runtime=False, sysinfo=True, timestamp=True
-            )
-        else:
-            reporter.dump_summary(
-                args.dump, runtime=True, sysinfo=False, timestamp=False
-            )
+        with open(args.dump, "w") as ofp:
+            if args.type == "active":
+                ofp.write(reporter.summary(runtime=False, sysinfo=True, timestamp=True))
+            else:
+                ofp.write(
+                    reporter.summary(runtime=True, sysinfo=False, timestamp=False)
+                )
         return 0
 
     if not reporter.reports:
@@ -578,12 +548,12 @@ def main(args=None):
         % (strftime("%Y/%m/%d %X"), Status.REPORT_FREQ)
     )
     print("[Reports]")
-    reporter.print_specific()
+    print(reporter.specific(), end="")
     if reporter.has_results:
         print("[Result Signatures]")
-        reporter.print_results()
+        print(reporter.results())
     print("[Summary]")
-    reporter.print_summary(sysinfo=args.system_report)
+    print(reporter.summary(sysinfo=args.system_report))
     return 0
 
 
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index c24f00a3..bb71805f 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -24,21 +24,13 @@ def _fake_sys_info():
     ]
 
 
-def test_status_reporter_01(tmp_path):
+def test_status_reporter_01():
     """test basic StatusReporter"""
     st_rpt = StatusReporter(list())
     assert not st_rpt.has_results
     st_rpt._sys_info = _fake_sys_info
-    assert "No status reports available" in st_rpt._specific()
-    report = tmp_path / "output.txt"
-    st_rpt.dump_specific(str(report))
-    assert report.is_file()
-    st_rpt.print_specific()
-    assert "No status reports available" in st_rpt._summary()
-    report.unlink()
-    st_rpt.dump_summary(str(report))
-    assert report.is_file()
-    st_rpt.print_summary()
+    assert "No status reports available" in st_rpt.specific()
+    assert "No status reports available" in st_rpt.summary()
 
 
 def test_status_reporter_02(tmp_path):
@@ -122,7 +114,7 @@ def test_status_reporter_04(tmp_path):
 
 
 def test_status_reporter_05(mocker, tmp_path):
-    """test StatusReporter._summary()"""
+    """test StatusReporter.summary()"""
     mocker.patch("grizzly.common.status.getpid", side_effect=(1, 2))
     mocker.patch("grizzly.common.status.time", side_effect=count(start=1.0, step=1.0))
     db_file = str(tmp_path / "status.db")
@@ -136,7 +128,7 @@ def test_status_reporter_05(mocker, tmp_path):
     rptr._sys_info = _fake_sys_info
     assert rptr.reports is not None
     assert len(rptr.reports) == 1
-    output = rptr._summary(runtime=False)
+    output = rptr.summary(runtime=False)
     assert "Iteration" in output
     assert "Rate" in output
     assert "Results" in output
@@ -157,7 +149,7 @@ def test_status_reporter_05(mocker, tmp_path):
     rptr = StatusReporter.load(db_file)
     rptr._sys_info = _fake_sys_info
     assert len(rptr.reports) == 2
-    output = rptr._summary(sysinfo=True, timestamp=True)
+    output = rptr.summary(sysinfo=True, timestamp=True)
     assert "Iteration" in output
     assert "Rate" in output
     assert "Results" in output
@@ -174,7 +166,7 @@ def test_status_reporter_05(mocker, tmp_path):
 
 
 def test_status_reporter_06(mocker, tmp_path):
-    """test StatusReporter._specific()"""
+    """test StatusReporter.specific()"""
     mocker.patch("grizzly.common.status.getpid", side_effect=(1, 2))
     db_file = str(tmp_path / "status.db")
     # single report
@@ -185,16 +177,19 @@ def test_status_reporter_06(mocker, tmp_path):
     status.report(force=True)
     rptr = StatusReporter.load(db_file)
     assert rptr.reports is not None
-    output = rptr._specific()
+    output = rptr.specific()
     assert len(output.strip().split("\n")) == 4
     assert "Ignored:" not in output
     assert "Iterations:" in output
     assert "Results:" in output
+    assert "(Blockers)" not in output
     assert "Runtime:" in output
     # multiple reports
     status = Status.start(db_file=db_file, enable_profiling=True)
     status.ignored = 1
-    status.iteration = 432422
+    status.iteration = 50
+    status.results.count("uid1", "sig1")
+    status.results.count("uid1", "sig1")
     status.results.count("uid1", "sig1")
     status.record("test1", 0.91)
     status.record("test1", 1.0)
@@ -203,19 +198,20 @@ def test_status_reporter_06(mocker, tmp_path):
     status.report(force=True)
     rptr = StatusReporter.load(db_file)
     assert len(rptr.reports) == 2
-    output = rptr._specific()
+    output = rptr.specific()
     assert len(output.strip().split("\n")) == 13
     assert "Ignored:" in output
     assert "Iterations:" in output
     assert "Results:" in output
     assert "Runtime:" in output
+    assert "(Blockers)" in output
     assert "Profiling entries:" in output
     assert "test1:" in output
     assert "test2:" in output
 
 
 def test_status_reporter_07(mocker, tmp_path):
-    """test StatusReporter._results()"""
+    """test StatusReporter.results()"""
     mocker.patch("grizzly.common.status.getpid", side_effect=(1, 2, 3))
     db_file = str(tmp_path / "status.db")
     # single report without results
@@ -228,7 +224,7 @@ def test_status_reporter_07(mocker, tmp_path):
     assert rptr.reports is not None
     assert len(rptr.reports) == 1
     assert not rptr.has_results
-    assert rptr._results() == "No results available\n"
+    assert rptr.results() == "No results available\n"
     # multiple reports with results
     status = Status.start(db_file=db_file)
     status.iteration = 1
@@ -244,7 +240,7 @@ def test_status_reporter_07(mocker, tmp_path):
     rptr = StatusReporter.load(db_file)
     assert rptr.has_results
     assert len(rptr.reports) == 3
-    output = rptr._results(max_len=16)
+    output = rptr.results(max_len=16)
     assert "3: '[@ test1]'" in output
     assert "1: '[@ test2]'" in output
     assert "1: '[@ longsignature...'" in output
@@ -283,7 +279,7 @@ def test_status_reporter_08(tmp_path):
         test_fp.write(b"KeyboardInterrupt\n")
     rptr = StatusReporter.load(db_file, tb_path=str(tmp_path))
     assert len(rptr.tracebacks) == 2
-    merged_log = rptr._summary()
+    merged_log = rptr.summary()
     assert len(merged_log.splitlines()) == 14
     assert "screenlog.1" in merged_log
     assert "screenlog.1234" in merged_log
@@ -302,7 +298,7 @@ def test_status_reporter_09(tmp_path):
     rptr = StatusReporter.load(str(tmp_path / "status.db"), tb_path=str(tmp_path))
     rptr._sys_info = _fake_sys_info
     assert len(rptr.tracebacks) == 1
-    output = rptr._summary()
+    output = rptr.summary()
     assert len(output.splitlines()) == 7
     assert "No status reports available" in output
     assert "IndexError" in output
@@ -340,7 +336,7 @@ def test_status_reporter_10(mocker, tmp_path):
     rptr = StatusReporter.load(db_file, tb_path=str(tmp_path))
     rptr._sys_info = _fake_sys_info
     assert len(rptr.tracebacks) == 10
-    merged_log = rptr._summary(
+    merged_log = rptr.summary(
         runtime=True, sysinfo=True, timestamp=True, iters_per_result=1
     )
     assert len(merged_log) < StatusReporter.SUMMARY_LIMIT

From e370b2b73294fa149c4c9795e87ed202f6cac706 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Tue, 19 Oct 2021 16:32:50 -0400
Subject: [PATCH 348/531] [reducer] Add original crash ID to FuzzManager
 metadata.

---
 grizzly/reduce/args.py  | 7 +++++++
 grizzly/reduce/core.py  | 6 ++++++
 grizzly/reduce/crash.py | 1 +
 3 files changed, 14 insertions(+)

diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index d4b8608b..1e556d50 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -4,6 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """CLI argument parsing for Grizzly reduction.
 """
+from argparse import SUPPRESS
 from logging import getLogger
 from pathlib import Path
 
@@ -55,6 +56,12 @@ def __init__(self):
             help="One or more strategies (space-separated). Available: %s (default: %s)"
             % (" ".join(sorted(STRATEGIES)), " ".join(DEFAULT_STRATEGIES)),
         )
+        # hidden argument to add original crash ID as metadata when reported
+        reduce_args.add_argument(
+            "--reducer-crash-id",
+            type=int,
+            help=SUPPRESS,
+        )
 
     def sanity_check(self, args):
         """Sanity check reducer args.
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 97bc1ff5..60f51de6 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -74,6 +74,7 @@ def __init__(
         expect_hang=False,
         idle_delay=0,
         idle_threshold=0,
+        reducer_crash_id=None,
         relaunch=1,
         report_period=None,
         report_to_fuzzmanager=False,
@@ -129,6 +130,7 @@ def __init__(
         # these parameters may be overwritten during analysis, so keep a copy of them
         self._original_relaunch = relaunch
         self._original_use_harness = use_harness
+        self._reducer_crash_id = reducer_crash_id
         self._report_to_fuzzmanager = report_to_fuzzmanager
         self._report_periodically = report_period
         self._report_tool = tool
@@ -667,6 +669,9 @@ def report(self, results, testcases, stats=None):
                 reporter = FuzzManagerReporter(self._report_tool)
                 if result.expected:
                     reporter.force_report = True
+                # add original-crash
+                if self._reducer_crash_id is not None:
+                    reporter.add_extra_metadata("reducer-input", self._reducer_crash_id)
             else:
                 report_dir = "reports" if result.expected else "other_reports"
                 reporter = FilesystemReporter(
@@ -809,6 +814,7 @@ def main(cls, args):
                     expect_hang=expect_hang,
                     idle_delay=args.idle_delay,
                     idle_threshold=args.idle_threshold,
+                    reducer_crash_id=args.reducer_crash_id,
                     relaunch=relaunch,
                     report_period=args.report_period,
                     report_to_fuzzmanager=args.fuzzmanager,
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index 61d16b9e..10087fe4 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -30,6 +30,7 @@ def main(args):
     bucket = None
     try:
         # download the crash
+        args.reducer_crash_id = args.input
         args.input = str(crash.testcase_path())
         if args.sig is None and crash.bucket is not None:
             bucket = Bucket(crash.bucket)

From 1206b2d2ca1fa609fdb34830a572fc801dfd7227 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 20 Oct 2021 16:11:59 -0700
Subject: [PATCH 349/531] [reducer] Do not include stats in unexpected results

---
 grizzly/reduce/core.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 60f51de6..d132cc09 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -677,8 +677,8 @@ def report(self, results, testcases, stats=None):
                 reporter = FilesystemReporter(
                     report_path=str(self._log_path / report_dir), major_bucket=False
                 )
-            # write reduction stats
-            if stats is not None:
+            # write reduction stats for expected results
+            if stats is not None and result.expected:
                 report_path = Path(result.report.path)
                 with (report_path / "reduce_stats.txt").open("w") as out:
                     for line in stats.format_lines():

From 2242fc1cb5cb664541f5e91a28145e3cd24f77ef Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 20 Oct 2021 16:04:34 -0700
Subject: [PATCH 350/531] Add StatusReporter.format_entries()

---
 grizzly/common/status_reporter.py      | 154 ++++++++++++++++---------
 grizzly/common/test_status_reporter.py |  45 +++++---
 2 files changed, 130 insertions(+), 69 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 2181293c..f07d6888 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -68,6 +68,42 @@ def load(cls, db_file, tb_path=None, time_limit=TIME_LIMIT):
             tracebacks=tracebacks,
         )
 
+    @staticmethod
+    def format_entries(entries):
+        """Generate formatted output from (label, body) pairs.
+        Each entry must have a label and an optional body.
+
+        Example:
+        entries = (
+            ("Test data output", None),
+            ("first", "1"),
+            ("second", "2"),
+            ("third", "3.0"),
+        )
+        Will generate...
+        Test data output
+         first : 1
+        second : 2
+         third : 3.0
+
+        Args:
+            entries list(2-tuple(str, str)): Data to merge.
+
+        Returns:
+            str: Formatted output.
+        """
+        label_lengths = tuple(len(x[0]) for x in entries if x[1])
+        max_len = max(label_lengths) if label_lengths else 0
+        out = list()
+        for label, body in entries:
+            if body:
+                out.append(
+                    "%s%s : %s" % ((" " * max(max_len - len(label), 0), label, body))
+                )
+            else:
+                out.append(label)
+        return "\n".join(out)
+
     def results(self, max_len=85):
         """Merged and generate formatted output from results.
 
@@ -87,19 +123,20 @@ def results(self, max_len=85):
                 counts[result.rid] += result.count
             blockers.update(x.rid for x in report.blockers())
         # generate output
-        txt = list()
+        entries = list()
         for rid, count in sorted(counts.items(), key=lambda x: x[1], reverse=True):
             desc = descs[rid]
             # trim long descriptions
             if len(descs[rid]) > max_len:
-                desc = "%s..." % (desc[:max_len],)
-            blocker = "*" if rid in blockers else ""
-            txt.append("%s%d: %r\n" % (blocker, count, desc))
-        if blockers:
-            txt.append("(* = Blocker)\n")
-        if not txt:
-            txt.append("No results available\n")
-        return "".join(txt)
+                desc = "%s..." % (desc[: max_len - 3],)
+            label = "%s%d" % ("*" if rid in blockers else "", count)
+            entries.append((label, desc))
+        if not entries:
+            entries.append(("No results available", None))
+        elif blockers:
+            entries.append(("(* = Blocker)", None))
+        entries.append(("", None))
+        return self.format_entries(entries)
 
     @staticmethod
     def _scan(path, fname_pattern):
@@ -123,45 +160,68 @@ def specific(self, iters_per_result=100):
         if not self.reports:
             return "No status reports available"
         self.reports.sort(key=lambda x: x.start_time)
-        txt = list()
+        entries = list()
         for report in self.reports:
-            txt.append(strftime("%Y/%m/%d %X", localtime(report.start_time)))
-            txt.append(" - %d\n" % (report.pid,))
-            txt.append("  Iterations: %d" % (report.iteration,))
-            txt.append(" @ %0.2f\n" % (round(report.rate, 2),))
+            label = "PID %d started at %s" % (
+                report.pid,
+                strftime("%Y/%m/%d %X", localtime(report.start_time)),
+            )
+            entries.append((label, None))
+            # iterations
+            entries.append(
+                ("Iterations", "%d @ %0.2f" % (report.iteration, round(report.rate, 2)))
+            )
+            # ignored
             if report.ignored:
                 ignore_pct = report.ignored / float(report.iteration) * 100
-                txt.append(
-                    "  Ignored: %d @ %0.1f%%\n" % (report.ignored, round(ignore_pct, 1))
+                entries.append(
+                    (
+                        "Ignored",
+                        "%d @ %0.1f%%" % (report.ignored, round(ignore_pct, 1)),
+                    )
                 )
-            txt.append("  Results: %d" % (report.results.total,))
+            # results
             if report.results.total:
-                result_pct = report.results.total / float(report.iteration) * 100
-                txt.append(" @ %0.1f%%" % (round(result_pct, 1),))
+                # avoid divide by zero if results are found before first update
+                iters = report.iteration if report.iteration else report.results.total
+                result_pct = report.results.total / float(iters) * 100
                 if any(report.blockers(iters_per_result=iters_per_result)):
-                    txt.append(" (Blockers)")
-            txt.append("\n")
-            txt.append("  Runtime: %s\n" % (timedelta(seconds=int(report.runtime)),))
-
+                    blk_str = " (Blockers detected)"
+                else:
+                    blk_str = ""
+                entries.append(
+                    (
+                        "Results",
+                        "%d @ %0.1f%% %s"
+                        % (report.results.total, round(result_pct, 1), blk_str),
+                    )
+                )
+            else:
+                entries.append(("Results", "0"))
+            # runtime
+            entries.append(("Runtime", str(timedelta(seconds=int(report.runtime)))))
             # add profiling data if it exists
             if any(report.profile_entries()):
-                txt.append("  Profiling entries:\n")
-            for entry in sorted(
-                report.profile_entries(), key=lambda x: x.total, reverse=True
-            ):
-                avg = entry.total / float(entry.count)
-                txt.append("    %s: %dx " % (entry.name, entry.count))
-                if entry.total > 300:
-                    txt.append(str(timedelta(seconds=int(entry.total))))
-                else:
-                    txt.append("%0.3fs" % (round(entry.total, 3),))
-                txt.append(" %0.2f%%" % (round(entry.total / report.runtime * 100, 2),))
-                txt.append(" (%0.3f avg," % (round(avg, 3),))
-                txt.append(" %0.3f max," % (round(entry.max, 3),))
-                txt.append(" %0.3f min)" % (round(entry.min, 3),))
-                txt.append("\n")
-            txt.append("\n")
-        return "".join(txt)
+                entries.append(("Profiling entries", None))
+                for entry in sorted(
+                    report.profile_entries(), key=lambda x: x.total, reverse=True
+                ):
+                    avg = entry.total / float(entry.count)
+                    body = list()
+                    body.append("%dx " % (entry.count,))
+                    if entry.total > 300:
+                        body.append(str(timedelta(seconds=int(entry.total))))
+                    else:
+                        body.append("%0.3fs" % (round(entry.total, 3),))
+                    body.append(
+                        " %0.2f%%" % (round(entry.total / report.runtime * 100, 2),)
+                    )
+                    body.append(" (%0.3f avg," % (round(avg, 3),))
+                    body.append(" %0.3f max," % (round(entry.max, 3),))
+                    body.append(" %0.3f min)" % (round(entry.min, 3),))
+                    entries.append((entry.name, "".join(body)))
+            entries.append(("", None))
+        return self.format_entries(entries)
 
     def summary(
         self, runtime=True, sysinfo=False, timestamp=False, iters_per_result=100
@@ -255,17 +315,7 @@ def summary(
             entries.append(("Timestamp", strftime("%Y/%m/%d %X %z", gmtime())))
 
         # Format output
-        label_lengths = tuple(len(x[0]) for x in entries if x[1])
-        max_len = max(label_lengths) if label_lengths else 0
-        msg = list()
-        for label, body in entries:
-            if body:
-                msg.append(
-                    "%s%s : %s" % ((" " * max(max_len - len(label), 0), label, body))
-                )
-            else:
-                msg.append(label)
-        msg = "\n".join(msg)
+        msg = self.format_entries(entries)
 
         if self.tracebacks:
             txt = self._merge_tracebacks(self.tracebacks, self.SUMMARY_LIMIT - len(msg))
@@ -548,7 +598,7 @@ def main(args=None):
         % (strftime("%Y/%m/%d %X"), Status.REPORT_FREQ)
     )
     print("[Reports]")
-    print(reporter.specific(), end="")
+    print(reporter.specific())
     if reporter.has_results:
         print("[Result Signatures]")
         print(reporter.results())
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index bb71805f..3e67a67b 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -179,11 +179,11 @@ def test_status_reporter_06(mocker, tmp_path):
     assert rptr.reports is not None
     output = rptr.specific()
     assert len(output.strip().split("\n")) == 4
-    assert "Ignored:" not in output
-    assert "Iterations:" in output
-    assert "Results:" in output
-    assert "(Blockers)" not in output
-    assert "Runtime:" in output
+    assert "Ignored" not in output
+    assert "Iterations" in output
+    assert "Results" in output
+    assert "(Blockers detected)" not in output
+    assert "Runtime" in output
     # multiple reports
     status = Status.start(db_file=db_file, enable_profiling=True)
     status.ignored = 1
@@ -200,14 +200,14 @@ def test_status_reporter_06(mocker, tmp_path):
     assert len(rptr.reports) == 2
     output = rptr.specific()
     assert len(output.strip().split("\n")) == 13
-    assert "Ignored:" in output
-    assert "Iterations:" in output
-    assert "Results:" in output
-    assert "Runtime:" in output
-    assert "(Blockers)" in output
-    assert "Profiling entries:" in output
-    assert "test1:" in output
-    assert "test2:" in output
+    assert "Ignored" in output
+    assert "Iterations" in output
+    assert "Results" in output
+    assert "Runtime" in output
+    assert "(Blockers detected)" in output
+    assert "Profiling entries" in output
+    assert "test1" in output
+    assert "test2" in output
 
 
 def test_status_reporter_07(mocker, tmp_path):
@@ -240,10 +240,10 @@ def test_status_reporter_07(mocker, tmp_path):
     rptr = StatusReporter.load(db_file)
     assert rptr.has_results
     assert len(rptr.reports) == 3
-    output = rptr.results(max_len=16)
-    assert "3: '[@ test1]'" in output
-    assert "1: '[@ test2]'" in output
-    assert "1: '[@ longsignature...'" in output
+    output = rptr.results(max_len=19)
+    assert "3 : [@ test1]" in output
+    assert "1 : [@ test2]" in output
+    assert "1 : [@ longsignature..." in output
     assert "(* = Blocker)" in output
     assert len(output.strip().split("\n")) == 4
 
@@ -342,6 +342,17 @@ def test_status_reporter_10(mocker, tmp_path):
     assert len(merged_log) < StatusReporter.SUMMARY_LIMIT
 
 
+def test_status_reporter_11():
+    """test StatusReporter.format_entries()"""
+    assert StatusReporter.format_entries([]) == ""
+    assert StatusReporter.format_entries([("test", None)]) == "test"
+    assert StatusReporter.format_entries([("test", "1")]) == "test : 1"
+    out = StatusReporter.format_entries(
+        [("first", "1"), ("second", "2"), ("third", "3")]
+    )
+    assert out == " first : 1\nsecond : 2\n third : 3"
+
+
 def test_traceback_report_01():
     """test simple TracebackReport"""
     tbr = TracebackReport("log.txt", ["0", "1", "2"], prev_lines=["-2", "-1"])

From 01d66297d1098b788138d95e25fc2c50483e1e22 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 2 Nov 2021 11:43:59 -0700
Subject: [PATCH 351/531] [sapphire] Pass query to dynamic response callback

---
 grizzly/common/iomanager.py |   2 +-
 grizzly/common/runner.py    |   2 +-
 grizzly/replay/replay.py    |   2 +-
 sapphire/job.py             |   2 -
 sapphire/server_map.py      |   3 +
 sapphire/test_job.py        |  10 ++--
 sapphire/test_sapphire.py   | 108 ++++++++++++++++++++++--------------
 sapphire/test_server_map.py |  12 ++--
 sapphire/worker.py          |   7 ++-
 9 files changed, 90 insertions(+), 58 deletions(-)

diff --git a/grizzly/common/iomanager.py b/grizzly/common/iomanager.py
index ef2d465e..c8bfec24 100644
--- a/grizzly/common/iomanager.py
+++ b/grizzly/common/iomanager.py
@@ -66,7 +66,7 @@ def create_testcase(self, adapter_name, time_limit):
         self.server_map.set_redirect("grz_next_test", self.page_name(offset=1))
         if self.harness is not None:
             self.server_map.set_dynamic_response(
-                "grz_harness", lambda: self.harness, mime_type="text/html"
+                "grz_harness", lambda _: self.harness, mime_type="text/html"
             )
         self._generated += 1
         return self._test
diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 9b45715a..e090e70b 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -199,7 +199,7 @@ def run(
         if self._tests_run == self._relaunch - 1:
             # overwrite instead of replace 'grz_next_test' for consistency
             server_map.set_redirect("grz_next_test", "grz_empty", required=True)
-            server_map.set_dynamic_response("grz_empty", lambda: b"", required=True)
+            server_map.set_dynamic_response("grz_empty", lambda _: b"", required=True)
         try:
             # unpack test case
             if test_path is None:
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 27ad3ab0..22779819 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -259,7 +259,7 @@ def run(
         server_map = ServerMap()
         if self._harness is not None:
             server_map.set_dynamic_response(
-                "grz_harness", lambda: self._harness, mime_type="text/html"
+                "grz_harness", lambda _: self._harness, mime_type="text/html"
             )
 
         # track unprocessed results
diff --git a/sapphire/job.py b/sapphire/job.py
index d699aec7..7f4d9573 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -136,8 +136,6 @@ def lookup_mime(cls, url):
         return mime
 
     def check_request(self, request):
-        if "?" in request:
-            request = request.split("?", 1)[0]
         to_serve = normpath(pathjoin(self.base_path, request))
         if "\x00" not in to_serve and isfile(to_serve):
             res = Resource(Resource.URL_FILE, to_serve, mime=self.lookup_mime(to_serve))
diff --git a/sapphire/server_map.py b/sapphire/server_map.py
index 8a61b16a..9e419601 100644
--- a/sapphire/server_map.py
+++ b/sapphire/server_map.py
@@ -3,6 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
+from inspect import signature
 from logging import getLogger
 from os.path import abspath, isdir, relpath
 from re import search as re_search
@@ -59,6 +60,8 @@ def set_dynamic_response(
         url = self._check_url(url)
         if not callable(callback):
             raise TypeError("callback must be callable")
+        if len(signature(callback).parameters) != 1:
+            raise TypeError("callback requires 1 argument")
         if not isinstance(mime_type, str):
             raise TypeError("mime_type must be of type 'str'")
         if url in self.include or url in self.redirect:
diff --git a/sapphire/test_job.py b/sapphire/test_job.py
index 1648db6e..d4f02c1f 100644
--- a/sapphire/test_job.py
+++ b/sapphire/test_job.py
@@ -84,7 +84,7 @@ def test_job_03(tmp_path):
     assert job.status == Served.NONE
     resource = job.check_request("one")
     assert resource.type == Resource.URL_REDIRECT
-    resource = job.check_request("two?q=123")
+    resource = job.check_request("two")
     assert resource is not None
     assert resource.type == Resource.URL_REDIRECT
     assert job.pending == 1
@@ -130,7 +130,7 @@ def test_job_04(mocker, tmp_path):
         assert resource.type == Resource.URL_INCLUDE
         assert resource.target == str(inc_1)
     # test nested include path pointing to a different include
-    resource = job.check_request("testinc/inc2/test_file_2.txt?q=123")
+    resource = job.check_request("testinc/inc2/test_file_2.txt")
     assert resource.type == Resource.URL_INCLUDE
     assert resource.target == str(inc_2)
     # test redirect root without leading '/'
@@ -195,8 +195,8 @@ def test_job_05(tmp_path):
 def test_job_06(tmp_path):
     """test Job dynamic"""
     smap = ServerMap()
-    smap.set_dynamic_response("cb1", lambda: 0, mime_type="mime_type")
-    smap.set_dynamic_response("cb2", lambda: 1)
+    smap.set_dynamic_response("cb1", lambda _: 0, mime_type="mime_type")
+    smap.set_dynamic_response("cb2", lambda _: 1)
     job = Job(str(tmp_path), server_map=smap)
     assert job.status == Served.ALL
     assert job.pending == 0
@@ -204,7 +204,7 @@ def test_job_06(tmp_path):
     assert resource.type == Resource.URL_DYNAMIC
     assert callable(resource.target)
     assert isinstance(resource.mime, str)
-    resource = job.check_request("cb2?q=123")
+    resource = job.check_request("cb2")
     assert resource is not None
     assert resource.type == Resource.URL_DYNAMIC
     assert callable(resource.target)
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 5493384d..9fbbcfff 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -423,46 +423,70 @@ def test_sapphire_18(client, tmp_path):
     assert inc403.code == 403
 
 
-def test_sapphire_19(client, tmp_path):
-    """test dynamic response - not required"""
+@pytest.mark.parametrize(
+    "query, required",
+    [
+        # dynamic response not required
+        (None, False),
+        # dynamic response is required
+        (None, True),
+        # dynamic response with query string
+        ("test123", True),
+        # dynamic response with empty query string
+        ("", True),
+    ],
+)
+def test_sapphire_19(client, tmp_path, query, required):
+    """test dynamic response"""
     _data = b"dynamic response -- TEST DATA!"
-    test_dr = _TestFile("dyn_test")
-    test_dr.len_org = len(_data)
-    test_dr.md5_org = hashlib.md5(_data).hexdigest()
-    smap = ServerMap()
-    smap.set_dynamic_response("dyn_test", lambda: _data, mime_type="text/plain")
-    test = _create_test("test_case.html", tmp_path)
-    with Sapphire(timeout=10) as serv:
-        client.launch("127.0.0.1", serv.port, [test_dr, test], in_order=True)
-        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == Served.ALL
-    assert client.wait(timeout=10)
-    assert test.code == 200
-    assert test.len_srv == test.len_org
-    assert test_dr.code == 200
-    assert test_dr.len_srv == test_dr.len_org
-    assert test_dr.md5_srv == test_dr.md5_org
+    # build request
+    path = "dyn_test"
+    if query is not None:
+        request = "?".join([path, query])
+    else:
+        request = path
+
+    # setup custom callback
+    def dr_callback(data):
+        if query:
+            assert data == query
+        else:
+            assert data == ""
+        return _data
 
-
-def test_sapphire_20(client, tmp_path):
-    """test dynamic response - required"""
-    _data = b"dynamic response -- TEST DATA!"
-    test_dr = _TestFile("dyn_test")
-    test_dr.len_org = len(_data)
-    test_dr.md5_org = hashlib.md5(_data).hexdigest()
     smap = ServerMap()
     smap.set_dynamic_response(
-        "dyn_test", lambda: _data, mime_type="text/plain", required=True
+        path, dr_callback, mime_type="text/plain", required=required
     )
+    # create files
+    test_dr = _TestFile(request)
+    test_dr.len_org = len(_data)
+    test_dr.md5_org = hashlib.md5(_data).hexdigest()
+    if required:
+        test = None
+        optional = []
+        files = [test_dr]
+    else:
+        test = _create_test("test_case.html", tmp_path)
+        optional = [test_dr.url]
+        files = [test_dr, test]
+    # test request
     with Sapphire(timeout=10) as serv:
-        client.launch("127.0.0.1", serv.port, [test_dr], in_order=True)
-        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == Served.ALL
+        client.launch("127.0.0.1", serv.port, files, in_order=True)
+        assert (
+            serv.serve_path(str(tmp_path), optional_files=optional, server_map=smap)[0]
+            == Served.ALL
+        )
     assert client.wait(timeout=10)
+    if not required:
+        assert test.code == 200
+        assert test.len_srv == test.len_org
     assert test_dr.code == 200
     assert test_dr.len_srv == test_dr.len_org
     assert test_dr.md5_srv == test_dr.md5_org
 
 
-def test_sapphire_21(client_factory, tmp_path):
+def test_sapphire_20(client_factory, tmp_path):
     """test pending_files == 0 in worker thread"""
     client_defer = client_factory(rx_size=2)
     # server should shutdown while this file is being served
@@ -484,7 +508,7 @@ def test_sapphire_21(client_factory, tmp_path):
     assert test_defer.code == 0
 
 
-def test_sapphire_22(client, tmp_path):
+def test_sapphire_21(client, tmp_path):
     """test handling an invalid request"""
     bad_test = _TestFile("bad.html")
     bad_test.custom_request = b"a bad request...0+%\xef\xb7\xba\r\n"
@@ -498,7 +522,7 @@ def test_sapphire_22(client, tmp_path):
     assert bad_test.code == 400
 
 
-def test_sapphire_23(client, tmp_path):
+def test_sapphire_22(client, tmp_path):
     """test handling an empty request"""
     bad_test = _TestFile("bad.html")
     bad_test.custom_request = b""
@@ -518,7 +542,7 @@ def test_sapphire_23(client, tmp_path):
     assert bad_test.code == 0
 
 
-def test_sapphire_24(client_factory, tmp_path):
+def test_sapphire_23(client_factory, tmp_path):
     """test requesting multiple files via multiple connections"""
     to_serve = list()
     for i in range(2):
@@ -547,10 +571,10 @@ def test_sapphire_24(client_factory, tmp_path):
         assert t_file.len_srv == t_file.len_org
 
 
-def test_sapphire_25(client_factory, tmp_path):
+def test_sapphire_24(client_factory, tmp_path):
     """test all request types via multiple connections"""
 
-    def _dyn_test_cb():
+    def _dyn_test_cb(_):
         return b"A" if random.getrandbits(1) else b"AA"
 
     smap = ServerMap()
@@ -586,11 +610,11 @@ def _dyn_test_cb():
         assert serv.serve_path(str(tmp_path), server_map=smap)[0] == Served.ALL
 
 
-def test_sapphire_26(client, tmp_path):
+def test_sapphire_25(client, tmp_path):
     """test dynamic response with bad callbacks"""
     test_dr = _TestFile("dynm_test")
     smap = ServerMap()
-    smap.set_dynamic_response("dynm_test", lambda: None, mime_type="text/plain")
+    smap.set_dynamic_response("dynm_test", lambda _: None, mime_type="text/plain")
     test = _create_test("test_case.html", tmp_path)
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [test_dr, test], in_order=True)
@@ -598,7 +622,7 @@ def test_sapphire_26(client, tmp_path):
             serv.serve_path(str(tmp_path), server_map=smap)
 
 
-def test_sapphire_27(client, tmp_path):
+def test_sapphire_26(client, tmp_path):
     """test serving to a slow client"""
     t_data = "".join(random.choice("ABCD1234") for _ in range(0x19000))  # 100KB
     t_file = _create_test(
@@ -617,7 +641,7 @@ def test_sapphire_27(client, tmp_path):
     assert t_file.md5_srv == t_file.md5_org
 
 
-def test_sapphire_28(client, tmp_path):
+def test_sapphire_27(client, tmp_path):
     """test timeout while requesting multiple files"""
     files_to_serve = list()
     t_data = "".join(random.choice("ABCD1234") for _ in range(1024)).encode("ascii")
@@ -635,7 +659,7 @@ def test_sapphire_28(client, tmp_path):
     assert len(files_served) < len(files_to_serve)
 
 
-def test_sapphire_29(client_factory, tmp_path):
+def test_sapphire_28(client_factory, tmp_path):
     """test Sapphire.serve_path() with forever=True"""
     clients = list()
     with Sapphire(timeout=10) as serv:
@@ -662,7 +686,7 @@ def _test_callback():
     assert test.len_srv == test.len_org
 
 
-def test_sapphire_30(client, tmp_path):
+def test_sapphire_29(client, tmp_path):
     """test interesting file names"""
     to_serve = [
         # space in file name
@@ -677,7 +701,7 @@ def test_sapphire_30(client, tmp_path):
     assert all(t_file.code == 200 for t_file in to_serve)
 
 
-def test_sapphire_31(client, tmp_path):
+def test_sapphire_30(client, tmp_path):
     """test interesting path string"""
     all_bytes = "".join(chr(i) for i in range(256))
     to_serve = [
@@ -695,7 +719,7 @@ def test_sapphire_31(client, tmp_path):
     assert all(t_file.code is not None for t_file in to_serve)
 
 
-def test_sapphire_32(mocker):
+def test_sapphire_31(mocker):
     """test Sapphire._create_listening_socket()"""
     fake_sleep = mocker.patch("sapphire.core.sleep", autospec=True)
     fake_sock = mocker.patch("sapphire.core.socket", autospec=True)
@@ -724,7 +748,7 @@ def test_sapphire_32(mocker):
     assert fake_sleep.call_count == 1
 
 
-def test_sapphire_33(mocker):
+def test_sapphire_32(mocker):
     """test Sapphire.clear_backlog()"""
     mocker.patch("sapphire.core.socket", autospec=True)
     mocker.patch("sapphire.core.time", autospec=True, return_value=1)
diff --git a/sapphire/test_server_map.py b/sapphire/test_server_map.py
index f7c9e517..09e0b834 100644
--- a/sapphire/test_server_map.py
+++ b/sapphire/test_server_map.py
@@ -19,20 +19,22 @@ def test_servermap_01():
 def test_servermap_02(tmp_path):
     """test ServerMap dynamic responses"""
     srv_map = ServerMap()
-    srv_map.set_dynamic_response("url_01", lambda: 0, mime_type="test/type")
+    srv_map.set_dynamic_response("url_01", lambda _: 0, mime_type="test/type")
     assert len(srv_map.dynamic) == 1
     assert "url_01" in srv_map.dynamic
     assert srv_map.dynamic["url_01"].mime == "test/type"
     assert callable(srv_map.dynamic["url_01"].target)
     assert srv_map.dynamic["url_01"].type == Resource.URL_DYNAMIC
-    srv_map.set_dynamic_response("url_02", lambda: 0, mime_type="foo")
+    srv_map.set_dynamic_response("url_02", lambda _: 0, mime_type="foo")
     assert len(srv_map.dynamic) == 2
     assert not srv_map.include
     assert not srv_map.redirect
     with pytest.raises(TypeError, match="callback must be callable"):
         srv_map.set_dynamic_response("x", None)
+    with pytest.raises(TypeError, match="callback requires 1 argument"):
+        srv_map.set_dynamic_response("x", lambda: 0)
     with pytest.raises(TypeError, match="mime_type must be of type 'str'"):
-        srv_map.set_dynamic_response("x", lambda: 0, None)
+        srv_map.set_dynamic_response("x", lambda _: 0, None)
     # test detecting collisions
     with pytest.raises(MapCollisionError):
         srv_map.set_include("url_01", str(tmp_path))
@@ -66,7 +68,7 @@ def test_servermap_03(tmp_path):
     with pytest.raises(MapCollisionError, match="URL collision on 'url_01'"):
         srv_map.set_redirect("url_01", "test_file")
     with pytest.raises(MapCollisionError):
-        srv_map.set_dynamic_response("url_01", lambda: 0, mime_type="test/type")
+        srv_map.set_dynamic_response("url_01", lambda _: 0, mime_type="test/type")
     # test overlapping includes
     with pytest.raises(MapCollisionError, match=r"'url_01' and '\w+' include"):
         srv_map.set_include("url_01", str(tmp_path))
@@ -97,7 +99,7 @@ def test_servermap_04(tmp_path):
     with pytest.raises(MapCollisionError):
         srv_map.set_include("url_01", str(tmp_path))
     with pytest.raises(MapCollisionError):
-        srv_map.set_dynamic_response("url_01", lambda: 0, mime_type="test/type")
+        srv_map.set_dynamic_response("url_01", lambda _: 0, mime_type="test/type")
 
 
 def test_servermap_05():
diff --git a/sapphire/worker.py b/sapphire/worker.py
index d221bf57..3a6630de 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -119,6 +119,10 @@ def handle_request(cls, conn, serv_job):
                 return
 
             request = unquote_plus(request.group("request").decode("ascii"))
+            if "?" in request:
+                request, query = request.split("?", 1)
+            else:
+                query = ""
             LOG.debug("check_request(%r)", request)
             resource = serv_job.check_request(request)
             if resource is None:
@@ -170,7 +174,8 @@ def handle_request(cls, conn, serv_job):
                 )
                 return
             elif resource.type == Resource.URL_DYNAMIC:
-                data = resource.target()
+                # pass query string to callback
+                data = resource.target(query)
                 if not isinstance(data, bytes):
                     LOG.debug("dynamic request: %r", request)
                     raise TypeError("dynamic request callback must return 'bytes'")

From 70e0901daaa41c2b00d392f669b893d152f37779 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 2 Nov 2021 12:29:03 -0700
Subject: [PATCH 352/531] Add ability to display log when submitting report

---
 grizzly/common/reporter.py      | 11 +++++++++++
 grizzly/common/test_reporter.py | 21 +++++++++++++++++++--
 2 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 2b7537c9..e5c64183 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -100,6 +100,17 @@ def submit(self, test_cases, report):
         assert isinstance(report, Report)
         assert report.path is not None
         self._pre_submit(report)
+        # output report contents to console
+        if getenv("GRZ_DISPLAY_REPORT") == "1":
+            if not report.is_hang:
+                with open(report.preferred, "rb") as log_fp:
+                    LOG.info(
+                        "=== BEGIN REPORT ===\n%s",
+                        log_fp.read().decode("utf-8", errors="ignore"),
+                    )
+            else:
+                LOG.info("=== BEGIN REPORT ===\nBrowser hang detected")
+            LOG.info("=== END REPORT ===")
         result = self._submit_report(report, test_cases)
         if report is not None:
             report.cleanup()
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index d67df445..46b8502f 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -28,8 +28,20 @@ def _create_crash_log(log_path):
         log_fp.write("    #1 0x1337dd in bar /file2.c:1806:19")
 
 
-def test_reporter_01(mocker):
+@mark.parametrize(
+    "diplay_report, is_hang",
+    [
+        # do not display report
+        ("0", False),
+        # display report
+        ("1", False),
+        # display report (hang)
+        ("1", True),
+    ],
+)
+def test_reporter_01(mocker, tmp_path, diplay_report, is_hang):
     """test creating a simple Reporter"""
+    mocker.patch("grizzly.common.reporter.getenv", return_value=diplay_report)
 
     class SimpleReporter(Reporter):
         def _pre_submit(self, report):
@@ -41,8 +53,13 @@ def _post_submit(self):
         def _submit_report(self, report, test_cases):
             pass
 
+    (tmp_path / "log_stderr.txt").write_bytes(b"log msg")
+    report = mocker.Mock(
+        spec_set=Report, is_hang=is_hang, preferred=str(tmp_path / "log_stderr.txt")
+    )
     reporter = SimpleReporter()
-    reporter.submit([], report=mocker.Mock(spec_set=Report))
+    reporter.submit([], report=report)
+    assert report.cleanup.call_count == 1
 
 
 def test_filesystem_reporter_01(tmp_path):

From 25952404292d979cd722abf159eee994f2cbfd66 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 8 Nov 2021 13:59:18 -0800
Subject: [PATCH 353/531] Simplify TestCase and TestFile implementations

- Write TestFile data to filesystem instead of caching
- Rename TestCase.add_from_data() to TestCase.add_from_bytes()
- Add 'copy' kwarg to TestCase.add_from_file()
- Add TestCase.data_path property for serving directly
- Replace TestCase.contains() with TestCase.contents property
---
 grizzly/adapter/no_op_adapter/__init__.py   |  14 +-
 grizzly/adapter/no_op_adapter/test_no_op.py |   4 +-
 grizzly/common/storage.py                   | 397 ++++++++------------
 grizzly/common/test_runner.py               |   7 +-
 grizzly/common/test_storage.py              | 394 +++++++++----------
 grizzly/reduce/test_reduce.py               |  34 +-
 grizzly/reduce/test_strategies.py           |  50 +--
 grizzly/reduce/test_strategies_beautify.py  |   8 +-
 grizzly/replay/test_main.py                 |   2 +-
 grizzly/session.py                          |   2 +-
 grizzly/test_session.py                     |   2 +-
 11 files changed, 395 insertions(+), 519 deletions(-)

diff --git a/grizzly/adapter/no_op_adapter/__init__.py b/grizzly/adapter/no_op_adapter/__init__.py
index 698ac5b8..0634c9e2 100644
--- a/grizzly/adapter/no_op_adapter/__init__.py
+++ b/grizzly/adapter/no_op_adapter/__init__.py
@@ -30,12 +30,12 @@ def setup(self, _input, _server_map):
         """
         self.enable_harness()
         self.fuzz["test"] = (
-            "<!DOCTYPE html>\n"
-            "<html>\n"
-            "<head>\n"
-            "<script>window.close()</script>\n"
-            "</head>\n"
-            "</html>"
+            b"<!DOCTYPE html>\n"
+            b"<html>\n"
+            b"<head>\n"
+            b"<script>window.close()</script>\n"
+            b"</head>\n"
+            b"</html>"
         )
 
     def generate(self, testcase, _server_map):
@@ -53,4 +53,4 @@ def generate(self, testcase, _server_map):
         Returns:
             None
         """
-        testcase.add_from_data(self.fuzz["test"], testcase.landing_page)
+        testcase.add_from_bytes(self.fuzz["test"], testcase.landing_page)
diff --git a/grizzly/adapter/no_op_adapter/test_no_op.py b/grizzly/adapter/no_op_adapter/test_no_op.py
index f732fb80..ba1f9b1e 100644
--- a/grizzly/adapter/no_op_adapter/test_no_op.py
+++ b/grizzly/adapter/no_op_adapter/test_no_op.py
@@ -14,6 +14,6 @@ def test_no_op_01():
     adapter.setup(None, None)
     test = TestCase("a", "b", adapter.name)
     assert not test.data_size
-    assert not test.contains("a")
+    assert "a" not in test.contents
     adapter.generate(test, None)
-    assert test.contains("a")
+    assert "a" in test.contents
diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index e749edb8..e751faa5 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -5,13 +5,14 @@
 
 import json
 from collections import namedtuple
-from itertools import chain
-from os import SEEK_END, listdir, makedirs, walk
+from itertools import chain, product
+from os import listdir, walk
 from os.path import abspath, basename, dirname, isdir, isfile
 from os.path import join as pathjoin
-from os.path import normpath, relpath
+from os.path import normpath, relpath, split
+from pathlib import Path
 from shutil import copyfileobj, rmtree
-from tempfile import SpooledTemporaryFile, mkdtemp
+from tempfile import NamedTemporaryFile, mkdtemp
 from time import time
 from zipfile import BadZipfile, ZipFile
 from zlib import error as zlib_error
@@ -48,7 +49,7 @@ class TestCase:
         "redirect_page",
         "time_limit",
         "timestamp",
-        "_existing_paths",
+        "_data_path",
         "_files",
     )
 
@@ -67,12 +68,15 @@ def __init__(
         self.env_vars = dict()
         self.hang = False
         self.input_fname = input_fname  # file that was used to create the test case
-        self.landing_page = landing_page
-        self.redirect_page = redirect_page
+        self.landing_page = TestFile.sanitize_path(landing_page)
+        if redirect_page is not None:
+            self.redirect_page = TestFile.sanitize_path(redirect_page)
+        else:
+            self.redirect_page = None
         self.time_limit = time_limit
         self.timestamp = time() if timestamp is None else timestamp
-        self._existing_paths = list()  # file paths in use
         self._files = TestFileMap(optional=list(), required=list())
+        self._data_path = Path(mkdtemp(prefix="testcase_", dir=grz_tmp("storage")))
 
     def __enter__(self):
         return self
@@ -80,23 +84,7 @@ def __enter__(self):
     def __exit__(self, *exc):
         self.cleanup()
 
-    def _add(self, target, test_file):
-        """Add a test file to test case and perform sanity checks.
-
-        Args:
-            target (list): Specific list of files to append target test_file to.
-            test_file (TestFile): TestFile to append.
-
-        Returns:
-            None
-        """
-        assert isinstance(test_file, TestFile), "only accepts TestFiles"
-        if test_file.file_name in self._existing_paths:
-            raise TestFileExists("%r exists in test" % (test_file.file_name,))
-        self._existing_paths.append(test_file.file_name)
-        target.append(test_file)
-
-    def add_batch(self, path, include_files, prefix=None):
+    def add_batch(self, path, include_files, prefix=None, copy=True):
         """Iterate over files in include_files and attach the files that are
         located in path to TestCase.
 
@@ -106,6 +94,7 @@ def add_batch(self, path, include_files, prefix=None):
                                            TestCase if they exist in path.
             prefix (str): Path prefix to prepend to file when adding to
                           the TestCase.
+            copy (bool): File will be copied if True otherwise the file will be moved.
 
         Returns:
             None
@@ -117,64 +106,64 @@ def add_batch(self, path, include_files, prefix=None):
                 continue
             if prefix:
                 test_path = "/".join((prefix, test_path))
-            self.add_from_file(fname, file_name=test_path)
+            self.add_from_file(fname, file_name=test_path, copy=copy)
 
-    def add_file(self, test_file, required=True):
-        """Add a TestFile to TestCase.
+    def add_from_bytes(self, data, file_name, required=True):
+        """Create a file and add it to the TestCase.
 
         Args:
-            test_file (TestFile): TestFile to add to TestCase.
-            required (bool): Indicates if test file must be served.
+            data (bytes): Data to write to file.
+            file_name (str): Used as file path on disk and URI. Relative to wwwroot.
+            required (bool): Indicates whether the file must be served.
 
         Returns:
             None
         """
-        if required:
-            self._add(self._files.required, test_file)
-        else:
-            self._add(self._files.optional, test_file)
+        assert isinstance(data, bytes)
+        with NamedTemporaryFile(delete=False, dir=grz_tmp("storage")) as in_fp:
+            in_fp.write(data)
+            datafile = in_fp.name
+
+        self.add_from_file(datafile, file_name=file_name, required=required, copy=False)
 
-    def add_from_data(self, data, file_name, encoding="UTF-8", required=True):
-        """Create a TestFile and add it to the TestCase.
+    def add_from_file(self, src_file, file_name=None, required=True, copy=False):
+        """Add a file to the TestCase by either copying or moving an existing file.
 
         Args:
-            data (bytes or str): Data to write to file. If data is of type str
-                                 encoding must be given.
-            file_name (str): Name for the TestFile.
-            encoding (str): Encoding to be used.
-            required (bool): Indicates whether the TestFile must be served.
+            src_file (str): Path to existing file to use.
+            file_name (str): Used as file path on disk and URI. Relative to wwwroot.
+                             If file_name is not given the name of the src_file
+                             will be used.
+            required (bool): Indicates whether the file must be served.
+            copy (bool): File will be copied if True otherwise the file will be moved.
 
         Returns:
             None
         """
-        tfile = TestFile.from_data(data, file_name, encoding=encoding)
-        try:
-            self.add_file(tfile, required=required)
-        except TestFileExists:
-            tfile.close()
-            raise
+        assert src_file
+        src_file = Path(src_file)
+        if file_name is None:
+            file_name = src_file.name
 
-    def add_from_file(self, input_file, file_name=None, required=True):
-        """Create a TestFile from an existing file and add it to the TestCase.
+        test_file = TestFile(file_name, self._data_path)
+        if test_file.file_name in self.contents:
+            raise TestFileExists("%r exists in test" % (test_file.file_name,))
 
-        Args:
-            input_file (str): Path to existing file to use.
-            file_name (str): Name for the TestFile. If file_name is not given
-                             the name of the input_file will be used.
-            required (bool): Indicates whether the TestFile must be served.
+        if copy:
+            TestFile.copy_file(src_file, test_file.data_file)
+        else:
+            test_file.data_file.parent.mkdir(exist_ok=True, parents=True)
+            src_file.rename(str(test_file.data_file))
 
-        Returns:
-            None
-        """
-        tfile = TestFile.from_file(input_file, file_name=file_name)
-        try:
-            self.add_file(tfile, required=required)
-        except TestFileExists:
-            tfile.close()
-            raise
+        # TODO: set 'required=False' by default
+        # landing_page is always 'required'
+        if required or test_file.file_name == self.landing_page:
+            self._files.required.append(test_file)
+        else:
+            self._files.optional.append(test_file)
 
     def cleanup(self):
-        """Close all the test files.
+        """Remove all the test files.
 
         Args:
             None
@@ -182,9 +171,10 @@ def cleanup(self):
         Returns:
             None
         """
-        for file_group in self._files:
-            for test_file in file_group:
-                test_file.close()
+        # TODO: can this be replaced with a single rmtree()?
+        for test_file in chain(self._files.required, self._files.optional):
+            test_file.unlink()
+        rmtree(str(self._data_path), ignore_errors=True)
 
     def clone(self):
         """Make a copy of the TestCase.
@@ -207,37 +197,61 @@ def clone(self):
         result.duration = self.duration
         result.env_vars = dict(self.env_vars)
         result.hang = self.hang
-        for entry in self._files.optional:
-            result.add_file(entry.clone(), required=False)
-        for entry in self._files.required:
-            result.add_file(entry.clone(), required=True)
+
+        # copy test data files
+        for entry, required in chain(
+            product(self._files.required, [True]),
+            product(self._files.optional, [False]),
+        ):
+            # pylint: disable=protected-access
+            data_file = result._data_path / entry.file_name
+            TestFile.copy_file(entry.data_file, data_file)
+            result.add_from_file(
+                str(data_file),
+                file_name=entry.file_name,
+                required=required,
+                copy=False,
+            )
         return result
 
-    def contains(self, file_name):
-        """Check TestCase contains the TestFile with name matching `file_name`.
+    @property
+    def contents(self):
+        """All files in TestCase.
+
+        Args:
+            None
+
+        Yields:
+            str: File path (relative to wwwroot).
+        """
+        for tfile in chain(self._files.required, self._files.optional):
+            yield tfile.file_name
+
+    @property
+    def data_path(self):
+        """Location test data is stored on disk. This is intended to be used as wwwroot.
 
         Args:
-            file_name (str): File name to search for in TestCase.
+            None
 
         Returns:
-            bool: True if file exists in the TestCase otherwise False.
+            str: Path to directory containing test case files.
         """
-        return file_name in self._existing_paths
+        return str(self._data_path)
 
     @property
     def data_size(self):
-        """The total amount of data used (bytes) by the TestFiles in the
-        TestCase.
+        """Total amount of data used (bytes) by the files in the TestCase.
 
         Args:
             None
 
         Returns:
-            int: Total size of the test case in byte.
+            int: Total size of the TestCase in bytes.
         """
         total = 0
         for group in self._files:
-            total += sum(x.size for x in group)
+            total += sum(x.data_file.stat().st_size for x in group)
         return total
 
     def dump(self, dst_path, include_details=False):
@@ -250,9 +264,10 @@ def dump(self, dst_path, include_details=False):
         Returns:
             None
         """
+        dst_path = Path(dst_path)
         # save test files to dst_path
         for test_file in chain(self._files.required, self._files.optional):
-            test_file.dump(dst_path)
+            TestFile.copy_file(test_file.data_file, dst_path / test_file.file_name)
         # save test case files and meta data including:
         # adapter used, input file, environment info and files
         if include_details:
@@ -270,8 +285,10 @@ def dump(self, dst_path, include_details=False):
             # save target assets and update meta data
             if self.assets and not self.assets.is_empty():
                 info["assets_path"] = "_assets_"
-                info["assets"] = self.assets.dump(dst_path, subdir=info["assets_path"])
-            with open(pathjoin(dst_path, "test_info.json"), "w") as out_fp:
+                info["assets"] = self.assets.dump(
+                    str(dst_path), subdir=info["assets_path"]
+                )
+            with (dst_path / "test_info.json").open("w") as out_fp:
                 json.dump(info, out_fp, indent=2, sort_keys=True)
 
     def get_file(self, file_name):
@@ -325,6 +342,7 @@ def load(cls, path, adjacent=False):
             elif isdir(path):
                 tests = list()
                 assets = None
+                # TODO: move (don't copy) 'unpacked' files
                 for tc_path in TestCase.scan_path(path):
                     tests.append(cls.load_single(tc_path, load_assets=assets is None))
                     # only load assets once
@@ -384,7 +402,7 @@ def load_single(cls, path, adjacent=False, load_assets=True):
             raise TestCaseLoadFailure("Missing or invalid TestCase %r" % (path,))
         # create testcase and add data
         test = cls(
-            None,
+            entry_point,
             None,
             info.get("adapter", None),
             input_fname=info.get("input", None),
@@ -393,8 +411,7 @@ def load_single(cls, path, adjacent=False, load_assets=True):
         )
         test.duration = info.get("duration", None)
         test.hang = info.get("hang", False)
-        test.add_from_file(pathjoin(path, entry_point))
-        test.landing_page = entry_point
+        test.add_from_file(pathjoin(path, entry_point), copy=True)
         if info:
             # load assets
             try:
@@ -404,19 +421,18 @@ def load_single(cls, path, adjacent=False, load_assets=True):
                         pathjoin(path, info.get("assets_path", "")),
                     )
             except (AssetError, OSError) as exc:
+                test.cleanup()
                 raise TestCaseLoadFailure(str(exc)) from None
             # load environment variables
-            try:
-                test.env_vars = info.get("env", dict())
-                assert isinstance(test.env_vars, dict)
-                # sanity check environment variable data
-                for name, value in test.env_vars.items():
-                    if not isinstance(name, str) or not isinstance(value, str):
-                        raise TestCaseLoadFailure("'env' contains invalid entries")
-            except TestCaseLoadFailure:
-                if test.assets:
-                    test.assets.cleanup()
-                raise
+            test.env_vars = info.get("env", dict())
+            assert isinstance(test.env_vars, dict)
+            # sanity check environment variable data
+            for name, value in test.env_vars.items():
+                if not isinstance(name, str) or not isinstance(value, str):
+                    test.cleanup()
+                    if test.assets:
+                        test.assets.cleanup()
+                    raise TestCaseLoadFailure("'env' contains invalid entries")
         # load all adjacent data from directory
         if adjacent:
             asset_path = info.get("assets_path", None)
@@ -430,19 +446,22 @@ def load_single(cls, path, adjacent=False, load_assets=True):
                         continue
                     location = "/".join((dpath.split(path, 1)[-1], fname))
                     test.add_from_file(
-                        pathjoin(dpath, fname), file_name=location, required=False
+                        pathjoin(dpath, fname),
+                        file_name=location,
+                        required=False,
+                        copy=True,
                     )
         return test
 
     @property
     def optional(self):
-        """Get file names of optional TestFiles.
+        """Get file paths of optional files.
 
         Args:
             None
 
         Yields:
-            str: File names of optional files.
+            str: File path of each optional file.
         """
         for test in self._files.optional:
             yield test.file_name
@@ -489,7 +508,7 @@ def purge_optional(self, keep):
             if fname not in keep_opt:
                 to_remove.append(idx)
         for idx in reversed(to_remove):
-            self._files.optional.pop(idx).close()
+            self._files.optional.pop(idx).unlink()
 
     @staticmethod
     def scan_path(path):
@@ -512,169 +531,63 @@ def scan_path(path):
 
 
 class TestFile:
-    CACHE_LIMIT = 0x80000  # data cache limit per file: 512KB
-    XFER_BUF = 0x10000  # transfer buffer size: 64KB
-
-    __slots__ = ("_file_name", "_fp")
-
-    def __init__(self, file_name):
-        # This is a naive fix for a larger path issue. This is a simple sanity
-        # check and does not check if invalid characters are used. If an invalid
-        # file name is used an exception will be raised when trying to write
-        # that file to the file system.
-        if "\\" in file_name:
-            file_name = file_name.replace("\\", "/")
-        if file_name.startswith("/"):
-            file_name = file_name.lstrip("/")
-        if file_name.endswith("."):
-            file_name = file_name.rstrip(".")
-        if (
-            not file_name
-            or ("/" in file_name and not file_name.rsplit("/", 1)[-1])
-            or file_name.startswith("../")
-        ):
-            raise TypeError("file_name is invalid %r" % (file_name,))
-        # name including path relative to wwwroot
-        self._file_name = normpath(file_name)
-        # pylint: disable=consider-using-with
-        self._fp = SpooledTemporaryFile(
-            dir=grz_tmp("storage"), max_size=self.CACHE_LIMIT, prefix="testfile_"
-        )
+    __slots__ = ("data_file", "file_name")
+
+    def __init__(self, file_name, data_path):
+        self.file_name = self.sanitize_path(file_name)
+        self.data_file = data_path / self.file_name
 
     def __enter__(self):
         return self
 
     def __exit__(self, *exc):
-        self.close()
-
-    def clone(self):
-        """Make a copy of the TestFile.
+        self.unlink()
 
-        Args:
-            None
-
-        Returns:
-            TestFile: A copy of the TestFile instance
-        """
-        cloned = type(self)(self._file_name)
-        self._fp.seek(0)
-        copyfileobj(
-            self._fp, cloned._fp, self.XFER_BUF  # pylint: disable=protected-access
-        )
-        return cloned
-
-    def close(self):
-        """Close the TestFile.
-
-        Args:
-            None
-
-        Returns:
-            None
-        """
-        self._fp.close()
-
-    @property
-    def data(self):
-        """Get the data from the TestFile. Not recommenced for large files.
-
-        Args:
-            None
-
-        Returns:
-            bytes: Data from the TestFile
-        """
-        pos = self._fp.tell()
-        self._fp.seek(0)
-        data = self._fp.read()
-        self._fp.seek(pos)
-        return data
-
-    def dump(self, path):
-        """Write TestFile data to the filesystem.
+    @staticmethod
+    def copy_file(src_file, dst_file):
+        """Copy data to file.
 
         Args:
-            path (str): Path to output data.
+            src_file (Path): File to read data from.
+            dst_file (Path): File to write data to.
 
         Returns:
             None
         """
-        target_path = pathjoin(path, dirname(self._file_name))
-        if not isdir(target_path):
-            makedirs(target_path)
-        self._fp.seek(0)
-        with open(pathjoin(path, self._file_name), "wb") as dst_fp:
-            copyfileobj(self._fp, dst_fp, self.XFER_BUF)
+        with src_file.open("rb") as src_fp:
+            dst_file.parent.mkdir(parents=True, exist_ok=True)
+            with dst_file.open("wb") as dst_fp:
+                copyfileobj(src_fp, dst_fp, 1_048_576)
 
-    @property
-    def file_name(self):
-        return self._file_name
-
-    @classmethod
-    def from_data(cls, data, file_name, encoding="UTF-8"):
-        """Create a TestFile and add it to the test case.
-
-        Args:
-            data (bytes or str): Data to write to file. If data is of type str
-                                 encoding must be given.
-            file_name (str): Name for the TestFile.
-            encoding (str): Encoding to be used.
-
-        Returns:
-            TestFile: A TestFile.
-        """
-        t_file = cls(file_name)
-        if data:
-            if isinstance(data, bytes) or not encoding:
-                t_file.write(data)
-            else:
-                t_file.write(data.encode(encoding))
-        return t_file
-
-    @classmethod
-    def from_file(cls, input_file, file_name=None):
-        """Create a TestFile from an existing file.
+    @staticmethod
+    def sanitize_path(path):
+        """Sanitize given path for use as a URI path.
 
         Args:
-            input_file (str): Path to existing file to use.
-            file_name (str): Name for the TestFile. If file_name is not given
-                             the name of the input_file will be used.
+            path (str): Path to sanitize. Must be relative to wwwroot.
 
         Returns:
-            TestFile: A TestFile.
+            str: Sanitized path.
         """
-        if file_name is None:
-            file_name = basename(input_file)
-        t_file = cls(file_name)
-        with open(input_file, "rb") as src_fp:
-            copyfileobj(
-                src_fp, t_file._fp, cls.XFER_BUF  # pylint: disable=protected-access
-            )
-        return t_file
-
-    @property
-    def size(self):
-        """Size of the file in bytes.
+        assert isinstance(path, str)
+        # check for missing filename or path containing drive letter (Windows)
+        if split(path)[-1] in ("", ".", "..") or ":" in path:
+            raise ValueError("invalid path %r" % (path,))
+        # normalize path
+        path = normpath(path).replace("\\", "/")
+        # check normalized path does not resolve to location outside of '.'
+        if path.startswith("../"):
+            raise ValueError("invalid path %r" % (path,))
+        return path.lstrip("/")
+
+    def unlink(self):
+        """Delete the TestFile data file.
 
         Args:
             None
 
-        Returns:
-            int: Size in bytes.
-        """
-        pos = self._fp.tell()
-        self._fp.seek(0, SEEK_END)
-        size = self._fp.tell()
-        self._fp.seek(pos)
-        return size
-
-    def write(self, data):
-        """Add data to the TestFile.
-
-        Args:
-            data (bytes): Data to add to the TestFile.
-
         Returns:
             None
         """
-        self._fp.write(data)
+        if self.data_file.exists():
+            self.data_file.unlink()
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 4155d1e3..2c486ceb 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -4,7 +4,6 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
 from itertools import count
-from os.path import join as pathjoin
 
 from pytest import mark, raises
 
@@ -338,9 +337,9 @@ def test_runner_10(mocker, tmp_path):
         result = runner.run([], smap, tcase)
         assert result.attempted
         assert result.status == Result.NONE
-        assert "inc_file.bin" in tcase._existing_paths
-        assert pathjoin("nested", "nested_inc.bin") in tcase._existing_paths
-        assert pathjoin("test", "inc_file3.txt") in tcase._existing_paths
+        assert "inc_file.bin" in tcase.contents
+        assert "nested/nested_inc.bin" in tcase.contents
+        assert "test/inc_file3.txt" in tcase.contents
 
 
 def test_idle_check_01(mocker):
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index c101720a..16a05a5b 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -30,10 +30,10 @@ def test_testcase_01(tmp_path):
         assert tcase.input_fname is None
         assert tcase.timestamp > 0
         assert not tcase.env_vars
-        assert not tcase._existing_paths
+        assert tcase.data_path
         assert not tcase._files.optional
         assert not tcase._files.required
-        assert not tcase.contains("no_file")
+        assert not any(tcase.contents)
         assert tcase.pop_assets() is None
         assert not any(tcase.optional)
         tcase.dump(str(tmp_path))
@@ -42,48 +42,68 @@ def test_testcase_01(tmp_path):
         assert (tmp_path / "test_info.json").is_file()
 
 
-def test_testcase_02(tmp_path):
-    """test TestCase with TestFiles"""
+@mark.parametrize(
+    "copy, required",
+    [
+        (True, True),
+        (True, False),
+        (False, True),
+        (False, False),
+    ],
+)
+def test_testcase_02(tmp_path, copy, required):
+    """test TestCase.add_from_file()"""
     with TestCase("land_page.html", "a.html", "adpt", input_fname="in.bin") as tcase:
-        in_file = tmp_path / "testfile1.bin"
-        in_file.write_bytes(b"test_req")
-        tcase.add_from_file(str(in_file))
-        assert tcase.data_size == 8
-        with raises(TestFileExists, match="'testfile1.bin' exists in test"):
-            tcase.add_from_file(str(in_file), file_name="testfile1.bin")
-        with raises(TestFileExists, match="'testfile1.bin' exists in test"):
-            tcase.add_from_data("test", "testfile1.bin")
-        tcase.add_from_data("test_nreq", "nested/testfile2.bin", required=False)
-        tcase.add_from_data("test_blah", "/testfile3.bin")
-        tcase.add_from_data("test_windows", "\\\\dir\\file.bin")
-        assert tcase.contains("testfile1.bin")
-        opt_files = list(tcase.optional)
-        assert os.path.join("nested", "testfile2.bin") in opt_files
-        assert len(opt_files) == 1
-        tcase.dump(str(tmp_path), include_details=True)
-        assert (tmp_path / "nested").is_dir()
-        test_info = loads((tmp_path / "test_info.json").read_text())
-        assert test_info["adapter"] == "adpt"
-        assert test_info["input"] == "in.bin"
-        assert test_info["target"] == "land_page.html"
-        assert isinstance(test_info["env"], dict)
-        assert in_file.read_bytes() == b"test_req"
-        assert (tmp_path / "nested" / "testfile2.bin").read_bytes() == b"test_nreq"
-        assert (tmp_path / "testfile3.bin").read_bytes() == b"test_blah"
-        assert (tmp_path / "dir" / "file.bin").read_bytes() == b"test_windows"
-        tcase.cleanup()
-
-
-def test_testcase_03():
+        in_file = tmp_path / "file.bin"
+        in_file.write_text("data")
+        tcase.add_from_file(str(in_file), copy=copy, required=required)
+        assert tcase.data_size == 4
+        assert "file.bin" in tcase.contents
+        if required:
+            assert in_file.name not in tcase.optional
+        else:
+            assert in_file.name in tcase.optional
+        assert in_file.exists() == copy
+        # try overwriting existing file
+        if copy:
+            with raises(TestFileExists, match="'file.bin' exists in test"):
+                tcase.add_from_file(str(in_file), copy=True)
+            assert in_file.exists()
+        else:
+            assert not in_file.exists()
+
+
+@mark.parametrize(
+    "file_paths",
+    [
+        ("a.bin",),
+        ("a/a.bin",),
+        ("a.bin", "b.bin"),
+        ("a.bin", "b/c.bin", "b/d.bin"),
+    ],
+)
+def test_testcase_03(tmp_path, file_paths):
+    """test TestCase.add_from_file()"""
+    with TestCase("land_page.html", "a.html", "adpt") as tcase:
+        for file_path in file_paths:
+            src_file = tmp_path / file_path
+            src_file.parent.mkdir(exist_ok=True, parents=True)
+            src_file.write_text("data")
+            tcase.add_from_file(str(src_file), file_name=file_path, required=True)
+            assert file_path in tcase.contents
+            assert file_path not in tcase.optional
+
+
+def test_testcase_04():
     """test TestCase.purge_optional()"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
         # no optional files
         tcase.purge_optional(["foo"])
         # setup
-        tcase.add_from_data("foo", "testfile1.bin")
-        tcase.add_from_data("foo", "testfile2.bin", required=False)
-        tcase.add_from_data("foo", "testfile3.bin", required=False)
-        tcase.add_from_data("foo", "not_served.bin", required=False)
+        tcase.add_from_bytes(b"foo", "testfile1.bin")
+        tcase.add_from_bytes(b"foo", "testfile2.bin", required=False)
+        tcase.add_from_bytes(b"foo", "testfile3.bin", required=False)
+        tcase.add_from_bytes(b"foo", "not_served.bin", required=False)
         assert len(tuple(tcase.optional)) == 3
         # nothing to remove - with required
         tcase.purge_optional(chain(["testfile1.bin"], tcase.optional))
@@ -102,17 +122,17 @@ def test_testcase_03():
         assert not any(tcase.optional)
 
 
-def test_testcase_04():
+def test_testcase_05():
     """test TestCase.data_size"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
         assert tcase.data_size == 0
-        tcase.add_from_data("1", "testfile1.bin", required=True)
+        tcase.add_from_bytes(b"1", "testfile1.bin", required=True)
         assert tcase.data_size == 1
-        tcase.add_from_data("12", "testfile2.bin", required=False)
+        tcase.add_from_bytes(b"12", "testfile2.bin", required=False)
         assert tcase.data_size == 3
 
 
-def test_testcase_05(tmp_path):
+def test_testcase_06(tmp_path):
     """test TestCase.load_single() using a directory - fail cases"""
     # missing test_info.json
     with raises(TestCaseLoadFailure, match="Missing 'test_info.json'"):
@@ -154,7 +174,7 @@ def test_testcase_05(tmp_path):
         TestCase.load_single(str(src_dir))
 
 
-def test_testcase_06(mocker, tmp_path):
+def test_testcase_07(mocker, tmp_path):
     """test TestCase.load_single() using a directory"""
     # build a valid test case
     src_dir = tmp_path / "src"
@@ -195,9 +215,7 @@ def test_testcase_06(mocker, tmp_path):
         assert "target.bin" in (x.file_name for x in dst._files.required)
         assert "optional.bin" in (x.file_name for x in dst._files.optional)
         assert "x.bin" in (x.file_name for x in dst._files.optional)
-        assert os.path.join("nested", "x.bin") in (
-            x.file_name for x in dst._files.optional
-        )
+        assert "nested/x.bin" in (x.file_name for x in dst._files.optional)
         assert dst.env_vars["TEST_ENV_VAR"] == "100"
         assert dst.timestamp > 0
     # test load with missing asset
@@ -206,7 +224,7 @@ def test_testcase_06(mocker, tmp_path):
         TestCase.load_single(str(dst_dir))
 
 
-def test_testcase_07(tmp_path):
+def test_testcase_08(tmp_path):
     """test TestCase.load_single() using a file"""
     # invalid entry_point specified
     with raises(TestCaseLoadFailure, match="Missing or invalid TestCase"):
@@ -232,7 +250,7 @@ def test_testcase_07(tmp_path):
         assert "optional.bin" in (x.file_name for x in tcase._files.optional)
 
 
-def test_testcase_08(tmp_path):
+def test_testcase_09(tmp_path):
     """test TestCase - dump, load and compare"""
     working = tmp_path / "working"
     working.mkdir()
@@ -243,7 +261,7 @@ def test_testcase_08(tmp_path):
         org.hang = True
         org.input_fname = "infile"
         org.time_limit = 10
-        org.add_from_data("a", "a.html")
+        org.add_from_bytes(b"a", "a.html")
         with AssetManager(base_path=str(tmp_path)) as assets:
             fake = tmp_path / "fake_asset"
             fake.touch()
@@ -251,21 +269,21 @@ def test_testcase_08(tmp_path):
             org.assets = assets
             org.dump(str(working), include_details=True)
         org.assets = None
-        loaded = TestCase.load_single(str(working), adjacent=False)
-        try:
-            for prop in TestCase.__slots__:
-                if prop.startswith("_") or prop in ("assets", "redirect_page"):
-                    continue
-                assert getattr(loaded, prop) == getattr(org, prop)
-            assert org._existing_paths == loaded._existing_paths
-            assert loaded.assets
-            assert "fake" in loaded.assets.assets
-        finally:
-            if loaded.assets:
-                loaded.assets.cleanup()
+        with TestCase.load_single(str(working), adjacent=False) as loaded:
+            try:
+                for prop in TestCase.__slots__:
+                    if prop.startswith("_") or prop in ("assets", "redirect_page"):
+                        continue
+                    assert getattr(loaded, prop) == getattr(org, prop)
+                assert not set(org.contents) ^ set(loaded.contents)
+                assert loaded.assets
+                assert "fake" in loaded.assets.assets
+            finally:
+                if loaded.assets:
+                    loaded.assets.cleanup()
 
 
-def test_testcase_09(tmp_path):
+def test_testcase_10(tmp_path):
     """test TestCase.load() - missing file and empty directory"""
     # missing file
     with raises(TestCaseLoadFailure, match="Invalid TestCase path"):
@@ -274,7 +292,7 @@ def test_testcase_09(tmp_path):
     assert not TestCase.load(str(tmp_path), adjacent=True)
 
 
-def test_testcase_10(tmp_path):
+def test_testcase_11(tmp_path):
     """test TestCase.load() - single file"""
     tfile = tmp_path / "testcase.html"
     tfile.touch()
@@ -283,23 +301,23 @@ def test_testcase_10(tmp_path):
         assert len(testcases) == 1
         assert all(x.assets is None for x in testcases)
     finally:
-        map(lambda x: x.cleanup, testcases)
+        any(x.cleanup() for x in testcases)
 
 
-def test_testcase_11(tmp_path):
+def test_testcase_12(tmp_path):
     """test TestCase.load() - single directory"""
     with TestCase("target.bin", None, "test-adapter") as src:
-        src.add_from_data("test", "target.bin")
+        src.add_from_bytes(b"test", "target.bin")
         src.dump(str(tmp_path), include_details=True)
     testcases = TestCase.load(str(tmp_path))
     try:
         assert len(testcases) == 1
         assert all(x.assets is None for x in testcases)
     finally:
-        map(lambda x: x.cleanup, testcases)
+        any(x.cleanup() for x in testcases)
 
 
-def test_testcase_12(tmp_path):
+def test_testcase_13(tmp_path):
     """test TestCase.load() - multiple directories (with assets)"""
     nested = tmp_path / "nested"
     nested.mkdir()
@@ -309,7 +327,7 @@ def test_testcase_12(tmp_path):
         assets.add("example", str(asset_file))
         with TestCase("target.bin", None, "test-adapter") as src:
             src.assets = assets
-            src.add_from_data("test", "target.bin")
+            src.add_from_bytes(b"test", "target.bin")
             src.dump(str(nested / "test-1"), include_details=True)
             src.dump(str(nested / "test-2"), include_details=True)
             src.dump(str(nested / "test-3"), include_details=True)
@@ -321,6 +339,7 @@ def test_testcase_12(tmp_path):
         assert asset is not None
         assert "example" in asset.assets
     finally:
+        any(x.cleanup() for x in testcases)
         for test in testcases:
             if test.assets:
                 test.cleanup()
@@ -328,7 +347,7 @@ def test_testcase_12(tmp_path):
     assert not TestCase.load(str(tmp_path))
 
 
-def test_testcase_13(tmp_path):
+def test_testcase_14(tmp_path):
     """test TestCase.load() - archive"""
     archive = tmp_path / "testcase.zip"
     # bad archive
@@ -337,7 +356,7 @@ def test_testcase_13(tmp_path):
         TestCase.load(str(archive))
     # build archive containing multiple testcases
     with TestCase("target.bin", None, "test-adapter") as src:
-        src.add_from_data("test", "target.bin")
+        src.add_from_bytes(b"test", "target.bin")
         src.dump(str(tmp_path / "test-0"), include_details=True)
         src.dump(str(tmp_path / "test-1"), include_details=True)
         src.dump(str(tmp_path / "test-2"), include_details=True)
@@ -358,10 +377,10 @@ def test_testcase_13(tmp_path):
         assert len(testcases) == 3
         assert all(x.assets is None for x in testcases)
     finally:
-        map(lambda x: x.cleanup, testcases)
+        any(x.cleanup() for x in testcases)
 
 
-def test_testcase_14(tmp_path):
+def test_testcase_15(tmp_path):
     """test TestCase.add_batch()"""
     include = tmp_path / "inc_path"
     include.mkdir()
@@ -376,32 +395,32 @@ def test_testcase_14(tmp_path):
     with TestCase("a.b", "a.b", "simple") as tcase:
         # missing directory
         tcase.add_batch("/missing/path/", tuple())
-        assert not tcase._existing_paths
+        assert not any(tcase.contents)
         # missing file
         with raises(IOError):
             tcase.add_batch(str(tmp_path), [str(tmp_path / "missing.bin")])
-        assert not tcase._existing_paths
+        assert not any(tcase.contents)
         # relative file name
         tcase.add_batch(str(include), ["file.bin"])
-        assert not tcase._existing_paths
+        assert not any(tcase.contents)
         # valid list
         tcase.add_batch(
             str(include),
             [str(inc_1), str(inc_2), str(tmp_path / "inc_path2" / "extra.bin")],
         )
-        assert tcase.contains("file.bin")
-        assert tcase.contains(os.path.join("nested", "nested.js"))
-        assert len(tcase._existing_paths) == 2
+        assert "file.bin" in tcase.contents
+        assert "nested/nested.js" in tcase.contents
+        assert len(list(tcase.contents)) == 2
         # nested url
         tcase.add_batch(str(include), [str(inc_1)], prefix="test")
-        assert tcase.contains(os.path.join("test", "file.bin"))
-        assert len(tcase._existing_paths) == 3
+        assert "test/file.bin" in tcase.contents
+        assert len(list(tcase.contents)) == 3
         # collision
         with raises(TestFileExists, match="'file.bin' exists in test"):
             tcase.add_batch(str(include), [str(inc_1)])
 
 
-def test_testcase_15(tmp_path):
+def test_testcase_16(tmp_path):
     """test TestCase.scan_path()"""
     # empty path
     (tmp_path / "not-test").mkdir()
@@ -409,7 +428,7 @@ def test_testcase_15(tmp_path):
     # multiple test case directories
     paths = [str(tmp_path / ("test-%d" % i)) for i in range(3)]
     with TestCase("test.htm", None, "test-adapter") as src:
-        src.add_from_data("test", "test.htm")
+        src.add_from_bytes(b"test", "test.htm")
         for path in paths:
             src.dump(path, include_details=True)
     tc_paths = list(TestCase.scan_path(str(tmp_path)))
@@ -419,162 +438,105 @@ def test_testcase_15(tmp_path):
     assert len(tc_paths) == 1
 
 
-def test_testcase_16():
+def test_testcase_17():
     """test TestCase.get_file()"""
     with TestCase("test.htm", None, "test-adapter") as src:
-        src.add_from_data("test", "test.htm")
+        src.add_from_bytes(b"test", "test.htm")
         assert src.get_file("missing") is None
-        assert src.get_file("test.htm").data == b"test"
+        assert src.get_file("test.htm")
 
 
-def test_testcase_17():
+def test_testcase_18():
     """test TestCase.clone()"""
     with TestCase("a.htm", "b.htm", "adpt", input_fname="fn", time_limit=2) as src:
         src.duration = 1.2
         src.hang = True
-        src.add_from_data("123", "test.htm")
-        src.add_from_data("456", "opt.htm", required=False)
+        src.add_from_bytes(b"123", "test.htm")
+        src.add_from_bytes(b"456", "opt.htm", required=False)
         src.env_vars["foo"] = "bar"
-        with src.clone() as tgt:
+        with src.clone() as dst:
             for prop in TestCase.__slots__:
                 if prop.startswith("_"):
                     continue
-                assert getattr(src, prop) == getattr(tgt, prop)
-            assert src.data_size == tgt.data_size
+                assert getattr(src, prop) == getattr(dst, prop)
+            assert src.data_size == dst.data_size
             for file, data in (
                 ("test.htm", b"123"),
                 ("opt.htm", b"456"),
             ):
-                src.get_file(file).write(b"src")
-                tgt.get_file(file).write(b"tgt")
-                assert src.get_file(file).data == data + b"src"
-                assert tgt.get_file(file).data == data + b"tgt"
-            assert tgt.env_vars == {"foo": "bar"}
+                assert src.get_file(file).data_file.read_bytes() == data
+                assert dst.get_file(file).data_file.read_bytes() == data
+            assert dst.env_vars == {"foo": "bar"}
+            assert not set(src.optional) ^ set(dst.optional)
 
 
-def test_testfile_01():
+def test_testfile_01(tmp_path):
     """test simple TestFile"""
-    with TestFile("test_file.txt") as tfile:
-        assert tfile.file_name == "test_file.txt"
-        assert not tfile._fp.closed
-        assert tfile.size == 0
-        tfile.close()
-        assert tfile._fp.closed
-
-
-def test_testfile_02():
-    """test TestFile file names"""
-    # empty file name
-    with raises(TypeError, match="file_name is invalid"):
-        TestFile("")
-    # path (root) with missing file name
-    with raises(TypeError, match="file_name is invalid"):
-        TestFile("/")
-    # path (root) with missing file name
-    with raises(TypeError, match="file_name is invalid"):
-        TestFile("/.")
-    # path with missing file name
-    with raises(TypeError, match="file_name is invalid"):
-        TestFile("path/")
-    # invalid use of '..'
-    with raises(TypeError, match="file_name is invalid"):
-        TestFile("../test")
-    # path (root) with file
-    with TestFile("/valid.txt") as tfile:
-        assert tfile.file_name == "valid.txt"
-    # path with file
-    with TestFile("path\\file") as tfile:
-        assert os.path.split(tfile.file_name) == ("path", "file")
-    # with valid use of '.' and '..'
-    with TestFile("./a/./b/../c") as tfile:
-        assert os.path.split(tfile.file_name) == ("a", "c")
-    # filename starting with '.'
-    with TestFile(".file") as tfile:
-        assert tfile.file_name == ".file"
-
-
-def test_testfile_03(tmp_path):
-    """test TestFile.write() and TestFile.dump()"""
-    out_file = tmp_path / "test_file.txt"
-    with TestFile(out_file.name) as tfile:
-        tfile.write(b"foo")
-        assert not out_file.is_file()
-        tfile.dump(str(tmp_path))
-        assert out_file.is_file()
-        assert out_file.read_text() == "foo"
-        tfile.write(b"bar")
-        tfile.dump(str(tmp_path))
-        assert out_file.read_text() == "foobar"
-
-
-def test_testfile_04(tmp_path):
-    """test TestFile.dump() file with nested path"""
-    file_path = "test/dir/path/file.txt"
-    with TestFile(file_path) as tfile:
-        out_file = tmp_path / file_path
-        tfile.write(b"foo")
-        assert not out_file.is_file()
-        tfile.dump(str(tmp_path))
-        assert out_file.is_file()
+    data_file = tmp_path / "file.txt"
+    data_file.write_text("test")
+    with TestFile(data_file.name, tmp_path) as tfile:
+        assert tfile.file_name == "file.txt"
+    assert not data_file.exists()
+
+
+def test_testfile_02(tmp_path):
+    """test TestFile.copy_file()"""
+    src_file = tmp_path / "src" / "file.txt"
+    src_file.parent.mkdir(parents=True)
+    src_file.write_bytes(b"test\n123\r\n")
+    dst_path = tmp_path / "dst"
+    dst_file = dst_path / "file.txt"
+    assert not dst_file.is_file()
+    TestFile.copy_file(src_file, dst_file)
+    assert dst_file.is_file()
+    assert dst_file.read_bytes() == b"test\n123\r\n"
+    assert src_file.exists()
+
+
+@mark.parametrize(
+    "path",
+    [
+        # empty file name
+        "",
+        # path (root) with missing file name
+        "/",
+        # path (root) with missing file name
+        "/.",
+        # path with missing file name
+        "path/",
+        # outside of wwwroot
+        "../test",
+        # outside of wwwroot
+        "a/../../b",
+        # outside of wwwroot
+        "..",
+        # outside of wwwroot
+        "C:\\test",
+        # cwd
+        ".",
+    ],
+)
+def test_testfile_03(path):
+    """test TestCase.sanitize_path() with invalid paths"""
+    with raises(ValueError, match="invalid path"):
+        TestFile.sanitize_path(path)
 
 
 @mark.parametrize(
-    "in_data, out_data",
+    "path, expected_result",
     [
-        # data as string
-        ("foo", "foo"),
-        # data as binary
-        (b"foo", "foo"),
+        ("a", "a"),
+        ("file.bin", "file.bin"),
+        ("a/file.bin", "a/file.bin"),
+        ("/file.bin", "file.bin"),
+        ("./file.bin", "file.bin"),
+        ("path\\file", "path/file"),
+        ("\\\\a\\b\\file.bin", "a/b/file.bin"),
+        (".file", ".file"),
+        ("a/../file.bin", "file.bin"),
+        ("./a/./b/../c", "a/c"),
     ],
 )
-def test_testfile_05(tmp_path, in_data, out_data):
-    """test TestFile.from_data()"""
-    with TestFile.from_data(in_data, "test_file.txt") as tfile:
-        tfile.dump(str(tmp_path))
-        out_file = tmp_path / "test_file.txt"
-        assert out_file.is_file()
-        assert out_file.read_text() == out_data
-
-
-def test_testfile_06(tmp_path):
-    """test TestFile.from_file()"""
-    in_file = tmp_path / "infile.txt"
-    in_file.write_bytes(b"foobar")
-    # check re-using filename
-    with TestFile.from_file(str(in_file)) as tfile:
-        assert tfile.file_name == "infile.txt"
-    # check data
-    with TestFile.from_file(str(in_file), file_name="outfile.txt") as tfile:
-        assert tfile.file_name == "outfile.txt"
-        tfile.dump(str(tmp_path))
-        out_file = tmp_path / "outfile.txt"
-        assert out_file.is_file()
-        assert out_file.read_text() == "foobar"
-
-
-def test_testfile_07(tmp_path):
-    """test TestFile.clone()"""
-    out_file = tmp_path / "test_file.txt"
-    with TestFile(out_file.name) as tf1:
-        tf1.write(b"foobar")
-        try:
-            tf2 = tf1.clone()
-            tf2.write(b"test")
-            assert tf1.file_name == tf2.file_name
-            assert tf1._fp != tf2._fp
-            tf2.dump(str(tmp_path))
-            assert out_file.is_file()
-            assert out_file.read_text() == "foobartest"
-        finally:
-            tf2.close()
-        tf1.dump(str(tmp_path))
-        assert out_file.is_file()
-        assert out_file.read_text() == "foobar"
-
-
-def test_testfile_08(tmp_path):
-    """test TestFile.data()"""
-    in_file = tmp_path / "infile.txt"
-    in_file.write_bytes(b"foobar")
-    with TestFile.from_file(str(in_file), file_name="outfile.txt") as tfile:
-        assert tfile.data == b"foobar"
+def test_testfile_04(path, expected_result):
+    """test TestCase.sanitize_path()"""
+    assert TestFile.sanitize_path(path) == expected_result
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 7d664669..61e4ccc6 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -271,11 +271,11 @@ def replay_run(_tests, _time_limit, **kw):
     replayer.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
-    test.add_from_data("1", "test.html")
+    test.add_from_bytes(b"1", "test.html")
     tests = [test]
     if harness_last_crashes is not None:
         test = TestCase("test.html", None, "test-adapter")
-        test.add_from_data("2", "test.html")
+        test.add_from_bytes(b"2", "test.html")
         tests.append(test.clone())
     log_path = tmp_path / "logs"
 
@@ -335,7 +335,7 @@ def wrapped(_):
     [
         # no repro
         ReproTestParams(
-            original="123456\n",
+            original=b"123456\n",
             strategies=["check"],
             detect_failure=lambda _: False,
             interesting_str="%r",
@@ -349,7 +349,7 @@ def wrapped(_):
         ),
         # reproduces, one strategy, no reduction works
         ReproTestParams(
-            original="1\n2\n3\n",
+            original=b"1\n2\n3\n",
             strategies=["check", "lines"],
             detect_failure=lambda contents: contents == "1\n2\n3\n",
             interesting_str="%r == '1\n2\n3\n'",
@@ -363,7 +363,7 @@ def wrapped(_):
         ),
         # reproduces, one strategy, some reduction works
         ReproTestParams(
-            original="odd\neven\n" * 3,
+            original=b"odd\neven\n" * 3,
             strategies=["check", "lines"],
             detect_failure=lambda contents: sum(
                 1 for line in contents.splitlines() if line == "odd"
@@ -380,7 +380,7 @@ def wrapped(_):
         ),
         # reproduces, one strategy, reduction only finds other
         ReproTestParams(
-            original="1\n2\n3\n",
+            original=b"1\n2\n3\n",
             strategies=["check", "lines"],
             detect_failure=bool,
             interesting_str="%r != ''",
@@ -394,7 +394,7 @@ def wrapped(_):
         ),
         # reproduces, 50% iterations work, 1 iteration produces other sig
         ReproTestParams(
-            original="1\n2\n3\n4\n5\n6\n",
+            original=b"1\n2\n3\n4\n5\n6\n",
             strategies=["check", "lines"],
             detect_failure=lambda contents: set(contents.splitlines()) >= set("135"),
             interesting_str="%r contains {'1', '3', '5'}",
@@ -408,7 +408,7 @@ def wrapped(_):
         ),
         # reproduces, two strategies, 1st no reduction, 2nd 50% reduction
         ReproTestParams(
-            original="A1\nA2\nA3\nA4\nA5\nA6\n",
+            original=b"A1\nA2\nA3\nA4\nA5\nA6\n",
             strategies=["check", "lines", "chars"],
             detect_failure=(
                 lambda contents: (
@@ -428,7 +428,7 @@ def wrapped(_):
         ),
         # reproduces, two strategies, 1st 50% reduction, 2nd no reduction
         ReproTestParams(
-            original="A1\nA2\nA3\nA4\nA5\nA6\n",
+            original=b"A1\nA2\nA3\nA4\nA5\nA6\n",
             strategies=["check", "lines", "chars"],
             detect_failure=(
                 lambda contents: (
@@ -447,7 +447,7 @@ def wrapped(_):
         ),
         # reproduces, two strategies, reduce only produces other sig
         ReproTestParams(
-            original="1\n2\n3\n",
+            original=b"1\n2\n3\n",
             strategies=["check", "lines", "chars"],
             detect_failure=bool,
             interesting_str="%r != ''",
@@ -473,7 +473,7 @@ def wrapped(_):
         ),
         # reproduces, one strategy, testcase reduces to 0
         ReproTestParams(
-            original="1\n2\n3\n",
+            original=b"1\n2\n3\n",
             strategies=["check", "lines"],
             detect_failure=lambda _: True,
             interesting_str="%r is anything, incl. empty",
@@ -487,7 +487,7 @@ def wrapped(_):
         ),
         # reproduces, two strategies, 1st no reduce, 2nd testcase reduces to 0
         ReproTestParams(
-            original="1\n2\n3\n",
+            original=b"1\n2\n3\n",
             strategies=["check", "lines", "lines"],
             detect_failure=_ignore_arg(
                 partial([True, False, False, False, False, False, True, True].pop, 0)
@@ -528,7 +528,7 @@ def test_repro(
 
     def replay_run(testcases, _time_limit, **_):
         for test in testcases:
-            contents = test.get_file("test.html").data.decode("ascii")
+            contents = test.get_file("test.html").data_file.read_text()
             # pylint: disable=logging-not-lazy
             LOG.debug("interesting if " + interesting_str, contents)
             if detect_failure(contents):
@@ -546,7 +546,7 @@ def replay_run(testcases, _time_limit, **_):
     replayer.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
-    test.add_from_data(original, "test.html")
+    test.add_from_bytes(original, "test.html")
     tests = [test]
     log_path = tmp_path / "logs"
 
@@ -746,7 +746,7 @@ def test_quality_update(mocker, tmp_path):
 
     def replay_run(testcases, _time_limit, **_kw):
         for test in testcases:
-            contents = test.get_file("test.html").data.decode("ascii")
+            contents = test.get_file("test.html").data_file.read_text()
             if not contents.strip():
                 continue
             log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
@@ -809,7 +809,7 @@ def test_include_assets_and_environ(mocker, tmp_path):
 
     def replay_run(testcases, _time_limit, **_kw):
         for test in testcases:
-            contents = test.get_file("test.html").data.decode("ascii")
+            contents = test.get_file("test.html").data_file.read_text()
             if not contents.strip():
                 continue
             log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
@@ -958,7 +958,7 @@ def replay_run(_testcases, _time_limit, **_):
     replayer.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
-    test.add_from_data("123\n", "test.html")
+    test.add_from_bytes(b"123\n", "test.html")
     tests = [test]
     log_path = tmp_path / "logs"
 
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 4c67f86b..154fff48 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -37,7 +37,7 @@ def update(self, success, served=None):
     with TestCase("a.htm", None, "adpt", input_fname="fn", time_limit=2) as src:
         src.duration = 1.2
         src.hang = is_hang
-        src.add_from_data("123", "a.htm")
+        src.add_from_bytes(b"123", "a.htm")
         strategy = _TestStrategy([src])
     for attempt in strategy:
         assert len(attempt) == 1
@@ -106,7 +106,7 @@ def entries(_):
     [
         # "list" is a no-op with a single testcase
         ListStrategyParams(
-            test_data=["123"],
+            test_data=[b"123"],
             strategies=["check", "list"],
             required_first=False,
             expected_run_calls=1,
@@ -115,7 +115,7 @@ def entries(_):
         ),
         # "list" reduces a list of testcases down to one required
         ListStrategyParams(
-            test_data=["", "", "123", ""],
+            test_data=[b"", b"", b"123", b""],
             strategies=["list"],
             required_first=False,
             expected_run_calls=4,
@@ -124,7 +124,7 @@ def entries(_):
         ),
         # "list" reduces a list of testcases down to two required
         ListStrategyParams(
-            test_data=["", "required", "123", ""],
+            test_data=[b"", b"required", b"123", b""],
             strategies=["list"],
             required_first=True,
             expected_run_calls=4,
@@ -152,7 +152,7 @@ def test_list(
     def replay_run(testcases, _time_limit, **_):
         required_seen = False
         for test in testcases:
-            contents = test.get_file("test.html").data.decode("ascii")
+            contents = test.get_file("test.html").data_file.read_text()
             LOG.debug("interesting if %r == '123'", contents)
             if contents == "required" and required_first:
                 required_seen = True
@@ -171,7 +171,7 @@ def replay_run(testcases, _time_limit, **_):
     tests = []
     for data in test_data:
         test = TestCase("test.html", None, "test-adapter")
-        test.add_from_data(data, "test.html")
+        test.add_from_bytes(data, "test.html")
         tests.append(test)
     log_path = tmp_path / "logs"
 
@@ -215,7 +215,7 @@ def replay_run(testcases, _time_limit, **_):
         # single test, first reduction uses 2 files, second uses only target file.
         PurgeUnservedTestParams(
             strategies=["chars"],
-            test_data=[{"test.html": "123", "opt.html": "456"}],
+            test_data=[{"test.html": b"123", "opt.html": b"456"}],
             served=[[["test.html", "opt.html"]], [["test.html"]], [["test.html"]]],
             expected_results={"1"},
             expected_run_calls=5,
@@ -225,7 +225,7 @@ def replay_run(testcases, _time_limit, **_):
         # single test, first reduction uses target only
         PurgeUnservedTestParams(
             strategies=["chars"],
-            test_data=[{"test.html": "123", "opt.html": "456"}],
+            test_data=[{"test.html": b"123", "opt.html": b"456"}],
             served=[[["test.html"]], [["test.html"]]],
             expected_results={"1"},
             expected_run_calls=3,
@@ -236,7 +236,7 @@ def replay_run(testcases, _time_limit, **_):
         # (no results -> Assertion)
         PurgeUnservedTestParams(
             strategies=["chars"],
-            test_data=[{"test.html": "123", "opt.html": "456"}],
+            test_data=[{"test.html": b"123", "opt.html": b"456"}],
             served=[[["test.html", "opt.html"]], [["opt.html"]]],
             expected_results=set(),
             expected_run_calls=4,
@@ -248,8 +248,8 @@ def replay_run(testcases, _time_limit, **_):
         PurgeUnservedTestParams(
             strategies=["chars"],
             test_data=[
-                {"test.html": "123", "opt.html": "456"},
-                {"test.html": "789", "opt.html": "abc"},
+                {"test.html": b"123", "opt.html": b"456"},
+                {"test.html": b"789", "opt.html": b"abc"},
             ],
             served=[
                 [["test.html", "opt.html"], ["test.html", "opt.html"]],
@@ -266,8 +266,8 @@ def replay_run(testcases, _time_limit, **_):
         PurgeUnservedTestParams(
             strategies=["chars"],
             test_data=[
-                {"test.html": "123", "opt.html": "456"},
-                {"test.html": "789", "opt.html": "abc"},
+                {"test.html": b"123", "opt.html": b"456"},
+                {"test.html": b"789", "opt.html": b"abc"},
             ],
             served=[
                 [["test.html", "opt.html"], ["test.html", "opt.html"]],
@@ -283,9 +283,9 @@ def replay_run(testcases, _time_limit, **_):
         PurgeUnservedTestParams(
             strategies=["list"],
             test_data=[
-                {"test.html": "123"},
-                {"test.html": "456"},
-                {"test.html": "789"},
+                {"test.html": b"123"},
+                {"test.html": b"456"},
+                {"test.html": b"789"},
             ],
             served=[[["test.html"]], [["test.html"]], [["test.html"]]],
             expected_results={"456"},
@@ -297,9 +297,9 @@ def replay_run(testcases, _time_limit, **_):
         PurgeUnservedTestParams(
             strategies=["list"],
             test_data=[
-                {"test.html": "123"},
-                {"test.html": "456"},
-                {"test.html": "789"},
+                {"test.html": b"123"},
+                {"test.html": b"456"},
+                {"test.html": b"789"},
             ],
             served=[None, None, None],
             expected_results={"789"},
@@ -332,10 +332,10 @@ def replay_run(testcases, _time_limit, **_):
         has_any = False
         for test in testcases:
             for file in ("test.html", "opt.html"):
-                if test.contains(file):
+                if file in test.contents:
                     LOG.debug("testcase contains %s", file)
                     has_any = True
-                    contents = test.get_file(file).data.decode("ascii")
+                    contents = test.get_file(file).data_file.read_text()
                     if not contents.strip():
                         return []
         if not has_any:
@@ -352,7 +352,7 @@ def replay_run(testcases, _time_limit, **_):
     for testcase in test_data:
         test = TestCase("test.html", None, "test-adapter")
         for filename, data in testcase.items():
-            test.add_from_data(data, filename)
+            test.add_from_bytes(data, filename)
         tests.append(test)
     log_path = tmp_path / "logs"
 
@@ -397,7 +397,7 @@ def test_dd_only(mocker, tmp_path):
 
     def replay_run(testcases, _time_limit, **_):
         for test in testcases:
-            contents = test.get_file("test.html").data.decode("ascii")
+            contents = test.get_file("test.html").data_file.read_text()
             LOG.debug("interesting if 'required' in %r", contents)
             interesting = "required" in contents
             if interesting:
@@ -411,8 +411,8 @@ def replay_run(testcases, _time_limit, **_):
     replayer.run.side_effect = replay_run
 
     test = TestCase("test.html", None, "test-adapter")
-    test.add_from_data("DDBEGIN\n123\nrequired\nDDEND\n", "test.html")
-    test.add_from_data("blah\n", "other.html")
+    test.add_from_bytes(b"DDBEGIN\n123\nrequired\nDDEND\n", "test.html")
+    test.add_from_bytes(b"blah\n", "other.html")
     tests = [test]
     log_path = tmp_path / "logs"
 
diff --git a/grizzly/reduce/test_strategies_beautify.py b/grizzly/reduce/test_strategies_beautify.py
index 384d3689..5dfbe27c 100644
--- a/grizzly/reduce/test_strategies_beautify.py
+++ b/grizzly/reduce/test_strategies_beautify.py
@@ -19,12 +19,12 @@ def _test_beautify(cls, interesting, test_name, test_data, reduced, mocker):
     mocker.patch("grizzly.reduce.strategies.beautify._contains_dd", return_value=True)
 
     best_test = TestCase(test_name, None, "test-adapter")
-    best_test.add_from_data(test_data, test_name)
+    best_test.add_from_bytes(test_data.encode("ascii"), test_name)
     best_tests = [best_test]
 
     def _interesting(testcases):
         for test in testcases:
-            contents = test.get_file(test_name).data.decode("ascii")
+            contents = test.get_file(test_name).data_file.read_bytes().decode("ascii")
             if interesting(contents):
                 return True
         return False
@@ -44,7 +44,9 @@ def _interesting(testcases):
                     for test in tests:
                         test.cleanup()
         assert len(best_tests) == 1
-        contents = best_tests[0].get_file(test_name).data.decode("ascii")
+        contents = (
+            best_tests[0].get_file(test_name).data_file.read_bytes().decode("ascii")
+        )
         assert contents == reduced
     finally:
         for test in best_tests:
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 3bd98431..25b456a4 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -47,7 +47,7 @@ def test_main_01(mocker, tmp_path):
     load_target.return_value.return_value = target
     with TestCase("test.html", None, "adpt") as src:
         src.env_vars["TEST_VAR"] = "100"
-        src.add_from_data("test", "test.html")
+        src.add_from_bytes(b"test", "test.html")
         src.dump(str(tmp_path / "testcase"), include_details=True)
     # setup args
     log_path = tmp_path / "logs"
diff --git a/grizzly/session.py b/grizzly/session.py
index 985adee9..a4a5cc30 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -227,7 +227,7 @@ def run(
             if not result.attempted:
                 LOG.warning("Test case was not served")
                 LOG.debug("ignoring test case since nothing was served")
-                if not current_test.contains(current_test.landing_page):
+                if current_test.landing_page not in current_test.contents:
                     raise SessionError("Test case is missing landing page")
                 if result.initial:
                     # since this is the first iteration since the Target launched
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 552b228f..b3b61e62 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -35,7 +35,7 @@ def setup(self, input_path, _server_map):
     def generate(self, testcase, _server_map):
         assert testcase.adapter_name == self.name
         testcase.input_fname = self.fuzz["input"]
-        testcase.add_from_data("test", testcase.landing_page)
+        testcase.add_from_bytes(b"test", testcase.landing_page)
         if self.remaining is not None:
             assert self.remaining > 0
             self.remaining -= 1

From c46b8242a10d08b2a49f8f399fa33d5898abacf0 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 9 Nov 2021 10:54:29 -0800
Subject: [PATCH 354/531] [sapphire] Update Job.served to yield posix paths

---
 sapphire/job.py           | 27 +++++++++++++++------------
 sapphire/test_job.py      | 11 +++++++----
 sapphire/test_sapphire.py |  6 +++---
 sapphire/worker.py        |  3 ++-
 4 files changed, 27 insertions(+), 20 deletions(-)

diff --git a/sapphire/job.py b/sapphire/job.py
index 7f4d9573..9cdffcf8 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -5,7 +5,7 @@
 """
 Sapphire HTTP server job
 """
-from collections import defaultdict, namedtuple
+from collections import namedtuple
 from enum import Enum, unique
 from logging import getLogger
 from mimetypes import guess_type
@@ -13,6 +13,7 @@
 from os.path import abspath, isdir, isfile
 from os.path import join as pathjoin
 from os.path import normpath, relpath, splitext
+from pathlib import Path
 from queue import Queue
 from threading import Event, Lock
 
@@ -76,7 +77,7 @@ def __init__(
     ):
         self._complete = Event()
         self._pending = Tracker(files=set(), lock=Lock())
-        self._served = Tracker(files=defaultdict(int), lock=Lock())
+        self._served = Tracker(files=set(), lock=Lock())
         self.accepting = Event()
         self.accepting.set()
         self.auto_close = auto_close
@@ -190,10 +191,11 @@ def check_request(self, request):
     def finish(self):
         self._complete.set()
 
-    def increment_served(self, target):
+    def mark_served(self, path):
         # update list of served files
+        assert isinstance(path, Path)
         with self._served.lock:
-            self._served.files[target] += 1
+            self._served.files.add(path)
 
     def is_complete(self, wait=None):
         if wait is not None:
@@ -227,18 +229,19 @@ def remove_pending(self, file_name):
     @property
     def served(self):
         # served files
-        # files served from www root will have a path relative to www root
+        # files served from wwwroot will have a relative path
         # include files will have an absolute path
         with self._served.lock:
             # make a copy of what is available (maybe a copy not necessary?)
-            served = tuple(self._served.files.keys())
-        for fname in served:
-            if fname.startswith(self.base_path):
-                # file is in www root
-                yield relpath(fname, self.base_path)
-            else:
+            served = tuple(self._served.files)
+        wwwroot = Path(self.base_path)
+        for path in served:
+            try:
+                # file is in wwwroot
+                yield path.relative_to(wwwroot).as_posix()
+            except ValueError:
                 # include file
-                yield fname
+                yield path.as_posix()
 
     @property
     def status(self):
diff --git a/sapphire/test_job.py b/sapphire/test_job.py
index d4f02c1f..f39e5cab 100644
--- a/sapphire/test_job.py
+++ b/sapphire/test_job.py
@@ -5,6 +5,7 @@
 # pylint: disable=protected-access
 
 import platform
+from pathlib import Path
 
 import pytest
 
@@ -248,12 +249,14 @@ def test_job_09():
 
 
 def test_job_10(tmp_path):
-    """test Job.increment_served() and Job.served"""
+    """test Job.mark_served() and Job.served"""
     job = Job(str(tmp_path))
     assert not any(job.served)
-    job.increment_served(str(tmp_path / "file.bin"))
-    assert "file.bin" in job.served
-    job.increment_served("/some/include/path/inc.bin")
+    job.mark_served(tmp_path / "a.bin")
+    assert "a.bin" in job.served
+    job.mark_served(tmp_path / "nested" / "b.bin")
+    assert "nested/b.bin" in job.served
+    job.mark_served(Path("/some/include/path/inc.bin"))
     assert "/some/include/path/inc.bin" in job.served
 
 
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 9fbbcfff..7539d647 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -410,9 +410,9 @@ def test_sapphire_18(client, tmp_path):
         status, files_served = serv.serve_path(str(root_path), server_map=smap)
     assert status == Served.ALL
     assert "test_case.html" in files_served
-    assert str(inc1_path / "included_file1.html") in files_served
-    assert str(inc2_path / "included_file2.html") in files_served
-    assert str(nest_path / "nested_file.html") in files_served
+    assert (inc1_path / "included_file1.html").as_posix() in files_served
+    assert (inc2_path / "included_file2.html").as_posix() in files_served
+    assert (nest_path / "nested_file.html").as_posix() in files_served
     assert client.wait(timeout=10)
     assert inc1.code == 200
     assert inc2.code == 200
diff --git a/sapphire/worker.py b/sapphire/worker.py
index 3a6630de..9cd9f0d7 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -8,6 +8,7 @@
 from logging import getLogger
 from os import stat
 from os.path import isfile
+from pathlib import Path
 from re import compile as re_compile
 from socket import error as sock_error
 from socket import timeout as sock_timeout
@@ -199,7 +200,7 @@ def handle_request(cls, conn, serv_job):
                     conn.sendall(in_fp.read(cls.DEFAULT_TX_SIZE))
                     offset = in_fp.tell()
             LOG.debug("200 %r (%d to go)", resource.target, serv_job.pending)
-            serv_job.increment_served(resource.target)
+            serv_job.mark_served(Path(resource.target))
 
         except (sock_error, sock_timeout):
             _, exc_obj, exc_tb = exc_info()

From 38515e7258db86d15b06984cda47b4fa5fb9a773 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 9 Nov 2021 11:00:45 -0800
Subject: [PATCH 355/531] Update TestCase to use Path objects where possible

---
 grizzly/common/storage.py      | 98 +++++++++++++++++-----------------
 grizzly/common/test_storage.py | 32 +++++------
 2 files changed, 66 insertions(+), 64 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index e751faa5..07942cb5 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -6,10 +6,8 @@
 import json
 from collections import namedtuple
 from itertools import chain, product
-from os import listdir, walk
-from os.path import abspath, basename, dirname, isdir, isfile
-from os.path import join as pathjoin
-from os.path import normpath, relpath, split
+from os import walk
+from os.path import normpath, split
 from pathlib import Path
 from shutil import copyfileobj, rmtree
 from tempfile import NamedTemporaryFile, mkdtemp
@@ -99,14 +97,17 @@ def add_batch(self, path, include_files, prefix=None, copy=True):
         Returns:
             None
         """
-        path = abspath(path)
-        for fname in (x for x in include_files if x.startswith(path)):
-            test_path = relpath(fname, path)
-            if test_path.startswith(".."):
+        path = Path(path)
+        for fname in include_files:
+            file = Path(fname)
+            try:
+                relative = file.relative_to(path)
+            except ValueError:
+                # cannot add files outside path
                 continue
             if prefix:
-                test_path = "/".join((prefix, test_path))
-            self.add_from_file(fname, file_name=test_path, copy=copy)
+                relative = prefix / relative
+            self.add_from_file(file, file_name=relative.as_posix(), copy=copy)
 
     def add_from_bytes(self, data, file_name, required=True):
         """Create a file and add it to the TestCase.
@@ -140,7 +141,6 @@ def add_from_file(self, src_file, file_name=None, required=True, copy=False):
         Returns:
             None
         """
-        assert src_file
         src_file = Path(src_file)
         if file_name is None:
             file_name = src_file.name
@@ -153,7 +153,7 @@ def add_from_file(self, src_file, file_name=None, required=True, copy=False):
             TestFile.copy_file(src_file, test_file.data_file)
         else:
             test_file.data_file.parent.mkdir(exist_ok=True, parents=True)
-            src_file.rename(str(test_file.data_file))
+            src_file.replace(test_file.data_file)
 
         # TODO: set 'required=False' by default
         # landing_page is always 'required'
@@ -207,7 +207,7 @@ def clone(self):
             data_file = result._data_path / entry.file_name
             TestFile.copy_file(entry.data_file, data_file)
             result.add_from_file(
-                str(data_file),
+                data_file,
                 file_name=entry.file_name,
                 required=required,
                 copy=False,
@@ -277,7 +277,7 @@ def dump(self, dst_path, include_details=False):
                 "duration": self.duration,
                 "env": self.env_vars,
                 "hang": self.hang,
-                "input": basename(self.input_fname) if self.input_fname else None,
+                "input": Path(self.input_fname).name if self.input_fname else None,
                 "target": self.landing_page,
                 "time_limit": self.time_limit,
                 "timestamp": self.timestamp,
@@ -291,17 +291,17 @@ def dump(self, dst_path, include_details=False):
             with (dst_path / "test_info.json").open("w") as out_fp:
                 json.dump(info, out_fp, indent=2, sort_keys=True)
 
-    def get_file(self, file_name):
+    def get_file(self, path):
         """Lookup and return the TestFile with the specified file name.
 
         Args:
-            file_name (str): Name of file to retrieve.
+            path (str): Path (relative to wwwroot) of TestFile to retrieve.
 
         Returns:
-            TestFile: TestFile with matching file name otherwise None.
+            TestFile: TestFile with matching path otherwise None.
         """
         for tfile in chain(self._files.optional, self._files.required):
-            if tfile.file_name == file_name:
+            if tfile.file_name == path:
                 return tfile
         return None
 
@@ -323,8 +323,9 @@ def load(cls, path, adjacent=False):
         Returns:
             list: TestCases successfully loaded from path.
         """
+        path = Path(path)
         # unpack archive if needed
-        if path.lower().endswith(".zip"):
+        if path.name.lower().endswith(".zip"):
             unpacked = mkdtemp(prefix="unpack_", dir=grz_tmp("storage"))
             try:
                 with ZipFile(path) as zip_fp:
@@ -332,14 +333,14 @@ def load(cls, path, adjacent=False):
             except (BadZipfile, zlib_error):
                 rmtree(unpacked, ignore_errors=True)
                 raise TestCaseLoadFailure("Testcase archive is corrupted") from None
-            path = unpacked
+            path = Path(unpacked)
         else:
             unpacked = None
         # load testcase data from disk
         try:
-            if isfile(path):
+            if path.is_file():
                 tests = [cls.load_single(path, adjacent=adjacent)]
-            elif isdir(path):
+            elif path.is_dir():
                 tests = list()
                 assets = None
                 # TODO: move (don't copy) 'unpacked' files
@@ -367,7 +368,7 @@ def load_single(cls, path, adjacent=False, load_assets=True):
         contain a valid 'test_info.json' file.
 
         Args:
-            path (str): Path to the directory or file to load.
+            path (Path): Path to the directory or file to load.
             adjacent (bool): Load adjacent files as part of the TestCase.
                              This is always true when loading a directory.
                              WARNING: This should be used with caution!
@@ -375,11 +376,11 @@ def load_single(cls, path, adjacent=False, load_assets=True):
         Returns:
             TestCase: A TestCase.
         """
-        path = abspath(path)
-        if isdir(path):
+        path = Path(path)
+        if path.is_dir():
             # load using test_info.json
             try:
-                with open(pathjoin(path, "test_info.json"), "r") as in_fp:
+                with (path / "test_info.json").open("r") as in_fp:
                     info = json.load(in_fp)
             except IOError:
                 raise TestCaseLoadFailure("Missing 'test_info.json'") from None
@@ -387,22 +388,21 @@ def load_single(cls, path, adjacent=False, load_assets=True):
                 raise TestCaseLoadFailure("Invalid 'test_info.json'") from None
             if not isinstance(info.get("target"), str):
                 raise TestCaseLoadFailure("'test_info.json' has invalid 'target' entry")
-            entry_point = basename(info["target"])
-            if not isfile(pathjoin(path, entry_point)):
+            entry_point = Path(path / info["target"])
+            if not entry_point.is_file():
                 raise TestCaseLoadFailure(
-                    "Entry point %r not found in '%s'" % (entry_point, path)
+                    "Entry point %r not found in %r" % (info["target"], str(path))
                 )
             # always load all contents of a directory if a 'test_info.json' is loaded
             adjacent = True
-        elif isfile(path):
-            entry_point = basename(path)
+        elif path.is_file():
+            entry_point = path
             info = dict()
-            path = dirname(path)
         else:
-            raise TestCaseLoadFailure("Missing or invalid TestCase %r" % (path,))
+            raise TestCaseLoadFailure("Missing or invalid TestCase %r" % (str(path),))
         # create testcase and add data
         test = cls(
-            entry_point,
+            entry_point.relative_to(entry_point.parent).as_posix(),
             None,
             info.get("adapter", None),
             input_fname=info.get("input", None),
@@ -411,14 +411,16 @@ def load_single(cls, path, adjacent=False, load_assets=True):
         )
         test.duration = info.get("duration", None)
         test.hang = info.get("hang", False)
-        test.add_from_file(pathjoin(path, entry_point), copy=True)
+        test.add_from_file(
+            entry_point, file_name=test.landing_page, required=True, copy=True
+        )
         if info:
             # load assets
             try:
                 if load_assets and info.get("assets", None):
                     test.assets = AssetManager.load(
                         info.get("assets"),
-                        pathjoin(path, info.get("assets_path", "")),
+                        str(entry_point.parent / info.get("assets_path", "")),
                     )
             except (AssetError, OSError) as exc:
                 test.cleanup()
@@ -436,17 +438,19 @@ def load_single(cls, path, adjacent=False, load_assets=True):
         # load all adjacent data from directory
         if adjacent:
             asset_path = info.get("assets_path", None)
-            for dpath, _, files in walk(path):
+            for dpath, _, files in walk(entry_point.parent):
                 # ignore asset path
-                if asset_path and dpath == pathjoin(path, asset_path):
+                dpath = Path(dpath)
+                if asset_path and dpath.samefile(entry_point.parent / asset_path):
                     continue
                 for fname in files:
+                    file = dpath / fname
+                    location = file.relative_to(entry_point.parent).as_posix()
                     # ignore files that have been previously loaded
-                    if fname in (entry_point, "test_info.json"):
+                    if location in (test.landing_page, "test_info.json"):
                         continue
-                    location = "/".join((dpath.split(path, 1)[-1], fname))
                     test.add_from_file(
-                        pathjoin(dpath, fname),
+                        file,
                         file_name=location,
                         required=False,
                         copy=True,
@@ -515,19 +519,17 @@ def scan_path(path):
         """Check path and subdirectories for potential test cases.
 
         Args:
-            path (str): Path to scan.
+            path (Path): Path to scan.
 
         Yields:
             str: Path to what appears to be a valid testcase.
         """
-        contents = listdir(path)
-        if "test_info.json" in contents:
+        if "test_info.json" in (x.name for x in path.iterdir()):
             yield path
         else:
-            for entry in contents:
-                tc_path = pathjoin(path, entry)
-                if isfile(pathjoin(tc_path, "test_info.json")):
-                    yield tc_path
+            for entry in path.iterdir():
+                if entry.is_dir() and (entry / "test_info.json").is_file():
+                    yield entry
 
 
 class TestFile:
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 16a05a5b..62859ea2 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -136,17 +136,17 @@ def test_testcase_06(tmp_path):
     """test TestCase.load_single() using a directory - fail cases"""
     # missing test_info.json
     with raises(TestCaseLoadFailure, match="Missing 'test_info.json'"):
-        TestCase.load_single(str(tmp_path))
+        TestCase.load_single(tmp_path)
     # invalid test_info.json
     (tmp_path / "test_info.json").write_bytes(b"X")
     with raises(TestCaseLoadFailure, match="Invalid 'test_info.json'"):
-        TestCase.load_single(str(tmp_path))
+        TestCase.load_single(tmp_path)
     # test_info.json missing 'target' entry
     (tmp_path / "test_info.json").write_bytes(b"{}")
     with raises(
         TestCaseLoadFailure, match="'test_info.json' has invalid 'target' entry"
     ):
-        TestCase.load_single(str(tmp_path))
+        TestCase.load_single(tmp_path)
     # build a test case
     src_dir = tmp_path / "src"
     src_dir.mkdir()
@@ -158,7 +158,7 @@ def test_testcase_06(tmp_path):
     # bad 'target' entry in test_info.json
     entry_point.unlink()
     with raises(TestCaseLoadFailure, match="Entry point 'target.bin' not found in"):
-        TestCase.load_single(str(src_dir))
+        TestCase.load_single(src_dir)
     # bad 'env' entry in test_info.json
     entry_point.touch()
     with AssetManager(base_path=str(tmp_path)) as assets:
@@ -171,7 +171,7 @@ def test_testcase_06(tmp_path):
     test_info["env"] = {"bad": 1}
     (src_dir / "test_info.json").write_text(dumps(test_info))
     with raises(TestCaseLoadFailure, match="'env' contains invalid entries"):
-        TestCase.load_single(str(src_dir))
+        TestCase.load_single(src_dir)
 
 
 def test_testcase_07(mocker, tmp_path):
@@ -206,7 +206,7 @@ def test_testcase_07(mocker, tmp_path):
             src.assets = assets
             src.dump(str(dst_dir), include_details=True)
     # test loading test case from test_info.json
-    with TestCase.load_single(str(dst_dir)) as dst:
+    with TestCase.load_single(dst_dir) as dst:
         asset = dst.pop_assets()
         assert asset
         with asset:
@@ -221,14 +221,14 @@ def test_testcase_07(mocker, tmp_path):
     # test load with missing asset
     mocker.patch("grizzly.common.storage.AssetManager.load", side_effect=OSError)
     with raises(TestCaseLoadFailure):
-        TestCase.load_single(str(dst_dir))
+        TestCase.load_single(dst_dir)
 
 
 def test_testcase_08(tmp_path):
     """test TestCase.load_single() using a file"""
     # invalid entry_point specified
     with raises(TestCaseLoadFailure, match="Missing or invalid TestCase"):
-        TestCase.load_single(str(tmp_path / "missing_file"), adjacent=False)
+        TestCase.load_single(tmp_path / "missing_file", adjacent=False)
     # valid test case
     src_dir = tmp_path / "src"
     src_dir.mkdir()
@@ -236,7 +236,7 @@ def test_testcase_08(tmp_path):
     entry_point.touch()
     (src_dir / "optional.bin").touch()
     # load single file test case
-    with TestCase.load_single(str(entry_point), adjacent=False) as tcase:
+    with TestCase.load_single(entry_point, adjacent=False) as tcase:
         assert tcase.assets is None
         assert not tcase.env_vars
         assert tcase.landing_page == "target.bin"
@@ -244,7 +244,7 @@ def test_testcase_08(tmp_path):
         assert "optional.bin" not in (x.file_name for x in tcase._files.optional)
         assert tcase.timestamp == 0
     # load full test case
-    with TestCase.load_single(str(entry_point), adjacent=True) as tcase:
+    with TestCase.load_single(entry_point, adjacent=True) as tcase:
         assert tcase.landing_page == "target.bin"
         assert "target.bin" in (x.file_name for x in tcase._files.required)
         assert "optional.bin" in (x.file_name for x in tcase._files.optional)
@@ -269,7 +269,7 @@ def test_testcase_09(tmp_path):
             org.assets = assets
             org.dump(str(working), include_details=True)
         org.assets = None
-        with TestCase.load_single(str(working), adjacent=False) as loaded:
+        with TestCase.load_single(working, adjacent=False) as loaded:
             try:
                 for prop in TestCase.__slots__:
                     if prop.startswith("_") or prop in ("assets", "redirect_page"):
@@ -424,17 +424,17 @@ def test_testcase_16(tmp_path):
     """test TestCase.scan_path()"""
     # empty path
     (tmp_path / "not-test").mkdir()
-    assert not any(TestCase.scan_path(str(tmp_path)))
+    assert not any(TestCase.scan_path(tmp_path))
     # multiple test case directories
-    paths = [str(tmp_path / ("test-%d" % i)) for i in range(3)]
+    paths = [tmp_path / ("test-%d" % i) for i in range(3)]
     with TestCase("test.htm", None, "test-adapter") as src:
         src.add_from_bytes(b"test", "test.htm")
         for path in paths:
-            src.dump(path, include_details=True)
-    tc_paths = list(TestCase.scan_path(str(tmp_path)))
+            src.dump(str(path), include_details=True)
+    tc_paths = list(TestCase.scan_path(tmp_path))
     assert len(tc_paths) == 3
     # single test case directory
-    tc_paths = list(TestCase.scan_path(str(paths[0])))
+    tc_paths = list(TestCase.scan_path(paths[0]))
     assert len(tc_paths) == 1
 
 

From 65c4cd83222cc53316013edd9c5945d8df592eaa Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 9 Nov 2021 14:03:55 -0800
Subject: [PATCH 356/531] Move files unpacked from a testcase archive

---
 grizzly/common/storage.py | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 07942cb5..db0b31f2 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -343,9 +343,12 @@ def load(cls, path, adjacent=False):
             elif path.is_dir():
                 tests = list()
                 assets = None
-                # TODO: move (don't copy) 'unpacked' files
                 for tc_path in TestCase.scan_path(path):
-                    tests.append(cls.load_single(tc_path, load_assets=assets is None))
+                    tests.append(
+                        cls.load_single(
+                            tc_path, load_assets=assets is None, copy=unpacked is None
+                        )
+                    )
                     # only load assets once
                     if not assets and tests[-1].assets:
                         assets = tests[-1].assets
@@ -363,7 +366,7 @@ def load(cls, path, adjacent=False):
         return tests
 
     @classmethod
-    def load_single(cls, path, adjacent=False, load_assets=True):
+    def load_single(cls, path, adjacent=False, load_assets=True, copy=True):
         """Load contents of a TestCase from disk. If `path` is a directory it must
         contain a valid 'test_info.json' file.
 
@@ -372,6 +375,8 @@ def load_single(cls, path, adjacent=False, load_assets=True):
             adjacent (bool): Load adjacent files as part of the TestCase.
                              This is always true when loading a directory.
                              WARNING: This should be used with caution!
+            load_assets (bool): Load assets files.
+            copy (bool): Files will be copied if True otherwise the they will be moved.
 
         Returns:
             TestCase: A TestCase.
@@ -412,7 +417,7 @@ def load_single(cls, path, adjacent=False, load_assets=True):
         test.duration = info.get("duration", None)
         test.hang = info.get("hang", False)
         test.add_from_file(
-            entry_point, file_name=test.landing_page, required=True, copy=True
+            entry_point, file_name=test.landing_page, required=True, copy=copy
         )
         if info:
             # load assets
@@ -453,7 +458,7 @@ def load_single(cls, path, adjacent=False, load_assets=True):
                         file,
                         file_name=location,
                         required=False,
-                        copy=True,
+                        copy=copy,
                     )
         return test
 

From bec348445f391cd03660201be1acc72213f86fec Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 9 Nov 2021 14:04:42 -0800
Subject: [PATCH 357/531] [replay] Remove use of TestCase.dump() to run tests

---
 grizzly/replay/replay.py      | 12 ------------
 grizzly/replay/test_replay.py |  3 ---
 2 files changed, 15 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 22779819..7a3f8852 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -6,7 +6,6 @@
 from logging import getLogger
 from os.path import dirname
 from os.path import join as pathjoin
-from shutil import rmtree
 from tempfile import mkdtemp
 
 from FTB.Signatures.CrashInfo import CrashSignature
@@ -264,16 +263,9 @@ def run(
 
         # track unprocessed results
         reports = dict()
-        # track unpacked testcases
-        unpacked = list()
         try:
             sig_hash = Report.calc_hash(self._signature) if self._signature else None
             test_count = len(testcases)
-            LOG.debug("unpacking testcases (%d)...", test_count)
-            for test in testcases:
-                dst_path = mkdtemp(prefix="tc_", dir=grz_tmp("serve"))
-                unpacked.append(dst_path)
-                test.dump(dst_path)
             relaunch = min(self._relaunch, repeat)
             runner = Runner(
                 self.server,
@@ -333,7 +325,6 @@ def run(
                         self.ignore,
                         server_map,
                         testcases[test_idx],
-                        test_path=unpacked[test_idx],
                         wait_for_callback=self._harness is None,
                     )
                     durations.append(run_result.duration)
@@ -505,9 +496,6 @@ def run(
             return results
 
         finally:
-            # remove unpacked testcase data
-            for tc_path in unpacked:
-                rmtree(tc_path)
             # we don't want to clean up but we are not checking results
             self.target.close(force_close=True)
             # remove unprocessed reports
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 35943d8f..0432be33 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -544,7 +544,6 @@ def test_replay_15(mocker):
         assert replay.status.iteration == 1
         assert replay.status.results.total == 0
     assert target.close.call_count == 2
-    assert all(x.dump.call_count == 1 for x in testcases)
 
 
 def test_replay_16(mocker):
@@ -569,7 +568,6 @@ def test_replay_16(mocker):
         assert replay.status.iteration == 10
         assert replay.status.results.total == 0
     assert target.monitor.is_healthy.call_count == 5
-    assert all(x.dump.call_count == 1 for x in testcases)
 
 
 def test_replay_17(mocker):
@@ -605,7 +603,6 @@ def test_replay_17(mocker):
     assert results[0].served[1][0] == "b.html"
     assert results[0].served[2][0] == "c.html"
     assert len(results[0].durations) == len(testcases)
-    assert all(x.dump.call_count == 1 for x in testcases)
 
 
 def test_replay_18(mocker):

From 6452000c9ffdda4870aa4a16b3af326c8158e627 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 9 Nov 2021 14:05:28 -0800
Subject: [PATCH 358/531] Serve TestCases directly from data path

---
 grizzly/common/runner.py      | 36 ++++++++++-------------------------
 grizzly/common/test_runner.py | 18 +-----------------
 2 files changed, 11 insertions(+), 43 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index e090e70b..d4199fb6 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -3,14 +3,11 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
-from shutil import rmtree
-from tempfile import mkdtemp
 from time import sleep, time
 
 from sapphire import Served
 
 from ..target import Result, TargetLaunchError, TargetLaunchTimeout
-from .utils import grz_tmp
 
 __all__ = ("Runner", "RunResult")
 __author__ = "Tyson Smith"
@@ -176,7 +173,6 @@ def run(
         ignore,
         server_map,
         testcase,
-        test_path=None,
         coverage=False,
         wait_for_callback=False,
     ):
@@ -186,7 +182,6 @@ def run(
             ignore (list): List of failure types to ignore.
             server_map (sapphire.ServerMap): A ServerMap.
             testcase (grizzly.TestCase): The test case that will be served.
-            test_path (str): Location of test case data on the filesystem.
             coverage (bool): Trigger coverage dump.
             wait_for_callback: (bool): Use `_keep_waiting()` to indicate when
                                        framework should move on.
@@ -200,27 +195,16 @@ def run(
             # overwrite instead of replace 'grz_next_test' for consistency
             server_map.set_redirect("grz_next_test", "grz_empty", required=True)
             server_map.set_dynamic_response("grz_empty", lambda _: b"", required=True)
-        try:
-            # unpack test case
-            if test_path is None:
-                wwwdir = mkdtemp(prefix="test_", dir=grz_tmp("serve"))
-                testcase.dump(wwwdir)
-            else:
-                wwwdir = test_path
-            # serve the test case
-            serve_start = time()
-            server_status, served = self._server.serve_path(
-                wwwdir,
-                continue_cb=self._keep_waiting,
-                forever=wait_for_callback,
-                optional_files=tuple(testcase.optional),
-                server_map=server_map,
-            )
-            duration = time() - serve_start
-        finally:
-            # remove temporary files
-            if test_path is None:
-                rmtree(wwwdir)
+        # serve the test case
+        serve_start = time()
+        server_status, served = self._server.serve_path(
+            testcase.data_path,
+            continue_cb=self._keep_waiting,
+            forever=wait_for_callback,
+            optional_files=tuple(testcase.optional),
+            server_map=server_map,
+        )
+        duration = time() - serve_start
         result = RunResult(served, duration, timeout=server_status == Served.TIMEOUT)
         result.attempted = testcase.landing_page in result.served
         result.initial = self._tests_run == 0
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 2c486ceb..ba4d76f9 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -15,7 +15,7 @@
 from .storage import TestCase
 
 
-def test_runner_01(mocker, tmp_path):
+def test_runner_01(mocker):
     """test Runner()"""
     mocker.patch("grizzly.common.runner.time", autospec=True, side_effect=count())
     server = mocker.Mock(spec_set=Sapphire)
@@ -42,7 +42,6 @@ def test_runner_01(mocker, tmp_path):
     assert target.close.call_count == 0
     assert target.dump_coverage.call_count == 0
     assert target.handle_hang.call_count == 0
-    assert testcase.dump.call_count == 1
     # dump coverage
     serv_map = ServerMap()
     server.serve_path.return_value = (Served.ALL, serv_files)
@@ -57,21 +56,6 @@ def test_runner_01(mocker, tmp_path):
     assert target.close.call_count == 0
     assert target.dump_coverage.call_count == 1
     assert target.handle_hang.call_count == 0
-    # existing test path
-    testcase.reset_mock()
-    tc_path = tmp_path / "tc"
-    tc_path.mkdir()
-    serv_map = ServerMap()
-    server.serve_path.return_value = (Served.ALL, serv_files)
-    result = runner.run([], serv_map, testcase, test_path=str(tc_path))
-    assert result.attempted
-    assert runner._tests_run == 3
-    assert not result.initial
-    assert result.status == Result.NONE
-    assert not serv_map.dynamic
-    assert target.close.call_count == 0
-    assert testcase.dump.call_count == 0
-    tc_path.is_dir()
 
 
 def test_runner_02(mocker):

From cd7c7c871c51aea1e04b5a3a0cdbbba410bfb208 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 10 Nov 2021 18:36:47 -0800
Subject: [PATCH 359/531] Simplify TestFile by making it a namedtuple

---
 grizzly/common/storage.py      | 125 +++++++++++++--------------------
 grizzly/common/test_storage.py |  72 ++++++++++---------
 2 files changed, 89 insertions(+), 108 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index db0b31f2..c6393d2e 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -18,7 +18,7 @@
 from ..target import AssetError, AssetManager
 from .utils import grz_tmp
 
-__all__ = ("TestCase", "TestFile", "TestCaseLoadFailure", "TestFileExists")
+__all__ = ("TestCase", "TestCaseLoadFailure", "TestFileExists")
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
@@ -32,6 +32,7 @@ class TestFileExists(Exception):
     TestFile with the same name"""
 
 
+TestFile = namedtuple("TestFile", "file_name data_file")
 TestFileMap = namedtuple("TestFileMap", "optional required")
 
 
@@ -66,9 +67,9 @@ def __init__(
         self.env_vars = dict()
         self.hang = False
         self.input_fname = input_fname  # file that was used to create the test case
-        self.landing_page = TestFile.sanitize_path(landing_page)
+        self.landing_page = self.sanitize_path(landing_page)
         if redirect_page is not None:
-            self.redirect_page = TestFile.sanitize_path(redirect_page)
+            self.redirect_page = self.sanitize_path(redirect_page)
         else:
             self.redirect_page = None
         self.time_limit = time_limit
@@ -123,9 +124,17 @@ def add_from_bytes(self, data, file_name, required=True):
         assert isinstance(data, bytes)
         with NamedTemporaryFile(delete=False, dir=grz_tmp("storage")) as in_fp:
             in_fp.write(data)
-            datafile = in_fp.name
+            data_file = Path(in_fp.name)
 
-        self.add_from_file(datafile, file_name=file_name, required=required, copy=False)
+        try:
+            self.add_from_file(
+                data_file, file_name=file_name, required=required, copy=False
+            )
+        finally:
+            # the temporary file should have been moved to the data path of the TestCase
+            # unless an exception occurred so remove it if needed
+            if data_file.is_file():
+                data_file.unlink()
 
     def add_from_file(self, src_file, file_name=None, required=True, copy=False):
         """Add a file to the TestCase by either copying or moving an existing file.
@@ -144,13 +153,14 @@ def add_from_file(self, src_file, file_name=None, required=True, copy=False):
         src_file = Path(src_file)
         if file_name is None:
             file_name = src_file.name
+        file_name = self.sanitize_path(file_name)
 
-        test_file = TestFile(file_name, self._data_path)
+        test_file = TestFile(file_name, self._data_path / file_name)
         if test_file.file_name in self.contents:
             raise TestFileExists("%r exists in test" % (test_file.file_name,))
 
         if copy:
-            TestFile.copy_file(src_file, test_file.data_file)
+            self.copy_file(src_file, test_file.data_file)
         else:
             test_file.data_file.parent.mkdir(exist_ok=True, parents=True)
             src_file.replace(test_file.data_file)
@@ -171,10 +181,7 @@ def cleanup(self):
         Returns:
             None
         """
-        # TODO: can this be replaced with a single rmtree()?
-        for test_file in chain(self._files.required, self._files.optional):
-            test_file.unlink()
-        rmtree(str(self._data_path), ignore_errors=True)
+        rmtree(self._data_path, ignore_errors=True)
 
     def clone(self):
         """Make a copy of the TestCase.
@@ -203,14 +210,8 @@ def clone(self):
             product(self._files.required, [True]),
             product(self._files.optional, [False]),
         ):
-            # pylint: disable=protected-access
-            data_file = result._data_path / entry.file_name
-            TestFile.copy_file(entry.data_file, data_file)
             result.add_from_file(
-                data_file,
-                file_name=entry.file_name,
-                required=required,
-                copy=False,
+                entry.data_file, file_name=entry.file_name, required=required, copy=True
             )
         return result
 
@@ -227,6 +228,22 @@ def contents(self):
         for tfile in chain(self._files.required, self._files.optional):
             yield tfile.file_name
 
+    @staticmethod
+    def copy_file(src_file, dst_file):
+        """Copy data from src_file to dst_file.
+
+        Args:
+            src_file (Path): File to read data from.
+            dst_file (Path): File to write data to.
+
+        Returns:
+            None
+        """
+        with src_file.open("rb") as src_fp:
+            dst_file.parent.mkdir(parents=True, exist_ok=True)
+            with dst_file.open("wb") as dst_fp:
+                copyfileobj(src_fp, dst_fp, 1_048_576)
+
     @property
     def data_path(self):
         """Location test data is stored on disk. This is intended to be used as wwwroot.
@@ -267,7 +284,7 @@ def dump(self, dst_path, include_details=False):
         dst_path = Path(dst_path)
         # save test files to dst_path
         for test_file in chain(self._files.required, self._files.optional):
-            TestFile.copy_file(test_file.data_file, dst_path / test_file.file_name)
+            self.copy_file(test_file.data_file, dst_path / test_file.file_name)
         # save test case files and meta data including:
         # adapter used, input file, environment info and files
         if include_details:
@@ -444,8 +461,8 @@ def load_single(cls, path, adjacent=False, load_assets=True, copy=True):
         if adjacent:
             asset_path = info.get("assets_path", None)
             for dpath, _, files in walk(entry_point.parent):
-                # ignore asset path
                 dpath = Path(dpath)
+                # ignore asset path
                 if asset_path and dpath.samefile(entry_point.parent / asset_path):
                     continue
                 for fname in files:
@@ -517,54 +534,7 @@ def purge_optional(self, keep):
             if fname not in keep_opt:
                 to_remove.append(idx)
         for idx in reversed(to_remove):
-            self._files.optional.pop(idx).unlink()
-
-    @staticmethod
-    def scan_path(path):
-        """Check path and subdirectories for potential test cases.
-
-        Args:
-            path (Path): Path to scan.
-
-        Yields:
-            str: Path to what appears to be a valid testcase.
-        """
-        if "test_info.json" in (x.name for x in path.iterdir()):
-            yield path
-        else:
-            for entry in path.iterdir():
-                if entry.is_dir() and (entry / "test_info.json").is_file():
-                    yield entry
-
-
-class TestFile:
-    __slots__ = ("data_file", "file_name")
-
-    def __init__(self, file_name, data_path):
-        self.file_name = self.sanitize_path(file_name)
-        self.data_file = data_path / self.file_name
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *exc):
-        self.unlink()
-
-    @staticmethod
-    def copy_file(src_file, dst_file):
-        """Copy data to file.
-
-        Args:
-            src_file (Path): File to read data from.
-            dst_file (Path): File to write data to.
-
-        Returns:
-            None
-        """
-        with src_file.open("rb") as src_fp:
-            dst_file.parent.mkdir(parents=True, exist_ok=True)
-            with dst_file.open("wb") as dst_fp:
-                copyfileobj(src_fp, dst_fp, 1_048_576)
+            self._files.optional.pop(idx).data_file.unlink()
 
     @staticmethod
     def sanitize_path(path):
@@ -587,14 +557,19 @@ def sanitize_path(path):
             raise ValueError("invalid path %r" % (path,))
         return path.lstrip("/")
 
-    def unlink(self):
-        """Delete the TestFile data file.
+    @staticmethod
+    def scan_path(path):
+        """Check path and subdirectories for potential test cases.
 
         Args:
-            None
+            path (Path): Path to scan.
 
-        Returns:
-            None
+        Yields:
+            str: Path to what appears to be a valid testcase.
         """
-        if self.data_file.exists():
-            self.data_file.unlink()
+        if "test_info.json" in (x.name for x in path.iterdir()):
+            yield path
+        else:
+            for entry in path.iterdir():
+                if entry.is_dir() and (entry / "test_info.json").is_file():
+                    yield entry
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 62859ea2..c9654aee 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -12,7 +12,7 @@
 from pytest import mark, raises
 
 from ..target import AssetManager
-from .storage import TestCase, TestCaseLoadFailure, TestFile, TestFileExists
+from .storage import TestCase, TestCaseLoadFailure, TestFileExists
 
 
 def test_testcase_01(tmp_path):
@@ -95,6 +95,18 @@ def test_testcase_03(tmp_path, file_paths):
 
 
 def test_testcase_04():
+    """test TestCase.add_from_bytes()"""
+    with TestCase("a.html", None, "adpt") as tcase:
+        tcase.add_from_bytes(b"foo", "a.html", required=True)
+        tcase.add_from_bytes(b"foo", "b.html", required=False)
+        assert "a.html" in (x.file_name for x in tcase._files.required)
+        assert "b.html" in (x.file_name for x in tcase._files.optional)
+        # add file with invalid file name
+        with raises(ValueError, match="invalid path ''"):
+            tcase.add_from_bytes(b"foo", "", required=False)
+
+
+def test_testcase_05():
     """test TestCase.purge_optional()"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
         # no optional files
@@ -122,7 +134,7 @@ def test_testcase_04():
         assert not any(tcase.optional)
 
 
-def test_testcase_05():
+def test_testcase_06():
     """test TestCase.data_size"""
     with TestCase("land_page.html", "redirect.html", "test-adapter") as tcase:
         assert tcase.data_size == 0
@@ -132,7 +144,7 @@ def test_testcase_05():
         assert tcase.data_size == 3
 
 
-def test_testcase_06(tmp_path):
+def test_testcase_07(tmp_path):
     """test TestCase.load_single() using a directory - fail cases"""
     # missing test_info.json
     with raises(TestCaseLoadFailure, match="Missing 'test_info.json'"):
@@ -174,7 +186,7 @@ def test_testcase_06(tmp_path):
         TestCase.load_single(src_dir)
 
 
-def test_testcase_07(mocker, tmp_path):
+def test_testcase_08(mocker, tmp_path):
     """test TestCase.load_single() using a directory"""
     # build a valid test case
     src_dir = tmp_path / "src"
@@ -224,7 +236,7 @@ def test_testcase_07(mocker, tmp_path):
         TestCase.load_single(dst_dir)
 
 
-def test_testcase_08(tmp_path):
+def test_testcase_09(tmp_path):
     """test TestCase.load_single() using a file"""
     # invalid entry_point specified
     with raises(TestCaseLoadFailure, match="Missing or invalid TestCase"):
@@ -250,7 +262,7 @@ def test_testcase_08(tmp_path):
         assert "optional.bin" in (x.file_name for x in tcase._files.optional)
 
 
-def test_testcase_09(tmp_path):
+def test_testcase_10(tmp_path):
     """test TestCase - dump, load and compare"""
     working = tmp_path / "working"
     working.mkdir()
@@ -283,7 +295,7 @@ def test_testcase_09(tmp_path):
                     loaded.assets.cleanup()
 
 
-def test_testcase_10(tmp_path):
+def test_testcase_11(tmp_path):
     """test TestCase.load() - missing file and empty directory"""
     # missing file
     with raises(TestCaseLoadFailure, match="Invalid TestCase path"):
@@ -292,7 +304,7 @@ def test_testcase_10(tmp_path):
     assert not TestCase.load(str(tmp_path), adjacent=True)
 
 
-def test_testcase_11(tmp_path):
+def test_testcase_12(tmp_path):
     """test TestCase.load() - single file"""
     tfile = tmp_path / "testcase.html"
     tfile.touch()
@@ -304,7 +316,7 @@ def test_testcase_11(tmp_path):
         any(x.cleanup() for x in testcases)
 
 
-def test_testcase_12(tmp_path):
+def test_testcase_13(tmp_path):
     """test TestCase.load() - single directory"""
     with TestCase("target.bin", None, "test-adapter") as src:
         src.add_from_bytes(b"test", "target.bin")
@@ -317,7 +329,7 @@ def test_testcase_12(tmp_path):
         any(x.cleanup() for x in testcases)
 
 
-def test_testcase_13(tmp_path):
+def test_testcase_14(tmp_path):
     """test TestCase.load() - multiple directories (with assets)"""
     nested = tmp_path / "nested"
     nested.mkdir()
@@ -347,7 +359,7 @@ def test_testcase_13(tmp_path):
     assert not TestCase.load(str(tmp_path))
 
 
-def test_testcase_14(tmp_path):
+def test_testcase_15(tmp_path):
     """test TestCase.load() - archive"""
     archive = tmp_path / "testcase.zip"
     # bad archive
@@ -380,7 +392,7 @@ def test_testcase_14(tmp_path):
         any(x.cleanup() for x in testcases)
 
 
-def test_testcase_15(tmp_path):
+def test_testcase_16(tmp_path):
     """test TestCase.add_batch()"""
     include = tmp_path / "inc_path"
     include.mkdir()
@@ -420,7 +432,7 @@ def test_testcase_15(tmp_path):
             tcase.add_batch(str(include), [str(inc_1)])
 
 
-def test_testcase_16(tmp_path):
+def test_testcase_17(tmp_path):
     """test TestCase.scan_path()"""
     # empty path
     (tmp_path / "not-test").mkdir()
@@ -438,7 +450,7 @@ def test_testcase_16(tmp_path):
     assert len(tc_paths) == 1
 
 
-def test_testcase_17():
+def test_testcase_18():
     """test TestCase.get_file()"""
     with TestCase("test.htm", None, "test-adapter") as src:
         src.add_from_bytes(b"test", "test.htm")
@@ -446,7 +458,7 @@ def test_testcase_17():
         assert src.get_file("test.htm")
 
 
-def test_testcase_18():
+def test_testcase_19():
     """test TestCase.clone()"""
     with TestCase("a.htm", "b.htm", "adpt", input_fname="fn", time_limit=2) as src:
         src.duration = 1.2
@@ -464,30 +476,24 @@ def test_testcase_18():
                 ("test.htm", b"123"),
                 ("opt.htm", b"456"),
             ):
-                assert src.get_file(file).data_file.read_bytes() == data
-                assert dst.get_file(file).data_file.read_bytes() == data
+                src_file = src.get_file(file).data_file
+                dst_file = dst.get_file(file).data_file
+                assert src_file.read_bytes() == data
+                assert dst_file.read_bytes() == data
+                assert not dst_file.samefile(src_file)
             assert dst.env_vars == {"foo": "bar"}
             assert not set(src.optional) ^ set(dst.optional)
 
 
-def test_testfile_01(tmp_path):
-    """test simple TestFile"""
-    data_file = tmp_path / "file.txt"
-    data_file.write_text("test")
-    with TestFile(data_file.name, tmp_path) as tfile:
-        assert tfile.file_name == "file.txt"
-    assert not data_file.exists()
-
-
-def test_testfile_02(tmp_path):
-    """test TestFile.copy_file()"""
+def test_testcase_20(tmp_path):
+    """test TestCase.copy_file()"""
     src_file = tmp_path / "src" / "file.txt"
     src_file.parent.mkdir(parents=True)
     src_file.write_bytes(b"test\n123\r\n")
     dst_path = tmp_path / "dst"
     dst_file = dst_path / "file.txt"
     assert not dst_file.is_file()
-    TestFile.copy_file(src_file, dst_file)
+    TestCase.copy_file(src_file, dst_file)
     assert dst_file.is_file()
     assert dst_file.read_bytes() == b"test\n123\r\n"
     assert src_file.exists()
@@ -516,10 +522,10 @@ def test_testfile_02(tmp_path):
         ".",
     ],
 )
-def test_testfile_03(path):
+def test_testcase_21(path):
     """test TestCase.sanitize_path() with invalid paths"""
     with raises(ValueError, match="invalid path"):
-        TestFile.sanitize_path(path)
+        TestCase.sanitize_path(path)
 
 
 @mark.parametrize(
@@ -537,6 +543,6 @@ def test_testfile_03(path):
         ("./a/./b/../c", "a/c"),
     ],
 )
-def test_testfile_04(path, expected_result):
+def test_testcase_22(path, expected_result):
     """test TestCase.sanitize_path()"""
-    assert TestFile.sanitize_path(path) == expected_result
+    assert TestCase.sanitize_path(path) == expected_result

From c6b63d693afeb265a7cb92865b8709068bff3e83 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 12 Nov 2021 16:16:19 -0800
Subject: [PATCH 360/531] [tests] Use Path() where possible in test_storage.py

---
 grizzly/common/test_storage.py | 92 +++++++++++++++++-----------------
 1 file changed, 45 insertions(+), 47 deletions(-)

diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index c9654aee..7099adec 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -4,9 +4,10 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
 
-import os
 from itertools import chain
 from json import dumps, loads
+from os import walk
+from pathlib import Path
 from zipfile import ZIP_DEFLATED, ZipFile
 
 from pytest import mark, raises
@@ -36,9 +37,9 @@ def test_testcase_01(tmp_path):
         assert not any(tcase.contents)
         assert tcase.pop_assets() is None
         assert not any(tcase.optional)
-        tcase.dump(str(tmp_path))
+        tcase.dump(tmp_path)
         assert not any(tmp_path.iterdir())
-        tcase.dump(str(tmp_path), include_details=True)
+        tcase.dump(tmp_path, include_details=True)
         assert (tmp_path / "test_info.json").is_file()
 
 
@@ -56,7 +57,7 @@ def test_testcase_02(tmp_path, copy, required):
     with TestCase("land_page.html", "a.html", "adpt", input_fname="in.bin") as tcase:
         in_file = tmp_path / "file.bin"
         in_file.write_text("data")
-        tcase.add_from_file(str(in_file), copy=copy, required=required)
+        tcase.add_from_file(in_file, copy=copy, required=required)
         assert tcase.data_size == 4
         assert "file.bin" in tcase.contents
         if required:
@@ -67,7 +68,7 @@ def test_testcase_02(tmp_path, copy, required):
         # try overwriting existing file
         if copy:
             with raises(TestFileExists, match="'file.bin' exists in test"):
-                tcase.add_from_file(str(in_file), copy=True)
+                tcase.add_from_file(in_file, copy=True)
             assert in_file.exists()
         else:
             assert not in_file.exists()
@@ -89,7 +90,7 @@ def test_testcase_03(tmp_path, file_paths):
             src_file = tmp_path / file_path
             src_file.parent.mkdir(exist_ok=True, parents=True)
             src_file.write_text("data")
-            tcase.add_from_file(str(src_file), file_name=file_path, required=True)
+            tcase.add_from_file(src_file, file_name=file_path, required=True)
             assert file_path in tcase.contents
             assert file_path not in tcase.optional
 
@@ -165,8 +166,8 @@ def test_testcase_07(tmp_path):
     entry_point = src_dir / "target.bin"
     entry_point.touch()
     with TestCase("target.bin", None, "test-adapter") as src:
-        src.add_from_file(str(entry_point))
-        src.dump(str(src_dir), include_details=True)
+        src.add_from_file(entry_point)
+        src.dump(src_dir, include_details=True)
     # bad 'target' entry in test_info.json
     entry_point.unlink()
     with raises(TestCaseLoadFailure, match="Entry point 'target.bin' not found in"):
@@ -178,7 +179,7 @@ def test_testcase_07(tmp_path):
         assets.add("example", str(tmp_path / "example_asset"), copy=False)
         with TestCase("target.bin", None, "test-adapter") as src:
             src.assets = assets
-            src.dump(str(src_dir), include_details=True)
+            src.dump(src_dir, include_details=True)
     test_info = loads((src_dir / "test_info.json").read_text())
     test_info["env"] = {"bad": 1}
     (src_dir / "test_info.json").write_text(dumps(test_info))
@@ -197,7 +198,7 @@ def test_testcase_08(mocker, tmp_path):
     asset_file.touch()
     (src_dir / "optional.bin").touch()
     (src_dir / "x.bin").touch()
-    nested = tmp_path / "src" / "nested"
+    nested = src_dir / "nested"
     nested.mkdir()
     # overlap file name in different directories
     (nested / "x.bin").touch()
@@ -207,16 +208,16 @@ def test_testcase_08(mocker, tmp_path):
         assets.add("example", str(asset_file))
         with TestCase("target.bin", None, "test-adapter") as src:
             src.env_vars["TEST_ENV_VAR"] = "100"
-            src.add_from_file(str(entry_point))
-            src.add_from_file(str(src_dir / "optional.bin"), required=False)
-            src.add_from_file(str(src_dir / "x.bin"), required=False)
+            src.add_from_file(entry_point)
+            src.add_from_file(src_dir / "optional.bin", required=False)
+            src.add_from_file(src_dir / "x.bin", required=False)
             src.add_from_file(
-                str(nested / "x.bin"),
-                file_name=os.path.join("nested", "x.bin"),
+                nested / "x.bin",
+                file_name=str((nested / "x.bin").relative_to(src_dir)),
                 required=False,
             )
             src.assets = assets
-            src.dump(str(dst_dir), include_details=True)
+            src.dump(dst_dir, include_details=True)
     # test loading test case from test_info.json
     with TestCase.load_single(dst_dir) as dst:
         asset = dst.pop_assets()
@@ -279,7 +280,7 @@ def test_testcase_10(tmp_path):
             fake.touch()
             assets.add("fake", str(fake))
             org.assets = assets
-            org.dump(str(working), include_details=True)
+            org.dump(working, include_details=True)
         org.assets = None
         with TestCase.load_single(working, adjacent=False) as loaded:
             try:
@@ -301,14 +302,14 @@ def test_testcase_11(tmp_path):
     with raises(TestCaseLoadFailure, match="Invalid TestCase path"):
         TestCase.load("missing")
     # empty path
-    assert not TestCase.load(str(tmp_path), adjacent=True)
+    assert not TestCase.load(tmp_path, adjacent=True)
 
 
 def test_testcase_12(tmp_path):
     """test TestCase.load() - single file"""
     tfile = tmp_path / "testcase.html"
     tfile.touch()
-    testcases = TestCase.load(str(tfile), adjacent=False)
+    testcases = TestCase.load(tfile, adjacent=False)
     try:
         assert len(testcases) == 1
         assert all(x.assets is None for x in testcases)
@@ -320,8 +321,8 @@ def test_testcase_13(tmp_path):
     """test TestCase.load() - single directory"""
     with TestCase("target.bin", None, "test-adapter") as src:
         src.add_from_bytes(b"test", "target.bin")
-        src.dump(str(tmp_path), include_details=True)
-    testcases = TestCase.load(str(tmp_path))
+        src.dump(tmp_path, include_details=True)
+    testcases = TestCase.load(tmp_path)
     try:
         assert len(testcases) == 1
         assert all(x.assets is None for x in testcases)
@@ -340,10 +341,10 @@ def test_testcase_14(tmp_path):
         with TestCase("target.bin", None, "test-adapter") as src:
             src.assets = assets
             src.add_from_bytes(b"test", "target.bin")
-            src.dump(str(nested / "test-1"), include_details=True)
-            src.dump(str(nested / "test-2"), include_details=True)
-            src.dump(str(nested / "test-3"), include_details=True)
-    testcases = TestCase.load(str(nested))
+            src.dump(nested / "test-1", include_details=True)
+            src.dump(nested / "test-2", include_details=True)
+            src.dump(nested / "test-3", include_details=True)
+    testcases = TestCase.load(nested)
     try:
         assert len(testcases) == 3
         assert all(x.assets is not None for x in testcases)
@@ -354,9 +355,9 @@ def test_testcase_14(tmp_path):
         any(x.cleanup() for x in testcases)
         for test in testcases:
             if test.assets:
-                test.cleanup()
+                test.assets.cleanup()
     # try loading testcases that are nested too deep
-    assert not TestCase.load(str(tmp_path))
+    assert not TestCase.load(tmp_path)
 
 
 def test_testcase_15(tmp_path):
@@ -365,29 +366,29 @@ def test_testcase_15(tmp_path):
     # bad archive
     archive.write_bytes(b"x")
     with raises(TestCaseLoadFailure, match="Testcase archive is corrupted"):
-        TestCase.load(str(archive))
+        TestCase.load(archive)
     # build archive containing multiple testcases
     with TestCase("target.bin", None, "test-adapter") as src:
         src.add_from_bytes(b"test", "target.bin")
-        src.dump(str(tmp_path / "test-0"), include_details=True)
-        src.dump(str(tmp_path / "test-1"), include_details=True)
-        src.dump(str(tmp_path / "test-2"), include_details=True)
-    (tmp_path / "test-1" / "prefs.js").write_bytes(b"fake_prefs")
+        src.dump(tmp_path / "test-0", include_details=True)
+        src.dump(tmp_path / "test-1", include_details=True)
+        src.dump(tmp_path / "test-2", include_details=True)
     (tmp_path / "log_dummy.txt").touch()
     (tmp_path / "not_a_tc").mkdir()
     (tmp_path / "not_a_tc" / "file.txt").touch()
-    with ZipFile(str(archive), mode="w", compression=ZIP_DEFLATED) as zfp:
-        for dir_name, _, dir_files in os.walk(str(tmp_path)):
-            arc_path = os.path.relpath(dir_name, str(tmp_path))
+    with ZipFile(archive, mode="w", compression=ZIP_DEFLATED) as zfp:
+        for dir_name, _, dir_files in walk(tmp_path):
             for file_name in dir_files:
+                file_path = Path(dir_name) / file_name
                 zfp.write(
-                    os.path.join(dir_name, file_name),
-                    arcname=os.path.join(arc_path, file_name),
+                    str(file_path),
+                    arcname=str(file_path.relative_to(tmp_path)),
                 )
-    testcases = TestCase.load(str(archive))
+    testcases = TestCase.load(archive)
     try:
         assert len(testcases) == 3
         assert all(x.assets is None for x in testcases)
+        assert all("target.bin" in x.contents for x in testcases)
     finally:
         any(x.cleanup() for x in testcases)
 
@@ -410,26 +411,23 @@ def test_testcase_16(tmp_path):
         assert not any(tcase.contents)
         # missing file
         with raises(IOError):
-            tcase.add_batch(str(tmp_path), [str(tmp_path / "missing.bin")])
+            tcase.add_batch(tmp_path, [tmp_path / "missing.bin"])
         assert not any(tcase.contents)
         # relative file name
-        tcase.add_batch(str(include), ["file.bin"])
+        tcase.add_batch(include, ["file.bin"])
         assert not any(tcase.contents)
         # valid list
-        tcase.add_batch(
-            str(include),
-            [str(inc_1), str(inc_2), str(tmp_path / "inc_path2" / "extra.bin")],
-        )
+        tcase.add_batch(include, [inc_1, inc_2, tmp_path / "inc_path2" / "extra.bin"])
         assert "file.bin" in tcase.contents
         assert "nested/nested.js" in tcase.contents
         assert len(list(tcase.contents)) == 2
         # nested url
-        tcase.add_batch(str(include), [str(inc_1)], prefix="test")
+        tcase.add_batch(include, [inc_1], prefix="test")
         assert "test/file.bin" in tcase.contents
         assert len(list(tcase.contents)) == 3
         # collision
         with raises(TestFileExists, match="'file.bin' exists in test"):
-            tcase.add_batch(str(include), [str(inc_1)])
+            tcase.add_batch(include, [inc_1])
 
 
 def test_testcase_17(tmp_path):
@@ -442,7 +440,7 @@ def test_testcase_17(tmp_path):
     with TestCase("test.htm", None, "test-adapter") as src:
         src.add_from_bytes(b"test", "test.htm")
         for path in paths:
-            src.dump(str(path), include_details=True)
+            src.dump(path, include_details=True)
     tc_paths = list(TestCase.scan_path(tmp_path))
     assert len(tc_paths) == 3
     # single test case directory

From 1673dd54172d734b7ec065938275afc94b7f4476 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 12 Nov 2021 16:25:22 -0800
Subject: [PATCH 361/531] [tests] Cleanup properly after tests

---
 grizzly/target/test_puppet_target.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 2bea116e..720d54ab 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -96,14 +96,14 @@ def test_puppet_target_03(mocker, tmp_path, healthy, reason, ignore, result, clo
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    target = PuppetTarget(str(fake_file), 300, 25, 5000)
     if "memory" in ignore:
         fake_ffp.return_value.available_logs.return_value = "ffp_worker_memory_usage"
     elif "log-limit" in ignore:
         fake_ffp.return_value.available_logs.return_value = "ffp_worker_log_size"
     fake_ffp.return_value.is_healthy.return_value = healthy
     fake_ffp.return_value.reason = reason
-    assert target.check_result(ignore) == result
+    with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
+        assert target.check_result(ignore) == result
     assert fake_ffp.return_value.close.call_count == closes
 
 
@@ -131,10 +131,10 @@ def test_puppet_target_04(mocker, tmp_path, healthy, usage, os_name, killed):
     fake_kill.side_effect = OSError
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    target = PuppetTarget(str(fake_file), 300, 25, 5000)
     fake_ffp.return_value.cpu_usage.return_value = usage
     fake_ffp.return_value.is_healthy.return_value = healthy
-    target.handle_hang()
+    with PuppetTarget(str(fake_file), 300, 25, 5000) as target:
+        target.handle_hang()
     assert fake_ffp.return_value.is_healthy.call_count == 1
     assert fake_ffp.return_value.close.call_count == 1
     assert fake_ffp.return_value.cpu_usage.call_count == (1 if usage else 0)
@@ -259,6 +259,7 @@ def test_puppet_target_05(mocker, tmp_path):
     fake_ffp.reset_mock()
     fake_kill.reset_mock()
     fake_proc_iter.reset_mock()
+    target.cleanup()
 
 
 def test_puppet_target_06(mocker, tmp_path):

From a438efed7f01aa0612d6ad87c6baff020c6675b9 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 12 Nov 2021 18:19:09 -0800
Subject: [PATCH 362/531] Use shutil.copyfile() and shutil.move() and remove
 TestCase.copy_file()

---
 grizzly/common/storage.py      | 30 ++++++++----------------------
 grizzly/common/test_storage.py | 18 ++----------------
 2 files changed, 10 insertions(+), 38 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index c6393d2e..c52f01dc 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -9,7 +9,7 @@
 from os import walk
 from os.path import normpath, split
 from pathlib import Path
-from shutil import copyfileobj, rmtree
+from shutil import copyfile, move, rmtree
 from tempfile import NamedTemporaryFile, mkdtemp
 from time import time
 from zipfile import BadZipfile, ZipFile
@@ -159,11 +159,11 @@ def add_from_file(self, src_file, file_name=None, required=True, copy=False):
         if test_file.file_name in self.contents:
             raise TestFileExists("%r exists in test" % (test_file.file_name,))
 
+        test_file.data_file.parent.mkdir(parents=True, exist_ok=True)
         if copy:
-            self.copy_file(src_file, test_file.data_file)
+            copyfile(src_file, test_file.data_file)
         else:
-            test_file.data_file.parent.mkdir(exist_ok=True, parents=True)
-            src_file.replace(test_file.data_file)
+            move(src_file, test_file.data_file)
 
         # TODO: set 'required=False' by default
         # landing_page is always 'required'
@@ -228,22 +228,6 @@ def contents(self):
         for tfile in chain(self._files.required, self._files.optional):
             yield tfile.file_name
 
-    @staticmethod
-    def copy_file(src_file, dst_file):
-        """Copy data from src_file to dst_file.
-
-        Args:
-            src_file (Path): File to read data from.
-            dst_file (Path): File to write data to.
-
-        Returns:
-            None
-        """
-        with src_file.open("rb") as src_fp:
-            dst_file.parent.mkdir(parents=True, exist_ok=True)
-            with dst_file.open("wb") as dst_fp:
-                copyfileobj(src_fp, dst_fp, 1_048_576)
-
     @property
     def data_path(self):
         """Location test data is stored on disk. This is intended to be used as wwwroot.
@@ -284,7 +268,9 @@ def dump(self, dst_path, include_details=False):
         dst_path = Path(dst_path)
         # save test files to dst_path
         for test_file in chain(self._files.required, self._files.optional):
-            self.copy_file(test_file.data_file, dst_path / test_file.file_name)
+            dst_file = dst_path / test_file.file_name
+            dst_file.parent.mkdir(parents=True, exist_ok=True)
+            copyfile(test_file.data_file, dst_file)
         # save test case files and meta data including:
         # adapter used, input file, environment info and files
         if include_details:
@@ -343,8 +329,8 @@ def load(cls, path, adjacent=False):
         path = Path(path)
         # unpack archive if needed
         if path.name.lower().endswith(".zip"):
-            unpacked = mkdtemp(prefix="unpack_", dir=grz_tmp("storage"))
             try:
+                unpacked = mkdtemp(prefix="unpack_", dir=grz_tmp("storage"))
                 with ZipFile(path) as zip_fp:
                     zip_fp.extractall(path=unpacked)
             except (BadZipfile, zlib_error):
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 7099adec..2f53bab9 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -483,20 +483,6 @@ def test_testcase_19():
             assert not set(src.optional) ^ set(dst.optional)
 
 
-def test_testcase_20(tmp_path):
-    """test TestCase.copy_file()"""
-    src_file = tmp_path / "src" / "file.txt"
-    src_file.parent.mkdir(parents=True)
-    src_file.write_bytes(b"test\n123\r\n")
-    dst_path = tmp_path / "dst"
-    dst_file = dst_path / "file.txt"
-    assert not dst_file.is_file()
-    TestCase.copy_file(src_file, dst_file)
-    assert dst_file.is_file()
-    assert dst_file.read_bytes() == b"test\n123\r\n"
-    assert src_file.exists()
-
-
 @mark.parametrize(
     "path",
     [
@@ -520,7 +506,7 @@ def test_testcase_20(tmp_path):
         ".",
     ],
 )
-def test_testcase_21(path):
+def test_testcase_20(path):
     """test TestCase.sanitize_path() with invalid paths"""
     with raises(ValueError, match="invalid path"):
         TestCase.sanitize_path(path)
@@ -541,6 +527,6 @@ def test_testcase_21(path):
         ("./a/./b/../c", "a/c"),
     ],
 )
-def test_testcase_22(path, expected_result):
+def test_testcase_21(path, expected_result):
     """test TestCase.sanitize_path()"""
     assert TestCase.sanitize_path(path) == expected_result

From 9f36d420922a3112848ce109588b6043c79a182a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 15 Nov 2021 10:17:49 -0800
Subject: [PATCH 363/531] Avoid marking files that might not be served as
 required

---
 grizzly/common/storage.py      | 7 ++++---
 grizzly/common/test_storage.py | 4 ++--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index c52f01dc..7cc80069 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -110,7 +110,7 @@ def add_batch(self, path, include_files, prefix=None, copy=True):
                 relative = prefix / relative
             self.add_from_file(file, file_name=relative.as_posix(), copy=copy)
 
-    def add_from_bytes(self, data, file_name, required=True):
+    def add_from_bytes(self, data, file_name, required=False):
         """Create a file and add it to the TestCase.
 
         Args:
@@ -136,7 +136,7 @@ def add_from_bytes(self, data, file_name, required=True):
             if data_file.is_file():
                 data_file.unlink()
 
-    def add_from_file(self, src_file, file_name=None, required=True, copy=False):
+    def add_from_file(self, src_file, file_name=None, required=False, copy=False):
         """Add a file to the TestCase by either copying or moving an existing file.
 
         Args:
@@ -165,7 +165,6 @@ def add_from_file(self, src_file, file_name=None, required=True, copy=False):
         else:
             move(src_file, test_file.data_file)
 
-        # TODO: set 'required=False' by default
         # landing_page is always 'required'
         if required or test_file.file_name == self.landing_page:
             self._files.required.append(test_file)
@@ -457,6 +456,8 @@ def load_single(cls, path, adjacent=False, load_assets=True, copy=True):
                     # ignore files that have been previously loaded
                     if location in (test.landing_page, "test_info.json"):
                         continue
+                    # NOTE: when loading all files except the entry point are
+                    # marked as `required=False`
                     test.add_from_file(
                         file,
                         file_name=location,
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 2f53bab9..3cd5e582 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -113,7 +113,7 @@ def test_testcase_05():
         # no optional files
         tcase.purge_optional(["foo"])
         # setup
-        tcase.add_from_bytes(b"foo", "testfile1.bin")
+        tcase.add_from_bytes(b"foo", "testfile1.bin", required=True)
         tcase.add_from_bytes(b"foo", "testfile2.bin", required=False)
         tcase.add_from_bytes(b"foo", "testfile3.bin", required=False)
         tcase.add_from_bytes(b"foo", "not_served.bin", required=False)
@@ -461,7 +461,7 @@ def test_testcase_19():
     with TestCase("a.htm", "b.htm", "adpt", input_fname="fn", time_limit=2) as src:
         src.duration = 1.2
         src.hang = True
-        src.add_from_bytes(b"123", "test.htm")
+        src.add_from_bytes(b"123", "test.htm", required=True)
         src.add_from_bytes(b"456", "opt.htm", required=False)
         src.env_vars["foo"] = "bar"
         with src.clone() as dst:

From ecb3e76d6548a33cfe97969321043168baccbd6e Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 5 Nov 2021 00:09:21 -0400
Subject: [PATCH 364/531] Move STATUS_DB to Status.

---
 grizzly/common/status.py               | 12 +++++++++---
 grizzly/common/status_reporter.py      |  3 +--
 grizzly/common/test_status_reporter.py | 21 +++++++++------------
 grizzly/conftest.py                    |  4 +++-
 grizzly/session.py                     |  4 ----
 5 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 46fdf79e..f3c71b94 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -8,9 +8,12 @@
 from json import dumps, loads
 from logging import getLogger
 from os import getpid
+from pathlib import Path
 from sqlite3 import OperationalError, connect
 from time import time
 
+from ..common.utils import grz_tmp
+
 __all__ = ("Status",)
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
@@ -84,6 +87,8 @@ class Status:
     # database will be updated no more than every 'REPORT_FREQ' seconds.
     REPORT_FREQ = 60
 
+    STATUS_DB = str(Path(grz_tmp()) / "fuzz-status.db")
+
     __slots__ = (
         "_db_file",
         "_enable_profiling",
@@ -180,7 +185,7 @@ def blockers(self, iters_per_result=100):
                     yield entry
 
     @classmethod
-    def loadall(cls, db_file, time_limit=300):
+    def loadall(cls, db_file=STATUS_DB, time_limit=300):
         """Load all status reports found in `db_file`.
 
         Args:
@@ -394,7 +399,7 @@ def runtime(self):
         return max(time() - self.start_time, 0)
 
     @classmethod
-    def start(cls, db_file, enable_profiling=False, report_limit=0):
+    def start(cls, db_file=None, enable_profiling=False, report_limit=0):
         """Create a unique Status object.
 
         Args:
@@ -404,7 +409,8 @@ def start(cls, db_file, enable_profiling=False, report_limit=0):
         Returns:
             Status: Active status report.
         """
-        assert db_file
+        if db_file is None:
+            db_file = cls.STATUS_DB
         status = cls(
             db_file=db_file,
             enable_profiling=enable_profiling,
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index f07d6888..a07aea6f 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -22,7 +22,6 @@
 
 from psutil import cpu_count, cpu_percent, disk_usage, virtual_memory
 
-from ..session import Session
 from .status import Status
 
 __all__ = ("StatusReporter",)
@@ -531,7 +530,7 @@ def main(args=None):
     basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
 
     # TODO: add support for reducer
-    modes = {"fuzzing": Session.STATUS_DB}
+    modes = {"fuzzing": Status.STATUS_DB}
 
     # report types: define name and time range of scan
     report_types = {
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 3e67a67b..b34cb998 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -524,23 +524,22 @@ def test_traceback_report_08(tmp_path):
     assert "AssertionError" in output
 
 
-def test_main_01(mocker, tmp_path):
+@mark.usefixtures("tmp_path_status_db")
+def test_main_01(mocker):
     """test main() with no reports"""
-    mocker.patch("grizzly.session.Session.STATUS_DB", str(tmp_path / "status.db"))
     mocker.patch(
         "grizzly.common.status_reporter.StatusReporter.CPU_POLL_INTERVAL", 0.01
     )
     assert main([]) == 0
 
 
-def test_main_02(mocker, tmp_path):
+@mark.usefixtures("tmp_path_status_db")
+def test_main_02(mocker):
     """test main() with a report"""
-    db_file = str(tmp_path / "status.db")
-    mocker.patch("grizzly.session.Session.STATUS_DB", db_file)
     mocker.patch(
         "grizzly.common.status_reporter.StatusReporter.CPU_POLL_INTERVAL", 0.01
     )
-    status = Status.start(db_file=db_file)
+    status = Status.start()
     status.iteration = 1
     status.results.count("uid", "[@ test]")
     status.report(force=True)
@@ -554,14 +553,13 @@ def test_main_02(mocker, tmp_path):
         "complete",
     ],
 )
+@mark.usefixtures("tmp_path_status_db")
 def test_main_03(mocker, tmp_path, report_type):
     """test main() --dump"""
-    db_file = str(tmp_path / "status.db")
-    mocker.patch("grizzly.session.Session.STATUS_DB", db_file)
     mocker.patch(
         "grizzly.common.status_reporter.StatusReporter.CPU_POLL_INTERVAL", 0.01
     )
-    status = Status.start(db_file=db_file)
+    status = Status.start()
     status.iteration = 1
     status.report(force=True)
     dump_file = tmp_path / "output.txt"
@@ -573,10 +571,9 @@ def test_main_03(mocker, tmp_path, report_type):
         assert b"Timestamp" not in dump_file.read_bytes()
 
 
-def test_main_04(capsys, mocker, tmp_path):
+@mark.usefixtures("tmp_path_status_db")
+def test_main_04(capsys):
     """test main() with invalid args"""
-    mocker.patch("grizzly.session.Session.STATUS_DB", str(tmp_path / "status.db"))
-
     with raises(SystemExit):
         main(["--tracebacks", "missing"])
     assert "--tracebacks must be a directory" in capsys.readouterr()[-1]
diff --git a/grizzly/conftest.py b/grizzly/conftest.py
index 9eca8c5c..4622b28c 100644
--- a/grizzly/conftest.py
+++ b/grizzly/conftest.py
@@ -7,8 +7,10 @@
 
 from pytest import fixture
 
+from grizzly.common.status import Status
+
 
 @fixture
 def tmp_path_status_db(tmp_path, mocker):
     """Use a temporary database file for testing."""
-    mocker.patch("grizzly.session.Session.STATUS_DB", new=str(tmp_path / "tmp.db"))
+    mocker.patch.object(Status, "STATUS_DB", new=str(tmp_path / "status-tmp.db"))
diff --git a/grizzly/session.py b/grizzly/session.py
index a4a5cc30..401953fd 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -3,13 +3,11 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
-from pathlib import Path
 from time import time
 
 from .common.iomanager import IOManager
 from .common.runner import Runner
 from .common.status import Status
-from .common.utils import grz_tmp
 from .target import Result, TargetLaunchError
 
 __all__ = ("SessionError", "LogOutputLimiter", "Session")
@@ -63,7 +61,6 @@ def ready(self, cur_iter, launches):
 class Session:
     DISPLAY_VERBOSE = 0  # display status every iteration
     DISPLAY_NORMAL = 1  # quickly reduce the amount of output
-    STATUS_DB = str(Path(grz_tmp()) / "fuzz-status.db")
 
     # display warning when target log files exceed limit (25MB)
     TARGET_LOG_SIZE_WARN = 0x1900000
@@ -102,7 +99,6 @@ def __init__(
         self.reporter = reporter
         self.server = server
         self.status = Status.start(
-            db_file=self.STATUS_DB,
             enable_profiling=enable_profiling,
             report_limit=report_limit,
         )

From bf9de93d973a3a202b0fd6e5a7aa53234a3f03c1 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 5 Nov 2021 00:13:11 -0400
Subject: [PATCH 365/531] Add reducer status reporting.

---
 grizzly/common/status.py               | 479 +++++++++++++++++++++++++
 grizzly/common/status_reporter.py      | 329 ++++++++++++++++-
 grizzly/common/test_status.py          | 234 +++++++++++-
 grizzly/common/test_status_reporter.py | 250 ++++++++++++-
 grizzly/conftest.py                    |  19 +-
 grizzly/reduce/core.py                 | 122 +++----
 grizzly/reduce/stats.py                | 331 -----------------
 grizzly/reduce/test_main.py            |   7 +-
 grizzly/reduce/test_main_fm.py         |  14 +-
 grizzly/reduce/test_reduce.py          |  23 +-
 grizzly/reduce/test_strategies.py      |   7 +-
 grizzly/replay/conftest.py             |   8 -
 grizzly/replay/test_main.py            |   2 +-
 grizzly/replay/test_replay.py          |   2 +-
 14 files changed, 1378 insertions(+), 449 deletions(-)
 delete mode 100644 grizzly/reduce/stats.py

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index f3c71b94..6bc12096 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -5,6 +5,7 @@
 """Manage Grizzly status reports."""
 from collections import defaultdict, namedtuple
 from contextlib import closing, contextmanager
+from copy import deepcopy
 from json import dumps, loads
 from logging import getLogger
 from os import getpid
@@ -643,3 +644,481 @@ def total(self):
             int: Total result count.
         """
         return sum(x for x in self._count.values())
+
+
+ReductionStep = namedtuple(
+    "ReductionStep", "name, duration, successes, attempts, size, iterations"
+)
+
+
+class ReductionStatus:
+    """Status for a single grizzly reduction"""
+
+    # database will be updated no more than every 'REPORT_FREQ' seconds.
+    REPORT_FREQ = 60
+
+    STATUS_DB = str(Path(grz_tmp()) / "reduce-status.db")
+
+    def __init__(
+        self,
+        strategies=None,
+        testcase_size_cb=None,
+        crash_id=None,
+        db_file=None,
+        pid=None,
+        exp_limit=EXP_LIMIT,
+    ):
+        """Initialize a ReductionStatus instance.
+
+        Arguments:
+            strategies (list(str)): List of strategies to be run.
+            testcase_size_cb (callable): Callback to get testcase size
+            crash_id (int): CrashManager ID of original testcase
+            db_file (str): Database file containing data. None in read-only mode.
+        """
+        self.analysis = {}
+        self.attempts = 0
+        self.iterations = 0
+        self.run_params = {}
+        self.signature_info = {}
+        self.successes = 0
+        self.current_strategy_idx = None
+        self._testcase_size_cb = testcase_size_cb
+        self.crash_id = crash_id
+        self.finished_steps = []
+        self._in_progress_steps = []
+        self.strategies = strategies
+        self._db_file = db_file
+        self.pid = pid
+        self.timestamp = time()
+        self._current_size = None
+
+        # prepare database
+        if self._db_file:
+            LOG.debug("status using db %r", self._db_file)
+            with closing(connect(self._db_file, timeout=DB_TIMEOUT)) as con:
+                _db_version_check(con)
+                cur = con.cursor()
+                with con:
+                    # create table if needed
+                    cur.execute(
+                        """CREATE TABLE IF NOT EXISTS reduce_status (
+                           pid INTEGER NOT NULL PRIMARY KEY,
+                           analysis TEXT NOT NULL,
+                           attempts INTEGER NOT NULL,
+                           iterations INTEGER NOT NULL,
+                           run_params TEXT NOT NULL,
+                           signature_info TEXT NOT NULL,
+                           successes INTEGER NOT NULL,
+                           crash_id INTEGER,
+                           finished_steps TEXT NOT NULL,
+                           _in_progress_steps TEXT NOT NULL,
+                           strategies TEXT NOT NULL,
+                           _current_size INTEGER NOT NULL,
+                           current_strategy_idx INTEGER,
+                           timestamp REAL NOT NULL);"""
+                    )
+                    # remove expired status data
+                    if exp_limit > 0:
+                        cur.execute(
+                            """DELETE FROM reduce_status WHERE timestamp <= ?;""",
+                            (time() - exp_limit,),
+                        )
+                    # avoid (unlikely) pid reuse collision
+                    cur.execute("""DELETE FROM reduce_status WHERE pid = ?;""", (pid,))
+
+    @classmethod
+    def start(
+        cls,
+        db_file=None,
+        strategies=None,
+        testcase_size_cb=None,
+        crash_id=None,
+    ):
+        """Create a unique ReductionStatus object.
+
+        Args:
+            db_file (str): Path to database containing status data.
+            strategies (list(str)): List of strategies to be run.
+            testcase_size_cb (callable): Callback to get testcase size
+            crash_id (int): CrashManager ID of original testcase
+
+        Returns:
+            ReductionStatus: Active status report.
+        """
+        if db_file is None:
+            db_file = cls.STATUS_DB
+        status = cls(
+            crash_id=crash_id,
+            db_file=db_file,
+            pid=getpid(),
+            strategies=strategies,
+            testcase_size_cb=testcase_size_cb,
+        )
+        status.report(force=True)
+        return status
+
+    def report(self, force=False, report_freq=REPORT_FREQ):
+        """Write status report to database. Reports are only written periodically.
+        It is limited by `report_freq`. The specified number of seconds must
+        elapse before another write will be performed unless `force` is True.
+
+        Args:
+            force (bool): Ignore report frequently limiting.
+            report_freq (int): Minimum number of seconds between writes.
+
+        Returns:
+            bool: Returns true if the report was successful otherwise false.
+        """
+        now = time()
+        if not force and now < (self.timestamp + report_freq):
+            return False
+        assert self._db_file
+        self.timestamp = now
+
+        with closing(connect(self._db_file, timeout=DB_TIMEOUT)) as con:
+            cur = con.cursor()
+            with con:
+                analysis = dumps(self.analysis)
+                run_params = dumps(self.run_params)
+                sig_info = dumps(self.signature_info)
+                finished = dumps(self.finished_steps)
+                in_prog = dumps([step.serialize() for step in self._in_progress_steps])
+                strategies = dumps(self.strategies)
+
+                cur.execute(
+                    """UPDATE reduce_status
+                       SET analysis = ?,
+                           attempts = ?,
+                           iterations = ?,
+                           run_params = ?,
+                           signature_info = ?,
+                           successes = ?,
+                           crash_id = ?,
+                           finished_steps = ?,
+                           _in_progress_steps = ?,
+                           strategies = ?,
+                           _current_size = ?,
+                           current_strategy_idx = ?,
+                           timestamp = ?
+                       WHERE pid = ?;""",
+                    (
+                        analysis,
+                        self.attempts,
+                        self.iterations,
+                        run_params,
+                        sig_info,
+                        self.successes,
+                        self.crash_id,
+                        finished,
+                        in_prog,
+                        strategies,
+                        self._testcase_size(),
+                        self.current_strategy_idx,
+                        self.timestamp,
+                        self.pid,
+                    ),
+                )
+                if cur.rowcount < 1:
+                    cur.execute(
+                        """INSERT INTO reduce_status(
+                               pid,
+                               analysis,
+                               attempts,
+                               iterations,
+                               run_params,
+                               signature_info,
+                               successes,
+                               crash_id,
+                               finished_steps,
+                               _in_progress_steps,
+                               strategies,
+                               _current_size,
+                               current_strategy_idx,
+                               timestamp)
+                           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);""",
+                        (
+                            self.pid,
+                            analysis,
+                            self.attempts,
+                            self.iterations,
+                            run_params,
+                            sig_info,
+                            self.successes,
+                            self.crash_id,
+                            finished,
+                            in_prog,
+                            strategies,
+                            self._testcase_size(),
+                            self.current_strategy_idx,
+                            self.timestamp,
+                        ),
+                    )
+
+        return True
+
+    @classmethod
+    def loadall(cls, db_file=STATUS_DB, time_limit=300):
+        """Load all reduction status reports found in `db_file`.
+
+        Args:
+            db_file (str): Path to database containing status data.
+            time_limit (int): Only include entries with a timestamp that is within the
+                              given number of seconds.
+
+        Yields:
+            Status: Successfully loaded read-only status objects.
+        """
+        assert db_file
+        assert time_limit >= 0
+        with closing(connect(db_file, timeout=DB_TIMEOUT)) as con:
+            cur = con.cursor()
+            # collect entries
+            try:
+                cur.execute(
+                    """SELECT pid,
+                              analysis,
+                              attempts,
+                              iterations,
+                              run_params,
+                              signature_info,
+                              successes,
+                              crash_id,
+                              finished_steps,
+                              _in_progress_steps,
+                              strategies,
+                              _current_size,
+                              current_strategy_idx,
+                              timestamp
+                       FROM reduce_status
+                       WHERE timestamp > ?
+                       ORDER BY timestamp DESC;""",
+                    (time() - time_limit,),
+                )
+                entries = cur.fetchall()
+            except OperationalError as exc:
+                if not str(exc).startswith("no such table:"):
+                    raise  # pragma: no cover
+                entries = ()
+
+        for entry in entries:
+            pid = entry[0]
+
+            status = cls(
+                strategies=loads(entry[10]),
+                crash_id=entry[7],
+                pid=pid,
+            )
+            status.analysis = loads(entry[1])
+            status.attempts = entry[2]
+            status.iterations = entry[3]
+            status.run_params = loads(entry[4])
+            status.signature_info = loads(entry[5])
+            status.successes = entry[6]
+            status.finished_steps = [
+                ReductionStep._make(step) for step in loads(entry[8])
+            ]
+            status._in_progress_steps = [
+                status._construct_milestone(*step) for step in loads(entry[9])
+            ]
+            status._current_size = entry[11]
+            status.current_strategy_idx = entry[12]
+            status.timestamp = entry[13]
+            yield status
+
+    def _testcase_size(self):
+        if self._db_file is None:
+            return self._current_size
+        return self._testcase_size_cb()
+
+    def __deepcopy__(self, memo):
+        """Return a deep copy of this instance."""
+        # pylint: disable=protected-access
+        result = type(self)(
+            strategies=deepcopy(self.strategies, memo),
+            crash_id=self.crash_id,
+            testcase_size_cb=self._testcase_size_cb,
+            pid=self.pid,
+        )
+        # assign after construction to avoid DB access
+        result._db_file = self._db_file
+        result.analysis = deepcopy(self.analysis, memo)
+        result.attempts = self.attempts
+        result.iterations = self.iterations
+        result.run_params = deepcopy(self.run_params, memo)
+        result.signature_info = deepcopy(self.signature_info, memo)
+        result.successes = self.successes
+        result.finished_steps = deepcopy(self.finished_steps, memo)
+        # finish open timers
+        for step in reversed(self._in_progress_steps):
+            result.record(
+                step.name,
+                attempts=step.attempts,
+                duration=step.duration,
+                iterations=step.iterations,
+                successes=step.successes,
+            )
+        return result
+
+    @property
+    def current_strategy(self):
+        if self._in_progress_steps:
+            return self._in_progress_steps[-1]
+        if self.finished_steps:
+            return self.finished_steps[-1]
+        return None
+
+    @property
+    def total(self):
+        if self._in_progress_steps:
+            return self._in_progress_steps[0]
+        if self.finished_steps:
+            return self.finished_steps[-1]
+        return None
+
+    @property
+    def original(self):
+        if self.finished_steps:
+            return self.finished_steps[0]
+        return None
+
+    def record(
+        self,
+        name,
+        duration=None,
+        iterations=None,
+        attempts=None,
+        successes=None,
+    ):
+        """Record reduction status for a given point in time:
+
+        - name of the milestone (eg. init, strategy name completed)
+        - elapsed time (seconds)
+        - # of iterations
+        - # of total attempts
+        - # of successful attempts
+
+        Arguments:
+            name (str): name of milestone
+            duration (float or None): seconds elapsed for period recorded
+            iterations (int or None): # of iterations performed
+            attempts (int or None): # of attempts performed
+            successes (int or None): # of attempts successful
+
+        Returns:
+            None
+        """
+        self.finished_steps.append(
+            ReductionStep(
+                name=name,
+                size=self._testcase_size(),
+                duration=duration,
+                iterations=iterations,
+                attempts=attempts,
+                successes=successes,
+            )
+        )
+
+    def _construct_milestone(self, name, start, attempts, iterations, successes):
+        # pylint: disable=no-self-argument
+        class _MilestoneTimer:
+            def __init__(sub):
+                sub.name = name
+                sub._start_time = start
+                sub._start_attempts = attempts
+                sub._start_iterations = iterations
+                sub._start_successes = successes
+
+            @property
+            def size(sub):
+                return self._testcase_size()  # pylint: disable=protected-access
+
+            @property
+            def attempts(sub):
+                return self.attempts - sub._start_attempts
+
+            @property
+            def iterations(sub):
+                return self.iterations - sub._start_iterations
+
+            @property
+            def successes(sub):
+                return self.successes - sub._start_successes
+
+            @property
+            def duration(sub):
+                if self._db_file is None:  # pylint: disable=protected-access
+                    return self.timestamp - sub._start_time
+                return time() - sub._start_time
+
+            def serialize(sub):
+                return (
+                    sub.name,
+                    sub._start_time,
+                    sub._start_attempts,
+                    sub._start_iterations,
+                    sub._start_successes,
+                )
+
+        return _MilestoneTimer()
+
+    @contextmanager
+    def measure(self, name):
+        """Time and record the period leading up to a reduction milestone.
+        eg. a strategy being run.
+
+        Arguments:
+            name (str): name of milestone
+
+        Yields:
+            None
+        """
+
+        tmr = self._construct_milestone(
+            name, time(), self.attempts, self.iterations, self.successes
+        )
+        self._in_progress_steps.append(tmr)
+        yield
+        assert self._in_progress_steps.pop() is tmr
+        self.record(
+            name,
+            attempts=tmr.attempts,
+            duration=tmr.duration,
+            iterations=tmr.iterations,
+            successes=tmr.successes,
+        )
+
+    def copy(self):
+        """Create a deep copy of this instance.
+
+        Arguments:
+            None
+
+        Returns:
+            ReductionStatus: Clone of self
+        """
+        return deepcopy(self)
+
+    def add_to_reporter(self, reporter, expected=True):
+        """Add the reducer status to reported metadata for the given reporter.
+
+        Arguments:
+            reporter (FuzzManagerReporter): Reporter to update.
+            expected (bool): Add detailed stats.
+
+        Returns:
+            None
+        """
+        # only add detailed stats for expected results
+        if expected:
+            reporter.add_extra_metadata("reducer-stats", self.finished_steps)
+        # other parameters
+        if self.analysis:
+            reporter.add_extra_metadata("reducer-analysis", self.analysis)
+        if self.run_params:
+            reporter.add_extra_metadata("reducer-params", self.run_params)
+        if self.signature_info:
+            reporter.add_extra_metadata("reducer-sig", self.signature_info)
+        # if input was an existing crash-id, record the original
+        if self.crash_id:
+            reporter.add_extra_metadata("reducer-input", self.crash_id)
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index a07aea6f..9acec38e 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -8,6 +8,7 @@
 from collections import defaultdict
 from datetime import timedelta
 from functools import partial
+from itertools import zip_longest
 from logging import DEBUG, INFO, basicConfig
 
 try:
@@ -18,11 +19,12 @@
 from os import SEEK_CUR, getenv, scandir
 from os.path import isdir
 from re import match
+from re import sub as re_sub
 from time import gmtime, localtime, strftime
 
 from psutil import cpu_count, cpu_percent, disk_usage, virtual_memory
 
-from .status import Status
+from .status import ReductionStatus, ReductionStep, Status
 
 __all__ = ("StatusReporter",)
 __author__ = "Tyson Smith"
@@ -512,6 +514,316 @@ def __str__(self):
         return "\n".join(["Log: %r" % self.file_name] + self.prev_lines + self.lines)
 
 
+class _TableFormatter:
+    """Format data in a table."""
+
+    def __init__(self, columns, formatters, vsep=" | ", hsep="-"):
+        """Initialize a TableFormatter instance.
+
+        Arguments:
+            columns (iterable(str)): List of column names for the table header.
+            formatters (iterable(callable)): List of format functions for each column.
+                                             None will result in hiding that column.
+            vsep (str): Vertical separation between columns.
+            hsep (str): Horizontal separation between header and data.
+        """
+        assert len(columns) == len(formatters)
+        self._columns = tuple(
+            column for (column, fmt) in zip(columns, formatters) if fmt is not None
+        )
+        self._formatters = formatters
+        self._vsep = vsep
+        self._hsep = hsep
+
+    def format_rows(self, rows):
+        """Format rows as a table and return a line generator.
+
+        Arguments:
+            rows (list(list(str))): Tabular data. Each row must be the same length as
+                                    `columns` passed to `__init__`.
+
+        Yields:
+            str: Each line of formatted tabular data.
+        """
+        max_width = [len(col) for col in self._columns]
+        formatted = []
+        for row in rows:
+            assert len(row) == len(self._formatters)
+            formatted.append([])
+            offset = 0
+            for idx, (data, formatter) in enumerate(zip(row, self._formatters)):
+                if formatter is None:
+                    offset += 1
+                    continue
+                data = formatter(data)
+                max_width[idx - offset] = max(max_width[idx - offset], len(data))
+                formatted[-1].append(data)
+
+        # build a format_str to space out the columns with separators using `max_width`
+        # the first column is left-aligned, and other fields are right-aligned.
+        format_str = self._vsep.join(
+            field % (width,)
+            for field, width in zip_longest(["%%-%ds"], max_width, fillvalue="%%%ds")
+        )
+        yield format_str % self._columns
+        yield self._hsep * (len(self._vsep) * (len(self._columns) - 1) + sum(max_width))
+        for row in formatted:
+            yield format_str % tuple(row)
+
+
+def _format_seconds(duration):
+    # format H:M:S, and then remove all leading zeros with regex
+    minutes, seconds = divmod(int(duration), 60)
+    hours, minutes = divmod(minutes, 60)
+    result = re_sub("^[0:]*", "", "%d:%02d:%02d" % (hours, minutes, seconds))
+    # if the result is all zeroes, ensure one zero is output
+    if not result:
+        result = "0"
+    # a bare number is ambiguous. output 's' for seconds
+    if ":" not in result:
+        result += "s"
+    return result
+
+
+def _format_duration(duration, total=0):
+    result = ""
+    if duration is not None:
+        if total == 0:
+            percent = 0  # pragma: no cover
+        else:
+            percent = int(100 * duration / total)
+        result = _format_seconds(duration)
+        result += " (%3d%%)" % (percent,)
+    return result
+
+
+def _format_number(number, total=0):
+    result = ""
+    if number is not None:
+        if total == 0:
+            percent = 0
+        else:
+            percent = int(100 * number / total)
+        result = "{:n} ({:3d}%)".format(number, percent)
+    return result
+
+
+class ReductionStatusReporter(StatusReporter):
+    """Create a status report for a reducer instance.
+    Merging multiple reports is not possible. This is intended for automated use only.
+    """
+
+    TIME_LIMIT = 120  # ignore older reports
+
+    # pylint: disable=super-init-not-called
+    def __init__(self, reports, tracebacks=None):
+        self.reports = reports
+        self.tracebacks = tracebacks
+
+    @property
+    def has_results(self):
+        return False  # TODO
+
+    @classmethod
+    def load(cls, db_file, tb_path=None, time_limit=TIME_LIMIT):
+        """Read Grizzly reduction status reports and create a ReductionStatusReporter
+        object.
+
+        Args:
+            path (str): Path to scan for status data files.
+            tb_path (str): Directory to scan for files containing Python tracebacks.
+            time_limit (int): Only include entries with a timestamp that is within the
+                              given number of seconds.
+
+        Returns:
+            ReductionStatusReporter: Contains available status reports and traceback
+                                     reports.
+        """
+        tracebacks = None if tb_path is None else cls._tracebacks(tb_path)
+        return cls(
+            list(ReductionStatus.loadall(db_file=db_file, time_limit=time_limit)),
+            tracebacks=tracebacks,
+        )
+
+    @staticmethod
+    def _analysis_entry(report):
+        return (
+            "Analysis",
+            ", ".join(
+                ("%s: %d%%" % (desc, 100 * reliability))
+                for desc, reliability in report.analysis.items()
+            ),
+        )
+
+    @staticmethod
+    def _run_params_entry(report):
+        return (
+            "Run Parameters",
+            ", ".join(
+                ("%s: %r" % (desc, value)) for desc, value in report.run_params.items()
+            ),
+        )
+
+    @staticmethod
+    def _signature_info_entry(report):
+        return (
+            "Signature",
+            ", ".join(
+                ("%s: %r" % (desc, value))
+                for desc, value in report.signature_info.items()
+            ),
+        )
+
+    def specific(  # pylint: disable=arguments-differ
+        self,
+        sysinfo=False,
+        timestamp=False,
+    ):
+        """Generate formatted output from status report.
+
+        Args:
+            None
+
+        Returns:
+            str: A formatted report.
+        """
+        if not self.reports:
+            return "No status reports available"
+
+        reports = []
+        for report in self.reports:
+            entries = []
+            if report.crash_id:
+                entries.append(("Crash ID", str(report.crash_id)))
+            if report.analysis:
+                entries.append(self._analysis_entry(report))
+            if report.run_params:
+                entries.append(self._run_params_entry(report))
+            if report.current_strategy:
+                entries.append(
+                    (
+                        "Current Strategy",
+                        "%s (%r of %d)"
+                        % (
+                            report.current_strategy.name,
+                            report.current_strategy_idx,
+                            len(report.strategies),
+                        ),
+                    )
+                )
+            if report.current_strategy and report.original:
+                # TODO: lines/tokens?
+                entries.append(
+                    (
+                        "Current/Original",
+                        "%dB / %dB"
+                        % (report.current_strategy.size, report.original.size),
+                    )
+                )
+            if report.total:
+                # TODO: other results
+                entries.append(
+                    (
+                        "Results",
+                        "%d successes, %d attempts"
+                        % (report.total.successes, report.total.attempts),
+                    )
+                )
+            if report.total and report.current_strategy:
+                entries.append(
+                    (
+                        "Time Elapsed",
+                        "%s in strategy, %s total"
+                        % (
+                            _format_seconds(report.current_strategy.duration),
+                            _format_seconds(report.total.duration),
+                        ),
+                    )
+                )
+
+            # System information
+            if sysinfo:
+                entries.extend(self._sys_info())
+
+            # Timestamp
+            if timestamp:
+                entries.append(("Timestamp", strftime("%Y/%m/%d %X %z", gmtime())))
+
+            reports.append(self.format_entries(entries))
+        return "\n\n".join(reports)
+
+    def summary(
+        self,
+        runtime=False,
+        sysinfo=False,
+        timestamp=False,
+    ):  # pylint: disable=arguments-differ
+        """Merge and generate a summary from status reports.
+
+        Args:
+            runtime (bool): Ignored (compatibility).
+            sysinfo (bool): Include system info (CPU, disk, RAM... etc) in output.
+            timestamp (bool): Include time stamp in output.
+
+        Returns:
+            str: A summary of merged reports.
+        """
+        if not self.reports:
+            return "No status reports available"
+
+        reports = []
+        for report in self.reports:
+            entries = []
+            lines = []
+            if report.analysis:
+                entries.append(self._analysis_entry(report))
+            if report.signature_info:
+                entries.append(self._signature_info_entry(report))
+            if report.run_params:
+                entries.append(self._run_params_entry(report))
+            if report.total and report.original:
+                tabulator = _TableFormatter(
+                    ReductionStep._fields,
+                    ReductionStep(
+                        name=str,
+                        # duration and attempts are % of total/last, size % of init/1st
+                        duration=partial(_format_duration, total=report.total.duration),
+                        attempts=partial(_format_number, total=report.total.attempts),
+                        successes=partial(_format_number, total=report.total.successes),
+                        iterations=None,  # hide
+                        size=partial(_format_number, total=report.original.size),
+                    ),
+                )
+                lines.extend(tabulator.format_rows(report.finished_steps))
+            # Format output
+            if entries:
+                lines.append(self.format_entries(entries))
+            if lines:
+                reports.append("\n".join(lines))
+
+        entries = []
+
+        # System information
+        if sysinfo:
+            entries.extend(self._sys_info())
+
+        # Timestamp
+        if timestamp:
+            entries.append(("Timestamp", strftime("%Y/%m/%d %X %z", gmtime())))
+
+        if entries:
+            reports.append(self.format_entries(entries))
+
+        msg = "\n\n".join(reports)
+
+        if self.tracebacks:
+            msg += self._merge_tracebacks(
+                self.tracebacks, self.SUMMARY_LIMIT - len(msg)
+            )
+
+        return msg
+
+
 def main(args=None):
     """Merge Grizzly status files into a single report (main entrypoint).
 
@@ -529,8 +841,10 @@ def main(args=None):
         log_fmt = "[%(asctime)s] %(message)s"
     basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
 
-    # TODO: add support for reducer
-    modes = {"fuzzing": Status.STATUS_DB}
+    modes = {
+        "fuzzing": (StatusReporter, Status.STATUS_DB),
+        "reducing": (ReductionStatusReporter, ReductionStatus.STATUS_DB),
+    }
 
     # report types: define name and time range of scan
     report_types = {
@@ -571,8 +885,8 @@ def main(args=None):
     if args.tracebacks and not isdir(args.tracebacks):
         parser.error("--tracebacks must be a directory")
 
-    status_db = modes.get(args.scan_mode)
-    reporter = StatusReporter.load(
+    reporter_cls, status_db = modes.get(args.scan_mode)
+    reporter = reporter_cls.load(
         db_file=status_db,
         tb_path=args.tracebacks,
         time_limit=report_types[args.type],
@@ -580,8 +894,11 @@ def main(args=None):
 
     if args.dump:
         with open(args.dump, "w") as ofp:
-            if args.type == "active":
+            if args.type == "active" and args.scan_mode == "fuzzing":
                 ofp.write(reporter.summary(runtime=False, sysinfo=True, timestamp=True))
+            elif args.type == "active":
+                # reducer only has one instance, so show specific report while running
+                ofp.write(reporter.specific(sysinfo=True, timestamp=True))
             else:
                 ofp.write(
                     reporter.summary(runtime=True, sysinfo=False, timestamp=False)
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index c179e6d5..4333a5a9 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -11,7 +11,15 @@
 
 from pytest import mark
 
-from .status import DB_VERSION, ResultCounter, Status, _db_version_check
+from .reporter import FuzzManagerReporter
+from .status import (
+    DB_VERSION,
+    ReductionStatus,
+    ReductionStep,
+    ResultCounter,
+    Status,
+    _db_version_check,
+)
 
 
 def test_status_01(mocker, tmp_path):
@@ -270,6 +278,230 @@ def test_status_08(tmp_path, buckets, ratio, iterations, blockers):
     assert len(tuple(status.blockers(iters_per_result=ratio))) == blockers
 
 
+def test_reduce_status_01(mocker, tmp_path):
+    """test ReductionStatus()"""
+    mocker.patch("grizzly.common.status.time", autospec=True, return_value=1.0)
+    strategies = ["strategy_%d" % (idx,) for idx in range(5)]
+
+    def fake_tc_size():
+        return 47
+
+    status = ReductionStatus.start(
+        str(tmp_path / "status.db"),
+        strategies=strategies,
+        testcase_size_cb=fake_tc_size,
+    )
+    assert status is not None
+    assert status.analysis == {}
+    assert status.attempts == 0
+    assert status.iterations == 0
+    assert status.run_params == {}
+    assert status.signature_info == {}
+    assert status.successes == 0
+    assert status.current_strategy_idx is None
+    assert status._testcase_size_cb is fake_tc_size
+    assert status.crash_id is None
+    assert status.finished_steps == []
+    assert status._in_progress_steps == []
+    assert status.strategies == strategies
+    assert status._db_file is not None
+    assert status.pid is not None
+    assert status.timestamp > 0.0
+    assert status._current_size is None
+
+
+def test_reduce_status_02(tmp_path):
+    """test ReductionStatus.report()"""
+    status = ReductionStatus.start(
+        str(tmp_path / "status.db"),
+        testcase_size_cb=lambda: 47,
+    )
+    # try to report before REPORT_FREQ elapses
+    assert not status.report()
+    # REPORT_FREQ elapses
+    status.timestamp = 0
+    assert status.report()
+    assert status.timestamp > 0
+    # force report
+    future = int(time()) + 1000
+    status.timestamp = future
+    assert status.report(force=True)
+    assert status.timestamp < future
+
+
+def test_reduce_status_03(tmp_path):
+    """test ReductionStatus.loadall()"""
+    db_file = str(tmp_path / "status.db")
+    strategies = ["strategy_%d" % (idx,) for idx in range(5)]
+    # create simple entry
+    status = ReductionStatus.start(
+        str(tmp_path / "status.db"),
+        strategies=strategies,
+        testcase_size_cb=lambda: 47,
+    )
+    loaded = tuple(ReductionStatus.loadall(db_file))
+    assert len(loaded) == 1
+    loaded = loaded[0]
+    assert status.analysis == loaded.analysis
+    assert status.attempts == loaded.attempts
+    assert status.iterations == loaded.iterations
+    assert status.run_params == loaded.run_params
+    assert status.signature_info == loaded.signature_info
+    assert status.successes == loaded.successes
+    assert status.current_strategy_idx == loaded.current_strategy_idx
+    assert loaded._testcase_size_cb is None
+    assert status.crash_id == loaded.crash_id
+    assert status.finished_steps == loaded.finished_steps
+    assert status._in_progress_steps == loaded._in_progress_steps
+    assert status.strategies == loaded.strategies
+    assert status._db_file is not None
+    assert status.pid == loaded.pid
+    assert status.timestamp == loaded.timestamp
+    assert loaded._current_size == 47
+    assert loaded._testcase_size() == 47
+
+
+def test_reduce_status_04(mocker, tmp_path):
+    """test ReductionStatus.loadall()"""
+    getpid = mocker.patch("grizzly.common.status.getpid", autospec=True)
+    db_file = str(tmp_path / "status.db")
+    for pid in range(5):
+        getpid.return_value = pid
+        ReductionStatus.start(
+            db_file,
+            testcase_size_cb=lambda: 47,
+        )
+    assert len(tuple(ReductionStatus.loadall(db_file))) == 5
+
+
+def test_reduce_status_05(mocker, tmp_path):
+    """test ReductionStatus milestone measurements"""
+    strategies = ["strategy_%d" % (idx,) for idx in range(5)]
+
+    # (time, testcase_size) steps to manually advance through
+    ticks = [
+        (0, 1000),
+        (1, 900),
+        (2, 800),
+        (3, 700),
+        (4, 600),
+        (5, 500),
+    ]
+
+    mocker.patch(
+        "grizzly.common.status.time",
+        autospec=True,
+        side_effect=lambda: ticks[0][0],
+    )
+    testcase_size_cb = mocker.Mock(side_effect=lambda: ticks[0][1])
+    status = ReductionStatus.start(
+        str(tmp_path / "status.db"),
+        strategies=strategies,
+        testcase_size_cb=testcase_size_cb,
+    )
+    status.record("begin")
+    assert status.original.name == "begin"
+    assert status.total.name == "begin"
+    assert status.current_strategy.name == "begin"
+    with status.measure("overall"):
+        assert status.original.name == "begin"
+        assert status.total.name == "overall"
+        assert status.current_strategy.name == "overall"
+        for idx in range(5):
+            with status.measure(strategies[idx]):
+                ticks.pop(0)
+                status.attempts += 2
+                status.successes += 1
+                status.iterations += 10
+                assert status.original.name == "begin"
+                assert status.total.name == "overall"
+                assert status.current_strategy.name == "strategy_%d" % (idx,)
+    assert status.finished_steps == [
+        ReductionStep("begin", None, None, None, 1000, None),
+        ReductionStep("strategy_0", 1, 1, 2, 900, 10),
+        ReductionStep("strategy_1", 1, 1, 2, 800, 10),
+        ReductionStep("strategy_2", 1, 1, 2, 700, 10),
+        ReductionStep("strategy_3", 1, 1, 2, 600, 10),
+        ReductionStep("strategy_4", 1, 1, 2, 500, 10),
+        ReductionStep("overall", 5, 5, 10, 500, 50),
+    ]
+    assert status.original.name == "begin"
+    assert status.total.name == "overall"
+    assert status.current_strategy.name == "overall"
+
+
+def test_reduce_status_06(mocker, tmp_path):
+    """test ReductionStatus in-progress milestones"""
+    mocker.patch("grizzly.common.status.time", autospec=True, return_value=1.0)
+    status = ReductionStatus.start(
+        str(tmp_path / "status.db"),
+        testcase_size_cb=lambda: 47,
+    )
+    with status.measure("milestone"):
+        assert len(status.finished_steps) == 0
+        status2 = status.copy()
+        assert len(status2.finished_steps) == 1
+
+    assert status.analysis == status2.analysis
+    assert status.attempts == status2.attempts
+    assert status.iterations == status2.iterations
+    assert status.run_params == status2.run_params
+    assert status.signature_info == status2.signature_info
+    assert status.successes == status2.successes
+    assert status.current_strategy_idx == status2.current_strategy_idx
+    assert status._testcase_size_cb is status2._testcase_size_cb
+    assert status.crash_id == status2.crash_id
+    assert status.finished_steps == status2.finished_steps
+    assert status._in_progress_steps == status2._in_progress_steps
+    assert status.strategies == status2.strategies
+    assert status._db_file is not None
+    assert status2._db_file is not None
+    assert status.pid == status2.pid
+    assert status.timestamp == status2.timestamp
+
+    with status.measure("milestone2"):
+        status.report(force=True)
+
+    loaded_status = tuple(ReductionStatus.loadall(str(tmp_path / "status.db")))
+    assert len(loaded_status) == 1
+    loaded_status = loaded_status[0]
+
+    assert loaded_status.finished_steps == status.finished_steps[:1]
+    assert len(loaded_status._in_progress_steps) == 1
+
+    loaded_status = loaded_status.copy()
+    assert len(loaded_status.finished_steps) == 2
+    assert len(loaded_status._in_progress_steps) == 0
+    assert loaded_status.original == status.original
+    for field in ReductionStep._fields:
+        if field == "size":
+            continue
+        assert getattr(loaded_status.total, field) == getattr(status.total, field)
+    assert loaded_status.total.size is None
+
+
+def test_reduce_status_07(mocker, tmp_path):
+    """test ReductionStatus metadata"""
+    reporter = mocker.Mock(spec_set=FuzzManagerReporter)
+    status = ReductionStatus.start(
+        str(tmp_path / "status.db"),
+        testcase_size_cb=lambda: 47,
+        crash_id=123,
+    )
+    status.analysis["thing"] = "done"
+    status.record("init")
+    status.run_params["knob"] = "turned"
+    status.signature_info["dumb"] = True
+    status.add_to_reporter(reporter)
+    assert reporter.add_extra_metadata.call_args_list == [
+        mocker.call("reducer-stats", status.finished_steps),
+        mocker.call("reducer-analysis", status.analysis),
+        mocker.call("reducer-params", status.run_params),
+        mocker.call("reducer-sig", status.signature_info),
+        mocker.call("reducer-input", status.crash_id),
+    ]
+
+
 @mark.parametrize(
     "keys, counts, limit, local_only",
     [
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index b34cb998..680e635b 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -11,7 +11,14 @@
 
 from pytest import mark, raises
 
-from .status_reporter import Status, StatusReporter, TracebackReport, main
+from .status_reporter import (
+    ReductionStatus,
+    ReductionStatusReporter,
+    Status,
+    StatusReporter,
+    TracebackReport,
+    main,
+)
 
 GBYTES = 1_073_741_824
 
@@ -24,6 +31,166 @@ def _fake_sys_info():
     ]
 
 
+def test_reduce_status_reporter_01():
+    """test basic ReductionStatusReporter"""
+    st_rpt = ReductionStatusReporter(None)
+    assert not st_rpt.has_results
+    st_rpt._sys_info = _fake_sys_info
+    assert "No status reports available" in st_rpt.specific()
+    assert "No status reports available" in st_rpt.summary()
+
+
+def test_reduce_status_reporter_02(mocker, tmp_path):
+    """test ReductionStatusReporter.load()"""
+    # missing reports path
+    st_rpt = ReductionStatusReporter.load(str(tmp_path / "status.db"))
+    assert not st_rpt.reports
+
+    # empty reports and tb paths
+    st_rpt = ReductionStatusReporter.load(
+        str(tmp_path / "status.db"), tb_path=str(tmp_path)
+    )
+    assert not st_rpt.reports
+    assert isinstance(st_rpt.tracebacks, list)
+    assert not st_rpt.tracebacks
+
+    # multiple reports
+    size_cb = mocker.Mock(side_effect=count(start=1000, step=-100))
+    db_file = str(tmp_path / "status.db")
+    ReductionStatus.start(
+        db_file=db_file,
+        testcase_size_cb=size_cb,
+    )
+    status2 = ReductionStatus(
+        db_file=db_file,
+        pid=1,
+        testcase_size_cb=size_cb,
+    )
+    status2.report(force=True)
+    st_rpt = ReductionStatusReporter.load(db_file)
+    assert len(st_rpt.reports) > 1
+
+
+def test_reduce_status_reporter_03(mocker, tmp_path):
+    """test ReductionStatusReporter.summary()"""
+    mocker.patch("grizzly.common.status.getpid", side_effect=(1, 2))
+    mocker.patch("grizzly.common.status.time", side_effect=count(start=1.0, step=1.0))
+    size_cb = mocker.Mock(side_effect=count(start=1000, step=-100))
+    db_file = str(tmp_path / "status.db")
+    # single report
+    status = ReductionStatus.start(
+        db_file=db_file,
+        testcase_size_cb=size_cb,
+    )
+    status.analysis["ran"] = True
+    status.run_params["speed"] = 123.0
+    status.signature_info["info"] = "crash"
+    status.record("init")
+    with status.measure("total"):
+        with status.measure("strategy_0"):
+            status.attempts += 1
+            status.successes += 1
+            status.iterations += 1
+        with status.measure("strategy_1"):
+            status.attempts += 3
+            status.successes += 1
+            status.iterations += 3
+    status.report(force=True)
+
+    rptr = ReductionStatusReporter.load(db_file)
+    rptr._sys_info = _fake_sys_info
+    assert rptr.reports
+    output = rptr.summary(sysinfo=True, timestamp=True)
+    assert "duration" in output
+    assert "successes" in output
+    assert "attempts" in output
+    assert "init" in output
+    assert "strategy_0" in output
+    assert "strategy_1" in output
+    assert "total" in output
+    assert "Timestamp" in output
+    assert len(output.splitlines()) == 14
+
+
+def test_reduce_status_reporter_04(mocker, tmp_path):
+    """test ReductionStatusReporter.specific()"""
+    mocker.patch("grizzly.common.status.getpid", side_effect=(1, 2))
+    db_file = str(tmp_path / "status.db")
+    # single report
+    status = ReductionStatus.start(
+        db_file=db_file,
+        strategies=["strategy_0"],
+        testcase_size_cb=lambda: 47,
+        crash_id=12,
+    )
+    assert status.original is None
+    rptr = ReductionStatusReporter.load(db_file)
+    assert rptr.reports
+    output = rptr.specific()
+    assert len(output.splitlines()) == 1
+    status.analysis["ran"] = True
+    status.run_params["splines"] = "reticulated"
+    status.record("init")
+    with status.measure("total"):
+        with status.measure("strategy_0"):
+            status.iterations = 1
+            status.attempts = 1
+            status.successes = 1
+    status.report(force=True)
+    rptr = ReductionStatusReporter.load(db_file)
+    assert rptr.reports
+    output = rptr.specific()
+    assert len(output.splitlines()) == 7
+    assert "Analysis" in output
+    assert "Run Parameters" in output
+    assert "Current Strategy" in output
+    assert "Current/Original" in output
+    assert "Results" in output
+    assert "Time Elapsed" in output
+
+
+def test_reduce_status_reporter_05(tmp_path):
+    """test ReductionStatusReporter.load() with traceback"""
+    db_file = str(tmp_path / "status.db")
+    status = ReductionStatus.start(
+        db_file=db_file,
+        testcase_size_cb=lambda: 47,
+    )
+    with status.measure("total"):
+        status.iteration = 1
+    status.report(force=True)
+    # create boring screenlog
+    (tmp_path / "screenlog.0").write_bytes(b"boring\ntest\n123\n")
+    # create first screenlog
+    with (tmp_path / "screenlog.1").open("wb") as test_fp:
+        test_fp.write(b"Traceback (most recent call last):\n")
+        test_fp.write(b"  blah\n")
+        test_fp.write(b"IndexError: list index out of range\n")
+    rptr = StatusReporter.load(db_file, tb_path=str(tmp_path))
+    assert len(rptr.tracebacks) == 1
+    # create second screenlog
+    with (tmp_path / "screenlog.1234").open("wb") as test_fp:
+        test_fp.write(b"Traceback (most recent call last):\n")
+        test_fp.write(b"  blah\n")
+        test_fp.write(b"foo.bar.error: blah\n")
+    rptr = StatusReporter.load(db_file, tb_path=str(tmp_path))
+    assert len(rptr.tracebacks) == 2
+    # create third screenlog
+    with (tmp_path / "screenlog.3").open("wb") as test_fp:
+        test_fp.write(b"Traceback (most recent call last):\n")
+        test_fp.write(b"  blah\n")
+        test_fp.write(b"KeyboardInterrupt\n")
+    rptr = ReductionStatusReporter.load(db_file, tb_path=str(tmp_path))
+    assert len(rptr.tracebacks) == 2
+    merged_log = rptr.summary()
+    assert len(merged_log.splitlines()) == 13
+    assert "screenlog.1" in merged_log
+    assert "screenlog.1234" in merged_log
+    assert "IndexError" in merged_log
+    assert "foo.bar.error" in merged_log
+    assert "screenlog.3" not in merged_log
+
+
 def test_status_reporter_01():
     """test basic StatusReporter"""
     st_rpt = StatusReporter(list())
@@ -546,6 +713,13 @@ def test_main_02(mocker):
     assert main([]) == 0
 
 
+@mark.parametrize(
+    "report_mode",
+    [
+        "fuzzing",
+        "reducing",
+    ],
+)
 @mark.parametrize(
     "report_type",
     [
@@ -553,17 +727,38 @@ def test_main_02(mocker):
         "complete",
     ],
 )
-@mark.usefixtures("tmp_path_status_db")
-def test_main_03(mocker, tmp_path, report_type):
+@mark.usefixtures("tmp_path_status_db", "tmp_path_reduce_status_db")
+def test_main_03(mocker, tmp_path, report_type, report_mode):
     """test main() --dump"""
     mocker.patch(
         "grizzly.common.status_reporter.StatusReporter.CPU_POLL_INTERVAL", 0.01
     )
-    status = Status.start()
-    status.iteration = 1
-    status.report(force=True)
+    if report_mode == "reducing":
+        status = ReductionStatus.start(
+            testcase_size_cb=lambda: 47,
+            strategies=[],
+        )
+        with status.measure("total"):
+            status.iteration = 1
+        status.report(force=True)
+    else:
+        status = Status.start()
+        status.iteration = 1
+        status.report(force=True)
     dump_file = tmp_path / "output.txt"
-    assert main(["--dump", str(dump_file), "--type", report_type]) == 0
+    assert (
+        main(
+            [
+                "--dump",
+                str(dump_file),
+                "--type",
+                report_type,
+                "--scan-mode",
+                report_mode,
+            ]
+        )
+        == 0
+    )
     assert dump_file.is_file()
     if report_type == "active":
         assert b"Runtime" not in dump_file.read_bytes()
@@ -577,3 +772,44 @@ def test_main_04(capsys):
     with raises(SystemExit):
         main(["--tracebacks", "missing"])
     assert "--tracebacks must be a directory" in capsys.readouterr()[-1]
+
+
+@mark.parametrize(
+    "report_type",
+    [
+        "active",
+        "complete",
+    ],
+)
+@mark.usefixtures("tmp_path_reduce_status_db")
+def test_main_05(mocker, tmp_path, report_type):
+    """test main() --dump"""
+    mocker.patch(
+        "grizzly.common.status_reporter.StatusReporter.CPU_POLL_INTERVAL", 0.01
+    )
+    status = ReductionStatus.start(
+        testcase_size_cb=lambda: 47,
+        strategies=[],
+    )
+    with status.measure("total"):
+        status.iteration = 1
+        status.report(force=True)
+    dump_file = tmp_path / "output.txt"
+    assert (
+        main(
+            [
+                "--dump",
+                str(dump_file),
+                "--type",
+                report_type,
+                "--scan-mode",
+                "reducing",
+            ]
+        )
+        == 0
+    )
+    assert dump_file.is_file()
+    if report_type == "active":
+        assert b"Runtime" not in dump_file.read_bytes()
+    else:
+        assert b"Timestamp" not in dump_file.read_bytes()
diff --git a/grizzly/conftest.py b/grizzly/conftest.py
index 4622b28c..fb0dd4b9 100644
--- a/grizzly/conftest.py
+++ b/grizzly/conftest.py
@@ -7,10 +7,27 @@
 
 from pytest import fixture
 
-from grizzly.common.status import Status
+from grizzly.common.status import ReductionStatus, Status
 
 
 @fixture
 def tmp_path_status_db(tmp_path, mocker):
     """Use a temporary database file for testing."""
     mocker.patch.object(Status, "STATUS_DB", new=str(tmp_path / "status-tmp.db"))
+
+
+@fixture
+def tmp_path_reduce_status_db(tmp_path, mocker):
+    """Use a temporary database file for testing."""
+    mocker.patch.object(
+        ReductionStatus, "STATUS_DB", new=str(tmp_path / "reduce-tmp.db")
+    )
+
+
+@fixture
+def tmp_path_replay_status_db(tmp_path, mocker):
+    """Use a temporary database file for testing."""
+    mocker.patch(
+        "grizzly.replay.replay.ReplayManager.STATUS_DB",
+        new=str(tmp_path / "replay-tmp.db"),
+    )
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index d132cc09..074b461e 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -19,12 +19,13 @@
 from ..common.fuzzmanager import CrashEntry
 from ..common.plugins import load as load_plugin
 from ..common.reporter import FilesystemReporter, FuzzManagerReporter, Quality
+from ..common.status import ReductionStatus
+from ..common.status_reporter import ReductionStatusReporter
 from ..common.storage import TestCaseLoadFailure
 from ..common.utils import ConfigError, Exit, configure_logging, grz_tmp
 from ..replay import ReplayManager
 from ..target import Target, TargetLaunchError, TargetLaunchTimeout
 from .exceptions import GrizzlyReduceBaseException, NotReproducible
-from .stats import ReductionStats
 from .strategies import STRATEGIES
 
 __author__ = "Jesse Schwartzentruber"
@@ -130,14 +131,17 @@ def __init__(
         # these parameters may be overwritten during analysis, so keep a copy of them
         self._original_relaunch = relaunch
         self._original_use_harness = use_harness
-        self._reducer_crash_id = reducer_crash_id
         self._report_to_fuzzmanager = report_to_fuzzmanager
         self._report_periodically = report_period
         self._report_tool = tool
         self._signature = signature
         self._signature_desc = signature_desc
         self._static_timeout = expect_hang or static_timeout
-        self._stats = ReductionStats()
+        self._status = ReductionStatus.start(
+            strategies=strategies,
+            testcase_size_cb=self.testcase_size,
+            crash_id=reducer_crash_id,
+        )
         self._use_analysis = use_analysis
         self._use_harness = use_harness
 
@@ -203,25 +207,23 @@ def update_timeout(self, results):
             LOG.info("Updating max timeout to: %r", new_iter_timeout)
             self.server.timeout = new_iter_timeout
 
-    def run_reliability_analysis(self, stats):
+    def run_reliability_analysis(self):
         """Run several analysis passes of the current testcase to find `run` parameters.
 
         The number of repetitions and minimum number of crashes are calculated to
         maximize the chances of observing the expected crash.
 
         Arguments:
-            stats (object): Open stats timer (from `ReductionStats.add_timed`).
-                            Pass to `ReductionStats.copy` to properly terminate
-                            the timer for reporting.
+            None
 
         Returns:
-            tuple(int, int, dict): Values for `repeat` and `min_crashes` resulting from
-                                   analysis, and info to include in stats.
+            tuple(int, int): Values for `repeat` and `min_crashes` resulting from
+                             analysis.
         """
+        self._status.report(force=True)
         harness_last_crashes = 0
         harness_crashes = 0
         non_harness_crashes = 0
-        info = {}
 
         # Reset parameters.
         # Use repeat=1 & relaunch=ITERATIONS because this is closer to how we will run
@@ -296,7 +298,8 @@ def run_reliability_analysis(self, stats):
                     idle_threshold=self._idle_threshold,
                 )
                 try:
-                    stats.add_iterations(replay.status.iteration)
+                    self._status.iterations += replay.status.iteration
+                    self._status.report()
                     crashes = sum(x.count for x in results if x.expected)
                     if crashes and not self._any_crash and self._signature_desc is None:
                         first_expected = next(
@@ -308,7 +311,6 @@ def run_reliability_analysis(self, stats):
                     self.report(
                         [result for result in results if not result.expected],
                         testcases,
-                        self._stats.copy(stats),
                     )
                     if use_harness:
                         # set harness_crashes in both cases (last_test True/False)
@@ -332,7 +334,7 @@ def run_reliability_analysis(self, stats):
                     self.ANALYSIS_ITERATIONS,
                     key,
                 )
-                info[key] = reliability
+                self._status.analysis[key] = reliability
                 # ensure same signature is always used
                 self._signature = replay.signature
 
@@ -399,7 +401,7 @@ def run_reliability_analysis(self, stats):
                 "* testcase was %s reliable with the harness",
                 "more" if harness_crashes > non_harness_crashes else "less",
             )
-        return (repeat, min_crashes, info)
+        return (repeat, min_crashes)
 
     def testcase_size(self):
         """Calculate the current testcase size.
@@ -424,18 +426,14 @@ def run(self, repeat=1, min_results=1):
         sig_given = self._signature is not None
         last_reports = None
         last_tried = None
-        self._stats.add("init", self.testcase_size())
+        self._status.record("init")
+        self._status.report(force=True)
         # record total stats overall so that any time missed by individual milestones
         # will still be included in the total
-        with self._stats.add_timed("final", self.testcase_size) as total_stats:
+        with self._status.measure("final"):
             if self._use_analysis:
-                with total_stats.add_timed("analysis") as stats:
-                    (
-                        repeat,
-                        min_results,
-                        reliability_info,
-                    ) = self.run_reliability_analysis(stats)
-                self._stats.add_info("Analysis", reliability_info)
+                with self._status.measure("analysis"):
+                    (repeat, min_results) = self.run_reliability_analysis()
                 any_success = True  # analysis ran and didn't raise
             # multi part test cases should always use relaunch == 1
             # since that can mean a delay is required
@@ -449,22 +447,18 @@ def run(self, repeat=1, min_results=1):
                 min_results,
                 relaunch,
             )
-            self._stats.add_info(
-                "Run Parameters",
-                {
-                    "Repeat": repeat,
-                    "Min Crashes": min_results,
-                    "Relaunch": relaunch,
-                    "Harness": self._use_harness,
-                },
-            )
+            self._status.run_params["harness"] = self._use_harness
+            self._status.run_params["min crashes"] = min_results
+            self._status.run_params["relaunch"] = relaunch
+            self._status.run_params["repeat"] = repeat
 
-            for strategy_no, strategy in enumerate(self.strategies):
+            for strategy_no, strategy in enumerate(self.strategies, start=1):
+                self._status.current_strategy_idx = strategy_no
                 LOG.info("")
                 LOG.info(
                     "Using strategy %s (%d/%d)",
                     strategy,
-                    strategy_no + 1,
+                    strategy_no,
                     len(self.strategies),
                 )
                 replay = ReplayManager(
@@ -482,10 +476,11 @@ def run(self, repeat=1, min_results=1):
                     last_tried = None
 
                 strategy_last_report = time()
-                strategy_stats = total_stats.add_timed(strategy.name)
+                strategy_stats = self._status.measure(strategy.name)
                 best_results = []
                 try:
                     with replay, strategy, strategy_stats:
+                        self._status.report(force=True)
                         for reduction in strategy:
                             keep_reduction = False
                             results = []
@@ -501,8 +496,8 @@ def run(self, repeat=1, min_results=1):
                                     min_results=min_results,
                                     repeat=repeat,
                                 )
-                                strategy_stats.add_iterations(replay.status.iteration)
-                                strategy_stats.add_attempts(1)
+                                self._status.iterations += replay.status.iteration
+                                self._status.attempts += 1
                                 self.update_timeout(results)
                                 # get the first expected result (if any),
                                 #   and update the strategy
@@ -512,7 +507,7 @@ def run(self, repeat=1, min_results=1):
                                 )
                                 success = first_expected is not None
                                 if success:
-                                    strategy_stats.add_successes(1)
+                                    self._status.successes += 1
                                     if (
                                         not self._any_crash
                                         and self._signature_desc is None
@@ -521,6 +516,7 @@ def run(self, repeat=1, min_results=1):
                                             # pylint: disable=line-too-long
                                             first_expected.report.crash_info.createShortSignature()  # noqa: E501
                                         )
+                                self._status.report()
                                 served = None
                                 if success and not self._any_crash:
                                     served = first_expected.served
@@ -562,9 +558,7 @@ def run(self, repeat=1, min_results=1):
                                     LOG.info("Attempt failed")
                                 # if the reduction found other crashes,
                                 #   report those immediately
-                                self.report(
-                                    results, reduction, self._stats.copy(strategy_stats)
-                                )
+                                self.report(results, reduction)
 
                                 now = time()
                                 if (
@@ -576,7 +570,6 @@ def run(self, repeat=1, min_results=1):
                                     last_reports = self.report(
                                         best_results,
                                         self.testcases,
-                                        self._stats.copy(strategy_stats),
                                     )
                                     for result in best_results:
                                         result.report.cleanup()
@@ -596,15 +589,11 @@ def run(self, repeat=1, min_results=1):
                         self._signature = replay.signature
 
                     if best_results:
-                        last_reports = self.report(
-                            best_results, self.testcases, self._stats.copy(total_stats)
-                        )
+                        last_reports = self.report(best_results, self.testcases)
 
                 except KeyboardInterrupt:
                     if best_results:
-                        last_reports = self.report(
-                            best_results, self.testcases, self._stats.copy(total_stats)
-                        )
+                        last_reports = self.report(best_results, self.testcases)
                         LOG.warning(
                             "Ctrl+C detected, best reduction so far " "reported as %r",
                             last_reports,
@@ -613,6 +602,7 @@ def run(self, repeat=1, min_results=1):
                 finally:
                     for result in best_results:
                         result.report.cleanup()
+                    self._status.report(force=True)
 
                 # store "tried" cache to pass to next strategy
                 last_tried = strategy.get_tried()
@@ -631,61 +621,51 @@ def run(self, repeat=1, min_results=1):
         # it's possible we made it this far without ever setting signature_desc.
         # this is only possible if --no-analysis is given
         # just give None instead of trying to format the CrashSignature
-        self._stats.add_info(
-            "Signature",
-            {
-                "given": sig_given,
-                "any": self._any_crash,
-                "description": self._signature_desc,
-            },
-        )
+        self._status.signature_info["any"] = self._any_crash
+        self._status.signature_info["description"] = self._signature_desc
+        self._status.signature_info["given"] = sig_given
 
         # log a summary of what was done.
         LOG.info(
             "Reduction summary:%s%s",
             os.linesep,
-            os.linesep.join(self._stats.format_lines()),
+            ReductionStatusReporter([self._status]).summary(),
         )
+        self._status.report(force=True)
 
         if any_success:
             return Exit.SUCCESS
         return Exit.FAILURE
 
-    def report(self, results, testcases, stats=None):
+    def report(self, results, testcases):
         """Report results, either to FuzzManager or to filesystem.
 
         Arguments:
             results (list(ReplayResult)): Results observed during reduction.
             testcases (list(TestCase)): Testcases used to trigger results.
-            stats (ReductionStats): Statistics for reduction of these results.
-                                    (may be different than `self._stats`)
 
         Returns:
             list(*): List of return values from `reporter.submit()`.
         """
         ret_values = []
+        status = self._status.copy()  # copy implicitly closes open counters
         for result in results:
             if self._report_to_fuzzmanager:
                 reporter = FuzzManagerReporter(self._report_tool)
                 if result.expected:
                     reporter.force_report = True
-                # add original-crash
-                if self._reducer_crash_id is not None:
-                    reporter.add_extra_metadata("reducer-input", self._reducer_crash_id)
             else:
                 report_dir = "reports" if result.expected else "other_reports"
                 reporter = FilesystemReporter(
                     report_path=str(self._log_path / report_dir), major_bucket=False
                 )
             # write reduction stats for expected results
-            if stats is not None and result.expected:
-                report_path = Path(result.report.path)
-                with (report_path / "reduce_stats.txt").open("w") as out:
-                    for line in stats.format_lines():
-                        print(line, file=out)
-                (report_path / "reduce_stats.json").write_text(stats.json())
-                if self._report_to_fuzzmanager:
-                    stats.add_to_reporter(reporter)
+            if result.expected:
+                (Path(result.report.path) / "reduce_stats.txt").write_text(
+                    ReductionStatusReporter([status]).summary()
+                )
+            if self._report_to_fuzzmanager:
+                status.add_to_reporter(reporter, expected=result.expected)
             # clone the tests so we can safely call purge_optional here for each report
             # (report.served may be different for non-expected or any-crash results)
             clones = [test.clone() for test in testcases]
diff --git a/grizzly/reduce/stats.py b/grizzly/reduce/stats.py
deleted file mode 100644
index 8a83c8c3..00000000
--- a/grizzly/reduce/stats.py
+++ /dev/null
@@ -1,331 +0,0 @@
-# coding=utf-8
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-"""Keep statistics about reduction."""
-import json
-import re
-from collections import namedtuple
-from copy import deepcopy
-from functools import partial
-from itertools import zip_longest
-from time import time
-
-ReductionStat = namedtuple(
-    "ReductionStat", "name, duration, successes, attempts, size, iterations"
-)
-
-
-class _FormatTable:
-    """Format tabular data in a table."""
-
-    def __init__(self, columns, formatters, vsep=" | ", hsep="-"):
-        """Initialize a FormatTable instance.
-
-        Arguments:
-            columns (iterable(str)): List of column names for the table header.
-            formatters (iterable(callable)): List of format functions for each column.
-                                             None will result in hiding that column.
-            vsep (str): Vertical separation between columns.
-            hsep (str): Horizontal separation between header and data.
-        """
-        assert len(columns) == len(formatters)
-        self._columns = tuple(
-            column for (column, fmt) in zip(columns, formatters) if fmt is not None
-        )
-        self._formatters = formatters
-        self._vsep = vsep
-        self._hsep = hsep
-
-    def format_rows(self, rows):
-        """Format rows as a table and return a line generator.
-
-        Arguments:
-            rows (list(list(str))): Tabular data. Each row must be the same length as
-                                    `columns` passed to `__init__`.
-
-        Yields:
-            str: Each line of formatted tabular data.
-        """
-        max_width = [len(col) for col in self._columns]
-        formatted = []
-        for row in rows:
-            assert len(row) == len(self._formatters)
-            formatted.append([])
-            offset = 0
-            for idx, (data, formatter) in enumerate(zip(row, self._formatters)):
-                if formatter is None:
-                    offset += 1
-                    continue
-                data = formatter(data)
-                max_width[idx - offset] = max(max_width[idx - offset], len(data))
-                formatted[-1].append(data)
-
-        # build a format_str to space out the columns with separators using `max_width`
-        # the first column is left-aligned, and other fields are right-aligned.
-        format_str = self._vsep.join(
-            field % (width,)
-            for field, width in zip_longest(["%%-%ds"], max_width, fillvalue="%%%ds")
-        )
-        yield format_str % self._columns
-        yield self._hsep * (len(self._vsep) * (len(self._columns) - 1) + sum(max_width))
-        for row in formatted:
-            yield format_str % tuple(row)
-
-
-def format_seconds(duration):
-    # format H:M:S, and then remove all leading zeros with regex
-    minutes, seconds = divmod(int(duration), 60)
-    hours, minutes = divmod(minutes, 60)
-    result = re.sub("^[0:]*", "", "%d:%02d:%02d" % (hours, minutes, seconds))
-    # if the result is all zeroes, ensure one zero is output
-    if not result:
-        result = "0"
-    return result
-
-
-def _format_duration(duration, total=0):
-    result = ""
-    if duration is not None:
-        if total == 0:
-            percent = 0  # pragma: no cover
-        else:
-            percent = int(100 * duration / total)
-        result = format_seconds(duration)
-        result += " (%3d%%)" % (percent,)
-    return result
-
-
-def _format_number(number, total=0):
-    result = ""
-    if number is not None:
-        if total == 0:
-            percent = 0
-        else:
-            percent = int(100 * number / total)
-        result = "{:n} ({:3d}%)".format(number, percent)
-    return result
-
-
-class ReductionStats:
-    """Statistics about reduction"""
-
-    def __init__(self):
-        """Initialize a ReductionStats instance."""
-        self._data = {"stats": []}
-
-    def __deepcopy__(self, memo):
-        """Return a deep copy of this instance."""
-        result = type(self)()
-        result._data = deepcopy(self._data, memo)  # pylint: disable=protected-access
-        return result
-
-    def add(
-        self,
-        name,
-        testcase_size,
-        elapsed=None,
-        iterations=None,
-        attempts=None,
-        successes=None,
-    ):
-        """Record reduction stats for a given point in time:
-
-        - name of the milestone (eg. init, strategy name completed)
-        - current testcase size (bytes)
-        - elapsed time (seconds)
-        - # of iterations
-        - # of total attempts
-        - # of successful attempts
-
-        Arguments:
-            name (str): name of milestone
-            testcase_size (int): size of testcase
-            elapsed (float or None): seconds elapsed for period recorded
-            iterations (int or None): # of iterations performed
-            attempts (int or None): # of attempts performed
-            successes (int or None): # of attempts successful
-
-        Returns:
-            None
-        """
-        self._data["stats"].append(
-            ReductionStat(
-                name=name,
-                size=testcase_size,
-                duration=elapsed,
-                iterations=iterations,
-                attempts=attempts,
-                successes=successes,
-            )
-        )
-
-    def add_info(self, name, value):
-        """Add extra information to be added to the stats report.
-
-        Arguments:
-            name (str): key to identify the information
-            value (object): Any JSON serializable value.
-
-        Returns:
-            None
-        """
-        assert not self.has_info(name)
-        self._data[name] = value
-
-    def has_info(self, name):
-        """Check whether the extra information specified by "name"
-        already exists in this instance.
-
-        Arguments:
-            name (str): key to identify the information
-
-        Returns:
-            bool: Whether the named info already exists.
-        """
-        assert isinstance(name, str)
-        return name in self._data
-
-    def add_timed(self, name, testcase_size_cb):
-        """Time and record the period leading up to a reduction milestone.
-        eg. a strategy being run.
-
-        Arguments:
-            name (str): name of milestone
-            testcase_size_cb (callable): callback to get testcase size when
-                                         context is exited.
-
-        Returns:
-            context: Timer context for the period being recorded up to the milestone.
-
-                     Attributes:
-                        attempts (int): # of attempts performed during period
-                        iterations (int): # of iterations performed during period.
-                        successes (int): # of successful attempts during period
-        """
-        # pylint: disable=no-self-argument
-        class _MilestoneTimer:
-            def __init__(sub, sub_name, parent=None):
-                sub._name = sub_name
-                sub._start = None
-                sub._attempts = 0
-                sub._iterations = 0
-                sub._successes = 0
-                sub._parent = parent
-
-            def add_attempts(sub, attempts):
-                sub._attempts += attempts
-                if sub._parent is not None:
-                    sub._parent.add_attempts(attempts)
-
-            def add_iterations(sub, iterations):
-                sub._iterations += iterations
-                if sub._parent is not None:
-                    sub._parent.add_iterations(iterations)
-
-            def add_successes(sub, successes):
-                sub._successes += successes
-                if sub._parent is not None:
-                    sub._parent.add_successes(successes)
-
-            def __enter__(sub):
-                sub._start = time()
-                return sub
-
-            def add_timed(sub, sub_name):
-                """Create a new timed period linked to this one."""
-                return type(sub)(sub_name, parent=sub)
-
-            def _stop_early(sub, other):
-                """Clone and stop the timer. Add as a new stat to `other`.
-
-                Arguments:
-                    other (ReductionStats): The stats to add the clone to.
-
-                Returns:
-                    None
-                """
-                elapsed = time() - sub._start
-                other.add(
-                    name,
-                    testcase_size_cb(),
-                    elapsed=elapsed,
-                    attempts=sub._attempts,
-                    successes=sub._successes,
-                    iterations=sub._iterations,
-                )
-                if sub._parent is not None:
-                    sub._parent._stop_early(other)  # pylint: disable=protected-access
-
-            def __exit__(sub, exc_type, exc_value, traceback):
-                elapsed = time() - sub._start
-                self.add(
-                    sub._name,
-                    testcase_size_cb(),
-                    elapsed=elapsed,
-                    attempts=sub._attempts,
-                    successes=sub._successes,
-                    iterations=sub._iterations,
-                )
-
-        return _MilestoneTimer(name)
-
-    def copy(self, stop_timer=None):
-        """Create a deep copy of this instance.
-
-        Arguments:
-            stop_timer (`add_timed` context):
-                In-progress `add_timed` call that should be stopped and added to the
-                result.
-
-        Returns:
-            ReductionStats: Clone of self
-        """
-        result = deepcopy(self)
-        if stop_timer is not None:
-            stop_timer._stop_early(result)  # pylint: disable=protected-access
-        return result
-
-    def format_lines(self):
-        """Format the current stats in a table.
-
-        Yields:
-            str: Formatted lines to be output.
-        """
-        for key, value in self._data.items():
-            if key == "stats":
-                continue
-            yield "%s: %r" % (key, value)
-        stats = self._data["stats"]
-        tabulator = _FormatTable(
-            ReductionStat._fields,
-            ReductionStat(
-                name=str,
-                # duration and attempts are % of total (last), size % of init (first)
-                duration=partial(_format_duration, total=stats[-1].duration),
-                attempts=partial(_format_number, total=stats[-1].attempts),
-                successes=partial(_format_number, total=stats[-1].successes),
-                iterations=None,  # hide
-                size=partial(_format_number, total=stats[0].size),
-            ),
-        )
-        yield from tabulator.format_rows(stats)
-
-    def add_to_reporter(self, reporter):
-        """Add the reducer stats to reported metadata for the given reporter.
-
-        Arguments:
-            reporter (FuzzManagerReporter): Reporter to update.
-
-        Returns:
-            None
-        """
-        reporter.add_extra_metadata("reducer-stats", self._data)
-
-    def json(self):
-        """Serialize the stats using JSON.
-
-        Returns:
-            str: Stats as JSON.
-        """
-        return json.dumps(self._data, indent=2)
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index d2ab80df..2840feed 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -16,7 +16,11 @@
 from .exceptions import GrizzlyReduceBaseException
 
 LOG = getLogger(__name__)
-pytestmark = mark.usefixtures("tmp_path_fm_config")
+pytestmark = mark.usefixtures(
+    "tmp_path_fm_config",
+    "tmp_path_replay_status_db",
+    "tmp_path_reduce_status_db",
+)
 
 
 def test_args_01(capsys, tmp_path, mocker):
@@ -151,6 +155,7 @@ def test_main_exit(mocker, patch_func, side_effect, return_value, kwargs, exit_c
     ],
 )
 def test_main_launch_error(mocker, exc_type):
+    mocker.patch("grizzly.reduce.core.ReductionStatus", autospec=True)
     mocker.patch("grizzly.reduce.core.FuzzManagerReporter", autospec=True)
     reporter = mocker.patch("grizzly.reduce.core.FilesystemReporter", autospec=True)
     mocker.patch("grizzly.reduce.core.load_plugin", autospec=True)
diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
index 633a8c6f..ef056c6c 100644
--- a/grizzly/reduce/test_main_fm.py
+++ b/grizzly/reduce/test_main_fm.py
@@ -6,7 +6,7 @@
 from copy import deepcopy
 from logging import getLogger
 
-import pytest
+from pytest import mark
 
 from ..common.reporter import Quality
 from ..common.utils import Exit
@@ -14,10 +14,14 @@
 from .crash import main as crash_main
 
 LOG = getLogger(__name__)
-pytestmark = pytest.mark.usefixtures("tmp_path_fm_config")
+pytestmark = mark.usefixtures(
+    "tmp_path_fm_config",
+    "tmp_path_replay_status_db",
+    "tmp_path_reduce_status_db",
+)
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     "arg_sig, arg_tool, crash_bucket, result_sig, result_tool",
     [
         # crash id is downloaded and core.main is called with the path
@@ -53,7 +57,7 @@ def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_
     assert args.tool == result_tool
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     "mgr_exit_code, pre_quality, post_quality",
     [
         (Exit.SUCCESS, Quality.UNREDUCED, Quality.ORIGINAL),
@@ -86,7 +90,7 @@ def test_crash_main_quality(mocker, mgr_exit_code, pre_quality, post_quality):
     assert crash.return_value.testcase_quality == post_quality
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     "crashes, main_exit_codes, result, arg_sig, arg_tool",
     [
         # no crashes -> success
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 61e4ccc6..469525e8 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -23,7 +23,12 @@
 from .strategies import Strategy
 
 LOG = getLogger(__name__)
-pytestmark = mark.usefixtures("tmp_path_fm_config", "reporter_sequential_strftime")
+pytestmark = mark.usefixtures(
+    "reporter_sequential_strftime",
+    "tmp_path_fm_config",
+    "tmp_path_replay_status_db",
+    "tmp_path_reduce_status_db",
+)
 
 
 def _fake_save_logs_foo(result_logs, meta=False):  # pylint: disable=unused-argument
@@ -279,18 +284,6 @@ def replay_run(_tests, _time_limit, **kw):
         tests.append(test.clone())
     log_path = tmp_path / "logs"
 
-    class _ReduceStats:
-        def __init__(self):
-            self._iters = 0
-
-        def add_iterations(self, iters):
-            self._iters += iters
-
-        @staticmethod
-        def _stop_early(_):
-            pass
-
-    stats = _ReduceStats()
     try:
         mgr = ReduceManager(
             None,
@@ -301,7 +294,7 @@ def _stop_early(_):
             log_path,
             use_harness=use_harness,
         )
-        repeat, min_crashes, _ = mgr.run_reliability_analysis(stats)
+        repeat, min_crashes = mgr.run_reliability_analysis()
     finally:
         for test in tests:
             test.cleanup()
@@ -310,7 +303,7 @@ def _stop_early(_):
     assert repeat == expected_repeat
     assert min_crashes == expected_min_crashes
     assert mgr._use_harness == result_harness
-    assert stats._iters == expected_iters * 11
+    assert mgr._status.iterations == expected_iters * 11
 
 
 def _ignore_arg(func):
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index 154fff48..fc0ca4f5 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -19,7 +19,12 @@
 from .strategies import Strategy, _load_strategies
 
 LOG = getLogger(__name__)
-pytestmark = mark.usefixtures("tmp_path_fm_config", "reporter_sequential_strftime")
+pytestmark = mark.usefixtures(
+    "reporter_sequential_strftime",
+    "tmp_path_fm_config",
+    "tmp_path_replay_status_db",
+    "tmp_path_reduce_status_db",
+)
 
 
 @mark.parametrize("is_hang", [True, False])
diff --git a/grizzly/replay/conftest.py b/grizzly/replay/conftest.py
index 0abd719b..479e5a63 100644
--- a/grizzly/replay/conftest.py
+++ b/grizzly/replay/conftest.py
@@ -20,11 +20,3 @@ def _grz_tmp(*subdir):
         return str(path)
 
     mocker.patch("grizzly.replay.replay.grz_tmp", _grz_tmp)
-
-
-@fixture
-def tmp_path_status_db(tmp_path, mocker):
-    """Use a temporary database file for testing."""
-    mocker.patch(
-        "grizzly.replay.replay.ReplayManager.STATUS_DB", new=str(tmp_path / "tmp.db")
-    )
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 25b456a4..81998224 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -22,7 +22,7 @@
 from .replay import ReplayManager
 from .test_replay import _fake_save_logs
 
-pytestmark = mark.usefixtures("tmp_path_grz_tmp", "tmp_path_status_db")
+pytestmark = mark.usefixtures("tmp_path_grz_tmp", "tmp_path_replay_status_db")
 
 
 def test_main_01(mocker, tmp_path):
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 0432be33..02c012b6 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -18,7 +18,7 @@
 from ..target import AssetManager, Result, Target
 from .replay import ReplayManager, ReplayResult
 
-pytestmark = mark.usefixtures("tmp_path_grz_tmp", "tmp_path_status_db")
+pytestmark = mark.usefixtures("tmp_path_grz_tmp", "tmp_path_replay_status_db")
 
 
 def _fake_save_logs(result_logs, _meta=False):

From 743b806a7d1006059ea952bfee54408cf2178032 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 17 Nov 2021 14:50:40 -0500
Subject: [PATCH 366/531] Add an iteration callback to replay, and use it in
 reduce.

---
 grizzly/reduce/core.py            |  9 ++++++---
 grizzly/reduce/test_reduce.py     | 26 +++++++++++++-------------
 grizzly/reduce/test_strategies.py | 12 ++++++------
 grizzly/replay/replay.py          |  4 ++++
 4 files changed, 29 insertions(+), 22 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 074b461e..f9a85380 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -207,6 +207,10 @@ def update_timeout(self, results):
             LOG.info("Updating max timeout to: %r", new_iter_timeout)
             self.server.timeout = new_iter_timeout
 
+    def _on_replay_iteration(self):
+        self._status.iterations += 1
+        self._status.report()
+
     def run_reliability_analysis(self):
         """Run several analysis passes of the current testcase to find `run` parameters.
 
@@ -296,10 +300,9 @@ def run_reliability_analysis(self):
                     exit_early=False,
                     idle_delay=self._idle_delay,
                     idle_threshold=self._idle_threshold,
+                    on_iteration_cb=self._on_replay_iteration,
                 )
                 try:
-                    self._status.iterations += replay.status.iteration
-                    self._status.report()
                     crashes = sum(x.count for x in results if x.expected)
                     if crashes and not self._any_crash and self._signature_desc is None:
                         first_expected = next(
@@ -495,8 +498,8 @@ def run(self, repeat=1, min_results=1):
                                     idle_threshold=self._idle_threshold,
                                     min_results=min_results,
                                     repeat=repeat,
+                                    on_iteration_cb=self._on_replay_iteration,
                                 )
-                                self._status.iterations += replay.status.iteration
                                 self._status.attempts += 1
                                 self.update_timeout(results)
                                 # get the first expected result (if any),
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index 469525e8..cc880e57 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -245,7 +245,6 @@ def test_analysis(
     """test that analysis sets reasonable params"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value.__enter__.return_value
-    replayer.status.iteration = 11
     crashes = []
     expected_iters = 0
     if harness_last_crashes is not None:
@@ -264,6 +263,7 @@ def replay_run(_tests, _time_limit, **kw):
         assert repeat <= len(crashes)
         assert not kw["exit_early"]
         for _ in range(repeat):
+            kw["on_iteration_cb"]()
             LOG.debug("interesting: %r", crashes[0])
             if crashes.pop(0):
                 log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
@@ -517,9 +517,9 @@ def test_repro(
     mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
-    replayer.status.iteration = 1
 
-    def replay_run(testcases, _time_limit, **_):
+    def replay_run(testcases, _time_limit, **kw):
+        kw["on_iteration_cb"]()
         for test in testcases:
             contents = test.get_file("test.html").data_file.read_text()
             # pylint: disable=logging-not-lazy
@@ -595,9 +595,9 @@ def test_report_01(mocker, tmp_path):
 
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
-    replayer.status.iteration = 1
 
-    def replay_run(_tests, _time_limit, **_kw):
+    def replay_run(_tests, _time_limit, **kw):
+        kw["on_iteration_cb"]()
         if replayer.run.call_count in {20, 40}:
             log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
             log_path.mkdir()
@@ -666,9 +666,9 @@ def test_report_02(mocker, tmp_path):
 
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
-    replayer.status.iteration = 1
 
-    def replay_run(_tests, _time_limit, **_kw):
+    def replay_run(_tests, _time_limit, **kw):
+        kw["on_iteration_cb"]()
         if replayer.run.call_count in {10, 20}:
             log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
             log_path.mkdir()
@@ -735,9 +735,9 @@ def test_quality_update(mocker, tmp_path):
     mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
-    replayer.status.iteration = 1
 
-    def replay_run(testcases, _time_limit, **_kw):
+    def replay_run(testcases, _time_limit, **kw):
+        kw["on_iteration_cb"]()
         for test in testcases:
             contents = test.get_file("test.html").data_file.read_text()
             if not contents.strip():
@@ -798,9 +798,9 @@ def test_include_assets_and_environ(mocker, tmp_path):
     mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
-    replayer.status.iteration = 1
 
-    def replay_run(testcases, _time_limit, **_kw):
+    def replay_run(testcases, _time_limit, **kw):
+        kw["on_iteration_cb"]()
         for test in testcases:
             contents = test.get_file("test.html").data_file.read_text()
             if not contents.strip():
@@ -938,9 +938,9 @@ def test_timeout_update(
     mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
-    replayer.status.iteration = 1
 
-    def replay_run(_testcases, _time_limit, **_):
+    def replay_run(_testcases, _time_limit, **kw):
+        kw["on_iteration_cb"]()
         LOG.debug("interesting true")
         log_path = tmp_path / ("crash%d_logs" % (replayer.run.call_count,))
         log_path.mkdir()
diff --git a/grizzly/reduce/test_strategies.py b/grizzly/reduce/test_strategies.py
index fc0ca4f5..264d8fd7 100644
--- a/grizzly/reduce/test_strategies.py
+++ b/grizzly/reduce/test_strategies.py
@@ -152,9 +152,9 @@ def test_list(
     mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
-    replayer.status.iteration = 1
 
-    def replay_run(testcases, _time_limit, **_):
+    def replay_run(testcases, _time_limit, **kw):
+        kw["on_iteration_cb"]()
         required_seen = False
         for test in testcases:
             contents = test.get_file("test.html").data_file.read_text()
@@ -329,9 +329,9 @@ def test_purge_unserved(
     mocker.patch("grizzly.reduce.strategies.lithium._contains_dd", return_value=True)
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
-    replayer.status.iteration = 1
 
-    def replay_run(testcases, _time_limit, **_):
+    def replay_run(testcases, _time_limit, **kw):
+        kw["on_iteration_cb"]()
         # test.html and opt.html should always contain one line.
         # return [] (no result) if either of them exist and are empty
         has_any = False
@@ -398,9 +398,9 @@ def test_dd_only(mocker, tmp_path):
     """test that only files containing DDBEGIN/END are reduced"""
     replayer = mocker.patch("grizzly.reduce.core.ReplayManager", autospec=True)
     replayer = replayer.return_value
-    replayer.status.iteration = 1
 
-    def replay_run(testcases, _time_limit, **_):
+    def replay_run(testcases, _time_limit, **kw):
+        kw["on_iteration_cb"]()
         for test in testcases:
             contents = test.get_file("test.html").data_file.read_text()
             LOG.debug("interesting if 'required' in %r", contents)
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 7a3f8852..de0a84e3 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -222,6 +222,7 @@ def run(
         expect_hang=False,
         idle_delay=0,
         idle_threshold=0,
+        on_iteration_cb=None,
     ):
         """Run testcase replay.
 
@@ -239,6 +240,7 @@ def run(
                                performed.
             idle_delay (int): Number of seconds to wait before polling for idle.
             idle_threshold (int): CPU usage threshold to mark the process as idle.
+            on_iteration_cb (callable): called every time a single iteration is run
 
         Returns:
             list: ReplayResults that were found running testcases.
@@ -277,6 +279,8 @@ def run(
             # perform iterations
             for _ in range(repeat):
                 self.status.iteration += 1
+                if on_iteration_cb is not None:
+                    on_iteration_cb()
                 if self.target.closed:
                     if self._harness is None:
                         location = runner.location(

From 020377c5d9e193968d4969bcaf688cc4c6d547bc Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 17 Nov 2021 15:58:54 -0500
Subject: [PATCH 367/531] Use global temp in Tox to speed up tests.

---
 tox.ini | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tox.ini b/tox.ini
index 77a22165..fcf3187a 100644
--- a/tox.ini
+++ b/tox.ini
@@ -4,7 +4,7 @@ skip_missing_interpreters = true
 tox_pip_extensions_ext_venv_update = true
 
 [testenv]
-commands = pytest -v --cache-clear --cov="{toxinidir}" --cov-config="{toxinidir}/pyproject.toml" --cov-report term-missing --basetemp="{envtmpdir}" {posargs}
+commands = pytest -v --cache-clear --cov="{toxinidir}" --cov-config="{toxinidir}/pyproject.toml" --cov-report term-missing {posargs}
 deps =
     pytest
     pytest-cov

From 90662d79f0a8a814461a9fa01916768b7b6bc57e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 18 Nov 2021 16:50:18 -0800
Subject: [PATCH 368/531] [sapphire] Simplify and rename check_request() ->
 lookup_resource()

---
 sapphire/job.py      | 90 +++++++++++++++++-----------------------
 sapphire/test_job.py | 99 ++++++++++++++++++++------------------------
 sapphire/worker.py   | 28 ++++---------
 3 files changed, 94 insertions(+), 123 deletions(-)

diff --git a/sapphire/job.py b/sapphire/job.py
index 9cdffcf8..2f0563a9 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -10,9 +10,9 @@
 from logging import getLogger
 from mimetypes import guess_type
 from os import walk
-from os.path import abspath, isdir, isfile
+from os.path import abspath, isdir
 from os.path import join as pathjoin
-from os.path import normpath, relpath, splitext
+from os.path import relpath, splitext
 from pathlib import Path
 from queue import Queue
 from threading import Event, Lock
@@ -136,56 +136,44 @@ def lookup_mime(cls, url):
             mime = guess_type(url)[0] or "application/octet-stream"
         return mime
 
-    def check_request(self, request):
-        to_serve = normpath(pathjoin(self.base_path, request))
-        if "\x00" not in to_serve and isfile(to_serve):
-            res = Resource(Resource.URL_FILE, to_serve, mime=self.lookup_mime(to_serve))
-            with self._pending.lock:
-                res.required = to_serve in self._pending.files
-            return res
+    def lookup_resource(self, path):
+        # check if path is a file in wwwroot
+        try:
+            local = Path(self.base_path) / path
+            if local.is_file():
+                local = local.resolve()
+                with self._pending.lock:
+                    required = str(local) in self._pending.files
+                return Resource(
+                    Resource.URL_FILE,
+                    local,
+                    mime=self.lookup_mime(path),
+                    required=required,
+                )
+        except OSError:  # pragma: no cover
+            # this is for compatibility with python versions < 3.8
+            # is_file() will raise if the path contains characters unsupported
+            # at the OS level
+            pass
+        # look for path in server map
         if self.server_map is not None:
-            if request in self.server_map.redirect:
-                return self.server_map.redirect[request]
-            if request in self.server_map.dynamic:
-                return self.server_map.dynamic[request]
-            # collect possible include matches
-            includes = tuple(
-                x for x in self.server_map.include if request.startswith(x)
-            )
-            if includes:
-                LOG.debug("potential include matches %r", includes)
-                # attempt to find match
-                url = request
-                while True:
-                    if url in includes:
-                        LOG.debug("found include match %r", url)
-                        location = (
-                            request.split(url, 1)[-1].lstrip("/") if url else request
-                        )
-                        # check location points to something
-                        if location:
-                            target = pathjoin(
-                                self.server_map.include[url].target, location
-                            )
-                            # if the mapping url is empty check the file exists
-                            if url or isfile(target):
-                                mime = self.server_map.include[url].mime
-                                if mime is None:
-                                    mime = self.lookup_mime(to_serve)
-                                return Resource(
-                                    Resource.URL_INCLUDE,
-                                    normpath(target),
-                                    mime=mime,
-                                    required=self.server_map.include[url].required,
-                                )
-                    if "/" in url:
-                        url = url.rsplit("/", 1)[0]
-                    elif url:
-                        # try empty mount point
-                        url = ""
-                    else:
-                        # include does not exist
-                        break
+            if path in self.server_map.redirect:
+                return self.server_map.redirect[path]
+            if path in self.server_map.dynamic:
+                return self.server_map.dynamic[path]
+            # search include paths for a match
+            for inc in (x for x in self.server_map.include if path.startswith(x)):
+                LOG.debug("checking include %r", inc)
+                file = path[len(inc) :].lstrip("/")
+                local = Path(self.server_map.include[inc].target) / file
+                if local.is_file():
+                    mime = self.server_map.include[inc].mime or self.lookup_mime(file)
+                    return Resource(
+                        Resource.URL_INCLUDE,
+                        local,
+                        mime=mime,
+                        required=self.server_map.include[inc].required,
+                    )
         return None
 
     def finish(self):
diff --git a/sapphire/test_job.py b/sapphire/test_job.py
index f39e5cab..75cbc77c 100644
--- a/sapphire/test_job.py
+++ b/sapphire/test_job.py
@@ -2,12 +2,11 @@
 """
 Job unit tests
 """
-# pylint: disable=protected-access
 
-import platform
 from pathlib import Path
+from platform import system
 
-import pytest
+from pytest import mark, raises
 
 from .job import Job, Served
 from .server_map import Resource, ServerMap
@@ -18,10 +17,11 @@ def test_job_01(tmp_path):
     job = Job(str(tmp_path))
     assert not job.forever
     assert job.status == Served.ALL
-    assert job.check_request("") is None
-    assert job.check_request("test") is None
-    assert job.check_request("test/test/") is None
-    assert job.check_request("test/../../") is None
+    assert job.lookup_resource("") is None
+    assert job.lookup_resource("test") is None
+    assert job.lookup_resource("test/test/") is None
+    assert job.lookup_resource("test/../../") is None
+    assert job.lookup_resource("\x00\x0B\xAD\xF0\x0D") is None
     assert not job.is_forbidden(str(tmp_path))
     assert not job.is_forbidden(str(tmp_path / "missing_file"))
     assert job.pending == 0
@@ -48,10 +48,10 @@ def test_job_02(tmp_path):
     )
     assert job.status == Served.NONE
     assert not job.is_complete()
-    resource = job.check_request("req_file_1.txt")
+    resource = job.lookup_resource("req_file_1.txt")
     assert resource.required
     assert job.pending == 2
-    assert resource.target == str(tmp_path / "req_file_1.txt")
+    assert resource.target == tmp_path / "req_file_1.txt"
     assert resource.type == Resource.URL_FILE
     assert not job.is_forbidden(str(req1_path))
     assert not job.remove_pending("no_file.test")
@@ -63,13 +63,13 @@ def test_job_02(tmp_path):
     assert job.status == Served.ALL
     assert job.pending == 0
     assert job.remove_pending(str(req1_path))
-    resource = job.check_request("opt_file_1.txt")
+    resource = job.lookup_resource("opt_file_1.txt")
     assert not resource.required
-    assert resource.target == str(opt1_path)
+    assert resource.target == opt1_path
     assert resource.type == Resource.URL_FILE
     assert job.remove_pending(str(opt1_path))
-    resource = job.check_request("nested/opt_file_2.txt")
-    assert resource.target == str(opt2_path)
+    resource = job.lookup_resource("nested/opt_file_2.txt")
+    assert resource.target == opt2_path
     assert resource.type == Resource.URL_FILE
     assert not resource.required
     job.finish()
@@ -83,9 +83,9 @@ def test_job_03(tmp_path):
     smap.set_redirect("two", "reqfile.txt")
     job = Job(str(tmp_path), server_map=smap)
     assert job.status == Served.NONE
-    resource = job.check_request("one")
+    resource = job.lookup_resource("one")
     assert resource.type == Resource.URL_REDIRECT
-    resource = job.check_request("two")
+    resource = job.lookup_resource("two")
     assert resource is not None
     assert resource.type == Resource.URL_REDIRECT
     assert job.pending == 1
@@ -117,37 +117,39 @@ def test_job_04(mocker, tmp_path):
     smap = ServerMap()
     smap.set_include("testinc", str(srv_include))
     # add manually to avoid sanity checks in ServerMap.set_include()
-    smap.include["testinc/fakedir"] = Resource(Resource.URL_INCLUDE, str(srv_include))
-    smap.include["testinc/1/2/3"] = Resource(Resource.URL_INCLUDE, str(srv_include))
-    smap.include[""] = Resource(Resource.URL_INCLUDE, str(srv_include))
+    smap.include["testinc/fakedir"] = Resource(Resource.URL_INCLUDE, srv_include)
+    smap.include["testinc/1/2/3"] = Resource(Resource.URL_INCLUDE, srv_include)
+    smap.include[""] = Resource(Resource.URL_INCLUDE, srv_include)
     smap.set_include("testinc/inc2", str(srv_include_2))
     job = Job(str(srv_root), server_map=smap)
     assert job.status == Served.NONE
+    # test include path pointing to a missing file
+    assert job.lookup_resource("testinc/missing") is None
     # test includes that map to 'srv_include'
     for incl, inc_path in smap.include.items():
         if inc_path != str(srv_include):  # only check 'srv_include' mappings
             continue
-        resource = job.check_request("/".join([incl, "test_file.txt"]))
+        resource = job.lookup_resource("/".join([incl, "test_file.txt"]))
         assert resource.type == Resource.URL_INCLUDE
-        assert resource.target == str(inc_1)
+        assert resource.target == inc_1
     # test nested include path pointing to a different include
-    resource = job.check_request("testinc/inc2/test_file_2.txt")
+    resource = job.lookup_resource("testinc/inc2/test_file_2.txt")
     assert resource.type == Resource.URL_INCLUDE
-    assert resource.target == str(inc_2)
+    assert resource.target == inc_2
     # test redirect root without leading '/'
-    resource = job.check_request("test_file.txt")
+    resource = job.lookup_resource("test_file.txt")
     assert resource.type == Resource.URL_INCLUDE
-    assert resource.target == str(srv_include / "test_file.txt")
+    assert resource.target == srv_include / "test_file.txt"
     # test redirect with file in a nested directory
-    resource = job.check_request("/".join(["testinc", "nested", "nested_file.txt"]))
+    resource = job.lookup_resource("/".join(["testinc", "nested", "nested_file.txt"]))
     assert resource.type == Resource.URL_INCLUDE
-    assert resource.target == str(nst_1)
+    assert resource.target == nst_1
     assert not job.is_forbidden(str(srv_root / ".." / "test" / "test_file.txt"))
     assert not job.is_forbidden(str(srv_include / ".." / "root" / "req_file.txt"))
 
 
 def test_job_05(tmp_path):
-    """test Job.check_request() with tricky includes"""
+    """test Job.lookup_resource() with tricky includes"""
     srv_root = tmp_path / "root"
     srv_root.mkdir()
     req = srv_root / "req_file.txt"
@@ -163,11 +165,11 @@ def test_job_05(tmp_path):
     smap = ServerMap()
     smap.include["inc"] = Resource(Resource.URL_INCLUDE, str(inc_dir))
     job = Job(str(srv_root), server_map=smap)
-    resource = job.check_request("inc/sub/include.js")
+    resource = job.lookup_resource("inc/sub/include.js")
     assert resource.type == Resource.URL_INCLUDE
-    assert resource.target == str(inc_file1)
+    assert resource.target == inc_file1
     # test checking only the include url
-    assert job.check_request("inc") is None
+    assert job.lookup_resource("inc") is None
     # file and include file collision (files should always win)
     smap.include.clear()
     inc_a = inc_dir / "a.bin"
@@ -175,22 +177,13 @@ def test_job_05(tmp_path):
     file_a = srv_root / "a.bin"
     file_a.write_bytes(b"a")
     smap.include["/"] = Resource(Resource.URL_INCLUDE, str(inc_dir))
-    resource = job.check_request("a.bin")
+    resource = job.lookup_resource("a.bin")
     assert resource.type == Resource.URL_FILE
-    assert resource.target == str(file_a)
-    # inc and inc subdir collision
-    # TODO: This can fail. How do we detect or support it?
-    # smap.include.clear()
-    # (inc_dir / "c").mkdir()
-    # inc_c_d = (inc_dir / "c" / "d.bin")
-    # inc_c_d.write_bytes(b"a")
-    # inc_d = (inc_dir / "d.bin")
-    # inc_d.write_bytes(b"a")
-    # smap.include["c"] = Resource(Resource.URL_INCLUDE, str(inc_dir))
-    # smap.include[""] = Resource(Resource.URL_INCLUDE, str(inc_dir / "c"))
-    # resource = job.check_request("c/d.bin")
-    # assert resource.type == Resource.URL_INCLUDE
-    # assert resource.target == str(inc_c_d)
+    assert resource.target == file_a
+    # TODO: inc and inc subdir collision can fail.
+    # /inc/a file
+    # /inc   a/file
+    # Should we detect and support it? Does it matter?
 
 
 def test_job_06(tmp_path):
@@ -201,11 +194,11 @@ def test_job_06(tmp_path):
     job = Job(str(tmp_path), server_map=smap)
     assert job.status == Served.ALL
     assert job.pending == 0
-    resource = job.check_request("cb1")
+    resource = job.lookup_resource("cb1")
     assert resource.type == Resource.URL_DYNAMIC
     assert callable(resource.target)
     assert isinstance(resource.mime, str)
-    resource = job.check_request("cb2")
+    resource = job.lookup_resource("cb2")
     assert resource is not None
     assert resource.type == Resource.URL_DYNAMIC
     assert callable(resource.target)
@@ -223,14 +216,14 @@ def test_job_07(tmp_path):
     job = Job(str(srv_root))
     assert job.status == Served.NONE
     assert job.pending == 1
-    resource = job.check_request("../no_access.txt")
-    assert resource.target == str(no_access)
+    resource = job.lookup_resource("../no_access.txt")
+    assert resource.target == no_access
     assert resource.type == Resource.URL_FILE
     assert not job.is_forbidden(str(test_1))
-    assert job.is_forbidden(str(srv_root / "../no_access.txt"))
+    assert job.is_forbidden(str(srv_root / ".." / "no_access.txt"))
 
 
-@pytest.mark.skipif(platform.system() == "Windows", reason="Unsupported on Windows")
+@mark.skipif(system() == "Windows", reason="Unsupported on Windows")
 def test_job_08(tmp_path):
     """test Job with file names containing invalid characters"""
     test_file = tmp_path / "test.txt"
@@ -239,12 +232,12 @@ def test_job_08(tmp_path):
     job = Job(str(tmp_path))
     assert job.status == Served.NONE
     assert job.pending == 1
-    assert job.check_request("test.txt").target == str(test_file)
+    assert job.lookup_resource("test.txt").target == test_file
 
 
 def test_job_09():
     """test Job with missing directory"""
-    with pytest.raises(OSError):
+    with raises(OSError):
         Job("missing")
 
 
diff --git a/sapphire/worker.py b/sapphire/worker.py
index 9cd9f0d7..edb16d51 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -6,9 +6,6 @@
 Sapphire HTTP server worker
 """
 from logging import getLogger
-from os import stat
-from os.path import isfile
-from pathlib import Path
 from re import compile as re_compile
 from socket import error as sock_error
 from socket import timeout as sock_timeout
@@ -124,12 +121,12 @@ def handle_request(cls, conn, serv_job):
                 request, query = request.split("?", 1)
             else:
                 query = ""
-            LOG.debug("check_request(%r)", request)
-            resource = serv_job.check_request(request)
+            LOG.debug("lookup_resource(%r)", request)
+            resource = serv_job.lookup_resource(request)
             if resource is None:
                 LOG.debug("resource is None")  # 404
             elif resource.type in (Resource.URL_FILE, Resource.URL_INCLUDE):
-                finish_job = serv_job.remove_pending(resource.target)
+                finish_job = serv_job.remove_pending(str(resource.target))
             elif resource.type in (Resource.URL_DYNAMIC, Resource.URL_REDIRECT):
                 finish_job = serv_job.remove_pending(request)
             else:  # pragma: no cover
@@ -150,15 +147,8 @@ def handle_request(cls, conn, serv_job):
                 LOG.debug("404 %r (%d to go)", request, serv_job.pending)
                 return
             if resource.type in (Resource.URL_FILE, Resource.URL_INCLUDE):
-                LOG.debug("target %r", resource.target)
-                # isfile() check for Resource.URL_FILE done by serv_job.check_request()
-                if resource.type == Resource.URL_INCLUDE and not isfile(
-                    resource.target
-                ):
-                    conn.sendall(cls._4xx_page(404, "Not Found", serv_job.auto_close))
-                    LOG.debug("404 %r (%d to go)", request, serv_job.pending)
-                    return
-                if serv_job.is_forbidden(resource.target):
+                LOG.debug("target %r", str(resource.target))
+                if serv_job.is_forbidden(str(resource.target)):
                     # NOTE: this does info leak if files exist on disk.
                     # We could replace 403 with 404 if it turns out we care but this
                     # is meant to run locally and only be accessible from localhost
@@ -189,18 +179,18 @@ def handle_request(cls, conn, serv_job):
 
             # at this point we know "resource.target" maps to a file on disk
             # serve the file
-            data_size = stat(resource.target).st_size
+            data_size = resource.target.stat().st_size
             LOG.debug(
                 "sending: %s bytes, mime: %r", format(data_size, ","), resource.mime
             )
-            with open(resource.target, "rb") as in_fp:
+            with resource.target.open("rb") as in_fp:
                 conn.sendall(cls._200_header(data_size, resource.mime))
                 offset = 0
                 while offset < data_size:
                     conn.sendall(in_fp.read(cls.DEFAULT_TX_SIZE))
                     offset = in_fp.tell()
-            LOG.debug("200 %r (%d to go)", resource.target, serv_job.pending)
-            serv_job.mark_served(Path(resource.target))
+            LOG.debug("200 %r (%d to go)", str(resource.target), serv_job.pending)
+            serv_job.mark_served(resource.target)
 
         except (sock_error, sock_timeout):
             _, exc_obj, exc_tb = exc_info()

From 1dbf472dec5a2bf94736bd9219539ae950756fd4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Sat, 20 Nov 2021 17:00:21 -0800
Subject: [PATCH 369/531] [tests] Update Sapphire test client path handling

---
 sapphire/conftest.py      |  6 ++--
 sapphire/test_sapphire.py | 72 ++++++++++++++++++++++-----------------
 2 files changed, 42 insertions(+), 36 deletions(-)

diff --git a/sapphire/conftest.py b/sapphire/conftest.py
index 071661e0..c357770d 100644
--- a/sapphire/conftest.py
+++ b/sapphire/conftest.py
@@ -12,7 +12,6 @@
 import time
 from http.client import BadStatusLine
 from urllib.error import HTTPError, URLError
-from urllib.parse import quote
 from urllib.request import urlopen
 
 import pytest
@@ -97,11 +96,10 @@ def _handle_request(
                     # if t_file.md5_org is set to anything but None the test client
                     # will calculate the md5 hash
                     data_hash = hashlib.md5() if t_file.md5_org is not None else None
-                    target_url = quote(t_file.url)
                 try:
                     if t_file.custom_request is None:
                         with urlopen(
-                            "http://%s:%d/%s" % (addr, port, target_url), timeout=10
+                            "http://%s:%d/%s" % (addr, port, t_file.url), timeout=10
                         ) as cli:
                             resp_code = cli.getcode()
                             content_type = cli.info().get("Content-Type")
@@ -170,7 +168,7 @@ def _handle_request(
                             exc_type.__name__,
                             exc_obj,
                             exc_tb.tb_lineno,
-                            t_file.url,
+                            t_file.file,
                         )
                         if indicate_failure:
                             if not skip_served or t_file.code is None:
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 7539d647..f482c4ed 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -9,6 +9,7 @@
 import random
 import socket
 import threading
+from urllib.parse import quote, urlparse
 
 import pytest
 
@@ -19,23 +20,28 @@
 
 
 class _TestFile:
-    def __init__(self, url):
+    def __init__(self, url, url_prefix=None):
         self.code = None
         self.content_type = None
         self.custom_request = None
+        if url_prefix:
+            self.file = "".join((url_prefix, url))
+        else:
+            self.file = url
         self.len_org = 0  # original file length
         self.len_srv = 0  # served file length
         self.lock = threading.Lock()
         self.md5_org = None
         self.md5_srv = None
         self.requested = 0  # number of time file was requested
-        self.url = url
+        url = urlparse(self.file.replace("\\", "/"))
+        self.url = (
+            "?".join((quote(url.path), url.query)) if url.query else quote(url.path)
+        )
 
 
 def _create_test(fname, path, data=b"Test!", calc_hash=False, url_prefix=None):
-    test = _TestFile(fname)
-    if url_prefix is not None:
-        test.url = "".join([url_prefix, fname])
+    test = _TestFile(fname, url_prefix=url_prefix)
     with (path / fname).open("w+b") as out_fp:
         out_fp.write(data)
         test.len_org = out_fp.tell()
@@ -83,7 +89,7 @@ def test_sapphire_02(client, tmp_path):
     files_to_serve = list()
     for i in range(3):
         files_to_serve.append(_create_test("test_case_%d.html" % i, tmp_path))
-    optional = [files_to_serve[0].url]
+    optional = [files_to_serve[0].file]
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve, in_order=True)
         status, served_list = serv.serve_path(str(tmp_path), optional_files=optional)
@@ -100,7 +106,7 @@ def test_sapphire_03(client, tmp_path):
     files_to_serve = list()
     for i in range(3):
         files_to_serve.append(_create_test("test_case_%d.html" % i, tmp_path))
-    optional = [files_to_serve[0].url]
+    optional = [files_to_serve[0].file]
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve[1:])
         status, served_list = serv.serve_path(str(tmp_path), optional_files=optional)
@@ -123,7 +129,7 @@ def test_sapphire_04(client, tmp_path):
         client.launch("127.0.0.1", serv.port, files_to_serve, in_order=True)
         assert serv.serve_path(str(tmp_path))[0] == Served.ALL
     assert client.wait(timeout=10)
-    assert "does_not_exist.html" in files_to_serve[0].url
+    assert "does_not_exist.html" in files_to_serve[0].file
     assert files_to_serve[0].code == 404
     assert files_to_serve[1].code == 200
 
@@ -148,9 +154,9 @@ def test_sapphire_05(client, tmp_path):
     assert status == Served.ALL
     assert len(files_served) == 1
     assert client.wait(timeout=10)
-    assert os.path.basename(__file__) in files_to_serve[0].url
+    assert os.path.basename(__file__) in files_to_serve[0].file
     assert files_to_serve[0].code == 403
-    assert "no_access.html" in files_to_serve[1].url
+    assert "no_access.html" in files_to_serve[1].file
     assert files_to_serve[1].code == 403
     assert files_to_serve[2].code == 200
 
@@ -214,7 +220,7 @@ def test_sapphire_09(client, tmp_path):
         t_data = "".join(random.choice("ABCD1234") for _ in range(test["size"])).encode(
             "ascii"
         )
-        (tmp_path / test["file"].url).write_bytes(t_data)
+        (tmp_path / test["file"].file).write_bytes(t_data)
         test["file"].md5_org = hashlib.md5(t_data).hexdigest()
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [test["file"] for test in tests])
@@ -232,7 +238,7 @@ def test_sapphire_10(client, tmp_path):
     """test serving a large (100MB) file"""
     t_file = _TestFile("test_case.html")
     data_hash = hashlib.md5()
-    with (tmp_path / t_file.url).open("wb") as test_fp:
+    with (tmp_path / t_file.file).open("wb") as test_fp:
         # write 100MB of 'A'
         data = b"A" * (100 * 1024)  # 100KB of 'A'
         for _ in range(1024):
@@ -283,7 +289,7 @@ def test_sapphire_13(client, tmp_path):
     for test in files_to_serve:
         assert test.code == 200
         assert test.len_srv == test.len_org
-        file_ext = os.path.splitext(test.url)[-1]
+        file_ext = os.path.splitext(test.file)[-1]
         content_type = {".html": "text/html"}.get(file_ext, "application/octet-stream")
         content_types.add(content_type)
         assert test.content_type == content_type
@@ -318,7 +324,7 @@ def test_sapphire_15(client, tmp_path):
             client.close()
             assert test.code == 200
             assert test.len_srv == test.len_org
-            (tmp_path / test.url).unlink()
+            (tmp_path / test.file).unlink()
 
 
 def test_sapphire_16(client, tmp_path):
@@ -344,7 +350,7 @@ def test_sapphire_17(client, tmp_path):
             "redir_test_case.html", tmp_path, data=b"Redirect DATA!"
         )
         redir_test = _TestFile("redirect_test")
-        smap.set_redirect(redir_test.url, redir_target.url, required=True)
+        smap.set_redirect(redir_test.file, redir_target.file, required=True)
         files_to_serve.append(redir_test)
         test = _create_test("test_case.html", tmp_path)
         files_to_serve.append(test)
@@ -468,7 +474,7 @@ def dr_callback(data):
         files = [test_dr]
     else:
         test = _create_test("test_case.html", tmp_path)
-        optional = [test_dr.url]
+        optional = [test_dr.file]
         files = [test_dr, test]
     # test request
     with Sapphire(timeout=10) as serv:
@@ -491,7 +497,7 @@ def test_sapphire_20(client_factory, tmp_path):
     client_defer = client_factory(rx_size=2)
     # server should shutdown while this file is being served
     test_defer = _create_test("defer_test.html", tmp_path)
-    optional = [test_defer.url]
+    optional = [test_defer.file]
     test = _create_test("test_case.html", tmp_path, data=b"112233")
     with Sapphire(timeout=10) as serv:
         # this test needs to wait just long enough to have the required file served
@@ -512,7 +518,7 @@ def test_sapphire_21(client, tmp_path):
     """test handling an invalid request"""
     bad_test = _TestFile("bad.html")
     bad_test.custom_request = b"a bad request...0+%\xef\xb7\xba\r\n"
-    optional = [bad_test.url]
+    optional = [bad_test.file]
     test = _create_test("test_case.html", tmp_path)
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [bad_test, test], in_order=True)
@@ -526,7 +532,7 @@ def test_sapphire_22(client, tmp_path):
     """test handling an empty request"""
     bad_test = _TestFile("bad.html")
     bad_test.custom_request = b""
-    optional = [bad_test.url]
+    optional = [bad_test.file]
     test = _create_test("test_case.html", tmp_path)
     with Sapphire(timeout=10) as serv:
         client.launch(
@@ -595,12 +601,12 @@ def _dyn_test_cb(_):
             redir_target = _create_test("redir_%03d.html" % i, tmp_path, data=b"AA")
             to_serve.append(_TestFile("redir_%03d" % i))
             smap.set_redirect(
-                to_serve[-1].url, redir_target.url, required=random.getrandbits(1) > 0
+                to_serve[-1].file, redir_target.file, required=random.getrandbits(1) > 0
             )
             # add dynamic responses
             to_serve.append(_TestFile("dynm_%03d" % i))
             smap.set_dynamic_response(
-                to_serve[-1].url, _dyn_test_cb, mime_type="text/plain"
+                to_serve[-1].file, _dyn_test_cb, mime_type="text/plain"
             )
         clients = list()
         for _ in range(100):  # number of clients to spawn
@@ -686,14 +692,18 @@ def _test_callback():
     assert test.len_srv == test.len_org
 
 
-def test_sapphire_29(client, tmp_path):
-    """test interesting file names"""
-    to_serve = [
+@pytest.mark.parametrize(
+    "file_name",
+    [
         # space in file name
-        _create_test("test case.html", tmp_path),
+        "test case.html",
         # non-alphanumeric chars (valid characters to use on filesystem)
-        _create_test("!@#$%^&(_+-=[]),;'~`{}", tmp_path),
-    ]
+        "!@$%^&(_+-=[]),'~`{}",
+    ],
+)
+def test_sapphire_29(client, tmp_path, file_name):
+    """test interesting file names"""
+    to_serve = [_create_test(file_name, tmp_path)]
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, to_serve)
         assert serv.serve_path(str(tmp_path))[0] == Served.ALL
@@ -703,18 +713,16 @@ def test_sapphire_29(client, tmp_path):
 
 def test_sapphire_30(client, tmp_path):
     """test interesting path string"""
-    all_bytes = "".join(chr(i) for i in range(256))
+    path = "".join(chr(i) for i in range(256))
     to_serve = [
         # should not trigger crash
-        _TestFile(all_bytes),
+        _TestFile(path),
         # used to keep server running
         _create_test("a.html", tmp_path),
     ]
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, to_serve, in_order=True)
-        assert (
-            serv.serve_path(str(tmp_path), optional_files=[all_bytes])[0] == Served.ALL
-        )
+        assert serv.serve_path(str(tmp_path), optional_files=[path])[0] == Served.ALL
     assert client.wait(timeout=10)
     assert all(t_file.code is not None for t_file in to_serve)
 

From eb9bf5a180043235ab991f04db64851a749a072d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Sat, 20 Nov 2021 17:00:49 -0800
Subject: [PATCH 370/531] [sapphire] Fix redirecting to files with non-ASCII
 file names

---
 sapphire/job.py           |  2 +-
 sapphire/test_sapphire.py | 42 +++++++++++++++------------
 sapphire/worker.py        | 60 ++++++++++++++++++---------------------
 3 files changed, 53 insertions(+), 51 deletions(-)

diff --git a/sapphire/job.py b/sapphire/job.py
index 2f0563a9..56d7b78d 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -150,7 +150,7 @@ def lookup_resource(self, path):
                     mime=self.lookup_mime(path),
                     required=required,
                 )
-        except OSError:  # pragma: no cover
+        except ValueError:  # pragma: no cover
             # this is for compatibility with python versions < 3.8
             # is_file() will raise if the path contains characters unsupported
             # at the OS level
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index f482c4ed..344972b6 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -340,29 +340,33 @@ def test_sapphire_16(client, tmp_path):
     assert test.len_srv == test.len_org
 
 
-def test_sapphire_17(client, tmp_path):
+@pytest.mark.parametrize(
+    "path",
+    [
+        # simple path
+        "test.html",
+        # non-alphanumeric chars (valid characters to use on filesystem)
+        "!@$%^&(_+-=[]),'~`{}",
+        # extended ascii chars
+        "€d’é-ñÿ",
+    ],
+)
+def test_sapphire_17(client, tmp_path, path):
     """test required mapped redirects"""
     smap = ServerMap()
     with Sapphire(timeout=10) as serv:
-        files_to_serve = list()
-        # redir_target will be requested indirectly via the redirect
-        redir_target = _create_test(
-            "redir_test_case.html", tmp_path, data=b"Redirect DATA!"
-        )
-        redir_test = _TestFile("redirect_test")
-        smap.set_redirect(redir_test.file, redir_target.file, required=True)
-        files_to_serve.append(redir_test)
-        test = _create_test("test_case.html", tmp_path)
-        files_to_serve.append(test)
-        client.launch("127.0.0.1", serv.port, files_to_serve)
-        status, served_list = serv.serve_path(str(tmp_path), server_map=smap)
+        # target will be requested indirectly via the redirect
+        target = _create_test(path, tmp_path, data=b"Redirect DATA!")
+        redirect = _TestFile("redirect")
+        # point "redirect" at target
+        smap.set_redirect("redirect", target.file, required=True)
+        client.launch("127.0.0.1", serv.port, [redirect])
+        status, served = serv.serve_path(str(tmp_path), server_map=smap)
     assert status == Served.ALL
-    assert len(served_list) == len(files_to_serve)
+    assert len(served) == 1
     assert client.wait(timeout=10)
-    assert test.code == 200
-    assert test.len_srv == test.len_org
-    assert redir_test.code == 200
-    assert redir_test.len_srv == redir_target.len_org
+    assert redirect.code == 200
+    assert redirect.len_srv == target.len_org
 
 
 def test_sapphire_18(client, tmp_path):
@@ -699,6 +703,8 @@ def _test_callback():
         "test case.html",
         # non-alphanumeric chars (valid characters to use on filesystem)
         "!@$%^&(_+-=[]),'~`{}",
+        # extended ascii chars
+        "€d’é-ñÿ",
     ],
 )
 def test_sapphire_29(client, tmp_path, file_name):
diff --git a/sapphire/worker.py b/sapphire/worker.py
index edb16d51..a070106f 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -12,7 +12,7 @@
 from sys import exc_info
 from threading import Thread, ThreadError, active_count
 from time import sleep
-from urllib.parse import unquote_plus
+from urllib.parse import quote, unquote, urlparse
 
 from .server_map import Resource
 
@@ -29,7 +29,7 @@ class WorkerError(Exception):
 class Worker:
     DEFAULT_REQUEST_LIMIT = 0x1000  # 4KB
     DEFAULT_TX_SIZE = 0x10000  # 64KB
-    REQ_PATTERN = re_compile(b"^GET\\s/(?P<request>\\S*)\\sHTTP/1")
+    REQ_PATTERN = re_compile(b"^GET\\s/(?P<url>\\S*)\\sHTTP/1")
 
     __slots__ = ("_conn", "_thread")
 
@@ -105,8 +105,9 @@ def handle_request(cls, conn, serv_job):
                 serv_job.accepting.set()
                 return
 
-            request = cls.REQ_PATTERN.match(raw_request)
-            if request is None:
+            # check if request can be handled
+            raw_url = cls.REQ_PATTERN.match(raw_request)
+            if raw_url is None:
                 serv_job.accepting.set()
                 conn.sendall(cls._4xx_page(400, "Bad Request", serv_job.auto_close))
                 LOG.debug(
@@ -116,35 +117,30 @@ def handle_request(cls, conn, serv_job):
                 )
                 return
 
-            request = unquote_plus(request.group("request").decode("ascii"))
-            if "?" in request:
-                request, query = request.split("?", 1)
-            else:
-                query = ""
-            LOG.debug("lookup_resource(%r)", request)
-            resource = serv_job.lookup_resource(request)
-            if resource is None:
-                LOG.debug("resource is None")  # 404
-            elif resource.type in (Resource.URL_FILE, Resource.URL_INCLUDE):
-                finish_job = serv_job.remove_pending(str(resource.target))
-            elif resource.type in (Resource.URL_DYNAMIC, Resource.URL_REDIRECT):
-                finish_job = serv_job.remove_pending(request)
-            else:  # pragma: no cover
-                # this should never happen
-                raise WorkerError("Unknown resource type %r" % (resource.type,))
-
-            if finish_job and serv_job.forever:
-                LOG.debug("serv_job.forever is set, resetting finish_job")
-                finish_job = False
+            # lookup resource
+            url = urlparse(unquote(raw_url.group("url").decode("ascii")))
+            LOG.debug("lookup_resource(%r)", url.path)
+            resource = serv_job.lookup_resource(url.path)
+            if resource:
+                if resource.type in (Resource.URL_FILE, Resource.URL_INCLUDE):
+                    finish_job = serv_job.remove_pending(str(resource.target))
+                elif resource.type in (Resource.URL_DYNAMIC, Resource.URL_REDIRECT):
+                    finish_job = serv_job.remove_pending(url.path)
+                else:  # pragma: no cover
+                    # this should never happen
+                    raise WorkerError("Unknown resource type %r" % (resource.type,))
+                if serv_job.forever:
+                    finish_job = False
 
             if not finish_job:
                 serv_job.accepting.set()
             else:
                 LOG.debug("expecting to finish")
 
+            # send response
             if resource is None:
                 conn.sendall(cls._4xx_page(404, "Not Found", serv_job.auto_close))
-                LOG.debug("404 %r (%d to go)", request, serv_job.pending)
+                LOG.debug("404 %r (%d to go)", url.path, serv_job.pending)
                 return
             if resource.type in (Resource.URL_FILE, Resource.URL_INCLUDE):
                 LOG.debug("target %r", str(resource.target))
@@ -153,27 +149,27 @@ def handle_request(cls, conn, serv_job):
                     # We could replace 403 with 404 if it turns out we care but this
                     # is meant to run locally and only be accessible from localhost
                     conn.sendall(cls._4xx_page(403, "Forbidden", serv_job.auto_close))
-                    LOG.debug("403 %r (%d to go)", request, serv_job.pending)
+                    LOG.debug("403 %r (%d to go)", url.path, serv_job.pending)
                     return
             elif resource.type == Resource.URL_REDIRECT:
-                conn.sendall(cls._307_redirect(resource.target))
+                conn.sendall(cls._307_redirect(quote(resource.target)))
                 LOG.debug(
                     "307 %r -> %r (%d to go)",
-                    request,
+                    url.path,
                     resource.target,
                     serv_job.pending,
                 )
                 return
             elif resource.type == Resource.URL_DYNAMIC:
                 # pass query string to callback
-                data = resource.target(query)
+                data = resource.target(url.query)
                 if not isinstance(data, bytes):
-                    LOG.debug("dynamic request: %r", request)
+                    LOG.debug("dynamic request: %r", url.path)
                     raise TypeError("dynamic request callback must return 'bytes'")
                 conn.sendall(cls._200_header(len(data), resource.mime))
                 conn.sendall(data)
                 LOG.debug(
-                    "200 %r - dynamic request (%d to go)", request, serv_job.pending
+                    "200 %r - dynamic request (%d to go)", url.path, serv_job.pending
                 )
                 return
 
@@ -189,7 +185,7 @@ def handle_request(cls, conn, serv_job):
                 while offset < data_size:
                     conn.sendall(in_fp.read(cls.DEFAULT_TX_SIZE))
                     offset = in_fp.tell()
-            LOG.debug("200 %r (%d to go)", str(resource.target), serv_job.pending)
+            LOG.debug("200 %r (%d to go)", url.path, serv_job.pending)
             serv_job.mark_served(resource.target)
 
         except (sock_error, sock_timeout):

From d5b36dcf4e1e446bb4ce22f3bc43a101da481cd8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 22 Nov 2021 10:07:32 -0800
Subject: [PATCH 371/531] [sapphire] Fix requesting includes with non-ASCII
 file names

---
 sapphire/job.py      | 21 +++++++++++++--------
 sapphire/test_job.py |  2 ++
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/sapphire/job.py b/sapphire/job.py
index 56d7b78d..94801453 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -166,14 +166,19 @@ def lookup_resource(self, path):
                 LOG.debug("checking include %r", inc)
                 file = path[len(inc) :].lstrip("/")
                 local = Path(self.server_map.include[inc].target) / file
-                if local.is_file():
-                    mime = self.server_map.include[inc].mime or self.lookup_mime(file)
-                    return Resource(
-                        Resource.URL_INCLUDE,
-                        local,
-                        mime=mime,
-                        required=self.server_map.include[inc].required,
-                    )
+                try:
+                    if not local.is_file():
+                        continue
+                except ValueError:  # pragma: no cover
+                    # python versions < 3.8 compatibility
+                    continue
+                # file exists, look up resource
+                return Resource(
+                    Resource.URL_INCLUDE,
+                    local.resolve(),
+                    mime=self.server_map.include[inc].mime or self.lookup_mime(file),
+                    required=self.server_map.include[inc].required,
+                )
         return None
 
     def finish(self):
diff --git a/sapphire/test_job.py b/sapphire/test_job.py
index 75cbc77c..bf7c9a93 100644
--- a/sapphire/test_job.py
+++ b/sapphire/test_job.py
@@ -125,6 +125,8 @@ def test_job_04(mocker, tmp_path):
     assert job.status == Served.NONE
     # test include path pointing to a missing file
     assert job.lookup_resource("testinc/missing") is None
+    # test include path pointing to an invalid file name
+    assert job.lookup_resource("testinc/\x00\x0B\xAD\xF0\x0D") is None
     # test includes that map to 'srv_include'
     for incl, inc_path in smap.include.items():
         if inc_path != str(srv_include):  # only check 'srv_include' mappings

From 8d4e22913033e9b3913fd4750e5b6a45a822fd81 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 22 Nov 2021 11:12:20 -0800
Subject: [PATCH 372/531] [sapphire] Re-order some operations in
 handle_request()

---
 sapphire/worker.py | 49 +++++++++++++++++++++-------------------------
 1 file changed, 22 insertions(+), 27 deletions(-)

diff --git a/sapphire/worker.py b/sapphire/worker.py
index a070106f..6af2f988 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -141,16 +141,6 @@ def handle_request(cls, conn, serv_job):
             if resource is None:
                 conn.sendall(cls._4xx_page(404, "Not Found", serv_job.auto_close))
                 LOG.debug("404 %r (%d to go)", url.path, serv_job.pending)
-                return
-            if resource.type in (Resource.URL_FILE, Resource.URL_INCLUDE):
-                LOG.debug("target %r", str(resource.target))
-                if serv_job.is_forbidden(str(resource.target)):
-                    # NOTE: this does info leak if files exist on disk.
-                    # We could replace 403 with 404 if it turns out we care but this
-                    # is meant to run locally and only be accessible from localhost
-                    conn.sendall(cls._4xx_page(403, "Forbidden", serv_job.auto_close))
-                    LOG.debug("403 %r (%d to go)", url.path, serv_job.pending)
-                    return
             elif resource.type == Resource.URL_REDIRECT:
                 conn.sendall(cls._307_redirect(quote(resource.target)))
                 LOG.debug(
@@ -159,7 +149,6 @@ def handle_request(cls, conn, serv_job):
                     resource.target,
                     serv_job.pending,
                 )
-                return
             elif resource.type == Resource.URL_DYNAMIC:
                 # pass query string to callback
                 data = resource.target(url.query)
@@ -171,22 +160,28 @@ def handle_request(cls, conn, serv_job):
                 LOG.debug(
                     "200 %r - dynamic request (%d to go)", url.path, serv_job.pending
                 )
-                return
-
-            # at this point we know "resource.target" maps to a file on disk
-            # serve the file
-            data_size = resource.target.stat().st_size
-            LOG.debug(
-                "sending: %s bytes, mime: %r", format(data_size, ","), resource.mime
-            )
-            with resource.target.open("rb") as in_fp:
-                conn.sendall(cls._200_header(data_size, resource.mime))
-                offset = 0
-                while offset < data_size:
-                    conn.sendall(in_fp.read(cls.DEFAULT_TX_SIZE))
-                    offset = in_fp.tell()
-            LOG.debug("200 %r (%d to go)", url.path, serv_job.pending)
-            serv_job.mark_served(resource.target)
+            elif serv_job.is_forbidden(str(resource.target)):
+                # NOTE: this does info leak if files exist on disk.
+                # We could replace 403 with 404 if it turns out we care.
+                # However this is meant to only be accessible via localhost.
+                LOG.debug("target %r", str(resource.target))
+                conn.sendall(cls._4xx_page(403, "Forbidden", serv_job.auto_close))
+                LOG.debug("403 %r (%d to go)", url.path, serv_job.pending)
+            else:
+                # serve the file
+                LOG.debug("target %r", str(resource.target))
+                data_size = resource.target.stat().st_size
+                LOG.debug(
+                    "sending: %s bytes, mime: %r", format(data_size, ","), resource.mime
+                )
+                with resource.target.open("rb") as in_fp:
+                    conn.sendall(cls._200_header(data_size, resource.mime))
+                    offset = 0
+                    while offset < data_size:
+                        conn.sendall(in_fp.read(cls.DEFAULT_TX_SIZE))
+                        offset = in_fp.tell()
+                LOG.debug("200 %r (%d to go)", url.path, serv_job.pending)
+                serv_job.mark_served(resource.target)
 
         except (sock_error, sock_timeout):
             _, exc_obj, exc_tb = exc_info()

From 9fe18b9b9a1a28fe8f7101efd98a1868949f5d65 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 22 Nov 2021 11:18:33 -0800
Subject: [PATCH 373/531] [sapphire] Update access check

---
 sapphire/job.py      | 25 +++++++++++++++----------
 sapphire/test_job.py | 16 ++++++++++------
 sapphire/worker.py   |  5 +++--
 3 files changed, 28 insertions(+), 18 deletions(-)

diff --git a/sapphire/job.py b/sapphire/job.py
index 94801453..daf6bce0 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -195,16 +195,21 @@ def is_complete(self, wait=None):
             return self._complete.wait(wait)
         return self._complete.is_set()
 
-    def is_forbidden(self, target_file):
-        target_file = abspath(target_file)
-        # check if target_file lives somewhere in wwwroot
-        if not target_file.startswith(self.base_path):
-            if self.server_map:
-                for resources in self.server_map.include.values():
-                    if target_file.startswith(resources.target):
-                        return False  # this is a valid include path
-            return True  # this is NOT a valid include path
-        return False  # this is a valid path
+    def is_forbidden(self, target, is_include=False):
+        # it is assumed that these file exists on disk
+        # and that the paths are absolute and sanitized
+        target = str(target)
+        if not is_include:
+            # check if target is in wwwroot
+            if target.startswith(self.base_path):
+                return False
+        elif self.server_map:
+            # check if target is in an included path
+            for resource in self.server_map.include.values():
+                if target.startswith(resource.target):
+                    # target is in a valid include path
+                    return False
+        return True
 
     @property
     def pending(self):
diff --git a/sapphire/test_job.py b/sapphire/test_job.py
index bf7c9a93..b5ad1cba 100644
--- a/sapphire/test_job.py
+++ b/sapphire/test_job.py
@@ -22,8 +22,8 @@ def test_job_01(tmp_path):
     assert job.lookup_resource("test/test/") is None
     assert job.lookup_resource("test/../../") is None
     assert job.lookup_resource("\x00\x0B\xAD\xF0\x0D") is None
-    assert not job.is_forbidden(str(tmp_path))
-    assert not job.is_forbidden(str(tmp_path / "missing_file"))
+    assert not job.is_forbidden(tmp_path)
+    assert not job.is_forbidden(tmp_path / "missing_file")
     assert job.pending == 0
     assert not job.is_complete()
     assert job.remove_pending("no_file.test")
@@ -146,8 +146,12 @@ def test_job_04(mocker, tmp_path):
     resource = job.lookup_resource("/".join(["testinc", "nested", "nested_file.txt"]))
     assert resource.type == Resource.URL_INCLUDE
     assert resource.target == nst_1
-    assert not job.is_forbidden(str(srv_root / ".." / "test" / "test_file.txt"))
-    assert not job.is_forbidden(str(srv_include / ".." / "root" / "req_file.txt"))
+    assert not job.is_forbidden(
+        (srv_root / ".." / "test" / "test_file.txt").resolve(), is_include=True
+    )
+    assert not job.is_forbidden(
+        (srv_include / ".." / "root" / "req_file.txt").resolve(), is_include=False
+    )
 
 
 def test_job_05(tmp_path):
@@ -221,8 +225,8 @@ def test_job_07(tmp_path):
     resource = job.lookup_resource("../no_access.txt")
     assert resource.target == no_access
     assert resource.type == Resource.URL_FILE
-    assert not job.is_forbidden(str(test_1))
-    assert job.is_forbidden(str(srv_root / ".." / "no_access.txt"))
+    assert not job.is_forbidden(test_1)
+    assert job.is_forbidden((srv_root / ".." / "no_access.txt").resolve())
 
 
 @mark.skipif(system() == "Windows", reason="Unsupported on Windows")
diff --git a/sapphire/worker.py b/sapphire/worker.py
index 6af2f988..b63e43ec 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -95,7 +95,6 @@ def done(self):
 
     @classmethod
     def handle_request(cls, conn, serv_job):
-        # pylint: disable=too-many-return-statements
         finish_job = False  # call finish() on return
         try:
             # receive all the incoming data
@@ -160,7 +159,9 @@ def handle_request(cls, conn, serv_job):
                 LOG.debug(
                     "200 %r - dynamic request (%d to go)", url.path, serv_job.pending
                 )
-            elif serv_job.is_forbidden(str(resource.target)):
+            elif serv_job.is_forbidden(
+                resource.target, is_include=resource.type == Resource.URL_INCLUDE
+            ):
                 # NOTE: this does info leak if files exist on disk.
                 # We could replace 403 with 404 if it turns out we care.
                 # However this is meant to only be accessible via localhost.

From 91b052dc3bca37f5c38dc2288ab575a01cca1c57 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 18 Nov 2021 11:51:29 -0500
Subject: [PATCH 374/531] Make analysis line more concise in reducer status.

---
 grizzly/reduce/core.py | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index f9a85380..ecedf7e0 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -328,15 +328,23 @@ def run_reliability_analysis(self):
                     for result in results:
                         result.report.cleanup()
                 reliability = crashes / self.ANALYSIS_ITERATIONS
-                key = ("using" if use_harness else "without") + " harness"
+                desc = ("using" if use_harness else "without") + " harness"
                 if last_test_only:
-                    key += "/last test only"
+                    desc += "/last test only"
+                else:
+                    desc += "/all tests"
                 LOG.info(
                     "Testcase was interesting %0.1f%% of %d attempts %s.",
                     100.0 * reliability,
                     self.ANALYSIS_ITERATIONS,
-                    key,
+                    desc,
                 )
+                if use_harness and last_test_only:
+                    key = "last test"
+                elif use_harness:
+                    key = "all tests"
+                else:
+                    key = "no harness"
                 self._status.analysis[key] = reliability
                 # ensure same signature is always used
                 self._signature = replay.signature

From 6c8deb167b6ad533594119593719575445bd6135 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 18 Nov 2021 15:13:37 -0500
Subject: [PATCH 375/531] Always write reducer stats to DB when recording a
 milestone.

This will better summarize what happened when exceptions are raised (eg.
fail to repro) since milestones like "final" are automatically recorded.
---
 grizzly/common/status.py      | 9 ++++++++-
 grizzly/common/test_status.py | 6 +++---
 grizzly/reduce/core.py        | 2 --
 3 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 6bc12096..a9f942c5 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -957,6 +957,7 @@ def __deepcopy__(self, memo):
                 duration=step.duration,
                 iterations=step.iterations,
                 successes=step.successes,
+                report=False,
             )
         return result
 
@@ -989,6 +990,7 @@ def record(
         iterations=None,
         attempts=None,
         successes=None,
+        report=True,
     ):
         """Record reduction status for a given point in time:
 
@@ -1004,6 +1006,7 @@ def record(
             iterations (int or None): # of iterations performed
             attempts (int or None): # of attempts performed
             successes (int or None): # of attempts successful
+            report (bool): Automatically force a report.
 
         Returns:
             None
@@ -1018,6 +1021,8 @@ def record(
                 successes=successes,
             )
         )
+        if report:
+            self.report(force=True)
 
     def _construct_milestone(self, name, start, attempts, iterations, successes):
         # pylint: disable=no-self-argument
@@ -1063,12 +1068,13 @@ def serialize(sub):
         return _MilestoneTimer()
 
     @contextmanager
-    def measure(self, name):
+    def measure(self, name, report=True):
         """Time and record the period leading up to a reduction milestone.
         eg. a strategy being run.
 
         Arguments:
             name (str): name of milestone
+            report (bool): Automatically force a report.
 
         Yields:
             None
@@ -1086,6 +1092,7 @@ def measure(self, name):
             duration=tmr.duration,
             iterations=tmr.iterations,
             successes=tmr.successes,
+            report=report,
         )
 
     def copy(self):
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 4333a5a9..78557bfc 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -462,9 +462,9 @@ def test_reduce_status_06(mocker, tmp_path):
     with status.measure("milestone2"):
         status.report(force=True)
 
-    loaded_status = tuple(ReductionStatus.loadall(str(tmp_path / "status.db")))
-    assert len(loaded_status) == 1
-    loaded_status = loaded_status[0]
+        loaded_status = tuple(ReductionStatus.loadall(str(tmp_path / "status.db")))
+        assert len(loaded_status) == 1
+        loaded_status = loaded_status[0]
 
     assert loaded_status.finished_steps == status.finished_steps[:1]
     assert len(loaded_status._in_progress_steps) == 1
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index ecedf7e0..383460ae 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -438,7 +438,6 @@ def run(self, repeat=1, min_results=1):
         last_reports = None
         last_tried = None
         self._status.record("init")
-        self._status.report(force=True)
         # record total stats overall so that any time missed by individual milestones
         # will still be included in the total
         with self._status.measure("final"):
@@ -613,7 +612,6 @@ def run(self, repeat=1, min_results=1):
                 finally:
                     for result in best_results:
                         result.report.cleanup()
-                    self._status.report(force=True)
 
                 # store "tried" cache to pass to next strategy
                 last_tried = strategy.get_tried()

From 907153e49768e1cc54fac66f06465a26808c35f9 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 18 Nov 2021 15:18:00 -0500
Subject: [PATCH 376/531] Add Crash ID to final reduction report.

---
 grizzly/common/status_reporter.py      | 8 +++++++-
 grizzly/common/test_status_reporter.py | 3 ++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 9acec38e..bb363ce9 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -655,6 +655,10 @@ def _analysis_entry(report):
             ),
         )
 
+    @staticmethod
+    def _crash_id_entry(report):
+        return ("Crash ID", str(report.crash_id))
+
     @staticmethod
     def _run_params_entry(report):
         return (
@@ -694,7 +698,7 @@ def specific(  # pylint: disable=arguments-differ
         for report in self.reports:
             entries = []
             if report.crash_id:
-                entries.append(("Crash ID", str(report.crash_id)))
+                entries.append(self._crash_id_entry(report))
             if report.analysis:
                 entries.append(self._analysis_entry(report))
             if report.run_params:
@@ -775,6 +779,8 @@ def summary(
         for report in self.reports:
             entries = []
             lines = []
+            if report.crash_id:
+                entries.append(self._crash_id_entry(report))
             if report.analysis:
                 entries.append(self._analysis_entry(report))
             if report.signature_info:
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 680e635b..bf7df87b 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -81,6 +81,7 @@ def test_reduce_status_reporter_03(mocker, tmp_path):
     status = ReductionStatus.start(
         db_file=db_file,
         testcase_size_cb=size_cb,
+        crash_id=123,
     )
     status.analysis["ran"] = True
     status.run_params["speed"] = 123.0
@@ -109,7 +110,7 @@ def test_reduce_status_reporter_03(mocker, tmp_path):
     assert "strategy_1" in output
     assert "total" in output
     assert "Timestamp" in output
-    assert len(output.splitlines()) == 14
+    assert len(output.splitlines()) == 15
 
 
 def test_reduce_status_reporter_04(mocker, tmp_path):

From 390eb1e29d0e205689422d12281a07b7a6bc2a6a Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 18 Nov 2021 16:28:29 -0500
Subject: [PATCH 377/531] Show tool name in reducer status report.

---
 grizzly/common/status.py               | 26 ++++++++++++++++++++------
 grizzly/common/status_reporter.py      |  5 ++++-
 grizzly/common/test_status_reporter.py |  2 ++
 grizzly/reduce/core.py                 |  1 +
 4 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index a9f942c5..0139de0a 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -22,7 +22,7 @@
 # time in seconds for db connection to wait before raising an exception
 DB_TIMEOUT = 30
 # used to track changes to the database layout
-DB_VERSION = 1
+DB_VERSION = 2
 # default expiration limit for entries in the database
 EXP_LIMIT = 86400
 LOG = getLogger(__name__)
@@ -666,6 +666,7 @@ def __init__(
         crash_id=None,
         db_file=None,
         pid=None,
+        tool=None,
         exp_limit=EXP_LIMIT,
     ):
         """Initialize a ReductionStatus instance.
@@ -675,6 +676,7 @@ def __init__(
             testcase_size_cb (callable): Callback to get testcase size
             crash_id (int): CrashManager ID of original testcase
             db_file (str): Database file containing data. None in read-only mode.
+            tool (str): The tool name used for reporting to FuzzManager.
         """
         self.analysis = {}
         self.attempts = 0
@@ -691,6 +693,7 @@ def __init__(
         self._db_file = db_file
         self.pid = pid
         self.timestamp = time()
+        self.tool = tool
         self._current_size = None
 
         # prepare database
@@ -716,7 +719,8 @@ def __init__(
                            strategies TEXT NOT NULL,
                            _current_size INTEGER NOT NULL,
                            current_strategy_idx INTEGER,
-                           timestamp REAL NOT NULL);"""
+                           timestamp REAL NOT NULL,
+                           tool TEXT);"""
                     )
                     # remove expired status data
                     if exp_limit > 0:
@@ -734,6 +738,7 @@ def start(
         strategies=None,
         testcase_size_cb=None,
         crash_id=None,
+        tool=None,
     ):
         """Create a unique ReductionStatus object.
 
@@ -742,6 +747,7 @@ def start(
             strategies (list(str)): List of strategies to be run.
             testcase_size_cb (callable): Callback to get testcase size
             crash_id (int): CrashManager ID of original testcase
+            tool (str): The tool name used for reporting to FuzzManager.
 
         Returns:
             ReductionStatus: Active status report.
@@ -754,6 +760,7 @@ def start(
             pid=getpid(),
             strategies=strategies,
             testcase_size_cb=testcase_size_cb,
+            tool=tool,
         )
         status.report(force=True)
         return status
@@ -800,7 +807,8 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                            strategies = ?,
                            _current_size = ?,
                            current_strategy_idx = ?,
-                           timestamp = ?
+                           timestamp = ?,
+                           tool = ?
                        WHERE pid = ?;""",
                     (
                         analysis,
@@ -816,6 +824,7 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                         self._testcase_size(),
                         self.current_strategy_idx,
                         self.timestamp,
+                        self.tool,
                         self.pid,
                     ),
                 )
@@ -835,8 +844,9 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                                strategies,
                                _current_size,
                                current_strategy_idx,
-                               timestamp)
-                           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);""",
+                               timestamp,
+                               tool)
+                           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);""",
                         (
                             self.pid,
                             analysis,
@@ -852,6 +862,7 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                             self._testcase_size(),
                             self.current_strategy_idx,
                             self.timestamp,
+                            self.tool,
                         ),
                     )
 
@@ -889,7 +900,8 @@ def loadall(cls, db_file=STATUS_DB, time_limit=300):
                               strategies,
                               _current_size,
                               current_strategy_idx,
-                              timestamp
+                              timestamp,
+                              tool
                        FROM reduce_status
                        WHERE timestamp > ?
                        ORDER BY timestamp DESC;""",
@@ -908,6 +920,7 @@ def loadall(cls, db_file=STATUS_DB, time_limit=300):
                 strategies=loads(entry[10]),
                 crash_id=entry[7],
                 pid=pid,
+                tool=entry[14],
             )
             status.analysis = loads(entry[1])
             status.attempts = entry[2]
@@ -939,6 +952,7 @@ def __deepcopy__(self, memo):
             crash_id=self.crash_id,
             testcase_size_cb=self._testcase_size_cb,
             pid=self.pid,
+            tool=self.tool,
         )
         # assign after construction to avoid DB access
         result._db_file = self._db_file
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index bb363ce9..be57e460 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -657,7 +657,10 @@ def _analysis_entry(report):
 
     @staticmethod
     def _crash_id_entry(report):
-        return ("Crash ID", str(report.crash_id))
+        crash_str = str(report.crash_id)
+        if report.tool:
+            crash_str += " (%s)" % (report.tool,)
+        return ("Crash ID", crash_str)
 
     @staticmethod
     def _run_params_entry(report):
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index bf7df87b..efc90413 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -82,6 +82,7 @@ def test_reduce_status_reporter_03(mocker, tmp_path):
         db_file=db_file,
         testcase_size_cb=size_cb,
         crash_id=123,
+        tool="fuzzmatic",
     )
     status.analysis["ran"] = True
     status.run_params["speed"] = 123.0
@@ -123,6 +124,7 @@ def test_reduce_status_reporter_04(mocker, tmp_path):
         strategies=["strategy_0"],
         testcase_size_cb=lambda: 47,
         crash_id=12,
+        tool="fuzzmatic",
     )
     assert status.original is None
     rptr = ReductionStatusReporter.load(db_file)
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 383460ae..47f8af3b 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -141,6 +141,7 @@ def __init__(
             strategies=strategies,
             testcase_size_cb=self.testcase_size,
             crash_id=reducer_crash_id,
+            tool=tool,
         )
         self._use_analysis = use_analysis
         self._use_harness = use_harness

From 62cda53b5a79ce0abe4d1898a54e9a28a217dc63 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 18 Nov 2021 16:44:27 -0500
Subject: [PATCH 378/531] Include latest reported crashes in reduction status.

---
 grizzly/common/status.py               | 20 +++++++++++++++-----
 grizzly/common/status_reporter.py      |  8 ++++++++
 grizzly/common/test_status_reporter.py |  6 ++++--
 grizzly/reduce/core.py                 | 17 ++++++++++-------
 4 files changed, 37 insertions(+), 14 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 0139de0a..515056fd 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -695,6 +695,7 @@ def __init__(
         self.timestamp = time()
         self.tool = tool
         self._current_size = None
+        self.last_reports = []
 
         # prepare database
         if self._db_file:
@@ -720,7 +721,8 @@ def __init__(
                            _current_size INTEGER NOT NULL,
                            current_strategy_idx INTEGER,
                            timestamp REAL NOT NULL,
-                           tool TEXT);"""
+                           tool TEXT,
+                           last_reports TEXT NOT NULL);"""
                     )
                     # remove expired status data
                     if exp_limit > 0:
@@ -792,6 +794,7 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                 finished = dumps(self.finished_steps)
                 in_prog = dumps([step.serialize() for step in self._in_progress_steps])
                 strategies = dumps(self.strategies)
+                last_reports = dumps(self.last_reports)
 
                 cur.execute(
                     """UPDATE reduce_status
@@ -808,7 +811,8 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                            _current_size = ?,
                            current_strategy_idx = ?,
                            timestamp = ?,
-                           tool = ?
+                           tool = ?,
+                           last_reports = ?
                        WHERE pid = ?;""",
                     (
                         analysis,
@@ -825,6 +829,7 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                         self.current_strategy_idx,
                         self.timestamp,
                         self.tool,
+                        last_reports,
                         self.pid,
                     ),
                 )
@@ -845,8 +850,9 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                                _current_size,
                                current_strategy_idx,
                                timestamp,
-                               tool)
-                           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);""",
+                               tool,
+                               last_reports)
+                           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);""",
                         (
                             self.pid,
                             analysis,
@@ -863,6 +869,7 @@ def report(self, force=False, report_freq=REPORT_FREQ):
                             self.current_strategy_idx,
                             self.timestamp,
                             self.tool,
+                            last_reports,
                         ),
                     )
 
@@ -901,7 +908,8 @@ def loadall(cls, db_file=STATUS_DB, time_limit=300):
                               _current_size,
                               current_strategy_idx,
                               timestamp,
-                              tool
+                              tool,
+                              last_reports
                        FROM reduce_status
                        WHERE timestamp > ?
                        ORDER BY timestamp DESC;""",
@@ -937,6 +945,7 @@ def loadall(cls, db_file=STATUS_DB, time_limit=300):
             status._current_size = entry[11]
             status.current_strategy_idx = entry[12]
             status.timestamp = entry[13]
+            status.last_reports = loads(entry[15])
             yield status
 
     def _testcase_size(self):
@@ -963,6 +972,7 @@ def __deepcopy__(self, memo):
         result.signature_info = deepcopy(self.signature_info, memo)
         result.successes = self.successes
         result.finished_steps = deepcopy(self.finished_steps, memo)
+        result.last_reports = deepcopy(self.last_reports, memo)
         # finish open timers
         for step in reversed(self._in_progress_steps):
             result.record(
diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index be57e460..62295395 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -662,6 +662,10 @@ def _crash_id_entry(report):
             crash_str += " (%s)" % (report.tool,)
         return ("Crash ID", crash_str)
 
+    @staticmethod
+    def _last_reports_entry(report):
+        return ("Latest Reports", ", ".join(str(r) for r in report.last_reports))
+
     @staticmethod
     def _run_params_entry(report):
         return (
@@ -706,6 +710,8 @@ def specific(  # pylint: disable=arguments-differ
                 entries.append(self._analysis_entry(report))
             if report.run_params:
                 entries.append(self._run_params_entry(report))
+            if report.last_reports:
+                entries.append(self._last_reports_entry(report))
             if report.current_strategy:
                 entries.append(
                     (
@@ -790,6 +796,8 @@ def summary(
                 entries.append(self._signature_info_entry(report))
             if report.run_params:
                 entries.append(self._run_params_entry(report))
+            if report.last_reports:
+                entries.append(self._last_reports_entry(report))
             if report.total and report.original:
                 tabulator = _TableFormatter(
                     ReductionStep._fields,
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index efc90413..307cd1ea 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -87,6 +87,7 @@ def test_reduce_status_reporter_03(mocker, tmp_path):
     status.analysis["ran"] = True
     status.run_params["speed"] = 123.0
     status.signature_info["info"] = "crash"
+    status.last_reports.append(45678)
     status.record("init")
     with status.measure("total"):
         with status.measure("strategy_0"):
@@ -111,7 +112,7 @@ def test_reduce_status_reporter_03(mocker, tmp_path):
     assert "strategy_1" in output
     assert "total" in output
     assert "Timestamp" in output
-    assert len(output.splitlines()) == 15
+    assert len(output.splitlines()) == 16
 
 
 def test_reduce_status_reporter_04(mocker, tmp_path):
@@ -133,6 +134,7 @@ def test_reduce_status_reporter_04(mocker, tmp_path):
     assert len(output.splitlines()) == 1
     status.analysis["ran"] = True
     status.run_params["splines"] = "reticulated"
+    status.last_reports.append(45678)
     status.record("init")
     with status.measure("total"):
         with status.measure("strategy_0"):
@@ -143,7 +145,7 @@ def test_reduce_status_reporter_04(mocker, tmp_path):
     rptr = ReductionStatusReporter.load(db_file)
     assert rptr.reports
     output = rptr.specific()
-    assert len(output.splitlines()) == 7
+    assert len(output.splitlines()) == 8
     assert "Analysis" in output
     assert "Run Parameters" in output
     assert "Current Strategy" in output
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 47f8af3b..c21d5796 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -436,7 +436,6 @@ def run(self, repeat=1, min_results=1):
         """
         any_success = False
         sig_given = self._signature is not None
-        last_reports = None
         last_tried = None
         self._status.record("init")
         # record total stats overall so that any time missed by individual milestones
@@ -578,7 +577,7 @@ def run(self, repeat=1, min_results=1):
                                     and now - strategy_last_report
                                     > self._report_periodically
                                 ):
-                                    last_reports = self.report(
+                                    self._status.last_reports = self.report(
                                         best_results,
                                         self.testcases,
                                     )
@@ -600,14 +599,18 @@ def run(self, repeat=1, min_results=1):
                         self._signature = replay.signature
 
                     if best_results:
-                        last_reports = self.report(best_results, self.testcases)
+                        self._status.last_reports = self.report(
+                            best_results, self.testcases
+                        )
 
                 except KeyboardInterrupt:
                     if best_results:
-                        last_reports = self.report(best_results, self.testcases)
+                        self._status.last_reports = self.report(
+                            best_results, self.testcases
+                        )
                         LOG.warning(
                             "Ctrl+C detected, best reduction so far " "reported as %r",
-                            last_reports,
+                            self._status.last_reports,
                         )
                     raise
                 finally:
@@ -618,8 +621,8 @@ def run(self, repeat=1, min_results=1):
                 last_tried = strategy.get_tried()
 
             # if we complete all strategies, mark the last reported crashes as reduced
-            if self._report_to_fuzzmanager and last_reports:
-                for crash_id in last_reports:
+            if self._report_to_fuzzmanager and self._status.last_reports:
+                for crash_id in self._status.last_reports:
                     LOG.info(
                         "Updating crash %d to %s (Q%d)",
                         crash_id,

From 2f332a0a2d6f4a24ddb918ff48419665f9567d05 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 23 Nov 2021 11:46:56 -0800
Subject: [PATCH 379/531] Filter file list passed to TestCase.add_batch()

---
 grizzly/common/runner.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index d4199fb6..a694ba86 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -211,7 +211,12 @@ def run(
         # TODO: fix calling TestCase.add_batch() for multi-test replay
         # add all include files that were served
         for url, resource in server_map.include.items():
-            testcase.add_batch(resource.target, result.served, prefix=url)
+            testcase.add_batch(
+                resource.target,
+                # only pass files that appear to be in current include path
+                (x for x in result.served if x.startswith(resource.target)),
+                prefix=url,
+            )
         if result.timeout:
             LOG.debug("timeout detected")
             if self._target.handle_hang(ignore_idle=True) or "timeout" in ignore:

From 89f7cb551bfc09e48dd401c26cb1f623c05125ba Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 23 Nov 2021 11:49:08 -0800
Subject: [PATCH 380/531] Fix support for absolute and relative paths in
 TestCase.purge_optional()

---
 grizzly/common/storage.py      | 24 ++++++++----------------
 grizzly/common/test_storage.py |  7 +++++--
 2 files changed, 13 insertions(+), 18 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index 7cc80069..f3011843 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -496,30 +496,22 @@ def pop_assets(self):
         return assets
 
     def purge_optional(self, keep):
-        """Remove optional files (by name) that are not in keep.
+        """Remove optional files that are not in keep.
 
         Args:
-            keep (iterable(str)): Files that will not be removed.
+            keep (iterable(str)): Files that will not be removed. This can contain
+                                  absolute (includes) and relative paths.
 
         Returns:
             None
         """
-        opt_files = tuple(x.file_name for x in self._files.optional)
-        if not opt_files:
-            # nothing to purge
-            return
-        # filter required files from opt_files files to keep
-        keep_opt = list()
-        for fname in set(keep):
-            if fname not in (x.file_name for x in self._files.required):
-                keep_opt.append(fname)
-        # sanity check keep (cannot remove file that does not exist)
-        assert all(fname in opt_files for fname in keep_opt)
-        # purge
         to_remove = list()
-        for idx, fname in enumerate(opt_files):
-            if fname not in keep_opt:
+        # iterate over optional files
+        for idx, opt in enumerate(self._files.optional):
+            # check entries in 'keep' for a match
+            if not any(x.endswith(opt.file_name) for x in keep):
                 to_remove.append(idx)
+        # purge
         for idx in reversed(to_remove):
             self._files.optional.pop(idx).data_file.unlink()
 
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index 3cd5e582..a372d2f8 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -121,8 +121,11 @@ def test_testcase_05():
         # nothing to remove - with required
         tcase.purge_optional(chain(["testfile1.bin"], tcase.optional))
         assert len(tuple(tcase.optional)) == 3
-        # nothing to remove - without required
-        tcase.purge_optional(tcase.optional)
+        # nothing to remove - use relative path (forced)
+        tcase.purge_optional(x.file_name for x in tcase._files.optional)
+        assert len(tuple(tcase.optional)) == 3
+        # nothing to remove - use absolute path
+        tcase.purge_optional(x.data_file.as_posix() for x in tcase._files.optional)
         assert len(tuple(tcase.optional)) == 3
         # remove not_served.bin
         tcase.purge_optional(["testfile2.bin", "testfile3.bin"])

From b33ff355a4b589af7d0b232f0e1c9fbf856faf5e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 24 Nov 2021 17:10:04 -0800
Subject: [PATCH 381/531] [sapphire] Use Path() where possible in Job()

- Fix Windows short file names
---
 sapphire/job.py           | 35 ++++++++++++++++-------------------
 sapphire/test_sapphire.py | 16 ++++++++++++++++
 2 files changed, 32 insertions(+), 19 deletions(-)

diff --git a/sapphire/job.py b/sapphire/job.py
index daf6bce0..5c78d0fc 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -10,9 +10,7 @@
 from logging import getLogger
 from mimetypes import guess_type
 from os import walk
-from os.path import abspath, isdir
-from os.path import join as pathjoin
-from os.path import relpath, splitext
+from os.path import splitext
 from pathlib import Path
 from queue import Queue
 from threading import Event, Lock
@@ -57,9 +55,9 @@ class Job:
         "_complete",
         "_pending",
         "_served",
+        "_wwwroot",
         "auto_close",
         "accepting",
-        "base_path",
         "exceptions",
         "forever",
         "initial_queue_size",
@@ -69,7 +67,7 @@ class Job:
 
     def __init__(
         self,
-        base_path,
+        wwwroot,
         auto_close=-1,
         forever=False,
         optional_files=None,
@@ -78,10 +76,10 @@ def __init__(
         self._complete = Event()
         self._pending = Tracker(files=set(), lock=Lock())
         self._served = Tracker(files=set(), lock=Lock())
+        self._wwwroot = Path(wwwroot).resolve()
         self.accepting = Event()
         self.accepting.set()
         self.auto_close = auto_close
-        self.base_path = abspath(base_path)  # wwwroot
         self.exceptions = Queue()
         self.forever = forever
         self.initial_queue_size = 0
@@ -92,25 +90,25 @@ def __init__(
     def _build_queue(self, optional_files):
         # build file list to track files that must be served
         # this is intended to only be called once by __init__()
-        for d_name, _, filenames in walk(self.base_path, followlinks=False):
+        for d_name, _, filenames in walk(self._wwwroot, followlinks=False):
+            d_path = Path(d_name)
             for f_name in filenames:
-                file_path = pathjoin(d_name, f_name)
-                location = relpath(file_path, start=self.base_path).replace("\\", "/")
+                file_path = d_path / f_name
+                location = file_path.relative_to(self._wwwroot).as_posix()
                 # do not add optional files to queue of required files
                 if optional_files and location in optional_files:
                     LOG.debug("optional: %r", location)
                     continue
-                file_path = abspath(file_path)
-                if "?" in file_path:
+                if "?" in str(file_path):
                     LOG.warning(
-                        "Cannot add files with '?' in path. Skipping %r", file_path
+                        "Cannot add files with '?' in path. Skipping %r", str(file_path)
                     )
                     continue
-                self._pending.files.add(file_path)
+                self._pending.files.add(str(file_path.resolve()))
                 LOG.debug("required: %r", location)
         # if nothing was found check if the path exists
-        if not self._pending.files and not isdir(self.base_path):
-            raise OSError("%r does not exist" % (self.base_path,))
+        if not self._pending.files and not self._wwwroot.is_dir():
+            raise OSError("%r does not exist" % (str(self._wwwroot),))
         if self.server_map:
             for redirect, resource in self.server_map.redirect.items():
                 if resource.required:
@@ -139,7 +137,7 @@ def lookup_mime(cls, url):
     def lookup_resource(self, path):
         # check if path is a file in wwwroot
         try:
-            local = Path(self.base_path) / path
+            local = self._wwwroot / path
             if local.is_file():
                 local = local.resolve()
                 with self._pending.lock:
@@ -201,7 +199,7 @@ def is_forbidden(self, target, is_include=False):
         target = str(target)
         if not is_include:
             # check if target is in wwwroot
-            if target.startswith(self.base_path):
+            if target.startswith(str(self._wwwroot)):
                 return False
         elif self.server_map:
             # check if target is in an included path
@@ -232,11 +230,10 @@ def served(self):
         with self._served.lock:
             # make a copy of what is available (maybe a copy not necessary?)
             served = tuple(self._served.files)
-        wwwroot = Path(self.base_path)
         for path in served:
             try:
                 # file is in wwwroot
-                yield path.relative_to(wwwroot).as_posix()
+                yield path.relative_to(self._wwwroot).as_posix()
             except ValueError:
                 # include file
                 yield path.as_posix()
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 344972b6..7060ca04 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -9,6 +9,7 @@
 import random
 import socket
 import threading
+from platform import system
 from urllib.parse import quote, urlparse
 
 import pytest
@@ -776,6 +777,21 @@ def test_sapphire_32(mocker):
     assert pending.close.call_count == 1
 
 
+@pytest.mark.skipif(system() != "Windows", reason="Only supported on Windows")
+def test_sapphire_33(client, tmp_path):
+    """test serving from path using Windows short file name"""
+    wwwroot = tmp_path / "long_path_name_that_can_be_truncated_on_windows"
+    wwwroot.mkdir()
+    with Sapphire(timeout=10) as serv:
+        assert serv.timeout == 10
+        test = _create_test("test_case.html", wwwroot)
+        client.launch("127.0.0.1", serv.port, [test])
+        assert serv.serve_path(tmp_path / "LONG_P~1")[0] == Served.ALL
+    assert client.wait(timeout=10)
+    assert test.code == 200
+    assert test.len_srv == test.len_org
+
+
 def test_main_01(mocker, tmp_path):
     """test Sapphire.main()"""
     args = mocker.Mock(path=str(tmp_path), port=4536, remote=False, timeout=None)

From 3d09e5abafa102ff580b0559f2b2d25db1d1651e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 24 Nov 2021 17:35:38 -0800
Subject: [PATCH 382/531] [sapphire] Have Job() only accept a Path()

---
 sapphire/core.py                    |  7 +--
 sapphire/job.py                     |  2 +-
 sapphire/test_connection_manager.py | 12 ++---
 sapphire/test_job.py                | 22 ++++-----
 sapphire/test_sapphire.py           | 76 ++++++++++++++---------------
 sapphire/test_worker.py             |  2 +-
 6 files changed, 60 insertions(+), 61 deletions(-)

diff --git a/sapphire/core.py b/sapphire/core.py
index 31a5585c..3a0cd5ba 100644
--- a/sapphire/core.py
+++ b/sapphire/core.py
@@ -7,7 +7,7 @@
 """
 from errno import EADDRINUSE
 from logging import getLogger
-from os.path import abspath
+from pathlib import Path
 from random import randint
 from socket import AF_INET, SO_REUSEADDR, SOCK_STREAM, SOL_SOCKET, gethostname, socket
 from time import sleep, time
@@ -156,7 +156,8 @@ def serve_path(
         Returns:
             tuple(int, tuple(str)): Status code and files served.
         """
-        LOG.debug("serving %r (forever=%r)", path, forever)
+        path = Path(path)
+        LOG.debug("serving %r (forever=%r)", str(path), forever)
         job = Job(
             path,
             auto_close=self._auto_close,
@@ -210,7 +211,7 @@ def main(cls, args):
             ) as serv:
                 LOG.info(
                     "Serving %r @ http://%s:%d/",
-                    abspath(args.path),
+                    str(Path(args.path).resolve()),
                     gethostname() if args.remote else "127.0.0.1",
                     serv.port,
                 )
diff --git a/sapphire/job.py b/sapphire/job.py
index 5c78d0fc..073bd516 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -76,7 +76,7 @@ def __init__(
         self._complete = Event()
         self._pending = Tracker(files=set(), lock=Lock())
         self._served = Tracker(files=set(), lock=Lock())
-        self._wwwroot = Path(wwwroot).resolve()
+        self._wwwroot = wwwroot.resolve()
         self.accepting = Event()
         self.accepting.set()
         self.auto_close = auto_close
diff --git a/sapphire/test_connection_manager.py b/sapphire/test_connection_manager.py
index 7df99e18..5a349e79 100644
--- a/sapphire/test_connection_manager.py
+++ b/sapphire/test_connection_manager.py
@@ -17,7 +17,7 @@
 def test_connection_manager_01(mocker, tmp_path):
     """test basic ConnectionManager"""
     (tmp_path / "testfile").write_bytes(b"test")
-    job = Job(str(tmp_path))
+    job = Job(tmp_path)
     clnt_sock = mocker.Mock(spec_set=socket)
     clnt_sock.recv.return_value = b"GET /testfile HTTP/1.1"
     serv_sock = mocker.Mock(spec_set=socket)
@@ -50,7 +50,7 @@ def test_connection_manager_03(mocker, tmp_path):
     (tmp_path / "test1").touch()
     (tmp_path / "test2").touch()
     (tmp_path / "test3").touch()
-    job = Job(str(tmp_path))
+    job = Job(tmp_path)
     clnt_sock = mocker.Mock(spec_set=socket)
     clnt_sock.recv.side_effect = (
         b"GET /test1 HTTP/1.1",
@@ -74,7 +74,7 @@ def test_connection_manager_03(mocker, tmp_path):
 def test_connection_manager_04(mocker, tmp_path):
     """test ConnectionManager.wait()"""
     (tmp_path / "test1").touch()
-    job = Job(str(tmp_path))
+    job = Job(tmp_path)
     clnt_sock = mocker.Mock(spec_set=socket)
     clnt_sock.recv.return_value = b""
     serv_sock = mocker.Mock(spec_set=socket)
@@ -86,7 +86,7 @@ def test_connection_manager_04(mocker, tmp_path):
         # callback abort
         assert loadmgr.wait(1, continue_cb=lambda: False, poll=0.01)
     # timeout
-    job = Job(str(tmp_path))
+    job = Job(tmp_path)
     fake_time = mocker.patch("sapphire.connection_manager.time", autospec=True)
     fake_time.side_effect = count()
     with ConnectionManager(job, serv_sock, max_workers=10) as loadmgr:
@@ -96,7 +96,7 @@ def test_connection_manager_04(mocker, tmp_path):
 def test_connection_manager_05(mocker, tmp_path):
     """test ConnectionManager re-raise worker exceptions"""
     (tmp_path / "test1").touch()
-    job = Job(str(tmp_path))
+    job = Job(tmp_path)
     clnt_sock = mocker.Mock(spec_set=socket)
     clnt_sock.recv.side_effect = Exception("worker exception")
     serv_sock = mocker.Mock(spec_set=socket)
@@ -112,7 +112,7 @@ def test_connection_manager_05(mocker, tmp_path):
 def test_connection_manager_06(mocker, tmp_path):
     """test ConnectionManager re-raise launcher exceptions"""
     (tmp_path / "test1").touch()
-    job = Job(str(tmp_path))
+    job = Job(tmp_path)
     serv_sock = mocker.Mock(spec_set=socket)
     serv_sock.accept.side_effect = Exception("launcher exception")
     with raises(Exception, match="launcher exception"):
diff --git a/sapphire/test_job.py b/sapphire/test_job.py
index b5ad1cba..ac469ee6 100644
--- a/sapphire/test_job.py
+++ b/sapphire/test_job.py
@@ -14,7 +14,7 @@
 
 def test_job_01(tmp_path):
     """test creating an empty Job"""
-    job = Job(str(tmp_path))
+    job = Job(tmp_path)
     assert not job.forever
     assert job.status == Served.ALL
     assert job.lookup_resource("") is None
@@ -44,7 +44,7 @@ def test_job_02(tmp_path):
     req2_path = tmp_path / "nested" / "req_file_2.txt"
     req2_path.write_bytes(b"d")
     job = Job(
-        str(tmp_path), optional_files=[opt1_path.name, "nested/%s" % (opt2_path.name,)]
+        tmp_path, optional_files=[opt1_path.name, "nested/%s" % (opt2_path.name,)]
     )
     assert job.status == Served.NONE
     assert not job.is_complete()
@@ -81,7 +81,7 @@ def test_job_03(tmp_path):
     smap = ServerMap()
     smap.set_redirect("one", "somefile.txt", required=False)
     smap.set_redirect("two", "reqfile.txt")
-    job = Job(str(tmp_path), server_map=smap)
+    job = Job(tmp_path, server_map=smap)
     assert job.status == Served.NONE
     resource = job.lookup_resource("one")
     assert resource.type == Resource.URL_REDIRECT
@@ -121,7 +121,7 @@ def test_job_04(mocker, tmp_path):
     smap.include["testinc/1/2/3"] = Resource(Resource.URL_INCLUDE, srv_include)
     smap.include[""] = Resource(Resource.URL_INCLUDE, srv_include)
     smap.set_include("testinc/inc2", str(srv_include_2))
-    job = Job(str(srv_root), server_map=smap)
+    job = Job(srv_root, server_map=smap)
     assert job.status == Served.NONE
     # test include path pointing to a missing file
     assert job.lookup_resource("testinc/missing") is None
@@ -170,7 +170,7 @@ def test_job_05(tmp_path):
     # test url matching part of the file name
     smap = ServerMap()
     smap.include["inc"] = Resource(Resource.URL_INCLUDE, str(inc_dir))
-    job = Job(str(srv_root), server_map=smap)
+    job = Job(srv_root, server_map=smap)
     resource = job.lookup_resource("inc/sub/include.js")
     assert resource.type == Resource.URL_INCLUDE
     assert resource.target == inc_file1
@@ -197,7 +197,7 @@ def test_job_06(tmp_path):
     smap = ServerMap()
     smap.set_dynamic_response("cb1", lambda _: 0, mime_type="mime_type")
     smap.set_dynamic_response("cb2", lambda _: 1)
-    job = Job(str(tmp_path), server_map=smap)
+    job = Job(tmp_path, server_map=smap)
     assert job.status == Served.ALL
     assert job.pending == 0
     resource = job.lookup_resource("cb1")
@@ -219,7 +219,7 @@ def test_job_07(tmp_path):
     test_1.write_bytes(b"a")
     no_access = tmp_path / "no_access.txt"
     no_access.write_bytes(b"a")
-    job = Job(str(srv_root))
+    job = Job(srv_root)
     assert job.status == Served.NONE
     assert job.pending == 1
     resource = job.lookup_resource("../no_access.txt")
@@ -235,21 +235,21 @@ def test_job_08(tmp_path):
     test_file = tmp_path / "test.txt"
     test_file.write_bytes(b"a")
     (tmp_path / "?_2.txt").write_bytes(b"a")
-    job = Job(str(tmp_path))
+    job = Job(tmp_path)
     assert job.status == Served.NONE
     assert job.pending == 1
     assert job.lookup_resource("test.txt").target == test_file
 
 
-def test_job_09():
+def test_job_09(tmp_path):
     """test Job with missing directory"""
     with raises(OSError):
-        Job("missing")
+        Job(tmp_path / "missing")
 
 
 def test_job_10(tmp_path):
     """test Job.mark_served() and Job.served"""
-    job = Job(str(tmp_path))
+    job = Job(tmp_path)
     assert not any(job.served)
     job.mark_served(tmp_path / "a.bin")
     assert "a.bin" in job.served
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 7060ca04..36d8436f 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -12,7 +12,7 @@
 from platform import system
 from urllib.parse import quote, urlparse
 
-import pytest
+from pytest import mark, raises
 
 from .core import Sapphire
 from .job import Served
@@ -58,7 +58,7 @@ def test_sapphire_00(client, tmp_path):
         assert serv.timeout == 10
         test = _create_test("test_case.html", tmp_path)
         client.launch("127.0.0.1", serv.port, [test])
-        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
+        assert serv.serve_path(tmp_path)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert test.code == 200
     assert test.len_srv == test.len_org
@@ -75,7 +75,7 @@ def test_sapphire_01(client, tmp_path):
         )
     with Sapphire(timeout=30) as serv:
         client.launch("127.0.0.1", serv.port, to_serve)
-        status, files_served = serv.serve_path(str(tmp_path))
+        status, files_served = serv.serve_path(tmp_path)
     assert status == Served.ALL
     assert len(to_serve) == len(files_served)
     assert client.wait(timeout=10)
@@ -93,7 +93,7 @@ def test_sapphire_02(client, tmp_path):
     optional = [files_to_serve[0].file]
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve, in_order=True)
-        status, served_list = serv.serve_path(str(tmp_path), optional_files=optional)
+        status, served_list = serv.serve_path(tmp_path, optional_files=optional)
     assert status == Served.ALL
     assert len(files_to_serve) == len(served_list)
     assert client.wait(timeout=10)
@@ -110,7 +110,7 @@ def test_sapphire_03(client, tmp_path):
     optional = [files_to_serve[0].file]
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve[1:])
-        status, served_list = serv.serve_path(str(tmp_path), optional_files=optional)
+        status, served_list = serv.serve_path(tmp_path, optional_files=optional)
     assert status == Served.ALL
     assert len(served_list) == len(files_to_serve) - 1
     assert client.wait(timeout=10)
@@ -128,7 +128,7 @@ def test_sapphire_04(client, tmp_path):
     files_to_serve.append(_create_test("test_case.html", tmp_path))
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve, in_order=True)
-        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
+        assert serv.serve_path(tmp_path)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert "does_not_exist.html" in files_to_serve[0].file
     assert files_to_serve[0].code == 404
@@ -151,7 +151,7 @@ def test_sapphire_05(client, tmp_path):
     files_to_serve.append(_create_test("test_case.html", root_dir))
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve, in_order=True)
-        status, files_served = serv.serve_path(str(root_dir))
+        status, files_served = serv.serve_path(root_dir)
     assert status == Served.ALL
     assert len(files_served) == 1
     assert client.wait(timeout=10)
@@ -166,7 +166,7 @@ def test_sapphire_06(client, tmp_path):
     """test serving no files... this should never happen but..."""
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [])
-        status, files_served = serv.serve_path(str(tmp_path))
+        status, files_served = serv.serve_path(tmp_path)
     assert status == Served.NONE
     assert not files_served
 
@@ -183,7 +183,7 @@ def test_sapphire_07(tmp_path):
         assert serv.timeout == 1
         _create_test("test_case.html", tmp_path)
         serv._timeout = 0.01  # force shorter timeout for faster tests
-        status, files_served = serv.serve_path(str(tmp_path))
+        status, files_served = serv.serve_path(tmp_path)
     assert status == Served.TIMEOUT
     assert not files_served
 
@@ -201,7 +201,7 @@ def is_running():
         files_to_serve.append(_create_test("test_case_%d.html" % i, tmp_path))
     with Sapphire() as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve[1:])
-        status, files_served = serv.serve_path(str(tmp_path), continue_cb=is_running)
+        status, files_served = serv.serve_path(tmp_path, continue_cb=is_running)
     assert status == Served.REQUEST
     assert len(files_served) < len(files_to_serve)
 
@@ -225,7 +225,7 @@ def test_sapphire_09(client, tmp_path):
         test["file"].md5_org = hashlib.md5(t_data).hexdigest()
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [test["file"] for test in tests])
-        status, served_list = serv.serve_path(str(tmp_path))
+        status, served_list = serv.serve_path(tmp_path)
     assert status == Served.ALL
     assert len(served_list) == len(tests)
     assert client.wait(timeout=10)
@@ -248,7 +248,7 @@ def test_sapphire_10(client, tmp_path):
     t_file.md5_org = data_hash.hexdigest()
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [t_file])
-        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
+        assert serv.serve_path(tmp_path)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert t_file.code == 200
     assert t_file.len_srv == (100 * 1024 * 1024)
@@ -262,7 +262,7 @@ def test_sapphire_11(client, tmp_path):
     )
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [t_file])
-        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
+        assert serv.serve_path(tmp_path)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert t_file.code == 200
     assert t_file.len_srv == t_file.len_org
@@ -284,7 +284,7 @@ def test_sapphire_13(client, tmp_path):
     files_to_serve.append(_create_test("test_case", tmp_path, data=os.urandom(5)))
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files_to_serve)
-        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
+        assert serv.serve_path(tmp_path)[0] == Served.ALL
     assert client.wait(timeout=10)
     content_types = set()
     for test in files_to_serve:
@@ -308,9 +308,7 @@ def _test_callback():
 
     with Sapphire(timeout=10) as serv:
         _create_test("test_case.html", tmp_path)
-        assert (
-            serv.serve_path(str(tmp_path), continue_cb=_test_callback)[0] == Served.NONE
-        )
+        assert serv.serve_path(tmp_path, continue_cb=_test_callback)[0] == Served.NONE
     assert cb_status["count"] == 2
 
 
@@ -320,7 +318,7 @@ def test_sapphire_15(client, tmp_path):
         for i in range(3):
             test = _create_test("test_case_%d.html" % i, tmp_path)
             client.launch("127.0.0.1", serv.port, [test])
-            assert serv.serve_path(str(tmp_path))[0] == Served.ALL
+            assert serv.serve_path(tmp_path)[0] == Served.ALL
             assert client.wait(timeout=10)
             client.close()
             assert test.code == 200
@@ -335,13 +333,13 @@ def test_sapphire_16(client, tmp_path):
     test = _create_test("test_case.html", tmp_path)
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [test])
-        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == Served.ALL
+        assert serv.serve_path(tmp_path, server_map=smap)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert test.code == 200
     assert test.len_srv == test.len_org
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     "path",
     [
         # simple path
@@ -362,7 +360,7 @@ def test_sapphire_17(client, tmp_path, path):
         # point "redirect" at target
         smap.set_redirect("redirect", target.file, required=True)
         client.launch("127.0.0.1", serv.port, [redirect])
-        status, served = serv.serve_path(str(tmp_path), server_map=smap)
+        status, served = serv.serve_path(tmp_path, server_map=smap)
     assert status == Served.ALL
     assert len(served) == 1
     assert client.wait(timeout=10)
@@ -418,7 +416,7 @@ def test_sapphire_18(client, tmp_path):
         smap.set_include("/", str(inc1_path))  # mount at '/'
         smap.set_include("inc_test", str(inc2_path))  # mount at '/inc_test'
         client.launch("127.0.0.1", serv.port, files_to_serve, in_order=True)
-        status, files_served = serv.serve_path(str(root_path), server_map=smap)
+        status, files_served = serv.serve_path(root_path, server_map=smap)
     assert status == Served.ALL
     assert "test_case.html" in files_served
     assert (inc1_path / "included_file1.html").as_posix() in files_served
@@ -434,7 +432,7 @@ def test_sapphire_18(client, tmp_path):
     assert inc403.code == 403
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     "query, required",
     [
         # dynamic response not required
@@ -485,7 +483,7 @@ def dr_callback(data):
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, files, in_order=True)
         assert (
-            serv.serve_path(str(tmp_path), optional_files=optional, server_map=smap)[0]
+            serv.serve_path(tmp_path, optional_files=optional, server_map=smap)[0]
             == Served.ALL
         )
     assert client.wait(timeout=10)
@@ -512,7 +510,7 @@ def test_sapphire_20(client_factory, tmp_path):
         )
         client = client_factory(rx_size=2)
         client.launch("127.0.0.1", serv.port, [test], throttle=0.1)
-        assert serv.serve_path(str(tmp_path), optional_files=optional)[0] == Served.ALL
+        assert serv.serve_path(tmp_path, optional_files=optional)[0] == Served.ALL
     assert client_defer.wait(timeout=10)
     assert client.wait(timeout=10)
     assert test.code == 200
@@ -527,7 +525,7 @@ def test_sapphire_21(client, tmp_path):
     test = _create_test("test_case.html", tmp_path)
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [bad_test, test], in_order=True)
-        assert serv.serve_path(str(tmp_path), optional_files=optional)[0] == Served.ALL
+        assert serv.serve_path(tmp_path, optional_files=optional)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert test.code == 200
     assert bad_test.code == 400
@@ -547,7 +545,7 @@ def test_sapphire_22(client, tmp_path):
             indicate_failure=True,
             in_order=True,
         )
-        assert serv.serve_path(str(tmp_path), optional_files=optional)[0] == Served.ALL
+        assert serv.serve_path(tmp_path, optional_files=optional)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert test.code == 200
     assert bad_test.code == 0
@@ -568,7 +566,7 @@ def test_sapphire_23(client_factory, tmp_path):
                 client.launch(
                     "127.0.0.1", serv.port, to_serve, in_order=True, throttle=0.05
                 )
-            status, files_served = serv.serve_path(str(tmp_path))
+            status, files_served = serv.serve_path(tmp_path)
             # call serv.close() instead of waiting for the clients to timeout
             serv.close()
         finally:
@@ -618,7 +616,7 @@ def _dyn_test_cb(_):
             clients.append(client_factory(rx_size=1))
             throttle = 0.05 if random.getrandbits(1) else 0
             clients[-1].launch("127.0.0.1", serv.port, to_serve, throttle=throttle)
-        assert serv.serve_path(str(tmp_path), server_map=smap)[0] == Served.ALL
+        assert serv.serve_path(tmp_path, server_map=smap)[0] == Served.ALL
 
 
 def test_sapphire_25(client, tmp_path):
@@ -629,8 +627,8 @@ def test_sapphire_25(client, tmp_path):
     test = _create_test("test_case.html", tmp_path)
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, [test_dr, test], in_order=True)
-        with pytest.raises(TypeError):
-            serv.serve_path(str(tmp_path), server_map=smap)
+        with raises(TypeError):
+            serv.serve_path(tmp_path, server_map=smap)
 
 
 def test_sapphire_26(client, tmp_path):
@@ -645,7 +643,7 @@ def test_sapphire_26(client, tmp_path):
     client.rx_size = 0x2800
     with Sapphire(timeout=60) as serv:
         client.launch("127.0.0.1", serv.port, [t_file], throttle=0.25)
-        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
+        assert serv.serve_path(tmp_path)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert t_file.code == 200
     assert t_file.len_srv == t_file.len_org
@@ -665,7 +663,7 @@ def test_sapphire_27(client, tmp_path):
         client.launch(
             "127.0.0.1", serv.port, files_to_serve, indicate_failure=True, throttle=0.1
         )
-        status, files_served = serv.serve_path(str(tmp_path))
+        status, files_served = serv.serve_path(tmp_path)
     assert status == Served.TIMEOUT
     assert len(files_served) < len(files_to_serve)
 
@@ -686,7 +684,7 @@ def _test_callback():
                 return test.requested < 3
 
         assert (
-            serv.serve_path(str(tmp_path), continue_cb=_test_callback, forever=True)[0]
+            serv.serve_path(tmp_path, continue_cb=_test_callback, forever=True)[0]
             == Served.ALL
         )
     for client in clients:
@@ -697,7 +695,7 @@ def _test_callback():
     assert test.len_srv == test.len_org
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     "file_name",
     [
         # space in file name
@@ -713,7 +711,7 @@ def test_sapphire_29(client, tmp_path, file_name):
     to_serve = [_create_test(file_name, tmp_path)]
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, to_serve)
-        assert serv.serve_path(str(tmp_path))[0] == Served.ALL
+        assert serv.serve_path(tmp_path)[0] == Served.ALL
     assert client.wait(timeout=10)
     assert all(t_file.code == 200 for t_file in to_serve)
 
@@ -729,7 +727,7 @@ def test_sapphire_30(client, tmp_path):
     ]
     with Sapphire(timeout=10) as serv:
         client.launch("127.0.0.1", serv.port, to_serve, in_order=True)
-        assert serv.serve_path(str(tmp_path), optional_files=[path])[0] == Served.ALL
+        assert serv.serve_path(tmp_path, optional_files=[path])[0] == Served.ALL
     assert client.wait(timeout=10)
     assert all(t_file.code is not None for t_file in to_serve)
 
@@ -748,7 +746,7 @@ def test_sapphire_31(mocker):
     fake_sock.reset_mock()
     # failure to bind
     fake_sock.return_value.bind.side_effect = OSError
-    with pytest.raises(OSError):
+    with raises(OSError):
         Sapphire._create_listening_socket(False, None)
     assert fake_sock.return_value.close.call_count == 1
     assert fake_sleep.call_count == 0
@@ -777,7 +775,7 @@ def test_sapphire_32(mocker):
     assert pending.close.call_count == 1
 
 
-@pytest.mark.skipif(system() != "Windows", reason="Only supported on Windows")
+@mark.skipif(system() != "Windows", reason="Only supported on Windows")
 def test_sapphire_33(client, tmp_path):
     """test serving from path using Windows short file name"""
     wwwroot = tmp_path / "long_path_name_that_can_be_truncated_on_windows"
diff --git a/sapphire/test_worker.py b/sapphire/test_worker.py
index 8708ae35..b3fcc711 100644
--- a/sapphire/test_worker.py
+++ b/sapphire/test_worker.py
@@ -69,7 +69,7 @@ def test_worker_03(mocker):
 def test_worker_04(mocker, tmp_path):
     """test Worker.launch()"""
     (tmp_path / "testfile").touch()
-    job = Job(str(tmp_path))
+    job = Job(tmp_path)
     clnt_sock = mocker.Mock(spec_set=socket.socket)
     clnt_sock.recv.return_value = b"GET /testfile HTTP/1.1"
     serv_sock = mocker.Mock(spec_set=socket.socket)

From a90ae59c4c23ca85a9b606702e0e04ec84bbb502 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 24 Nov 2021 18:10:58 -0800
Subject: [PATCH 383/531] [sapphire] Remove Job.initial_queue_size

---
 sapphire/job.py           | 16 ++++++----------
 sapphire/test_job.py      | 10 +++++++---
 sapphire/test_sapphire.py |  7 +++----
 3 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/sapphire/job.py b/sapphire/job.py
index 073bd516..ac0c859d 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -60,7 +60,6 @@ class Job:
         "accepting",
         "exceptions",
         "forever",
-        "initial_queue_size",
         "server_map",
         "worker_complete",
     )
@@ -82,7 +81,6 @@ def __init__(
         self.auto_close = auto_close
         self.exceptions = Queue()
         self.forever = forever
-        self.initial_queue_size = 0
         self.server_map = server_map
         self.worker_complete = Event()
         self._build_queue(optional_files)
@@ -123,8 +121,7 @@ def _build_queue(self, optional_files):
                 if resource.required:
                     self._pending.files.add(dyn_resp)
                     LOG.debug("%s: %r -> %r", "required", dyn_resp, resource.target)
-        self.initial_queue_size = len(self._pending.files)
-        LOG.debug("%d files required to serve", self.initial_queue_size)
+        LOG.debug("%d files required to serve", len(self._pending.files))
 
     @classmethod
     def lookup_mime(cls, url):
@@ -241,9 +238,8 @@ def served(self):
     @property
     def status(self):
         with self._pending.lock:
-            queue_size = len(self._pending.files)
-        if queue_size == 0:
-            return Served.ALL
-        if queue_size < self.initial_queue_size:
-            return Served.REQUEST
-        return Served.NONE
+            if not self._served.files:
+                return Served.NONE
+            if not self._pending.files:
+                return Served.ALL
+        return Served.REQUEST
diff --git a/sapphire/test_job.py b/sapphire/test_job.py
index ac469ee6..686e77af 100644
--- a/sapphire/test_job.py
+++ b/sapphire/test_job.py
@@ -16,7 +16,7 @@ def test_job_01(tmp_path):
     """test creating an empty Job"""
     job = Job(tmp_path)
     assert not job.forever
-    assert job.status == Served.ALL
+    assert job.status == Served.NONE
     assert job.lookup_resource("") is None
     assert job.lookup_resource("test") is None
     assert job.lookup_resource("test/test/") is None
@@ -53,21 +53,25 @@ def test_job_02(tmp_path):
     assert job.pending == 2
     assert resource.target == tmp_path / "req_file_1.txt"
     assert resource.type == Resource.URL_FILE
-    assert not job.is_forbidden(str(req1_path))
+    assert not job.is_forbidden(req1_path)
     assert not job.remove_pending("no_file.test")
     assert job.pending == 2
     assert not job.remove_pending(str(req1_path))
+    job.mark_served(req1_path)
     assert job.status == Served.REQUEST
     assert job.pending == 1
     assert job.remove_pending(str(req2_path))
+    job.mark_served(req2_path)
     assert job.status == Served.ALL
     assert job.pending == 0
     assert job.remove_pending(str(req1_path))
+    job.mark_served(req1_path)
     resource = job.lookup_resource("opt_file_1.txt")
     assert not resource.required
     assert resource.target == opt1_path
     assert resource.type == Resource.URL_FILE
     assert job.remove_pending(str(opt1_path))
+    job.mark_served(opt1_path)
     resource = job.lookup_resource("nested/opt_file_2.txt")
     assert resource.target == opt2_path
     assert resource.type == Resource.URL_FILE
@@ -198,7 +202,7 @@ def test_job_06(tmp_path):
     smap.set_dynamic_response("cb1", lambda _: 0, mime_type="mime_type")
     smap.set_dynamic_response("cb2", lambda _: 1)
     job = Job(tmp_path, server_map=smap)
-    assert job.status == Served.ALL
+    assert job.status == Served.NONE
     assert job.pending == 0
     resource = job.lookup_resource("cb1")
     assert resource.type == Resource.URL_DYNAMIC
diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 36d8436f..9443833c 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -471,12 +471,11 @@ def dr_callback(data):
     test_dr = _TestFile(request)
     test_dr.len_org = len(_data)
     test_dr.md5_org = hashlib.md5(_data).hexdigest()
+    test = _create_test("test_case.html", tmp_path)
     if required:
-        test = None
-        optional = []
-        files = [test_dr]
+        optional = [test.file]
+        files = [test, test_dr]
     else:
-        test = _create_test("test_case.html", tmp_path)
         optional = [test_dr.file]
         files = [test_dr, test]
     # test request

From 7c08f634d03d11752a3dfeb2f87581231fc47066 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 25 Nov 2021 16:54:32 -0800
Subject: [PATCH 384/531] Add '--smoke-test' command line argument

This can be used in CI to run a few iterations.
---
 grizzly/args.py         |  6 ++++
 grizzly/main.py         | 11 ++++++--
 grizzly/session.py      |  5 ++++
 grizzly/test_main.py    | 27 ++++++++++++------
 grizzly/test_session.py | 61 +++++++++++++++++++++++++++++++++++++----
 5 files changed, 93 insertions(+), 17 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 130e47ad..5001abb6 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -281,6 +281,12 @@ def __init__(self):
             default=0,
             help="Maximum number of iterations to be performed. (default: no limit)",
         )
+        self.parser.add_argument(
+            "--smoke-test",
+            action="store_true",
+            help="Perform a small number of iterations to check if everything is"
+            " working as expected. Exit immediately if a result is found.",
+        )
         self.parser.add_argument(
             "-v",
             "--verbose",
diff --git a/grizzly/main.py b/grizzly/main.py
index 20fad42b..e6f8df6f 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -107,8 +107,10 @@ def main(args):
             reporter = FilesystemReporter(pathjoin(getcwd(), "results"))
             LOG.info("Results will be stored in %r", reporter.report_path)
 
-        if args.limit:
-            LOG.info("%r iteration(s) will be attempted", args.limit)
+        # make sure an iteration limit is set if smoke_test is True
+        iteration_limit = (args.limit or 10) if args.smoke_test else args.limit
+        if iteration_limit:
+            LOG.info("%r iteration(s) will be attempted", iteration_limit)
         if args.runtime:
             LOG.info("Runtime is limited to %rs", args.runtime)
 
@@ -138,7 +140,8 @@ def main(args):
                 args.ignore,
                 time_limit,
                 input_path=args.input,
-                iteration_limit=args.limit,
+                iteration_limit=iteration_limit,
+                result_limit=1 if args.smoke_test else 0,
                 runtime_limit=args.runtime,
                 display_mode=display_mode,
             )
@@ -164,4 +167,6 @@ def main(args):
             adapter.cleanup()
         LOG.info("Done.")
 
+    if session and session.status.results.total > 0:
+        return Exit.ERROR
     return Exit.SUCCESS
diff --git a/grizzly/session.py b/grizzly/session.py
index 401953fd..92ec37bf 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -141,6 +141,7 @@ def run(
         time_limit,
         input_path=None,
         iteration_limit=0,
+        result_limit=0,
         runtime_limit=0,
         display_mode=DISPLAY_NORMAL,
     ):
@@ -287,6 +288,10 @@ def run(
                 LOG.info("Hit iteration limit (%d)", iteration_limit)
                 break
 
+            if result_limit and self.status.results.total >= result_limit:
+                LOG.info("Hit result limit (%ds)", result_limit)
+                break
+
             if runtime_limit and self.status.runtime >= runtime_limit:
                 LOG.info("Hit runtime limit (%ds)", runtime_limit)
                 break
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index af2bf0b6..ce96b297 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -38,6 +38,7 @@ def __init__(self):
         self.relaunch = 1000
         self.runtime = 0
         self.s3_fuzzmanager = False
+        self.smoke_test = False
         self.time_limit = None
         self.timeout = None
         self.tool = None
@@ -47,23 +48,25 @@ def __init__(self):
 
 
 @mark.parametrize(
-    "cov, adpt_relaunch, limit, runtime, verbose",
+    "cov, adpt_relaunch, limit, runtime, smoke_test, verbose",
     [
         # successful run
-        (False, 0, 0, 0, True),
+        (False, 0, 0, 0, False, True),
         # successful run (with iteration limit)
-        (False, 0, 10, 0, True),
+        (False, 0, 10, 0, False, True),
         # successful run (with runtime limit)
-        (False, 0, 0, 10, True),
+        (False, 0, 0, 10, False, True),
         # successful run (with coverage)
-        (True, 0, 0, 0, False),
+        (True, 0, 0, 0, False, False),
         # relaunch 1
-        (False, 1, 0, 0, False),
+        (False, 1, 0, 0, False, False),
         # relaunch 10
-        (False, 10, 0, 0, False),
+        (False, 10, 0, 0, False, False),
+        # smoke test detects result
+        (False, 0, 0, 0, True, False),
     ],
 )
-def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, verbose):
+def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, smoke_test, verbose):
     """test main()"""
     fake_adapter = mocker.NonCallableMock(spec_set=Adapter)
     fake_adapter.RELAUNCH = adpt_relaunch
@@ -78,6 +81,7 @@ def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, verbose):
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec_set=True)
     fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
+    fake_session.return_value.status.results.total = 1 if smoke_test else 0
     args = FakeArgs()
     args.asset = [
         ["fake", "fake"],
@@ -87,13 +91,14 @@ def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, verbose):
     args.limit = limit
     args.runtime = runtime
     args.rr = True
+    args.smoke_test = smoke_test
     args.valgrind = True
     args.xvfb = True
     args.verbose = verbose
     if not verbose:
         args.log_level = 20
     args.coverage = cov
-    assert main(args) == Exit.SUCCESS
+    assert main(args) == (Exit.ERROR if smoke_test else Exit.SUCCESS)
     assert fake_session.mock_calls[0][-1]["coverage"] == cov
     if adpt_relaunch:
         assert fake_session.mock_calls[0][-1]["relaunch"] == adpt_relaunch
@@ -128,6 +133,7 @@ def test_main_02(mocker, reporter):
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
+    fake_session.return_value.status.results.total = 0
     args = FakeArgs()
     args.adapter = "fake"
     if reporter == "FuzzManager":
@@ -166,6 +172,7 @@ def test_main_03(mocker, exit_code, to_raise):
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
+    fake_session.return_value.status.results.total = 0
     args = FakeArgs()
     args.adapter = "fake"
     args.input = "fake"
@@ -202,6 +209,7 @@ def test_main_04(mocker, arg_testlimit, arg_timeout, exit_code):
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
+    fake_session.return_value.status.results.total = 0
     args = FakeArgs()
     args.adapter = "fake"
     args.time_limit = arg_testlimit
@@ -235,6 +243,7 @@ def test_main_05(mocker, pernosco, rr, valgrind):
     )
     fake_session = mocker.patch("grizzly.main.Session", autospec=True)
     fake_session.return_value.server = mocker.Mock(spec_set=Sapphire)
+    fake_session.return_value.status.results.total = 0
     args = FakeArgs()
     args.adapter = "fake"
     # maximum one debugger allowed at a time
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index b3b61e62..043d95b5 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -6,7 +6,7 @@
 """
 unit tests for grizzly.Session
 """
-from itertools import count
+from itertools import chain, count, repeat
 
 from pytest import mark, raises
 
@@ -191,6 +191,9 @@ def test_session_02(mocker, harness, relaunch, remaining):
 )
 def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters, has_sig):
     """test Session - detecting failure"""
+    collector = mocker.patch("grizzly.common.report.Collector", autospec=True)
+    # don't search for signatures locally
+    collector.return_value.sigCacheDir = None
     adapter = SimpleAdapter(harness)
     reporter = mocker.Mock(spec_set=Reporter)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
@@ -208,9 +211,9 @@ def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters, has
         side_effect=((x % relaunch == 0) for x in range(iters))
     )
     # failure is on final iteration
-    target.check_result.side_effect = [Result.NONE for x in range(iters - 1)] + [
-        Result.FOUND
-    ]
+    target.check_result.side_effect = chain(
+        repeat(Result.NONE, iters - 1), (Result.FOUND,)
+    )
     target.log_size.return_value = 1
     # create Report
     log_path = tmp_path / "logs"
@@ -444,7 +447,7 @@ def test_session_10(mocker):
     ],
 )
 def test_session_11(mocker, harness, report_size, relaunch, iters, report_limit):
-    """test Session - limit result submission"""
+    """test Session - limit report submission"""
     adapter = SimpleAdapter(harness)
     reporter = mocker.Mock(spec_set=Reporter)
     report = mocker.Mock(spec_set=Report, major="abc", minor="def", crash_hash="123")
@@ -479,6 +482,54 @@ def test_session_11(mocker, harness, report_size, relaunch, iters, report_limit)
         assert reporter.submit.call_args[0][1].major == "abc"
 
 
+@mark.parametrize(
+    "harness, iters, result_limit, results",
+    [
+        # hit result limit
+        (True, 0, 1, 1),
+        # don't hit result limit (one result)
+        (True, 10, 5, 1),
+        # don't hit result limit (no results)
+        (True, 2, 1, 0),
+    ],
+)
+def test_session_12(mocker, harness, iters, result_limit, results):
+    """test Session - limit results"""
+    adapter = SimpleAdapter(harness)
+    reporter = mocker.Mock(spec_set=Reporter)
+    report = mocker.Mock(spec_set=Report, major="abc", minor="def", crash_hash="123")
+    report.crash_info.createShortSignature.return_value = "[@ sig]"
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
+    target = mocker.Mock(
+        spec_set=Target,
+        assets=mocker.Mock(spec_set=AssetManager),
+        environ=dict(),
+        launch_timeout=30,
+    )
+    target.monitor.launches = 1
+    # avoid shutdown delay
+    target.monitor.is_healthy.return_value = False
+    type(target).closed = mocker.PropertyMock(return_value=True)
+    target.check_result.side_effect = chain(
+        repeat(Result.FOUND, results), repeat(Result.NONE, iters - results)
+    )
+    target.log_size.return_value = 1
+    target.create_report.return_value = report
+    with Session(adapter, reporter, server, target, relaunch=1) as session:
+        server.serve_path = lambda *a, **kv: (
+            Served.ALL,
+            [session.iomanager.page_name(offset=-1)],
+        )
+        session.run(
+            [], 10, input_path="a.bin", iteration_limit=iters, result_limit=result_limit
+        )
+    if results >= result_limit > iters:
+        # limited by result_limit
+        assert session.status.iteration == result_limit
+    else:
+        assert session.status.iteration == iters
+
+
 def test_log_output_limiter_01(mocker):
     """test LogOutputLimiter.ready() not ready"""
     fake_time = mocker.patch("grizzly.session.time", autospec=True)

From 1527917a2e79cd3412cc072ebf6d2727034c8ebf Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 25 Nov 2021 17:47:24 -0800
Subject: [PATCH 385/531] [tests] Patch common.report.Collector to avoid
 scanning disk for signatures

---
 grizzly/conftest.py           | 8 ++++++++
 grizzly/replay/test_main.py   | 4 +++-
 grizzly/replay/test_replay.py | 4 +++-
 grizzly/test_session.py       | 5 +----
 4 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/grizzly/conftest.py b/grizzly/conftest.py
index fb0dd4b9..3d358155 100644
--- a/grizzly/conftest.py
+++ b/grizzly/conftest.py
@@ -10,6 +10,14 @@
 from grizzly.common.status import ReductionStatus, Status
 
 
+@fixture
+def patch_collector(mocker):
+    """Provide a mock Collector to avoid scanning for signatures on disk."""
+    collector = mocker.patch("grizzly.common.report.Collector", autospec=True)
+    # don't search for signatures locally
+    collector.return_value.sigCacheDir = None
+
+
 @fixture
 def tmp_path_status_db(tmp_path, mocker):
     """Use a temporary database file for testing."""
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 81998224..0899ca70 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -22,7 +22,9 @@
 from .replay import ReplayManager
 from .test_replay import _fake_save_logs
 
-pytestmark = mark.usefixtures("tmp_path_grz_tmp", "tmp_path_replay_status_db")
+pytestmark = mark.usefixtures(
+    "patch_collector", "tmp_path_grz_tmp", "tmp_path_replay_status_db"
+)
 
 
 def test_main_01(mocker, tmp_path):
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 02c012b6..5ff59f0b 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -18,7 +18,9 @@
 from ..target import AssetManager, Result, Target
 from .replay import ReplayManager, ReplayResult
 
-pytestmark = mark.usefixtures("tmp_path_grz_tmp", "tmp_path_replay_status_db")
+pytestmark = mark.usefixtures(
+    "patch_collector", "tmp_path_grz_tmp", "tmp_path_replay_status_db"
+)
 
 
 def _fake_save_logs(result_logs, _meta=False):
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 043d95b5..0f7167ca 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -18,7 +18,7 @@
 from .session import LogOutputLimiter, Session, SessionError
 from .target import AssetManager, Result, Target, TargetLaunchError
 
-pytestmark = mark.usefixtures("tmp_path_status_db")
+pytestmark = mark.usefixtures("patch_collector", "tmp_path_status_db")
 
 
 class SimpleAdapter(Adapter):
@@ -191,9 +191,6 @@ def test_session_02(mocker, harness, relaunch, remaining):
 )
 def test_session_03(mocker, tmp_path, harness, report_size, relaunch, iters, has_sig):
     """test Session - detecting failure"""
-    collector = mocker.patch("grizzly.common.report.Collector", autospec=True)
-    # don't search for signatures locally
-    collector.return_value.sigCacheDir = None
     adapter = SimpleAdapter(harness)
     reporter = mocker.Mock(spec_set=Reporter)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)

From efefb96d20ca820672ab490f828bd16f644de0bd Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 26 Nov 2021 10:56:58 -0800
Subject: [PATCH 386/531] Make '--smoke-test' display browser crash log

---
 grizzly/common/reporter.py      | 11 +++++++++--
 grizzly/common/test_reporter.py | 18 +++++++++++-------
 grizzly/main.py                 |  1 +
 3 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index e5c64183..8d119608 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -73,6 +73,11 @@ class Quality(IntEnum):
 
 
 class Reporter(metaclass=ABCMeta):
+    __slots__ = ("display_logs",)
+
+    def __init__(self):
+        self.display_logs = getenv("GRZ_DISPLAY_REPORT") == "1"
+
     @abstractmethod
     def _post_submit(self):
         pass
@@ -101,7 +106,7 @@ def submit(self, test_cases, report):
         assert report.path is not None
         self._pre_submit(report)
         # output report contents to console
-        if getenv("GRZ_DISPLAY_REPORT") == "1":
+        if self.display_logs:
             if not report.is_hang:
                 with open(report.preferred, "rb") as log_fp:
                     LOG.info(
@@ -121,9 +126,10 @@ def submit(self, test_cases, report):
 class FilesystemReporter(Reporter):
     DISK_SPACE_ABORT = 512 * 1024 * 1024  # 512 MB
 
-    __slots__ = ("major_bucket", "report_path")
+    __slots__ = ("major_bucket", "min_space", "report_path")
 
     def __init__(self, report_path, major_bucket=True):
+        super().__init__()
         self.major_bucket = major_bucket
         self.min_space = FilesystemReporter.DISK_SPACE_ABORT
         assert isinstance(report_path, str) and report_path
@@ -168,6 +174,7 @@ class FuzzManagerReporter(Reporter):
     __slots__ = ("_extra_metadata", "force_report", "quality", "tool")
 
     def __init__(self, tool=None):
+        super().__init__()
         self._extra_metadata = {}
         self.force_report = False
         self.quality = Quality.UNREDUCED
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 46b8502f..3033f693 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -29,19 +29,18 @@ def _create_crash_log(log_path):
 
 
 @mark.parametrize(
-    "diplay_report, is_hang",
+    "display_logs, is_hang",
     [
         # do not display report
-        ("0", False),
+        (False, False),
         # display report
-        ("1", False),
+        (True, False),
         # display report (hang)
-        ("1", True),
+        (True, True),
     ],
 )
-def test_reporter_01(mocker, tmp_path, diplay_report, is_hang):
+def test_reporter_01(mocker, tmp_path, display_logs, is_hang):
     """test creating a simple Reporter"""
-    mocker.patch("grizzly.common.reporter.getenv", return_value=diplay_report)
 
     class SimpleReporter(Reporter):
         def _pre_submit(self, report):
@@ -58,6 +57,7 @@ def _submit_report(self, report, test_cases):
         spec_set=Report, is_hang=is_hang, preferred=str(tmp_path / "log_stderr.txt")
     )
     reporter = SimpleReporter()
+    reporter.display_logs = display_logs
     reporter.submit([], report=report)
     assert report.cleanup.call_count == 1
 
@@ -174,6 +174,11 @@ def test_fuzzmanager_reporter_01(mocker, tmp_path):
 )
 def test_fuzzmanager_reporter_02(mocker, tmp_path, tests, frequent, ignored, force):
     """test FuzzManagerReporter.submit()"""
+    mocker.patch(
+        "grizzly.common.reporter.FuzzManagerReporter._ignored",
+        new_callable=mocker.MagicMock,
+        return_value=ignored,
+    )
     mocker.patch(
         "grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path)
     )
@@ -201,7 +206,6 @@ def test_fuzzmanager_reporter_02(mocker, tmp_path, tests, frequent, ignored, for
         test_cases.append(fake_test)
     reporter = FuzzManagerReporter("fake_bin")
     reporter.force_report = force
-    reporter._ignored = lambda x: ignored
     reporter.submit(test_cases, Report(str(log_path), "fake_bin", is_hang=True))
     assert not log_path.is_dir()
     if (frequent and not force) or ignored:
diff --git a/grizzly/main.py b/grizzly/main.py
index e6f8df6f..06bdf8da 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -106,6 +106,7 @@ def main(args):
         else:
             reporter = FilesystemReporter(pathjoin(getcwd(), "results"))
             LOG.info("Results will be stored in %r", reporter.report_path)
+        reporter.display_logs = args.smoke_test or reporter.display_logs
 
         # make sure an iteration limit is set if smoke_test is True
         iteration_limit = (args.limit or 10) if args.smoke_test else args.limit

From 83d87d561c8d1ed3b4b59e7b4ffc262b7050650a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 26 Nov 2021 13:24:30 -0800
Subject: [PATCH 387/531] Add testcase Quality.IGNORED

---
 grizzly/common/reporter.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 8d119608..0dba61a2 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -56,6 +56,8 @@ class Quality(IntEnum):
     REDUCED = 0
     # original used for reduction (a reduced version exists)
     ORIGINAL = 1
+    # used to manually mark a report as unreducible
+    IGNORED = 3
     # the testcase is currently being reduced
     REDUCING = 4
     # haven't attempted reduction yet (1st attempt, generic reducer)

From 79a260a8da927a017e492cb0e5e01d69fdb92704 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 26 Nov 2021 13:39:35 -0800
Subject: [PATCH 388/531] Update minimum required version of FFPuppet

---
 setup.cfg | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.cfg b/setup.cfg
index 941f955c..32c370c3 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -22,7 +22,7 @@ include_package_data = True
 install_requires =
     cssbeautifier
     fasteners
-    ffpuppet >= 0.8.4
+    ffpuppet >= 0.8.7
     FuzzManager
     jsbeautifier
     lithium-reducer >= 0.5.3

From b36b7ebd9e01662998ed7a5d80addf5478ed1762 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 29 Nov 2021 17:58:19 -0800
Subject: [PATCH 389/531] Fix typo

---
 grizzly/session.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/session.py b/grizzly/session.py
index 92ec37bf..c8078978 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -289,7 +289,7 @@ def run(
                 break
 
             if result_limit and self.status.results.total >= result_limit:
-                LOG.info("Hit result limit (%ds)", result_limit)
+                LOG.info("Hit result limit (%d)", result_limit)
                 break
 
             if runtime_limit and self.status.runtime >= runtime_limit:

From fca0e4d22dd79090f9442639f313a83eabf2e7c8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 29 Nov 2021 18:01:03 -0800
Subject: [PATCH 390/531] Add 'grizzly.replay.crash' and
 'grizzly.replay.bucket'

This involved updating and reusing the 'grizzly.reduce.crash'
and 'grizzly.reduce.bucket' code.
---
 grizzly/common/fuzzmanager.py      |  34 ++++++++
 grizzly/common/test_fuzzmanager.py |  57 +++++++++----
 grizzly/reduce/args.py             |  32 +------
 grizzly/reduce/bucket.py           |  53 ++----------
 grizzly/reduce/core.py             |   2 +-
 grizzly/reduce/crash.py            |  33 +++-----
 grizzly/reduce/test_main_fm.py     | 130 +++--------------------------
 grizzly/replay/args.py             |  54 ++++++++++++
 grizzly/replay/bucket.py           |  55 ++++++++++++
 grizzly/replay/crash.py            |  57 +++++++++++++
 grizzly/replay/test_args.py        |  20 ++++-
 grizzly/replay/test_main_fm.py     | 105 +++++++++++++++++++++++
 12 files changed, 394 insertions(+), 238 deletions(-)
 create mode 100644 grizzly/replay/bucket.py
 create mode 100644 grizzly/replay/crash.py
 create mode 100644 grizzly/replay/test_main_fm.py

diff --git a/grizzly/common/fuzzmanager.py b/grizzly/common/fuzzmanager.py
index 8a73568b..952d1633 100644
--- a/grizzly/common/fuzzmanager.py
+++ b/grizzly/common/fuzzmanager.py
@@ -4,6 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Interface for getting Crash and Bucket data from CrashManager API"""
 import json
+from contextlib import contextmanager
 from logging import getLogger
 from os import unlink
 from pathlib import Path
@@ -42,6 +43,12 @@ def __init__(self, bucket_id):
     def bucket_id(self):
         return self._bucket_id
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.cleanup()
+
     def __getattr__(self, name):
         if self._data is None:
             self._data = self._coll.get(self._url).json()
@@ -215,9 +222,16 @@ def __init__(self, crash_id):
     def crash_id(self):
         return self._crash_id
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.cleanup()
+
     def __getattr__(self, name):
         if self._data is None or (name in self.RAW_FIELDS and name not in self._data):
             need_raw = "1" if name in self.RAW_FIELDS else "0"
+            # TODO: handle 403 and 404?
             self._data = self._coll.get(
                 self._url, params={"include_raw": need_raw}
             ).json()
@@ -283,3 +297,23 @@ def testcase_path(self):
             raise
         self._tc_filename = Path(filename)
         return self._tc_filename
+
+
+@contextmanager
+def load_fm_data(crash_id, load_bucket=False):
+    """Load CrashEntry including Bucket from FuzzManager.
+
+    Arguments:
+        crash_id (int): Crash ID to load.
+        load_bucket (bool): Attempt to load bucket.
+
+    Yields:
+        2-tuple(CrashEntry, Bucket): Data loaded from FuzzManager.
+    """
+    with CrashEntry(crash_id) as crash:
+        # load signature if needed
+        if load_bucket and crash.bucket:
+            with Bucket(crash.bucket) as bucket:
+                yield crash, bucket
+        else:
+            yield crash, None
diff --git a/grizzly/common/test_fuzzmanager.py b/grizzly/common/test_fuzzmanager.py
index 5d8cd636..b9de8164 100644
--- a/grizzly/common/test_fuzzmanager.py
+++ b/grizzly/common/test_fuzzmanager.py
@@ -5,9 +5,9 @@
 """Tests for interface for getting Crash and Bucket data from CrashManager API"""
 import json
 
-from pytest import raises
+from pytest import mark, raises
 
-from .fuzzmanager import Bucket, CrashEntry
+from .fuzzmanager import Bucket, CrashEntry, load_fm_data
 
 
 def test_bucket_1(mocker):
@@ -90,8 +90,7 @@ def test_bucket_4(mocker):
         "shortDescription": "sig desc",
         "best_quality": 0,
     }
-    bucket = Bucket(123)
-    try:
+    with Bucket(123) as bucket:
         assert coll.return_value.get.call_count == 0
         sig_path = bucket.signature_path()
         assert sig_path.is_file()
@@ -106,8 +105,6 @@ def test_bucket_4(mocker):
         assert coll.return_value.get.call_count == 1
         # second call returns same path
         assert bucket.signature_path() == sig_path
-    finally:
-        bucket.cleanup()
     assert coll.return_value.get.call_count == 1
 
 
@@ -173,13 +170,12 @@ def test_crash_3(mocker):
         "id": 234,
         "testcase": "test.bz2",
     }
-    crash = CrashEntry(234)
-    assert crash.testcase == "test.bz2"  # pre-load data dict so I can re-patch get
-    coll.return_value.get.return_value = mocker.Mock(
-        content=b"\x01\x02\x03",
-        headers={"content-disposition"},
-    )
-    try:
+    with CrashEntry(234) as crash:
+        assert crash.testcase == "test.bz2"  # pre-load data dict so I can re-patch get
+        coll.return_value.get.return_value = mocker.Mock(
+            content=b"\x01\x02\x03",
+            headers={"content-disposition"},
+        )
         assert coll.return_value.get.call_count == 1
         tc_path = crash.testcase_path()
         assert tc_path.is_file()
@@ -188,6 +184,37 @@ def test_crash_3(mocker):
         assert coll.return_value.get.call_count == 2
         # second call returns same path
         assert crash.testcase_path() == tc_path
-    finally:
-        crash.cleanup()
     assert coll.return_value.get.call_count == 2
+
+
+@mark.parametrize(
+    "bucket_id, load_bucket",
+    [
+        # Nothing to load, don't try
+        (None, False),
+        # Nothing to load, try
+        (None, True),
+        # Bucket exists, don't load it
+        (111, False),
+        # Bucket exists, load it
+        (111, True),
+    ],
+)
+def test_load_fm_data_1(mocker, bucket_id, load_bucket):
+    """test load_fm_data()"""
+    coll = mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
+    coll.return_value.serverProtocol = "http"
+    coll.return_value.serverPort = 123
+    coll.return_value.serverHost = "allizom.org"
+    coll.return_value.get.return_value = mocker.Mock(
+        content=b"\x01\x02\x03",
+        headers={"content-disposition"},
+    )
+    coll.return_value.get.return_value.json.return_value = {"bucket": bucket_id}
+
+    with load_fm_data(123, load_bucket) as (crash, bucket):
+        assert isinstance(crash, CrashEntry)
+        if load_bucket and bucket_id:
+            assert isinstance(bucket, Bucket)
+        else:
+            assert bucket is None
diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 1e556d50..7b522e66 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -4,7 +4,6 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """CLI argument parsing for Grizzly reduction.
 """
-from argparse import SUPPRESS
 from logging import getLogger
 from pathlib import Path
 
@@ -56,12 +55,6 @@ def __init__(self):
             help="One or more strategies (space-separated). Available: %s (default: %s)"
             % (" ".join(sorted(STRATEGIES)), " ".join(DEFAULT_STRATEGIES)),
         )
-        # hidden argument to add original crash ID as metadata when reported
-        reduce_args.add_argument(
-            "--reducer-crash-id",
-            type=int,
-            help=SUPPRESS,
-        )
 
     def sanity_check(self, args):
         """Sanity check reducer args.
@@ -108,30 +101,7 @@ class ReduceFuzzManagerIDArgs(ReduceArgs):
     def __init__(self):
         """Initialize argument parser."""
         super().__init__()
-
-        # madhax alert!
-        #
-        # We need to modify the meaning of the 'input' positional to accept an int ID
-        # instead of a local testcase.
-        # This is not possible with the public argparse API.
-        #
-        # refs: stackoverflow.com/questions/32807319/disable-remove-argument-in-argparse
-        #       bugs.python.org/issue19462
-
-        # look up the action for the positional `input` arg
-        action = None
-        for arg in self.parser._actions:
-            if arg.dest == "input" and not arg.option_strings:
-                action = arg
-                break
-        assert action is not None
-
-        # modify it's type and help string
-        action.type = int
-        action.help = "FuzzManager ID to reduce"
-
-        # ... and Bob's your uncle
-        self._sanity_skip.add("input")
+        self.update_arg("input", int, "FuzzManager ID to reduce")
 
 
 class ReduceFuzzManagerIDQualityArgs(ReduceFuzzManagerIDArgs):
diff --git a/grizzly/reduce/bucket.py b/grizzly/reduce/bucket.py
index 8570c93d..409e184e 100644
--- a/grizzly/reduce/bucket.py
+++ b/grizzly/reduce/bucket.py
@@ -2,53 +2,10 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from logging import getLogger
-
-from ..common.fuzzmanager import Bucket
-from ..common.utils import Exit
-from ..main import configure_logging
-from .args import ReduceFuzzManagerIDQualityArgs
-from .crash import main as crash_main
-
-LOG = getLogger(__name__)
-
-
-def main(args):
-    """CLI for `grizzly.reduce.bucket`.
-
-    Arguments:
-        args (argparse.Namespace): Result from `ReduceArgs.parse_args`.
-
-    Returns:
-        int: 0 for success. non-0 indicates a problem.
-    """
-    configure_logging(args.log_level)
-    LOG.info("Trying all crashes in bucket %d until one reduces", args.input)
-
-    # ensure --tool is reset for each call to grizzly.reduce.crash.main()
-    orig_tool = args.tool
-
-    # if no crashes in bucket, return success
-    result = Exit.SUCCESS
-
-    bucket = Bucket(args.input)
-    try:
-        if args.sig is None:
-            args.sig = str(bucket.signature_path())
-
-        for crash in bucket.iter_crashes(args.quality):
-            args.input = crash.crash_id
-            args.tool = orig_tool
-
-            # call grizzly.reduce.crash
-            result = Exit(crash_main(args))
-            if result in {Exit.SUCCESS, Exit.ABORT}:
-                break
-
-    finally:
-        bucket.cleanup()
-    return result
-
 
 if __name__ == "__main__":
-    raise SystemExit(main(ReduceFuzzManagerIDQualityArgs().parse_args()))
+    from ..replay.bucket import bucket_main
+    from .args import ReduceFuzzManagerIDQualityArgs
+    from .crash import main
+
+    raise SystemExit(bucket_main(ReduceFuzzManagerIDQualityArgs().parse_args(), main))
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index c21d5796..227112ce 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -807,7 +807,7 @@ def main(cls, args):
                     expect_hang=expect_hang,
                     idle_delay=args.idle_delay,
                     idle_threshold=args.idle_threshold,
-                    reducer_crash_id=args.reducer_crash_id,
+                    reducer_crash_id=args.original_crash_id,
                     relaunch=relaunch,
                     report_period=args.report_period,
                     report_to_fuzzmanager=args.fuzzmanager,
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index 10087fe4..deefd1c5 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -4,10 +4,11 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
 
-from ..common.fuzzmanager import Bucket, CrashEntry
+from ..common.fuzzmanager import load_fm_data
 from ..common.reporter import Quality
 from ..common.utils import Exit
 from ..main import configure_logging
+from ..replay.crash import modify_args
 from .args import ReduceFuzzManagerIDArgs
 from .core import ReduceManager
 
@@ -24,23 +25,14 @@ def main(args):
         int: 0 for success. non-0 indicates a problem.
     """
     configure_logging(args.log_level)
-    crash = CrashEntry(args.input)
-    initial_quality = Quality(crash.testcase_quality)
-    LOG.info("Loaded crash %d (%s)", crash.crash_id, initial_quality.name)
-    bucket = None
-    try:
-        # download the crash
-        args.reducer_crash_id = args.input
-        args.input = str(crash.testcase_path())
-        if args.sig is None and crash.bucket is not None:
-            bucket = Bucket(crash.bucket)
-            args.sig = str(bucket.signature_path())
-        if args.tool is None:
-            LOG.info("Setting default --tool=%s from CrashEntry", crash.tool)
-            args.tool = crash.tool
-
+    with load_fm_data(args.input, load_bucket=not args.sig) as (crash, bucket):
+        LOG.info(
+            "Loaded crash %d (%s) from FuzzManager",
+            crash.crash_id,
+            Quality(crash.testcase_quality).name,
+        )
         # call grizzly.reduce
-        result = ReduceManager.main(args)
+        result = ReduceManager.main(modify_args(args, crash, bucket))
 
         # update quality
         # map Exit.* -> Quality.*
@@ -50,7 +42,7 @@ def main(args):
         if args.fuzzmanager:
             quality = {
                 Exit.ERROR: Quality.REDUCER_ERROR,
-                Exit.ABORT: initial_quality,
+                Exit.ABORT: Quality(crash.testcase_quality),
                 Exit.SUCCESS: Quality.ORIGINAL,
                 Exit.FAILURE: Quality.NOT_REPRODUCIBLE,
             }.get(result, Quality.UNREDUCED)
@@ -65,10 +57,7 @@ def main(args):
                 quality,
             )
             crash.testcase_quality = quality.value
-    finally:
-        crash.cleanup()
-        if bucket is not None:
-            bucket.cleanup()
+
     return result
 
 
diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
index ef056c6c..7124d6d4 100644
--- a/grizzly/reduce/test_main_fm.py
+++ b/grizzly/reduce/test_main_fm.py
@@ -3,17 +3,12 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Unit tests for `grizzly.reduce.crash` and `grizzly.reduce.bucket`."""
-from copy import deepcopy
-from logging import getLogger
-
 from pytest import mark
 
 from ..common.reporter import Quality
 from ..common.utils import Exit
-from .bucket import main as bucket_main
 from .crash import main as crash_main
 
-LOG = getLogger(__name__)
 pytestmark = mark.usefixtures(
     "tmp_path_fm_config",
     "tmp_path_replay_status_db",
@@ -22,43 +17,7 @@
 
 
 @mark.parametrize(
-    "arg_sig, arg_tool, crash_bucket, result_sig, result_tool",
-    [
-        # crash id is downloaded and core.main is called with the path
-        (None, None, None, None, "test-tool"),
-        # crash in bucket, bucket will be downloaded and passed to --sig
-        (None, None, 789, "test_sig.json", "test-tool"),
-        # crash in bucket, --sig is respected
-        ("arg_sig.json", None, 789, "arg_sig.json", "test-tool"),
-        # --tool respected
-        (None, "tool2", None, None, "tool2"),
-    ],
-)
-def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_tool):
-    """tests for `grizzly.reduce.crash.main`"""
-    mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
-    crash = mocker.patch("grizzly.reduce.crash.CrashEntry", autospec=True)
-    bucket = mocker.patch("grizzly.reduce.crash.Bucket", autospec=True)
-    mocker.patch("grizzly.reduce.crash.ReduceManager.main", return_value=Exit.SUCCESS)
-    crash.return_value.testcase_path.return_value = "test_path.zip"
-    crash.return_value.bucket = crash_bucket
-    crash.return_value.testcase_quality = 5
-    crash.return_value.tool = "test-tool"
-    bucket.return_value.signature_path.return_value = "test_sig.json"
-
-    args = mocker.Mock(
-        input=12345,
-        sig=arg_sig,
-        tool=arg_tool,
-    )
-    crash_main(args)
-    assert args.input == "test_path.zip"
-    assert args.sig == result_sig
-    assert args.tool == result_tool
-
-
-@mark.parametrize(
-    "mgr_exit_code, pre_quality, post_quality",
+    "exit_code, pre_quality, post_quality",
     [
         (Exit.SUCCESS, Quality.UNREDUCED, Quality.ORIGINAL),
         (Exit.ERROR, Quality.UNREDUCED, Quality.REDUCER_ERROR),
@@ -69,82 +28,13 @@ def test_crash_main(mocker, arg_sig, arg_tool, crash_bucket, result_sig, result_
         (Exit.FAILURE, Quality.UNREDUCED, Quality.NOT_REPRODUCIBLE),
     ],
 )
-def test_crash_main_quality(mocker, mgr_exit_code, pre_quality, post_quality):
+def test_crash_main_quality(mocker, exit_code, pre_quality, post_quality):
     """test that quality is updated"""
-    mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
-    crash = mocker.patch("grizzly.reduce.crash.CrashEntry", autospec=True)
-    mocker.patch("grizzly.reduce.crash.Bucket", autospec=True)
-    mgr = mocker.patch("grizzly.reduce.crash.ReduceManager", autospec=True)
-    crash.return_value.testcase_path.return_value = "test_path.zip"
-    crash.return_value.testcase_quality = pre_quality
-    crash.return_value.bucket = None
-    crash.return_value.tool = "test-tool"
-    mgr.main.return_value = mgr_exit_code
-
-    args = mocker.Mock(
-        input=12345,
-        sig=None,
-        tool=None,
-    )
-    assert crash_main(args) == mgr_exit_code
-    assert crash.return_value.testcase_quality == post_quality
-
-
-@mark.parametrize(
-    "crashes, main_exit_codes, result, arg_sig, arg_tool",
-    [
-        # no crashes -> success
-        ([], [], Exit.SUCCESS, None, None),
-        # 1 crash fails -> no success
-        ([(123, "test-tool")], [Exit.ERROR], Exit.ERROR, None, None),
-        # second of 3 succeeds -> success
-        (
-            [(123, "test-tool"), (456, "test-tool2")],
-            [Exit.ERROR, Exit.SUCCESS],
-            Exit.SUCCESS,
-            None,
-            None,
-        ),
-        # --sig is respected
-        ([(123, "test-tool")], [Exit.SUCCESS], Exit.SUCCESS, "test_sig2.json", None),
-        # --tool is respected
-        ([(123, "test-tool")], [Exit.SUCCESS], Exit.SUCCESS, None, "test-tool-arg"),
-        # abort in crash main should also abort bucket main
-        ([(123, "test-tool")], [Exit.ABORT], Exit.ABORT, None, None),
-    ],
-)
-def test_bucket_main(mocker, crashes, main_exit_codes, result, arg_sig, arg_tool):
-    """tests for `grizzly.reduce.bucket.main`"""
-    call_args = []
-
-    def copy_args(args):
-        call_args.append(deepcopy(args))
-        return main_exit_codes[main.call_count - 1]
-
-    mocker.patch("grizzly.common.fuzzmanager.Collector", autospec=True)
-    bucket = mocker.patch("grizzly.reduce.bucket.Bucket", autospec=True)
-    main = mocker.patch(
-        "grizzly.reduce.bucket.crash_main", autospec=True, side_effect=copy_args
-    )
-    bucket.return_value.signature_path.return_value = "test_sig.json"
-    bucket.return_value.iter_crashes.return_value = [
-        mocker.Mock(crash_id=crash, tool=tool) for crash, tool in crashes
-    ]
-
-    args = mocker.Mock(
-        input=789,
-        sig=arg_sig,
-        tool=arg_tool,
-    )
-    assert bucket_main(args) == result
-    assert main.call_count == len(main_exit_codes)
-    for idx, (crash, _tool) in enumerate(crashes[: main.call_count]):
-        assert call_args[idx].input == crash
-        if arg_tool is not None:
-            assert call_args[idx].tool == arg_tool
-        else:
-            assert call_args[idx].tool is None
-        if arg_sig is not None:
-            assert call_args[idx].sig == arg_sig
-        else:
-            assert call_args[idx].sig == "test_sig.json"
+    mocker.patch("grizzly.reduce.crash.ReduceManager.main", return_value=exit_code)
+    crash = mocker.Mock(testcase_quality=pre_quality, crash_id=1)
+    load_fm_data = mocker.patch("grizzly.reduce.crash.load_fm_data")
+    load_fm_data.return_value.__enter__ = mocker.Mock(return_value=(crash, None))
+    args = mocker.Mock(input=12345, sig=None, tool=None)
+    assert crash_main(args) == exit_code
+    # verify testcase quality was updated
+    assert crash.testcase_quality == post_quality
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index 9a110c2e..210c6cd9 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -2,6 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from argparse import SUPPRESS
 from os.path import exists, isfile
 
 from ..args import CommonArgs
@@ -59,6 +60,12 @@ def __init__(self):
             action="store_true",
             help="Don't use the harness for redirection. Implies '--relaunch=1'.",
         )
+        # hidden argument to add original crash ID as metadata when reported
+        replay_args.add_argument(
+            "--original-crash-id",
+            type=int,
+            help=SUPPRESS,
+        )
         replay_args.add_argument(
             "--repeat",
             type=int,
@@ -102,3 +109,50 @@ def sanity_check(self, args):
 
         if args.sig is not None and not isfile(args.sig):
             self.parser.error("signature file not found: %r" % (args.sig,))
+
+    def update_arg(self, name, new_type, help_msg):
+        # madhax alert!
+        #
+        # We need to modify the meaning of the 'input' positional to accept an int ID
+        # instead of a local testcase.
+        # This is not possible with the public argparse API.
+        #
+        # refs: stackoverflow.com/questions/32807319/disable-remove-argument-in-argparse
+        #       bugs.python.org/issue19462
+
+        # look up the action for the positional `input` arg
+        action = None
+        for arg in self.parser._actions:  # pylint: disable=protected-access
+            if arg.dest == name and not arg.option_strings:
+                action = arg
+                break
+        assert action is not None
+
+        # modify its type and help string
+        action.type = new_type
+        action.help = help_msg
+
+        # ... and Bob's your uncle
+        self._sanity_skip.add("input")
+
+
+class ReplayFuzzManagerIDArgs(ReplayArgs):
+    def __init__(self):
+        """Initialize argument parser."""
+        super().__init__()
+        self.update_arg("input", int, "FuzzManager ID to replay")
+
+
+class ReplayFuzzManagerIDQualityArgs(ReplayFuzzManagerIDArgs):
+    def __init__(self):
+        """Initialize argument parser."""
+        super().__init__()
+        self.parser.add_argument(
+            "--quality", type=int, help="Only try crashes with a given quality value"
+        )
+
+    def sanity_check(self, args):
+        super().sanity_check(args)
+
+        if args.quality is not None and args.quality < 0:
+            self.parser.error("'--quality' value cannot be negative")
diff --git a/grizzly/replay/bucket.py b/grizzly/replay/bucket.py
new file mode 100644
index 00000000..7b2abbf2
--- /dev/null
+++ b/grizzly/replay/bucket.py
@@ -0,0 +1,55 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from logging import getLogger
+
+from ..common.fuzzmanager import Bucket
+from ..common.utils import Exit
+from ..main import configure_logging
+from .args import ReplayFuzzManagerIDQualityArgs
+from .crash import main as crash_main
+
+LOG = getLogger(__name__)
+
+
+def bucket_main(args, tool_main):
+    """CLI for `grizzly.reduce.bucket` and `grizzly.replay.bucket`.
+
+    Arguments:
+        args (argparse.Namespace): Result from `parse_args()`.
+        tool_main (callable): Main function from a supported Grizzly tool.
+
+    Returns:
+        int: 0 for success. non-0 indicates a problem.
+    """
+    assert callable(tool_main)
+    configure_logging(args.log_level)
+    LOG.info("Trying each crash in bucket %d until successful", args.input)
+
+    # ensure --tool is reset for each call to tool_main()
+    orig_tool = args.tool
+
+    # if no crashes in bucket, return success
+    result = Exit.SUCCESS
+
+    with Bucket(args.input) as bucket:
+        if args.sig is None:
+            args.sig = str(bucket.signature_path())
+
+        for crash in bucket.iter_crashes(args.quality):
+            args.input = crash.crash_id
+            args.tool = orig_tool
+
+            # call grizzly tool
+            result = Exit(tool_main(args))
+            if result in {Exit.SUCCESS, Exit.ABORT}:
+                break
+
+    return result
+
+
+if __name__ == "__main__":
+    raise SystemExit(
+        bucket_main(ReplayFuzzManagerIDQualityArgs().parse_args(), crash_main)
+    )
diff --git a/grizzly/replay/crash.py b/grizzly/replay/crash.py
new file mode 100644
index 00000000..7b03560b
--- /dev/null
+++ b/grizzly/replay/crash.py
@@ -0,0 +1,57 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+from logging import getLogger
+
+from ..common.fuzzmanager import load_fm_data
+from ..main import configure_logging
+from .args import ReplayFuzzManagerIDArgs
+from .replay import ReplayManager
+
+LOG = getLogger(__name__)
+
+
+def main(args):
+    """CLI for `grizzly.replay.crash`.
+
+    Arguments:
+        args (argparse.Namespace): Result from `ReplayArgs.parse_args`.
+
+    Returns:
+        int: 0 for success. non-0 indicates a problem.
+    """
+    configure_logging(args.log_level)
+    with load_fm_data(args.input, load_bucket=not args.sig) as (crash, bucket):
+        LOG.info("Loaded crash %d from FuzzManager", crash.crash_id)
+        # call grizzly.replay
+        return ReplayManager.main(modify_args(args, crash, bucket))
+
+
+def modify_args(args, crash, bucket):
+    """
+
+    Arguments:
+        args (argparse.Namespace): Result from `ReplayArgs.parse_args`.
+
+
+
+    Returns:
+        args (argparse.Namespace): Modified arguments.
+    """
+    args.original_crash_id = args.input
+    args.input = str(crash.testcase_path())
+    if args.tool is None:
+        LOG.info("Setting default --tool=%s from CrashEntry", crash.tool)
+        args.tool = crash.tool
+
+    # load signature if needed
+    if bucket is not None:
+        args.sig = str(bucket.signature_path())
+
+    return args
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(ReplayFuzzManagerIDArgs().parse_args()))
diff --git a/grizzly/replay/test_args.py b/grizzly/replay/test_args.py
index 8935faf0..897620a6 100644
--- a/grizzly/replay/test_args.py
+++ b/grizzly/replay/test_args.py
@@ -7,7 +7,7 @@
 """
 from pytest import mark, raises
 
-from .args import ReplayArgs
+from .args import ReplayArgs, ReplayFuzzManagerIDArgs, ReplayFuzzManagerIDQualityArgs
 
 
 def test_replay_args_01(capsys, mocker, tmp_path):
@@ -59,3 +59,21 @@ def test_replay_args_02(capsys, mocker, tmp_path, args, msg):
             argv=[str(fake_bin), str(fake_bin), "--platform", target] + args
         )
     assert msg in capsys.readouterr()[-1]
+
+
+def test_replay_args_03(tmp_path):
+    """test ReplayFuzzManagerIDArgs"""
+    exe = tmp_path / "binary"
+    exe.touch()
+    ReplayFuzzManagerIDArgs().parse_args([str(exe), "123"])
+
+
+def test_replay_args_04(capsys, tmp_path):
+    """test ReplayFuzzManagerIDQualityArgs"""
+    exe = tmp_path / "binary"
+    exe.touch()
+    with raises(SystemExit):
+        ReplayFuzzManagerIDQualityArgs().parse_args(
+            [str(exe), "123", "--quality", "-1"]
+        )
+    assert "error: '--quality' value cannot be negative" in capsys.readouterr()[-1]
diff --git a/grizzly/replay/test_main_fm.py b/grizzly/replay/test_main_fm.py
new file mode 100644
index 00000000..a75223a5
--- /dev/null
+++ b/grizzly/replay/test_main_fm.py
@@ -0,0 +1,105 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Unit tests for `grizzly.replay.crash` and `grizzly.replay.bucket`."""
+from copy import deepcopy
+
+from pytest import mark
+
+from ..common.fuzzmanager import Bucket, CrashEntry
+from ..common.utils import Exit
+from .bucket import bucket_main
+from .crash import main as crash_main
+from .crash import modify_args
+
+
+def test_crash_main(mocker):
+    """test main()"""
+    mocker.patch("grizzly.replay.crash.ReplayManager.main", return_value=0)
+    crash = mocker.Mock(spec=CrashEntry, crash_id=1, tool="tool-name")
+    load_fm_data = mocker.patch("grizzly.replay.crash.load_fm_data")
+    load_fm_data.return_value.__enter__ = mocker.Mock(return_value=(crash, None))
+    args = mocker.Mock(input=12345, sig=None, tool=None)
+    assert crash_main(args) == 0
+
+
+@mark.parametrize(
+    "arg_tool, signature",
+    [
+        (None, None),
+        ("arg_tool", None),
+        (None, "bucket_sig"),
+    ],
+)
+def test_modify_args(mocker, arg_tool, signature):
+    """test modify_args()"""
+    args = mocker.Mock(input="org_input", tool=arg_tool, sig=None)
+    crash = mocker.Mock(spec=CrashEntry, tool="crash_tool")
+    crash.testcase_path.return_value = "crash_input"
+    if signature is not None:
+        bucket = mocker.Mock(spec=Bucket)
+        bucket.signature_path.return_value = signature
+    else:
+        bucket = None
+    mod = modify_args(args, crash, bucket)
+    assert mod.original_crash_id == "org_input"
+    assert mod.input == "crash_input"
+    assert mod.tool == ("crash_tool" if arg_tool is None else arg_tool)
+    assert mod.sig == signature
+
+
+@mark.parametrize(
+    "crashes, main_exit_codes, result, arg_sig, arg_tool",
+    [
+        # no crashes -> success
+        ([], [], Exit.SUCCESS, None, None),
+        # 1 crash fails -> no success
+        ([(123, "test-tool")], [Exit.ERROR], Exit.ERROR, None, None),
+        # second of 3 succeeds -> success
+        (
+            [(123, "test-tool"), (456, "test-tool2")],
+            [Exit.ERROR, Exit.SUCCESS],
+            Exit.SUCCESS,
+            None,
+            None,
+        ),
+        # --sig is respected
+        ([(123, "test-tool")], [Exit.SUCCESS], Exit.SUCCESS, "test_sig2.json", None),
+        # --tool is respected
+        ([(123, "test-tool")], [Exit.SUCCESS], Exit.SUCCESS, None, "test-tool-arg"),
+        # abort in crash main should also abort bucket main
+        ([(123, "test-tool")], [Exit.ABORT], Exit.ABORT, None, None),
+    ],
+)
+def test_bucket_main(mocker, crashes, main_exit_codes, result, arg_sig, arg_tool):
+    """tests for `grizzly.replay.bucket.bucket_main`"""
+    call_args = []
+
+    def copy_args(args):
+        call_args.append(deepcopy(args))
+        return main_exit_codes[main.call_count - 1]
+
+    bucket = mocker.Mock(spec=Bucket)
+    bucket.signature_path.return_value = "test_sig.json"
+    bucket.iter_crashes.return_value = (
+        mocker.Mock(crash_id=crash, tool=tool) for crash, tool in crashes
+    )
+    fake_bucket = mocker.patch("grizzly.replay.bucket.Bucket", autospec=True)
+    fake_bucket.return_value.__enter__.return_value = bucket
+
+    main = mocker.Mock(side_effect=copy_args)
+
+    args = mocker.Mock(input=789, sig=arg_sig, tool=arg_tool)
+    assert bucket_main(args, main) == result
+    assert main.call_count == len(main_exit_codes)
+    for idx, (crash, _tool) in enumerate(crashes[: main.call_count]):
+        assert call_args[idx].input == crash
+        if arg_tool is not None:
+            assert call_args[idx].tool == arg_tool
+        else:
+            assert call_args[idx].tool is None
+        if arg_sig is not None:
+            assert call_args[idx].sig == arg_sig
+        else:
+            assert call_args[idx].sig == "test_sig.json"

From 1c41478e32f323189a2c322ec041c3e0902a158a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 2 Dec 2021 13:11:55 -0800
Subject: [PATCH 391/531] [tests] Add on_iteration_cb coverage

---
 grizzly/replay/test_replay.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 5ff59f0b..02d7b532 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -42,12 +42,13 @@ def test_replay_01(mocker):
     target = mocker.Mock(spec_set=Target, closed=True, launch_timeout=30)
     target.check_result.return_value = Result.NONE
     target.monitor.is_healthy.return_value = False
+    iter_cb = mocker.Mock()
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager([], server, target, use_harness=True, relaunch=1) as replay:
-            assert not replay.run([testcase], 10)
+            assert not replay.run([testcase], 10, on_iteration_cb=iter_cb)
             assert replay.signature is None
             assert replay.status.ignored == 0
-            assert replay.status.iteration == 1
+            assert replay.status.iteration == iter_cb.call_count == 1
             assert replay.status.results.total == 0
             assert target.monitor.is_healthy.call_count == 1
             assert target.close.call_count == 2
@@ -62,14 +63,17 @@ def test_replay_02(mocker):
     target = mocker.Mock(spec_set=Target, closed=False, launch_timeout=30)
     target.check_result.return_value = Result.NONE
     target.monitor.is_healthy.return_value = False
+    iter_cb = mocker.Mock()
     with TestCase("index.html", "redirect.html", "test-adapter") as testcase:
         with ReplayManager(
             [], server, target, use_harness=True, relaunch=100
         ) as replay:
-            assert not replay.run([testcase], 10, repeat=10, min_results=1)
+            assert not replay.run(
+                [testcase], 10, repeat=10, min_results=1, on_iteration_cb=iter_cb
+            )
             assert replay.signature is None
             assert replay.status.ignored == 0
-            assert replay.status.iteration == 10
+            assert replay.status.iteration == iter_cb.call_count == 10
             assert replay.status.results.total == 0
             assert target.handle_hang.call_count == 0
             assert target.monitor.is_healthy.call_count == 1

From 33f27adab0646fc65ccca5a36f4e3167a95eb500 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 7 Jan 2022 16:49:04 -0500
Subject: [PATCH 392/531] Report other results after each reduction stage,
 rather than immediately.

---
 grizzly/reduce/core.py        | 56 +++++++++++++++++++++++++++++++----
 grizzly/reduce/test_reduce.py | 16 ++--------
 2 files changed, 54 insertions(+), 18 deletions(-)

diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 227112ce..fbcfb823 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -488,6 +488,7 @@ def run(self, repeat=1, min_results=1):
                 strategy_last_report = time()
                 strategy_stats = self._status.measure(strategy.name)
                 best_results = []
+                other_results = {}
                 try:
                     with replay, strategy, strategy_stats:
                         self._status.report(force=True)
@@ -566,9 +567,50 @@ def run(self, repeat=1, min_results=1):
                                     ]
                                 else:
                                     LOG.info("Attempt failed")
+
                                 # if the reduction found other crashes,
-                                #   report those immediately
-                                self.report(results, reduction)
+                                # save those for reporting later
+
+                                # only save the smallest testcase that has found
+                                # each result
+                                for result in results:
+                                    other_result_exists = bool(
+                                        result.report.minor in other_results
+                                    )
+
+                                    is_smaller = None
+                                    if other_result_exists:
+                                        # we have a result already queued for this sig
+                                        # check size to see which to keep
+                                        reduction_size = sum(
+                                            tc.data_size for tc in reduction
+                                        )
+                                        _, old_reduction = other_results[
+                                            result.report.minor
+                                        ]
+                                        old_size = sum(
+                                            tc.data_size for tc in old_reduction
+                                        )
+                                        is_smaller = bool(reduction_size < old_size)
+
+                                    if not other_result_exists or is_smaller:
+                                        if other_result_exists:
+                                            # clean-up old result
+                                            old_result, old_reduction = other_results[
+                                                result.report.minor
+                                            ]
+                                            old_result.report.cleanup()
+                                            for testcase in old_reduction:
+                                                testcase.cleanup()
+                                        # store this reduction for later reporting
+                                        # as the other result
+                                        other_results[result.report.minor] = (
+                                            result,
+                                            [
+                                                testcase.clone()
+                                                for testcase in reduction
+                                            ],
+                                        )
 
                                 now = time()
                                 if (
@@ -591,8 +633,6 @@ def run(self, repeat=1, min_results=1):
                                 if not keep_reduction:
                                     for testcase in reduction:
                                         testcase.cleanup()
-                                for result in results:
-                                    result.report.cleanup()
 
                         # if self._signature was already set, this will do nothing
                         # otherwise, ensure the first found signature is used throughout
@@ -602,6 +642,8 @@ def run(self, repeat=1, min_results=1):
                         self._status.last_reports = self.report(
                             best_results, self.testcases
                         )
+                    for result, reduction in other_results.values():
+                        self.report([result], reduction)
 
                 except KeyboardInterrupt:
                     if best_results:
@@ -609,13 +651,17 @@ def run(self, repeat=1, min_results=1):
                             best_results, self.testcases
                         )
                         LOG.warning(
-                            "Ctrl+C detected, best reduction so far " "reported as %r",
+                            "Ctrl+C detected, best reduction so far reported as %r",
                             self._status.last_reports,
                         )
                     raise
                 finally:
                     for result in best_results:
                         result.report.cleanup()
+                    for result, reduction in other_results.values():
+                        result.report.cleanup()
+                        for testcase in reduction:
+                            testcase.cleanup()
 
                 # store "tried" cache to pass to next strategy
                 last_tried = strategy.get_tried()
diff --git a/grizzly/reduce/test_reduce.py b/grizzly/reduce/test_reduce.py
index cc880e57..699040e7 100644
--- a/grizzly/reduce/test_reduce.py
+++ b/grizzly/reduce/test_reduce.py
@@ -381,8 +381,8 @@ def wrapped(_):
             expected_run_calls=6,
             n_reports=1,
             reports={"1\n2\n3\n"},
-            n_other=5,
-            other_reports={"1\n", "3\n", "1\n2\n", "1\n3\n", "2\n3\n"},
+            n_other=1,
+            other_reports={"1\n"},
             result=0,
         ),
         # reproduces, 50% iterations work, 1 iteration produces other sig
@@ -448,19 +448,9 @@ def wrapped(_):
             expected_run_calls=16,
             n_reports=1,
             reports={"1\n2\n3\n"},
-            n_other=15,
+            n_other=2,
             other_reports={
-                "\n2\n3\n",
                 "1\n",
-                "1\n\n3\n",
-                "1\n2\n",
-                "1\n2\n\n",
-                "1\n2\n3",
-                "1\n23\n",
-                "1\n3\n",
-                "12\n3\n",
-                "2\n3\n",
-                "3\n",
             },
             result=0,
         ),

From 2dcea8f00a18d087c03b058977fb04a1729a85f5 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 20 Jan 2022 16:53:10 -0800
Subject: [PATCH 393/531] Update '--logs' argument

When running grizzly it defaults to the current directory.
When running grizzly reduce/replay defaults to None (no logs).
---
 grizzly/args.py        | 7 +++++++
 grizzly/main.py        | 4 ++--
 grizzly/replay/args.py | 7 +------
 grizzly/test_main.py   | 1 +
 4 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 5001abb6..8bcf9c93 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -4,6 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from argparse import ArgumentParser, HelpFormatter
 from logging import CRITICAL, DEBUG, ERROR, INFO, WARNING
+from os import getcwd
 from os.path import exists, isfile
 from platform import system
 
@@ -158,6 +159,12 @@ def __init__(self):
             help="Space separated list of issue types to ignore. Valid options: %s"
             " (default: %s)" % (" ".join(self.IGNORABLE), " ".join(self.IGNORE)),
         )
+        self.reporter_grp.add_argument(
+            "-l",
+            "--logs",
+            default=getcwd(),
+            help="Location to save logs and test cases. (default: %(default)r)",
+        )
         self.reporter_grp.add_argument(
             "--tool",
             help="Override tool name used when reporting issues to FuzzManager",
diff --git a/grizzly/main.py b/grizzly/main.py
index 06bdf8da..23cd969f 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -3,7 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import DEBUG, getLogger
-from os import getcwd, getpid
+from os import getpid
 from os.path import join as pathjoin
 
 from sapphire import Sapphire
@@ -104,7 +104,7 @@ def main(args):
             )
             reporter = S3FuzzManagerReporter(tool=args.tool)
         else:
-            reporter = FilesystemReporter(pathjoin(getcwd(), "results"))
+            reporter = FilesystemReporter(pathjoin(args.logs, "results"))
             LOG.info("Results will be stored in %r", reporter.report_path)
         reporter.display_logs = args.smoke_test or reporter.display_logs
 
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index 210c6cd9..3e119429 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -11,6 +11,7 @@
 class ReplayArgs(CommonArgs):
     def __init__(self):
         super().__init__()
+        self.parser.set_defaults(logs=None)
         self.parser.add_argument(
             "input",
             help="Accepted input includes: "
@@ -42,12 +43,6 @@ def __init__(self):
             default=0,
             help="CPU usage threshold to mark the process as idle (default: disabled)",
         )
-        replay_args.add_argument(
-            "-l",
-            "--logs",
-            help="Location to save logs. If the path exists it must be empty, if it "
-            "does not exist it will be created.",
-        )
         replay_args.add_argument(
             "--min-crashes",
             type=int,
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index ce96b297..dafe55e9 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -28,6 +28,7 @@ def __init__(self):
         self.launch_timeout = 300
         self.limit = 0
         self.limit_reports = 0
+        self.logs = "."
         self.log_level = 10  # 10 = DEBUG, 20 = INFO
         self.log_limit = 0
         self.memory = 0

From 19858371e094a33f8fe96d9515c0dbbfde943016 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 20 Jan 2022 18:03:24 -0800
Subject: [PATCH 394/531] Add GRZ_TMP environment variable to override use of
 os.gettempdir() in grz_tmp()

---
 grizzly/common/utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/common/utils.py b/grizzly/common/utils.py
index 6d93cc8b..26ffb01d 100644
--- a/grizzly/common/utils.py
+++ b/grizzly/common/utils.py
@@ -70,6 +70,6 @@ def configure_logging(log_level):
 
 
 def grz_tmp(*subdir):
-    path = pathjoin(gettempdir(), "grizzly", *subdir)
+    path = pathjoin(getenv("GRZ_TMP", gettempdir()), "grizzly", *subdir)
     makedirs(path, exist_ok=True)
     return path

From 596318e9b525ae233694fc2a9411ee2561e63fe9 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 20 Jan 2022 11:20:39 -0500
Subject: [PATCH 395/531] [ci] Add macOS CI

---
 .github/scripts/start-worker.sh           | 58 +++++++++++++++++++++++
 .github/workflows/taskcluster-pr.yml      | 11 +++++
 .github/workflows/taskcluster-push.yml    | 11 +++++
 .github/workflows/taskcluster-release.yml | 11 +++++
 .pre-commit-config.yaml                   |  2 +-
 .taskcluster.yml                          | 10 ++++
 6 files changed, 102 insertions(+), 1 deletion(-)
 create mode 100755 .github/scripts/start-worker.sh
 create mode 100644 .github/workflows/taskcluster-pr.yml
 create mode 100644 .github/workflows/taskcluster-push.yml
 create mode 100644 .github/workflows/taskcluster-release.yml

diff --git a/.github/scripts/start-worker.sh b/.github/scripts/start-worker.sh
new file mode 100755
index 00000000..baa0c7af
--- /dev/null
+++ b/.github/scripts/start-worker.sh
@@ -0,0 +1,58 @@
+#!/bin/sh -e
+
+[ -z "$TASKCLUSTER_ACCESS_TOKEN" ] && echo "Missing TASKCLUSTER_ACCESS_TOKEN" >&2 && exit 2
+[ -z "$TC_WORKER_ID" ] && echo "Missing TC_WORKER_ID" >&2 && exit 2
+
+set -x
+
+TC_VERSION=v44.4.0
+TC_PROJECT=fuzzing
+TC_WORKER_TYPE=ci-osx
+TC_IDLE_TIMEOUT=300
+
+TASKCLUSTER_ROOT_URL="https://community-tc.services.mozilla.com"
+TASKCLUSTER_CLIENT_ID="project/$TC_PROJECT/worker-$TC_WORKER_TYPE-gh"
+
+set +x
+cat > worker.config <<EOF
+{
+  "accessToken": "$TASKCLUSTER_ACCESS_TOKEN",
+  "clientId": "$TASKCLUSTER_CLIENT_ID",
+  "disableReboots": true,
+  "ed25519SigningKeyLocation": "worker.key",
+  "idleTimeoutSecs": $TC_IDLE_TIMEOUT,
+  "livelogExecutable": "$PWD/livelog",
+  "provisionerId": "proj-$TC_PROJECT",
+  "publicIP": "127.0.0.1",
+  "requiredDiskSpaceMegabytes": 512,
+  "rootURL": "$TASKCLUSTER_ROOT_URL",
+  "sentryProject": "generic-worker",
+  "taskclusterProxyExecutable": "$PWD/taskcluster-proxy",
+  "taskclusterProxyPort": 8080,
+  "tasksDir": "tasks",
+  "workerGroup": "proj-$TC_PROJECT",
+  "workerId": "$TC_WORKER_ID",
+  "workerType": "$TC_WORKER_TYPE",
+  "wstAudience": "communitytc",
+  "wstServerURL": "https://community-websocktunnel.services.mozilla.com"
+}
+EOF
+set -x
+unset TASKCLUSTER_ACCESS_TOKEN
+
+curl -sSL "https://github.com/taskcluster/taskcluster/releases/download/$TC_VERSION/generic-worker-simple-darwin-amd64" -o generic-worker
+curl -sSL "https://github.com/taskcluster/taskcluster/releases/download/$TC_VERSION/livelog-darwin-amd64" -o livelog
+curl -sSL "https://github.com/taskcluster/taskcluster/releases/download/$TC_VERSION/taskcluster-proxy-darwin-amd64" -o taskcluster-proxy
+chmod +x generic-worker livelog taskcluster-proxy
+
+./generic-worker new-ed25519-keypair --file worker.key
+mkdir tasks
+set +e
+./generic-worker run --config worker.config
+case $? in
+0|68)
+  ;;
+*)
+  exit $?
+  ;;
+esac
diff --git a/.github/workflows/taskcluster-pr.yml b/.github/workflows/taskcluster-pr.yml
new file mode 100644
index 00000000..642e7736
--- /dev/null
+++ b/.github/workflows/taskcluster-pr.yml
@@ -0,0 +1,11 @@
+name: taskcluster PR worker
+on: [pull_request]
+jobs:
+  osx-tc-worker-pr:
+    runs-on: macos-10.15
+    env:
+      TASKCLUSTER_ACCESS_TOKEN: ${{ secrets.TASKCLUSTER_ACCESS_TOKEN }}
+      TC_WORKER_ID: "gh-grizzly-pr-${{ github.run_id }}-${{ github.run_attempt }}"
+    steps:
+      - uses: actions/checkout@v2
+      - run: .github/scripts/start-worker.sh
diff --git a/.github/workflows/taskcluster-push.yml b/.github/workflows/taskcluster-push.yml
new file mode 100644
index 00000000..ea8a9aff
--- /dev/null
+++ b/.github/workflows/taskcluster-push.yml
@@ -0,0 +1,11 @@
+name: taskcluster push worker
+on: [push]
+jobs:
+  osx-tc-worker-push:
+    runs-on: macos-10.15
+    env:
+      TASKCLUSTER_ACCESS_TOKEN: ${{ secrets.TASKCLUSTER_ACCESS_TOKEN }}
+      TC_WORKER_ID: "gh-grizzly-push-${{ github.run_id }}-${{ github.run_attempt }}"
+    steps:
+      - uses: actions/checkout@v2
+      - run: .github/scripts/start-worker.sh
diff --git a/.github/workflows/taskcluster-release.yml b/.github/workflows/taskcluster-release.yml
new file mode 100644
index 00000000..4c73528e
--- /dev/null
+++ b/.github/workflows/taskcluster-release.yml
@@ -0,0 +1,11 @@
+name: taskcluster release worker
+on: [release]
+jobs:
+  osx-tc-worker-release:
+    runs-on: macos-10.15
+    env:
+      TASKCLUSTER_ACCESS_TOKEN: ${{ secrets.TASKCLUSTER_ACCESS_TOKEN }}
+      TC_WORKER_ID: "gh-grizzly-release-${{ github.run_id }}-${{ github.run_attempt }}"
+    steps:
+      - uses: actions/checkout@v2
+      - run: .github/scripts/start-worker.sh
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 32225bdb..f9210dfd 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -41,7 +41,7 @@ repos:
     hooks:
       - id: taskcluster_yml
   - repo: https://github.com/MozillaSecurity/orion
-    rev: v0.0.2
+    rev: v0.0.4
     hooks:
       - id: orion_ci
   - repo: meta
diff --git a/.taskcluster.yml b/.taskcluster.yml
index f2b207c1..649a0af2 100644
--- a/.taskcluster.yml
+++ b/.taskcluster.yml
@@ -60,6 +60,11 @@ tasks:
             version: "3.8"
             env:
               TOXENV: py38
+          - name: test python 3.8 (macos)
+            version: "3.8"
+            platform: macos
+            env:
+              TOXENV: py38
           - name: test python 3.8 (windows)
             version: "3.8"
             platform: windows
@@ -69,6 +74,11 @@ tasks:
             version: "3.9"
             env:
               TOXENV: py39
+          - name: tests python 3.9 (macos)
+            version: "3.9"
+            platform: macos
+            env:
+              TOXENV: py39
           - name: lint
             version: "3.9"
             env:

From 0eecde2f68db96ee7334a41b86f2b8af2f62936d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 26 Jan 2022 18:46:38 -0800
Subject: [PATCH 396/531] Fix a few typos

---
 grizzly/common/status_reporter.py      | 15 +++++++--------
 grizzly/common/test_status_reporter.py |  2 +-
 sapphire/worker.py                     |  4 ++--
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index 62295395..cfe997f3 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -393,13 +393,13 @@ def _sys_info():
         return entries
 
     @staticmethod
-    def _tracebacks(path, ignore_kbi=True, max_preceeding=5):
+    def _tracebacks(path, ignore_kbi=True, max_preceding=5):
         """Search screen logs for tracebacks.
 
         Args:
             path (str): Directory containing log files.
             ignore_kbi (bool): Do not include KeyboardInterupts in results
-            max_preceeding (int): Maximum number of lines preceding traceback to
+            max_preceding (int): Maximum number of lines preceding traceback to
                                   include.
 
         Returns:
@@ -407,7 +407,7 @@ def _tracebacks(path, ignore_kbi=True, max_preceeding=5):
         """
         tracebacks = list()
         for screen_log in StatusReporter._scan(path, r"screenlog\.\d+"):
-            tbr = TracebackReport.from_file(screen_log, max_preceeding=max_preceeding)
+            tbr = TracebackReport.from_file(screen_log, max_preceding=max_preceding)
             if tbr is None:
                 continue
             if ignore_kbi and tbr.is_kbi:
@@ -432,14 +432,13 @@ def __init__(self, file_name, lines, is_kbi=False, prev_lines=None):
         self.is_kbi = is_kbi
 
     @classmethod
-    def from_file(cls, input_log, max_preceeding=5):
+    def from_file(cls, input_log, max_preceding=5):
         """Create TracebackReport from a text file containing a Python traceback.
         Only the first traceback in the file will be parsed.
 
         Args:
             input_log (str): File to parse.
-            max_preceeding (int): Number of lines to collect leading up to the
-                                  traceback.
+            max_preceding (int): Number of lines to collect leading up to the traceback.
 
         Returns:
             TracebackReport: Contains data from input_log.
@@ -489,8 +488,8 @@ def from_file(cls, input_log, max_preceeding=5):
                     tb_end = min(line_num + 1, line_count)
                     break
         assert tb_start is not None
-        if max_preceeding > 0:
-            prev_start = max(tb_start - max_preceeding, 0)
+        if max_preceding > 0:
+            prev_start = max(tb_start - max_preceding, 0)
             prev_lines = data[prev_start:tb_start]
         else:
             prev_lines = None
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index 307cd1ea..b843b19f 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -577,7 +577,7 @@ def test_traceback_report_03(tmp_path):
         test_fp.write(b"    a = b[10]\n")
         test_fp.write(b"foo.bar.error: blah\n")
         test_fp.write(b"end junk\n")
-    tbr = TracebackReport.from_file(str(test_log), max_preceeding=0)
+    tbr = TracebackReport.from_file(str(test_log), max_preceding=0)
     assert len(tbr.lines) == 6
     assert not tbr.prev_lines
     assert not tbr.is_kbi
diff --git a/sapphire/worker.py b/sapphire/worker.py
index b63e43ec..486dd82e 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -50,11 +50,11 @@ def _200_header(c_length, c_type, encoding="ascii"):
         return data.encode(encoding)
 
     @staticmethod
-    def _307_redirect(redirct_to, encoding="ascii"):
+    def _307_redirect(redirect_to, encoding="ascii"):
         data = (
             "HTTP/1.1 307 Temporary Redirect\r\n"
             "Location: %s\r\n"
-            "Connection: close\r\n\r\n" % (redirct_to,)
+            "Connection: close\r\n\r\n" % (redirect_to,)
         )
         return data.encode(encoding)
 

From 9422546f1e78f2369e3e411bdbd820bcd40bde95 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 28 Jan 2022 13:47:44 -0800
Subject: [PATCH 397/531] Round the results of getloadavg() since precision
 varies across platforms

---
 grizzly/common/status_reporter.py      | 5 ++++-
 grizzly/common/test_status_reporter.py | 4 ++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index cfe997f3..ab9d1b9b 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -367,7 +367,10 @@ def _sys_info():
             )
         )
         if getloadavg is not None:
-            disp.append(" %s" % (str(getloadavg()),))
+            disp.append("(")
+            # round the results of getloadavg(), precision varies across platforms
+            disp.append(", ".join("%0.1f" % (round(x, 1),) for x in getloadavg()))
+            disp.append(")")
         entries.append(("CPU & Load", "".join(disp)))
 
         # memory usage
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index b843b19f..c04974e6 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -230,7 +230,7 @@ def test_status_reporter_02(tmp_path):
         (
             Mock(free=12, total=GBYTES),
             Mock(available=12, total=GBYTES),
-            lambda: "(0.12, 0.34, 0.56)",
+            lambda: (0.12, 0.34, 0.56),
         ),
     ],
 )
@@ -263,7 +263,7 @@ def test_status_reporter_03(mocker, disk, memory, getloadavg):
     assert sysinfo[1][0] == "Memory"
     assert sysinfo[2][0] == "Disk"
     if getloadavg is not None:
-        assert sysinfo[0][-1].endswith("(0.12, 0.34, 0.56)")
+        assert sysinfo[0][-1].endswith("(0.1, 0.3, 0.6)")
     if disk.free < GBYTES or memory.available < GBYTES:
         assert "MB" in sysinfo[1][-1]
         assert "MB" in sysinfo[2][-1]

From 8ad4a4fc591e35d8519e7f242965e36fdeecc02e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 31 Jan 2022 17:05:26 -0800
Subject: [PATCH 398/531] [sapphire] Use Path.rglob() instead of os.walk()

---
 sapphire/job.py | 32 +++++++++++++++-----------------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/sapphire/job.py b/sapphire/job.py
index ac0c859d..ce73cf8a 100644
--- a/sapphire/job.py
+++ b/sapphire/job.py
@@ -9,7 +9,6 @@
 from enum import Enum, unique
 from logging import getLogger
 from mimetypes import guess_type
-from os import walk
 from os.path import splitext
 from pathlib import Path
 from queue import Queue
@@ -88,22 +87,21 @@ def __init__(
     def _build_queue(self, optional_files):
         # build file list to track files that must be served
         # this is intended to only be called once by __init__()
-        for d_name, _, filenames in walk(self._wwwroot, followlinks=False):
-            d_path = Path(d_name)
-            for f_name in filenames:
-                file_path = d_path / f_name
-                location = file_path.relative_to(self._wwwroot).as_posix()
-                # do not add optional files to queue of required files
-                if optional_files and location in optional_files:
-                    LOG.debug("optional: %r", location)
-                    continue
-                if "?" in str(file_path):
-                    LOG.warning(
-                        "Cannot add files with '?' in path. Skipping %r", str(file_path)
-                    )
-                    continue
-                self._pending.files.add(str(file_path.resolve()))
-                LOG.debug("required: %r", location)
+        for entry in self._wwwroot.rglob("*"):
+            if not entry.is_file():
+                continue
+            location = entry.relative_to(self._wwwroot).as_posix()
+            # do not add optional files to queue of required files
+            if optional_files and location in optional_files:
+                LOG.debug("optional: %r", location)
+                continue
+            if "?" in str(entry):
+                LOG.warning(
+                    "Cannot add files with '?' in path. Skipping %r", str(entry)
+                )
+                continue
+            self._pending.files.add(str(entry.resolve()))
+            LOG.debug("required: %r", location)
         # if nothing was found check if the path exists
         if not self._pending.files and not self._wwwroot.is_dir():
             raise OSError("%r does not exist" % (str(self._wwwroot),))

From bf4b880d6c9a784bb273f57b029c35225876df6e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 31 Jan 2022 17:12:39 -0800
Subject: [PATCH 399/531] Replace another instance of os.walk() with
 Path.rglob()

---
 grizzly/common/storage.py      | 34 ++++++++++++++++------------------
 grizzly/common/test_storage.py | 12 +++---------
 2 files changed, 19 insertions(+), 27 deletions(-)

diff --git a/grizzly/common/storage.py b/grizzly/common/storage.py
index f3011843..309ff58e 100644
--- a/grizzly/common/storage.py
+++ b/grizzly/common/storage.py
@@ -6,7 +6,6 @@
 import json
 from collections import namedtuple
 from itertools import chain, product
-from os import walk
 from os.path import normpath, split
 from pathlib import Path
 from shutil import copyfile, move, rmtree
@@ -445,25 +444,24 @@ def load_single(cls, path, adjacent=False, load_assets=True, copy=True):
         # load all adjacent data from directory
         if adjacent:
             asset_path = info.get("assets_path", None)
-            for dpath, _, files in walk(entry_point.parent):
-                dpath = Path(dpath)
+            for entry in Path(entry_point.parent).rglob("*"):
+                if not entry.is_file():
+                    continue
+                location = entry.relative_to(entry_point.parent).as_posix()
                 # ignore asset path
-                if asset_path and dpath.samefile(entry_point.parent / asset_path):
+                if asset_path and location.startswith(asset_path):
                     continue
-                for fname in files:
-                    file = dpath / fname
-                    location = file.relative_to(entry_point.parent).as_posix()
-                    # ignore files that have been previously loaded
-                    if location in (test.landing_page, "test_info.json"):
-                        continue
-                    # NOTE: when loading all files except the entry point are
-                    # marked as `required=False`
-                    test.add_from_file(
-                        file,
-                        file_name=location,
-                        required=False,
-                        copy=copy,
-                    )
+                # ignore files that have been previously loaded
+                if location in (test.landing_page, "test_info.json"):
+                    continue
+                # NOTE: when loading all files except the entry point are
+                # marked as `required=False`
+                test.add_from_file(
+                    entry,
+                    file_name=location,
+                    required=False,
+                    copy=copy,
+                )
         return test
 
     @property
diff --git a/grizzly/common/test_storage.py b/grizzly/common/test_storage.py
index a372d2f8..00f9b2f6 100644
--- a/grizzly/common/test_storage.py
+++ b/grizzly/common/test_storage.py
@@ -6,8 +6,6 @@
 
 from itertools import chain
 from json import dumps, loads
-from os import walk
-from pathlib import Path
 from zipfile import ZIP_DEFLATED, ZipFile
 
 from pytest import mark, raises
@@ -380,13 +378,9 @@ def test_testcase_15(tmp_path):
     (tmp_path / "not_a_tc").mkdir()
     (tmp_path / "not_a_tc" / "file.txt").touch()
     with ZipFile(archive, mode="w", compression=ZIP_DEFLATED) as zfp:
-        for dir_name, _, dir_files in walk(tmp_path):
-            for file_name in dir_files:
-                file_path = Path(dir_name) / file_name
-                zfp.write(
-                    str(file_path),
-                    arcname=str(file_path.relative_to(tmp_path)),
-                )
+        for entry in tmp_path.rglob("*"):
+            if entry.is_file():
+                zfp.write(str(entry), arcname=str(entry.relative_to(tmp_path)))
     testcases = TestCase.load(archive)
     try:
         assert len(testcases) == 3

From 578830548cb98c31e440d830fab2b43ec5ecddf0 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 1 Feb 2022 10:44:59 -0800
Subject: [PATCH 400/531] Use pathlib in a few more places

---
 grizzly/common/report.py        | 20 +++-----
 grizzly/common/reporter.py      | 89 +++++++++++++++------------------
 grizzly/common/test_report.py   | 33 ++++++------
 grizzly/common/test_reporter.py | 16 +++---
 grizzly/reduce/core.py          |  2 +
 5 files changed, 74 insertions(+), 86 deletions(-)

diff --git a/grizzly/common/report.py b/grizzly/common/report.py
index efa8e07c..569226f8 100644
--- a/grizzly/common/report.py
+++ b/grizzly/common/report.py
@@ -6,8 +6,7 @@
 from hashlib import sha1
 from logging import getLogger
 from os import SEEK_END, scandir, stat, unlink
-from os.path import basename, isdir, isfile
-from os.path import join as pathjoin
+from pathlib import Path
 from platform import machine, system
 from re import DOTALL, VERBOSE
 from re import compile as re_compile
@@ -52,15 +51,14 @@ class Report:
     )
 
     def __init__(self, log_path, target_binary, is_hang=False, size_limit=MAX_LOG_SIZE):
-        assert isinstance(log_path, str)
         assert isinstance(target_binary, str)
         self._crash_info = None
         self._logs = self.select_logs(log_path)
         assert self._logs is not None
         self._signature = None
-        self._target_binary = target_binary
+        self._target_binary = Path(target_binary)
         self.is_hang = is_hang
-        self.path = log_path
+        self.path = Path(log_path)
         # tail files in log_path if needed
         if size_limit < 1:
             LOG.warning("No limit set on report log size!")
@@ -106,8 +104,8 @@ def cleanup(self):
         Returns:
             None
         """
-        if self.path and isdir(self.path):
-            rmtree(self.path)
+        if self.path and self.path.is_dir():
+            rmtree(str(self.path))
         self.path = None
 
     @property
@@ -143,17 +141,15 @@ def crash_info(self):
             else:
                 aux_data = None
             # create ProgramConfiguration that can be reported to a FM server
-            if isfile("%s.fuzzmanagerconf" % (self._target_binary,)):
+            if Path("%s.fuzzmanagerconf" % (self._target_binary,)).is_file():
                 # attempt to use "<target_binary>.fuzzmanagerconf"
                 fm_cfg = ProgramConfiguration.fromBinary(self._target_binary)
             else:
                 LOG.debug("'%s.fuzzmanagerconf' does not exist", self._target_binary)
-                fm_cfg = None
-            if fm_cfg is None:
                 LOG.debug("creating ProgramConfiguration")
                 cpu = machine().lower()
                 fm_cfg = ProgramConfiguration(
-                    basename(self._target_binary),
+                    self._target_binary.name,
                     "x86_64" if cpu == "amd64" else cpu,
                     system(),
                 )
@@ -180,7 +176,7 @@ def crash_signature(self):
         """
         if self._signature is None:
             collector = Collector()
-            with InterProcessLock(pathjoin(grz_tmp(), "fm_sigcache.lock")):
+            with InterProcessLock(str(Path(grz_tmp()) / "fm_sigcache.lock")):
                 if collector.sigCacheDir:
                     cache_sig, _ = collector.search(self.crash_info)
                     if cache_sig:
diff --git a/grizzly/common/reporter.py b/grizzly/common/reporter.py
index 0dba61a2..c0e46a19 100644
--- a/grizzly/common/reporter.py
+++ b/grizzly/common/reporter.py
@@ -6,10 +6,8 @@
 from enum import IntEnum, unique
 from json import dumps, loads
 from logging import WARNING, getLogger
-from os import getcwd, getenv, makedirs, mkdir, unlink, walk
-from os.path import basename, expanduser, isdir, isfile
-from os.path import join as pathjoin
-from os.path import realpath, relpath
+from os import getenv
+from pathlib import Path
 from shutil import copyfile, move, rmtree
 from tarfile import open as tar_open
 from tempfile import TemporaryDirectory
@@ -134,8 +132,7 @@ def __init__(self, report_path, major_bucket=True):
         super().__init__()
         self.major_bucket = major_bucket
         self.min_space = FilesystemReporter.DISK_SPACE_ABORT
-        assert isinstance(report_path, str) and report_path
-        self.report_path = report_path
+        self.report_path = Path(report_path)
 
     def _pre_submit(self, report):
         pass
@@ -146,32 +143,31 @@ def _post_submit(self):
     def _submit_report(self, report, test_cases):
         # create major bucket directory in working directory if needed
         if self.major_bucket:
-            dest_path = pathjoin(self.report_path, report.major[:16])
+            dest = self.report_path / report.major[:16]
         else:
-            dest_path = self.report_path
-        makedirs(dest_path, exist_ok=True)
+            dest = self.report_path
+        dest.mkdir(parents=True, exist_ok=True)
         # dump test cases and the contained files to working directory
         for test_number, test_case in enumerate(test_cases):
-            dump_path = pathjoin(dest_path, "%s-%d" % (report.prefix, test_number))
-            if not isdir(dump_path):
-                mkdir(dump_path)
+            dump_path = dest / ("%s-%d" % (report.prefix, test_number))
+            dump_path.mkdir(exist_ok=True)
             test_case.dump(dump_path, include_details=True)
         # move logs into bucket directory
-        log_path = pathjoin(dest_path, "%s_%s" % (report.prefix, "logs"))
-        if isdir(log_path):
-            LOG.warning("Report log path exists %r", log_path)
-        move(report.path, log_path)
+        log_path = dest / ("%s_%s" % (report.prefix, "logs"))
+        if log_path.is_dir():
+            LOG.warning("Report log path exists %r", str(log_path))
+        move(str(report.path), str(log_path))
         # avoid filling the disk
-        free_space = disk_usage(log_path).free
+        free_space = disk_usage(str(log_path)).free
         if free_space < self.min_space:
             raise RuntimeError(
                 "Running low on disk space (%0.1fMB)" % (free_space / 1048576.0,)
             )
-        return dest_path
+        return dest
 
 
 class FuzzManagerReporter(Reporter):
-    FM_CONFIG = pathjoin(expanduser("~"), ".fuzzmanagerconf")
+    FM_CONFIG = Path.home() / ".fuzzmanagerconf"
 
     __slots__ = ("_extra_metadata", "force_report", "quality", "tool")
 
@@ -195,9 +191,9 @@ def sanity_check(bin_file):
         Returns:
             None
         """
-        if not isfile(FuzzManagerReporter.FM_CONFIG):
+        if not FuzzManagerReporter.FM_CONFIG.is_file():
             raise IOError("Missing: %s" % (FuzzManagerReporter.FM_CONFIG,))
-        if not isfile("".join([bin_file, ".fuzzmanagerconf"])):
+        if not Path("".join([bin_file, ".fuzzmanagerconf"])).is_file():
             raise IOError("Missing: %s.fuzzmanagerconf" % (bin_file,))
         ProgramConfiguration.fromBinary(bin_file)
 
@@ -222,13 +218,13 @@ def _pre_submit(self, report):
 
     def _process_rr_trace(self, report):
         # don't report large files to FuzzManager
-        trace_path = pathjoin(report.path, "rr-traces")
-        if isdir(trace_path):
+        trace_path = report.path / "rr-traces"
+        if trace_path.is_dir():
             LOG.info("Ignored rr trace")
             self.add_extra_metadata("rr-trace", "ignored")
             # remove traces so they are not uploaded to FM (because they are huge)
             # use S3FuzzManagerReporter instead
-            rmtree(trace_path)
+            rmtree(str(trace_path))
 
     @staticmethod
     def _ignored(report):
@@ -257,7 +253,7 @@ def _submit_report(self, report, test_cases):
 
         if not self.force_report:
             # search for a cached signature match
-            with InterProcessLock(pathjoin(grz_tmp(), "fm_sigcache.lock")):
+            with InterProcessLock(str(Path(grz_tmp()) / "fm_sigcache.lock")):
                 _, cache_metadata = collector.search(report.crash_info)
 
             # check if signature has been marked as frequent in FM
@@ -279,9 +275,8 @@ def _submit_report(self, report, test_cases):
         test_case_meta = []
         for test_number, test_case in enumerate(test_cases):
             test_case_meta.append([test_case.adapter_name, test_case.input_fname])
-            dump_path = pathjoin(report.path, "%s-%d" % (report.prefix, test_number))
-            if not isdir(dump_path):
-                mkdir(dump_path)
+            dump_path = report.path / ("%s-%d" % (report.prefix, test_number))
+            dump_path.mkdir(exist_ok=True)
             test_case.dump(dump_path, include_details=True)
         report.crash_info.configuration.addMetadata(
             {"grizzly_input": repr(test_case_meta)}
@@ -300,23 +295,21 @@ def _submit_report(self, report, test_cases):
         # TODO: this should likely move to ffpuppet
         # grab screen log (used in automation)
         if getenv("WINDOW") is not None:
-            screen_log = pathjoin(getcwd(), "screenlog.%s" % (getenv("WINDOW"),))
-            if isfile(screen_log):
-                target_log = pathjoin(report.path, "screenlog.txt")
-                copyfile(screen_log, target_log)
+            screen_log = Path.cwd() / ("screenlog.%s" % (getenv("WINDOW"),))
+            if screen_log.is_file():
+                target_log = report.path / "screenlog.txt"
+                copyfile(str(screen_log), str(target_log))
                 Report.tail(target_log, 10240)  # limit to last 10K
 
         with TemporaryDirectory(prefix="fm-zip", dir=grz_tmp()) as tmp_dir:
             # add results to a zip file
-            zip_name = pathjoin(tmp_dir, "%s.zip" % (report.prefix,))
+            zip_name = Path(tmp_dir) / ("%s.zip" % (report.prefix,))
             with ZipFile(zip_name, mode="w", compression=ZIP_DEFLATED) as zip_fp:
                 # add test files
-                for dir_name, _, dir_files in walk(report.path):
-                    arc_path = relpath(dir_name, report.path)
-                    for file_name in dir_files:
+                for entry in report.path.rglob("*"):
+                    if entry.is_file():
                         zip_fp.write(
-                            pathjoin(dir_name, file_name),
-                            arcname=pathjoin(arc_path, file_name),
+                            str(entry), arcname=str(entry.relative_to(report.path))
                         )
             # override tool name if specified
             if self.tool is not None:
@@ -335,22 +328,22 @@ class S3FuzzManagerReporter(FuzzManagerReporter):
     @staticmethod
     def compress_rr_trace(src, dest):
         # resolve symlink to latest trace available
-        latest_trace = realpath(pathjoin(src, "latest-trace"))
-        assert isdir(latest_trace), "missing latest-trace directory"
-        rr_arc = pathjoin(dest, "rr.tar.bz2")
+        latest_trace = (src / "latest-trace").resolve(strict=True)
+        assert latest_trace.is_dir(), "missing latest-trace directory"
+        rr_arc = dest / "rr.tar.bz2"
         LOG.debug("creating %r from %r", rr_arc, latest_trace)
         with tar_open(rr_arc, "w:bz2") as arc_fp:
-            arc_fp.add(latest_trace, arcname=basename(latest_trace))
+            arc_fp.add(str(latest_trace), arcname=latest_trace.name)
         # remove path containing uncompressed traces
-        rmtree(src)
+        rmtree(str(src))
         return rr_arc
 
     def _pre_submit(self, report):
         self._process_rr_trace(report)
 
     def _process_rr_trace(self, report):
-        trace_path = pathjoin(report.path, "rr-traces")
-        if not isdir(trace_path):
+        trace_path = report.path / "rr-traces"
+        if not trace_path.is_dir():
             return None
         s3_bucket = getenv("GRZ_S3_BUCKET")
         assert s3_bucket is not None
@@ -373,15 +366,15 @@ def _process_rr_trace(self, report):
             LOG.info("rr trace exists at %r", s3_url)
             self.add_extra_metadata("rr-trace", s3_url)
             # remove traces so they are not reported to FM
-            rmtree(trace_path)
+            rmtree(str(trace_path))
             return s3_url
 
         # Upload to S3
         rr_arc = self.compress_rr_trace(trace_path, report.path)
         s3_res.meta.client.upload_file(
-            rr_arc, s3_bucket, s3_key, ExtraArgs={"ACL": "public-read"}
+            str(rr_arc), s3_bucket, s3_key, ExtraArgs={"ACL": "public-read"}
         )
-        unlink(rr_arc)
+        rr_arc.unlink()
         self.add_extra_metadata("rr-trace", s3_url)
         return s3_url
 
diff --git a/grizzly/common/test_report.py b/grizzly/common/test_report.py
index edc408ea..994de37e 100644
--- a/grizzly/common/test_report.py
+++ b/grizzly/common/test_report.py
@@ -5,11 +5,10 @@
 """test Grizzly Report"""
 # pylint: disable=protected-access
 
-import os
 from pathlib import Path
 
-import pytest
 from FTB.Signatures.CrashInfo import CrashInfo
+from pytest import mark, raises
 
 from .report import Report
 
@@ -27,9 +26,9 @@ def test_report_01(tmp_path):
     (tmp_path / "not_a_log.txt").touch()
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    report = Report(str(tmp_path), "a.bin", size_limit=0)
-    assert report._target_binary == "a.bin"
-    assert report.path == str(tmp_path)
+    report = Report(tmp_path, "a.bin", size_limit=0)
+    assert report._target_binary.name == "a.bin"
+    assert report.path == tmp_path
     assert report._logs.aux is None
     assert report._logs.stderr.endswith("log_stderr.txt")
     assert report._logs.stdout.endswith("log_stdout.txt")
@@ -47,8 +46,8 @@ def test_report_02(tmp_path):
     (tmp_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     _create_crash_log(tmp_path / "log_asan_blah.txt")
-    report = Report(str(tmp_path), "bin")
-    assert report.path == str(tmp_path)
+    report = Report(tmp_path, "bin")
+    assert report.path == tmp_path
     assert report._logs.aux.endswith("log_asan_blah.txt")
     assert report._logs.stderr.endswith("log_stderr.txt")
     assert report._logs.stdout.endswith("log_stdout.txt")
@@ -66,7 +65,7 @@ def test_report_03(tmp_path):
     tmp_file.write_bytes(b"blah\ntest\n123\xEF\x00FOO")
     length = tmp_file.stat().st_size
     # no size limit
-    with pytest.raises(AssertionError):
+    with raises(AssertionError):
         Report.tail(str(tmp_file), 0)
     assert tmp_file.stat().st_size == length
     Report.tail(str(tmp_file), 3)
@@ -256,17 +255,17 @@ def test_report_10(tmp_path):
     (tmp_path / "unrelated.txt").write_bytes(b"nothing burger\n" * 200)
     (tmp_path / "rr-trace").mkdir()
     size_limit = len("STDERR log\n")
-    report = Report(str(tmp_path), "bin", size_limit=size_limit)
-    assert report.path == str(tmp_path)
+    report = Report(tmp_path, "bin", size_limit=size_limit)
+    assert report.path == tmp_path
     assert report._logs.aux is None
     assert report._logs.stderr.endswith("log_stderr.txt")
     assert report._logs.stdout.endswith("log_stdout.txt")
     assert report.preferred.endswith("log_stderr.txt")
     assert report.stack is None
     size_limit += len("[LOG TAILED]\n")
-    assert os.stat(os.path.join(report.path, report._logs.stderr)).st_size == size_limit
-    assert os.stat(os.path.join(report.path, report._logs.stdout)).st_size == size_limit
-    assert os.stat(os.path.join(report.path, "unrelated.txt")).st_size == size_limit
+    assert (report.path / report._logs.stderr).stat().st_size == size_limit
+    assert (report.path / report._logs.stdout).stat().st_size == size_limit
+    assert (report.path / "unrelated.txt").stat().st_size == size_limit
     report.cleanup()
     assert not tmp_path.is_dir()
 
@@ -288,7 +287,7 @@ def test_report_12(tmp_path):
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     _create_crash_log(tmp_path / "log_asan_blah.txt")
     # no binary.fuzzmanagerconf
-    report = Report(str(tmp_path), target_binary="fake_bin")
+    report = Report(tmp_path, target_binary="fake_bin")
     assert report._crash_info is None
     assert report.crash_info is not None
     assert report._crash_info is not None
@@ -298,13 +297,13 @@ def test_report_12(tmp_path):
         conf.write(b"platform = x86-64\n")
         conf.write(b"product = mozilla-central\n")
         conf.write(b"os = linux\n")
-    report = Report(str(tmp_path), target_binary=str(tmp_path / "fake_bin"))
+    report = Report(tmp_path, target_binary=str(tmp_path / "fake_bin"))
     assert report._crash_info is None
     assert report.crash_info is not None
     assert report._crash_info is not None
 
 
-@pytest.mark.parametrize(
+@mark.parametrize(
     "sig_cache, has_sig",
     [
         # signature exists in cache
@@ -330,7 +329,7 @@ def test_report_13(mocker, tmp_path, sig_cache, has_sig):
     (tmp_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     if has_sig:
         _create_crash_log(tmp_path / "log_asan_blah.txt")
-    report = Report(str(tmp_path), "bin")
+    report = Report(tmp_path, "bin")
     assert report._signature is None
     if has_sig:
         assert report.crash_signature
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 3033f693..3241b237 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -140,15 +140,15 @@ def test_fuzzmanager_reporter_01(mocker, tmp_path):
     fake_reporter = mocker.patch("grizzly.common.reporter.ProgramConfiguration")
     fake_reporter.fromBinary.return_value = mocker.Mock(spec_set=ProgramConfiguration)
     # missing global FM config file
-    FuzzManagerReporter.FM_CONFIG = "no_file"
-    with raises(IOError, match="Missing: no_file"):
+    FuzzManagerReporter.FM_CONFIG = tmp_path / "no_file"
+    with raises(IOError, match="Missing: %s" % (FuzzManagerReporter.FM_CONFIG,)):
         FuzzManagerReporter.sanity_check("fake")
     # missing binary FM config file
     fake_fmc = tmp_path / ".fuzzmanagerconf"
     fake_fmc.touch()
     fake_bin = tmp_path / "bin"
     fake_bin.touch()
-    FuzzManagerReporter.FM_CONFIG = str(fake_fmc)
+    FuzzManagerReporter.FM_CONFIG = fake_fmc
     with raises(IOError, match="bin.fuzzmanagerconf"):
         FuzzManagerReporter.sanity_check(str(fake_bin))
     # success
@@ -179,9 +179,7 @@ def test_fuzzmanager_reporter_02(mocker, tmp_path, tests, frequent, ignored, for
         new_callable=mocker.MagicMock,
         return_value=ignored,
     )
-    mocker.patch(
-        "grizzly.common.reporter.getcwd", autospec=True, return_value=str(tmp_path)
-    )
+    mocker.patch("grizzly.common.reporter.Path.cwd", return_value=tmp_path)
     mocker.patch("grizzly.common.reporter.getenv", autospec=True, return_value="0")
     fake_collector = mocker.patch("grizzly.common.reporter.Collector", autospec=True)
     fake_collector.return_value.search.return_value = (
@@ -258,7 +256,7 @@ def test_s3fuzzmanager_reporter_02(mocker, tmp_path):
     fake_resource = mocker.patch("grizzly.common.reporter.resource", autospec=True)
 
     fake_report = mocker.Mock(spec_set=Report)
-    fake_report.path = "no-path"
+    fake_report.path = tmp_path / "no-path"
     reporter = S3FuzzManagerReporter("fake_bin")
     # test will missing rr-trace
     assert reporter._pre_submit(fake_report) is None
@@ -268,7 +266,7 @@ def test_s3fuzzmanager_reporter_02(mocker, tmp_path):
     trace_dir = tmp_path / "rr-traces" / "latest-trace"
     trace_dir.mkdir(parents=True)
     fake_report.minor = "1234abcd"
-    fake_report.path = str(tmp_path)
+    fake_report.path = tmp_path
     reporter._pre_submit(fake_report)
     assert not any(tmp_path.iterdir())
     assert "rr-trace" in reporter._extra_metadata
@@ -317,7 +315,7 @@ def test_s3fuzzmanager_reporter_03(tmp_path):
     src = tmp_path / "rr-traces"
     dest = tmp_path / "dest"
     dest.mkdir()
-    S3FuzzManagerReporter.compress_rr_trace(str(src), str(dest))
+    S3FuzzManagerReporter.compress_rr_trace(src, dest)
     assert not src.is_dir()
     assert (dest / "rr.tar.bz2").is_file()
     with tar_open(str(dest / "rr.tar.bz2"), "r:bz2") as arc_fp:
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index fbcfb823..8b58a9f4 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -734,6 +734,8 @@ def report(self, results, testcases):
                         clone.purge_optional(served)
                 result = reporter.submit(clones, result.report)
                 if result is not None:
+                    if isinstance(result, Path):
+                        result = str(result)
                     ret_values.append(result)
             finally:
                 for clone in clones:

From 5a31074bccba7647a524fcda780960f115a7c9bd Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 1 Feb 2022 11:01:16 -0800
Subject: [PATCH 401/531] Switch to pathlib in adapter.py

---
 grizzly/adapter/adapter.py | 30 ++++++++++++++----------------
 1 file changed, 14 insertions(+), 16 deletions(-)

diff --git a/grizzly/adapter/adapter.py b/grizzly/adapter/adapter.py
index 0d88bc4d..473a5f1b 100644
--- a/grizzly/adapter/adapter.py
+++ b/grizzly/adapter/adapter.py
@@ -3,9 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from abc import ABCMeta, abstractmethod
-from os import walk
-from os.path import abspath, dirname, isdir, isfile
-from os.path import join as pathjoin
+from pathlib import Path
 
 __all__ = ("Adapter", "AdapterError")
 __author__ = "Tyson Smith"
@@ -36,7 +34,7 @@ class Adapter(metaclass=ABCMeta):
                          remaining to process.
     """
 
-    HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
+    HARNESS_FILE = str((Path(__file__).parent / "../common/harness.html").resolve())
     # Only report test cases with served content.
     IGNORE_UNSERVED = True
     # Maximum iterations between Target relaunches (<1 use default)
@@ -111,18 +109,18 @@ def scan_path(path, ignore=("desktop.ini", "thumbs.db"), recursive=False):
         Yields:
             str: Absolute path to files.
         """
-        full_path = abspath(path)
-        if isdir(full_path):
-            for root, _, files in walk(full_path):
-                for fname in files:
-                    if fname in ignore or fname.startswith("."):
-                        # skip ignored and hidden system files
-                        continue
-                    yield pathjoin(root, fname)
-                if not recursive:
-                    break
-        elif isfile(full_path):
-            yield full_path
+        path = Path(path).resolve()
+        if path.is_dir():
+            path_iter = path.rglob("*") if recursive else path.glob("*")
+            for entry in path_iter:
+                if not entry.is_file():
+                    continue
+                if entry.name in ignore or entry.name.startswith("."):
+                    # skip ignored and hidden system files
+                    continue
+                yield str(entry)
+        elif path.is_file():
+            yield str(path)
 
     @abstractmethod
     def generate(self, testcase, server_map):

From 5fa647a7f940ce716dc8e489fdfeb537b0ca930e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 1 Feb 2022 11:05:54 -0800
Subject: [PATCH 402/531] Fix spacing in 'CPU & Load' reporting

---
 grizzly/common/status_reporter.py      | 2 +-
 grizzly/common/test_status_reporter.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/status_reporter.py b/grizzly/common/status_reporter.py
index ab9d1b9b..4a098718 100644
--- a/grizzly/common/status_reporter.py
+++ b/grizzly/common/status_reporter.py
@@ -367,7 +367,7 @@ def _sys_info():
             )
         )
         if getloadavg is not None:
-            disp.append("(")
+            disp.append(" (")
             # round the results of getloadavg(), precision varies across platforms
             disp.append(", ".join("%0.1f" % (round(x, 1),) for x in getloadavg()))
             disp.append(")")
diff --git a/grizzly/common/test_status_reporter.py b/grizzly/common/test_status_reporter.py
index c04974e6..1aaf57c5 100644
--- a/grizzly/common/test_status_reporter.py
+++ b/grizzly/common/test_status_reporter.py
@@ -263,7 +263,7 @@ def test_status_reporter_03(mocker, disk, memory, getloadavg):
     assert sysinfo[1][0] == "Memory"
     assert sysinfo[2][0] == "Disk"
     if getloadavg is not None:
-        assert sysinfo[0][-1].endswith("(0.1, 0.3, 0.6)")
+        assert sysinfo[0][-1].endswith(" (0.1, 0.3, 0.6)")
     if disk.free < GBYTES or memory.available < GBYTES:
         assert "MB" in sysinfo[1][-1]
         assert "MB" in sysinfo[2][-1]

From 22074c561fc89fb2175178c44036c08bf9db6811 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 1 Feb 2022 12:37:25 -0800
Subject: [PATCH 403/531] Use Path objs in a few more places

---
 grizzly/common/test_reporter.py | 27 ++++++++++++---------------
 grizzly/main.py                 |  6 +++---
 grizzly/reduce/core.py          |  2 +-
 3 files changed, 16 insertions(+), 19 deletions(-)

diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 3241b237..93f71f90 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -71,8 +71,8 @@ def test_filesystem_reporter_01(tmp_path):
     _create_crash_log(tmp_path / "log_asan_blah.txt")
     report_path = tmp_path / "reports"
     report_path.mkdir()
-    reporter = FilesystemReporter(str(report_path))
-    reporter.submit([], Report(str(log_path), "fake_bin"))
+    reporter = FilesystemReporter(report_path)
+    reporter.submit([], Report(log_path, "fake_bin"))
     buckets = tuple(report_path.iterdir())
     # check major bucket
     assert len(buckets) == 1
@@ -94,8 +94,8 @@ def test_filesystem_reporter_02(tmp_path, mocker):
     tests = list(mocker.Mock(spec_set=TestCase) for _ in range(10))
     report_path = tmp_path / "reports"
     assert not report_path.exists()
-    reporter = FilesystemReporter(str(report_path))
-    reporter.submit(tests, Report(str(log_path), "fake_bin"))
+    reporter = FilesystemReporter(report_path)
+    reporter.submit(tests, Report(log_path, "fake_bin"))
     assert not log_path.exists()
     assert report_path.exists()
     assert len(tuple(report_path.iterdir())) == 1
@@ -105,7 +105,7 @@ def test_filesystem_reporter_02(tmp_path, mocker):
     (log_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (log_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     tests = list(mocker.Mock(spec_set=TestCase) for _ in range(2))
-    reporter.submit(tests, Report(str(log_path), "fake_bin"))
+    reporter.submit(tests, Report(log_path, "fake_bin"))
     assert all(x.dump.call_count == 1 for x in tests)
     assert len(tuple(report_path.iterdir())) == 2
     assert len(tuple(report_path.glob("NO_STACK"))) == 1
@@ -117,18 +117,18 @@ def test_filesystem_reporter_03(tmp_path):
     log_path.mkdir()
     (log_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (log_path / "log_stdout.txt").write_bytes(b"STDOUT log")
-    reporter = FilesystemReporter(str(tmp_path / "reports"))
+    reporter = FilesystemReporter(tmp_path / "reports")
     reporter.min_space = 2 ** 50
     with raises(RuntimeError, match="Running low on disk space"):
-        reporter.submit([], Report(str(log_path), "fake_bin"))
+        reporter.submit([], Report(log_path, "fake_bin"))
 
 
 def test_filesystem_reporter_04(mocker, tmp_path):
     """test FilesystemReporter w/o major bucket"""
     fake_report = tmp_path / "fake_report"
     fake_report.mkdir()
-    report = mocker.Mock(spec_set=Report, path=str(fake_report), prefix="test_prefix")
-    reporter = FilesystemReporter(str(tmp_path / "dst"), major_bucket=False)
+    report = mocker.Mock(spec_set=Report, path=fake_report, prefix="test_prefix")
+    reporter = FilesystemReporter(tmp_path / "dst", major_bucket=False)
     reporter.submit([], report)
     assert not fake_report.is_dir()
     assert not report.major.call_count
@@ -141,7 +141,7 @@ def test_fuzzmanager_reporter_01(mocker, tmp_path):
     fake_reporter.fromBinary.return_value = mocker.Mock(spec_set=ProgramConfiguration)
     # missing global FM config file
     FuzzManagerReporter.FM_CONFIG = tmp_path / "no_file"
-    with raises(IOError, match="Missing: %s" % (FuzzManagerReporter.FM_CONFIG,)):
+    with raises(IOError, match="no_file"):
         FuzzManagerReporter.sanity_check("fake")
     # missing binary FM config file
     fake_fmc = tmp_path / ".fuzzmanagerconf"
@@ -204,7 +204,7 @@ def test_fuzzmanager_reporter_02(mocker, tmp_path, tests, frequent, ignored, for
         test_cases.append(fake_test)
     reporter = FuzzManagerReporter("fake_bin")
     reporter.force_report = force
-    reporter.submit(test_cases, Report(str(log_path), "fake_bin", is_hang=True))
+    reporter.submit(test_cases, Report(log_path, "fake_bin", is_hang=True))
     assert not log_path.is_dir()
     if (frequent and not force) or ignored:
         assert fake_collector.return_value.submit.call_count == 0
@@ -220,10 +220,7 @@ def test_fuzzmanager_reporter_03(mocker, tmp_path):
     log_file = tmp_path / "test.log"
     log_file.touch()
     report = mocker.Mock(
-        spec_set=Report,
-        path=str(tmp_path),
-        preferred=str(log_file),
-        stack=None,
+        spec_set=Report, path=tmp_path, preferred=str(log_file), stack=None
     )
     # not ignored
     assert not FuzzManagerReporter._ignored(report)
diff --git a/grizzly/main.py b/grizzly/main.py
index 23cd969f..df49db11 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -4,7 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import DEBUG, getLogger
 from os import getpid
-from os.path import join as pathjoin
+from pathlib import Path
 
 from sapphire import Sapphire
 
@@ -104,8 +104,8 @@ def main(args):
             )
             reporter = S3FuzzManagerReporter(tool=args.tool)
         else:
-            reporter = FilesystemReporter(pathjoin(args.logs, "results"))
-            LOG.info("Results will be stored in %r", reporter.report_path)
+            reporter = FilesystemReporter(Path(args.logs) / "results")
+            LOG.info("Results will be stored in %r", str(reporter.report_path))
         reporter.display_logs = args.smoke_test or reporter.display_logs
 
         # make sure an iteration limit is set if smoke_test is True
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 8b58a9f4..5fc482b0 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -716,7 +716,7 @@ def report(self, results, testcases):
             else:
                 report_dir = "reports" if result.expected else "other_reports"
                 reporter = FilesystemReporter(
-                    report_path=str(self._log_path / report_dir), major_bucket=False
+                    report_path=self._log_path / report_dir, major_bucket=False
                 )
             # write reduction stats for expected results
             if result.expected:

From 547d84c256703480896b85944f3e41a641b765a2 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 2 Feb 2022 13:31:56 -0800
Subject: [PATCH 404/531] Check '/proc/sys/kernel/perf_event_paranoid' before
 launching with rr

---
 grizzly/args.py      |  8 ++++++++
 grizzly/test_args.py | 30 ++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+)

diff --git a/grizzly/args.py b/grizzly/args.py
index 8bcf9c93..e3ee72e2 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -6,6 +6,7 @@
 from logging import CRITICAL, DEBUG, ERROR, INFO, WARNING
 from os import getcwd
 from os.path import exists, isfile
+from pathlib import Path
 from platform import system
 
 from .common.plugins import scan as scan_plugins
@@ -229,6 +230,13 @@ def sanity_check(self, args):
         if args.relaunch < 1:
             self.parser.error("--relaunch must be >= 1")
 
+        if args.pernosco or args.rr:
+            # currently we only support rr on Linux
+            settings = "/proc/sys/kernel/perf_event_paranoid"
+            value = int(Path(settings).read_text())
+            if value > 1:
+                self.parser.error("rr needs %s <= 1, but it is %d" % (settings, value))
+
         if args.platform not in targets:
             self.parser.error("Platform %r not installed" % (args.platform,))
 
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index cdbe595f..70e23e3d 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -3,6 +3,8 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
+from platform import system
+
 from pytest import mark, raises
 
 from .args import CommonArgs, GrizzlyArgs
@@ -180,3 +182,31 @@ def test_grizzly_args_04(capsys, mocker, tmp_path, args, msg):
             argv=[str(fake_bin), "adpt", "--platform", "targ1"] + args
         )
     assert msg in capsys.readouterr()[-1]
+
+
+@mark.skipif(system() != "Linux", reason="Only supported on Linux")
+@mark.parametrize(
+    "args, msg",
+    [
+        # test checking perf_event_paranoid
+        (
+            ["--rr"],
+            "error: rr needs /proc/sys/kernel/perf_event_paranoid <= 1, but it is 99",
+        ),
+    ],
+)
+def test_grizzly_args_05(capsys, mocker, tmp_path, args, msg):
+    """test CommonArgs.parse_args() - debugger system checks"""
+    mocker.patch(
+        "grizzly.args.scan_plugins",
+        autospec=True,
+        side_effect=["targ1", "adpt", "targ1", "adpt"],
+    )
+    mocker.patch("grizzly.args.Path.read_text", autospec=True, return_value="99")
+    fake_bin = tmp_path / "fake.bin"
+    fake_bin.touch()
+    with raises(SystemExit):
+        GrizzlyArgs().parse_args(
+            argv=[str(fake_bin), "adpt", "--platform", "targ1"] + args
+        )
+    assert msg in capsys.readouterr()[-1]

From 35ff2a6945a9761103a027f19fb101b5ac436905 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 3 Feb 2022 16:18:12 -0800
Subject: [PATCH 405/531] Use pathlib in replay

---
 grizzly/replay/replay.py      | 14 ++++++--------
 grizzly/replay/test_replay.py | 14 ++++++--------
 2 files changed, 12 insertions(+), 16 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index de0a84e3..be927f3f 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -4,8 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 from logging import getLogger
-from os.path import dirname
-from os.path import join as pathjoin
+from pathlib import Path
 from tempfile import mkdtemp
 
 from FTB.Signatures.CrashInfo import CrashSignature
@@ -38,9 +37,9 @@ def __init__(self, report, served, durations, expected):
 
 
 class ReplayManager:
-    HARNESS_FILE = pathjoin(dirname(__file__), "..", "common", "harness.html")
+    HARNESS_FILE = str(Path(__file__).parent / ".." / "common" / "harness.html")
     DEFAULT_TIME_LIMIT = 30
-    STATUS_DB = pathjoin(grz_tmp(), "replay-status.db")
+    STATUS_DB = str(Path(grz_tmp()) / "replay-status.db")
 
     __slots__ = (
         "ignore",
@@ -193,11 +192,10 @@ def report_to_filesystem(path, results, tests=None):
         Returns:
             None
         """
+        path = Path(path)
         others = list(x.report for x in results if not x.expected)
         if others:
-            reporter = FilesystemReporter(
-                pathjoin(path, "other_reports"), major_bucket=False
-            )
+            reporter = FilesystemReporter(path / "other_reports", major_bucket=False)
             for report in others:
                 reporter.submit(tests or [], report=report)
         expected = list(x for x in results if x.expected)
@@ -208,7 +206,7 @@ def report_to_filesystem(path, results, tests=None):
                 for test, served in zip(tests, expected[0].served):
                     LOG.debug("calling test.purge_optional() with %r", served)
                     test.purge_optional(served)
-            reporter = FilesystemReporter(pathjoin(path, "reports"), major_bucket=False)
+            reporter = FilesystemReporter(path / "reports", major_bucket=False)
             for result in expected:
                 reporter.submit(tests or [], report=result.report)
 
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 02d7b532..304679e1 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -632,7 +632,7 @@ def test_replay_18(mocker):
 def test_replay_19(mocker, tmp_path):
     """test ReplayManager.report_to_filesystem()"""
     # no reports
-    ReplayManager.report_to_filesystem(str(tmp_path), [])
+    ReplayManager.report_to_filesystem(tmp_path, [])
     assert not any(tmp_path.iterdir())
     # with reports and tests
     (tmp_path / "report_expected").mkdir()
@@ -640,27 +640,25 @@ def test_replay_19(mocker, tmp_path):
         spec_set=ReplayResult, count=1, durations=[1], expected=True, served=[]
     )
     result0.report = mocker.Mock(
-        spec_set=Report, path=str(tmp_path / "report_expected"), prefix="expected"
+        spec_set=Report, path=tmp_path / "report_expected", prefix="expected"
     )
     (tmp_path / "report_other1").mkdir()
     result1 = mocker.Mock(
         spec_set=ReplayResult, count=1, durations=[1], expected=False, served=None
     )
     result1.report = mocker.Mock(
-        spec_set=Report, path=str(tmp_path / "report_other1"), prefix="other1"
+        spec_set=Report, path=tmp_path / "report_other1", prefix="other1"
     )
     (tmp_path / "report_other2").mkdir()
     result2 = mocker.Mock(
         spec_set=ReplayResult, count=1, durations=[1], expected=False, served=None
     )
     result2.report = mocker.Mock(
-        spec_set=Report, path=str(tmp_path / "report_other2"), prefix="other2"
+        spec_set=Report, path=tmp_path / "report_other2", prefix="other2"
     )
     test = mocker.Mock(spec_set=TestCase)
     path = tmp_path / "dest"
-    ReplayManager.report_to_filesystem(
-        str(path), [result0, result1, result2], tests=[test]
-    )
+    ReplayManager.report_to_filesystem(path, [result0, result1, result2], tests=[test])
     assert test.dump.call_count == 3  # called once per report
     assert not (tmp_path / "report_expected").is_dir()
     assert not (tmp_path / "report_other1").is_dir()
@@ -675,7 +673,7 @@ def test_replay_19(mocker, tmp_path):
     (tmp_path / "report_expected").mkdir()
     result0.reset_mock()
     path = tmp_path / "dest2"
-    ReplayManager.report_to_filesystem(str(path), [result0])
+    ReplayManager.report_to_filesystem(path, [result0])
     assert not (tmp_path / "report_expected").is_dir()
     assert path.is_dir()
     assert (path / "reports" / "expected_logs").is_dir()

From b1d912c87bbd942bda975994d7eb7013894fb2b2 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 11 Feb 2022 13:43:49 -0800
Subject: [PATCH 406/531] [sapphire] Include query string in redirect

---
 sapphire/test_sapphire.py | 15 +++++++++------
 sapphire/worker.py        |  6 +++++-
 2 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/sapphire/test_sapphire.py b/sapphire/test_sapphire.py
index 9443833c..0ebc9b01 100644
--- a/sapphire/test_sapphire.py
+++ b/sapphire/test_sapphire.py
@@ -340,23 +340,26 @@ def test_sapphire_16(client, tmp_path):
 
 
 @mark.parametrize(
-    "path",
+    "path, query",
     [
         # simple path
-        "test.html",
+        ("test.html", None),
+        # simple path with query
+        ("test.html", "foo=1&bar=2"),
         # non-alphanumeric chars (valid characters to use on filesystem)
-        "!@$%^&(_+-=[]),'~`{}",
+        ("!@$%^&(_+-=[]),'~`{}", None),
         # extended ascii chars
-        "€d’é-ñÿ",
+        ("€d’é-ñÿ", None),
     ],
 )
-def test_sapphire_17(client, tmp_path, path):
+def test_sapphire_17(client, tmp_path, path, query):
     """test required mapped redirects"""
     smap = ServerMap()
     with Sapphire(timeout=10) as serv:
         # target will be requested indirectly via the redirect
         target = _create_test(path, tmp_path, data=b"Redirect DATA!")
-        redirect = _TestFile("redirect")
+        request_path = "redirect" if query is None else "?".join(("redirect", query))
+        redirect = _TestFile(request_path)
         # point "redirect" at target
         smap.set_redirect("redirect", target.file, required=True)
         client.launch("127.0.0.1", serv.port, [redirect])
diff --git a/sapphire/worker.py b/sapphire/worker.py
index 486dd82e..061f1c50 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -141,7 +141,11 @@ def handle_request(cls, conn, serv_job):
                 conn.sendall(cls._4xx_page(404, "Not Found", serv_job.auto_close))
                 LOG.debug("404 %r (%d to go)", url.path, serv_job.pending)
             elif resource.type == Resource.URL_REDIRECT:
-                conn.sendall(cls._307_redirect(quote(resource.target)))
+                redirect_to = [quote(resource.target)]
+                if url.query:
+                    LOG.debug("appending query %r", url.query)
+                    redirect_to.append(url.query)
+                conn.sendall(cls._307_redirect("?".join(redirect_to)))
                 LOG.debug(
                     "307 %r -> %r (%d to go)",
                     url.path,

From 82769f87af9d1067a2bb012cf96fe2e9fd894eab Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 11 Feb 2022 14:32:15 -0800
Subject: [PATCH 407/531] Use common entry point '/grz_start'

---
 grizzly/common/harness.html      |  2 +-
 grizzly/common/iomanager.py      |  7 -------
 grizzly/common/runner.py         | 12 ++++++------
 grizzly/common/test_iomanager.py | 12 ------------
 grizzly/replay/replay.py         | 11 ++++++-----
 grizzly/session.py               | 19 +++++++++++++++----
 6 files changed, 28 insertions(+), 35 deletions(-)

diff --git a/grizzly/common/harness.html b/grizzly/common/harness.html
index 129f7a7a..796cb10c 100644
--- a/grizzly/common/harness.html
+++ b/grizzly/common/harness.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 <meta charset=UTF-8>
-<title>&#x1f43b; &sdot; Grizzly &sdot; &#x1f98a;</title>
+<title>Grizzly &sdot; Harness</title>
 <script>
 let close_after, limit_tmr, time_limit
 let sub = null
diff --git a/grizzly/common/iomanager.py b/grizzly/common/iomanager.py
index c8bfec24..7caf6b2d 100644
--- a/grizzly/common/iomanager.py
+++ b/grizzly/common/iomanager.py
@@ -18,14 +18,12 @@ class IOManager:
         "_generated",
         "_report_size",
         "_test",
-        "harness",
         "server_map",
         "tests",
     )
 
     def __init__(self, report_size=1):
         assert report_size > 0
-        self.harness = None
         self.server_map = ServerMap()
         self.tests = deque()
         self._generated = 0  # number of test cases generated
@@ -59,15 +57,10 @@ def create_testcase(self, adapter_name, time_limit):
             time_limit=time_limit,
         )
         # reset redirect map
-        self.server_map.redirect.clear()
         self.server_map.set_redirect(
             "grz_current_test", self.page_name(), required=False
         )
         self.server_map.set_redirect("grz_next_test", self.page_name(offset=1))
-        if self.harness is not None:
-            self.server_map.set_dynamic_response(
-                "grz_harness", lambda _: self.harness, mime_type="text/html"
-            )
         self._generated += 1
         return self._test
 
diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index a694ba86..12a8af39 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -118,6 +118,7 @@ def launch(self, location, max_retries=3, retry_delay=0):
         assert max_retries >= 0
         assert retry_delay >= 0
         self._server.clear_backlog()
+        self._tests_run = 0
         LOG.debug("launching target (timeout %ds)", self._target.launch_timeout)
         for retries in reversed(range(max_retries)):
             try:
@@ -140,7 +141,6 @@ def launch(self, location, max_retries=3, retry_delay=0):
                     continue
                 raise
             break
-        self._tests_run = 0
 
     @staticmethod
     def location(srv_path, srv_port, close_after=None, time_limit=None):
@@ -161,11 +161,11 @@ def location(srv_path, srv_port, close_after=None, time_limit=None):
         if close_after is not None:
             assert close_after >= 0
             args.append("close_after=%d" % (close_after,))
-        if time_limit is not None:
-            assert time_limit >= 0
+        if time_limit:
+            assert time_limit > 0
             args.append("time_limit=%d" % (time_limit * 1000,))
         if args:
-            return "?".join([location, "&".join(args)])
+            return "?".join((location, "&".join(args)))
         return location
 
     def run(
@@ -183,8 +183,8 @@ def run(
             server_map (sapphire.ServerMap): A ServerMap.
             testcase (grizzly.TestCase): The test case that will be served.
             coverage (bool): Trigger coverage dump.
-            wait_for_callback: (bool): Use `_keep_waiting()` to indicate when
-                                       framework should move on.
+            wait_for_callback (bool): Use `_keep_waiting()` to indicate when
+                                      framework should move on.
 
         Returns:
             RunResult: Files served, status and timeout flag from the run.
diff --git a/grizzly/common/test_iomanager.py b/grizzly/common/test_iomanager.py
index 574d36aa..b1863606 100644
--- a/grizzly/common/test_iomanager.py
+++ b/grizzly/common/test_iomanager.py
@@ -11,7 +11,6 @@
 def test_iomanager_01():
     """test a simple IOManager"""
     with IOManager() as iom:
-        assert iom.harness is None
         assert iom.server_map is not None
         assert not iom.tests
         assert iom._generated == 0
@@ -68,7 +67,6 @@ def test_iomanager_04():
         assert not iom.server_map.dynamic
         assert not iom.server_map.include
         assert not iom.server_map.redirect
-        # without a harness, no input files
         tcase = iom.create_testcase("test-adapter", time_limit)
         assert tcase is not None
         assert not any(tcase.optional)
@@ -76,16 +74,6 @@ def test_iomanager_04():
         assert "grz_current_test" in iom.server_map.redirect
         assert iom.server_map.redirect["grz_current_test"].target == tcase.landing_page
         assert "grz_next_test" in iom.server_map.redirect
-        assert "grz_harness" not in iom.server_map.dynamic
         assert iom._test is not None
         iom.purge()
         assert iom._test is None
-        # with a harness
-        iom.harness = b"harness-data"
-        tcase = iom.create_testcase("test-adapter", time_limit)
-        assert tcase is not None
-        assert tcase.time_limit == time_limit
-        assert "grz_current_test" in iom.server_map.redirect
-        assert iom.server_map.redirect["grz_current_test"].target == tcase.landing_page
-        assert "grz_next_test" in iom.server_map.redirect
-        assert "grz_harness" in iom.server_map.dynamic
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index be927f3f..42ceb69b 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -256,10 +256,13 @@ def run(
         self.status = Status.start(db_file=self.STATUS_DB)
 
         server_map = ServerMap()
-        if self._harness is not None:
+        if self._harness is None:
+            server_map.set_redirect("grz_start", "grz_current_test", required=False)
+        else:
             server_map.set_dynamic_response(
                 "grz_harness", lambda _: self._harness, mime_type="text/html"
             )
+            server_map.set_redirect("grz_start", "grz_harness", required=False)
 
         # track unprocessed results
         reports = dict()
@@ -281,12 +284,10 @@ def run(
                     on_iteration_cb()
                 if self.target.closed:
                     if self._harness is None:
-                        location = runner.location(
-                            "/grz_current_test", self.server.port
-                        )
+                        location = runner.location("/grz_start", self.server.port)
                     else:
                         location = runner.location(
-                            "/grz_harness",
+                            "/grz_start",
                             self.server.port,
                             close_after=relaunch * test_count,
                             time_limit=time_limit,
diff --git a/grizzly/session.py b/grizzly/session.py
index c8078978..434902dd 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -152,7 +152,18 @@ def run(
         LOG.debug("calling adapter.setup()")
         self.adapter.setup(input_path, self.iomanager.server_map)
         LOG.debug("configuring harness")
-        self.iomanager.harness = self.adapter.get_harness()
+        harness = self.adapter.get_harness()
+        if harness is None:
+            self.iomanager.server_map.set_redirect(
+                "grz_start", "grz_current_test", required=False
+            )
+        else:
+            self.iomanager.server_map.set_dynamic_response(
+                "grz_harness", lambda _: harness, mime_type="text/html", required=False
+            )
+            self.iomanager.server_map.set_redirect(
+                "grz_start", "grz_harness", required=False
+            )
 
         log_limiter = LogOutputLimiter(verbose=display_mode == self.DISPLAY_VERBOSE)
         # limit relaunch to max iterations if needed
@@ -171,13 +182,13 @@ def run(
                 # (re-)launch target
                 self.iomanager.purge()
                 self.adapter.pre_launch()
-                if self.iomanager.harness is None:
+                if harness is None:
                     # harness is not in use, open the test case
-                    location = runner.location("/grz_current_test", self.server.port)
+                    location = runner.location("/grz_start", self.server.port)
                 else:
                     # harness is in use, open it and it will open the test case.
                     location = runner.location(
-                        "/grz_harness",
+                        "/grz_start",
                         self.server.port,
                         close_after=relaunch,
                         time_limit=time_limit,

From a3a20d40761641ec6b716fbc7c46ca2cae5c3e67 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 22 Feb 2022 12:31:41 -0800
Subject: [PATCH 408/531] [replay] Display message before processing result

This can help inform the end user and avoid aborting when a result
is being processed.
---
 grizzly/replay/replay.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 42ceb69b..d8a92a70 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -345,6 +345,9 @@ def run(
                             LOG.warning("Timeout too short? System too busy?")
                 # process run results
                 if run_result.status == Result.FOUND:
+                    # processing the result may take a few minutes (rr)
+                    # update console to show progress
+                    LOG.info("Processing result...")
                     # TODO: use self.target.create_report here
                     log_path = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
                     self.target.save_logs(log_path)

From 19d96cf47eda460edf5eb4dcf73ad58d9e7a22a2 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 28 Feb 2022 18:26:30 -0800
Subject: [PATCH 409/531] Use new PrefPicker API

---
 grizzly/target/puppet_target.py | 29 +++++++++++------------------
 setup.cfg                       |  2 +-
 2 files changed, 12 insertions(+), 19 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 3b9ffc01..431a691c 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -5,7 +5,7 @@
 from logging import getLogger
 from os import kill
 from os.path import isfile
-from os.path import join as pathjoin
+from pathlib import Path
 from platform import system
 from signal import SIGABRT
 
@@ -23,7 +23,7 @@
 
 from ..common.reporter import Report
 from ..common.utils import grz_tmp
-from .target import Result, Target, TargetError, TargetLaunchError, TargetLaunchTimeout
+from .target import Result, Target, TargetLaunchError, TargetLaunchTimeout
 from .target_monitor import TargetMonitor
 
 __all__ = ("PuppetTarget",)
@@ -314,17 +314,12 @@ def process_assets(self):
         self._prefs = self.assets.get("prefs")
         # generate temporary prefs.js with prefpicker
         if self._prefs is None:
-            for template in PrefPicker.templates():
-                if template.endswith("browser-fuzzing.yml"):
-                    LOG.debug("using prefpicker template %r", template)
-                    with TemporaryDirectory(dir=grz_tmp("target")) as tmp_path:
-                        prefs = pathjoin(tmp_path, "prefs.js")
-                        PrefPicker.load_template(template).create_prefsjs(prefs)
-                        LOG.debug("generated %r", prefs)
-                        self._prefs = self.assets.add("prefs", prefs, copy=False)
-                    break
-            else:  # pragma: no cover
-                raise TargetError("Failed to generate prefs.js")
+            LOG.debug("using prefpicker to generate prefs.js")
+            with TemporaryDirectory(dir=grz_tmp("target")) as tmp_path:
+                prefs = Path(tmp_path) / "prefs.js"
+                template = PrefPicker.lookup_template("browser-fuzzing.yml")
+                PrefPicker.load_template(template).create_prefsjs(prefs)
+                self._prefs = self.assets.add("prefs", str(prefs), copy=False)
         abort_tokens = self.assets.get("abort-tokens")
         if abort_tokens:
             LOG.debug("loading 'abort tokens' from %r", abort_tokens)
@@ -336,16 +331,14 @@ def process_assets(self):
 
         # configure sanitizer suppressions
         opts = SanitizerOptions()
-        for sanitizer in ["lsan", "tsan", "ubsan"]:
+        for sanitizer in ("lsan", "tsan", "ubsan"):
             asset = "%s-suppressions" % (sanitizer,)
             # load existing sanitizer options from environment
             var_name = "%s_OPTIONS" % (sanitizer.upper(),)
             opts.load_options(self.environ.get(var_name, ""))
             if self.assets.get(asset):
                 # use suppression file if provided as asset
-                opts.add(
-                    "suppressions", "%r" % (self.assets.get(asset),), overwrite=True
-                )
+                opts.add("suppressions", repr(self.assets.get(asset)), overwrite=True)
             elif opts.get("suppressions"):
                 supp_file = opts.pop("suppressions")
                 if SanitizerOptions.is_quoted(supp_file):
@@ -355,7 +348,7 @@ def process_assets(self):
                     LOG.debug("using %r from environment", asset)
                     opts.add(
                         "suppressions",
-                        "%r" % (self.assets.add(asset, supp_file),),
+                        repr(self.assets.add(asset, supp_file)),
                         overwrite=True,
                     )
                 else:
diff --git a/setup.cfg b/setup.cfg
index 32c370c3..32aa8c3e 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -26,7 +26,7 @@ install_requires =
     FuzzManager
     jsbeautifier
     lithium-reducer >= 0.5.3
-    prefpicker
+    prefpicker >= 1.1.0
     psutil >= 4.4.0
 packages =
     grizzly

From d2bb6ed4ab00a0954a04e7a99782cdc45857bbd5 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Sat, 26 Feb 2022 17:36:12 -0800
Subject: [PATCH 410/531] Update argument handling

---
 grizzly/args.py             |  80 +++++++++++------------
 grizzly/main.py             |   5 +-
 grizzly/reduce/args.py      |  15 +----
 grizzly/reduce/core.py      |   2 +-
 grizzly/reduce/test_main.py |   8 ---
 grizzly/replay/args.py      |  21 +++----
 grizzly/replay/replay.py    |   5 +-
 grizzly/replay/test_main.py |   4 +-
 grizzly/test_args.py        | 122 ++++++++++++++++++------------------
 grizzly/test_main.py        |   4 +-
 10 files changed, 120 insertions(+), 146 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index e3ee72e2..a3eedd64 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -4,7 +4,6 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from argparse import ArgumentParser, HelpFormatter
 from logging import CRITICAL, DEBUG, ERROR, INFO, WARNING
-from os import getcwd
 from os.path import exists, isfile
 from pathlib import Path
 from platform import system
@@ -34,7 +33,7 @@ def add_arguments(self, actions):
 
 class CommonArgs:
     IGNORABLE = ("log-limit", "memory", "timeout")
-    IGNORE = ("log-limit", "timeout")
+    DEFAULT_IGNORE = ("log-limit", "timeout")
 
     def __init__(self):
         # log levels for console logging
@@ -52,14 +51,16 @@ def __init__(self):
                 formatter_class=SortingHelpFormatter, conflict_handler="resolve"
             )
 
+        targets = scan_plugins("grizzly_targets")
+        if not targets:
+            self.parser.error("No Platforms (Targets) are installed")
+
         self.parser.add_argument("binary", help="Firefox binary to run")
         self.parser.add_argument(
             "--log-level",
+            choices=sorted(self._level_map),
             default="INFO",
-            help="Configure console logging. Options: %s (default: %%(default)s)"
-            % ", ".join(
-                k for k, v in sorted(self._level_map.items(), key=lambda x: x[1])
-            ),
+            help="Configure console logging (default: %(default)s)",
         )
 
         # build 'asset' help string
@@ -109,8 +110,8 @@ def __init__(self):
         self.launcher_grp.add_argument(
             "--platform",
             default="ffpuppet",
-            help="Installed Platforms (Targets): %s (default: %%(default)s)"
-            % ", ".join(sorted(scan_plugins("grizzly_targets"))),
+            choices=sorted(targets),
+            help="Target to use (default: %(default)s)",
         )
         self.launcher_grp.add_argument(
             "-p", "--prefs", help="DEPRECATED. prefs.js file to use"
@@ -156,15 +157,19 @@ def __init__(self):
         self.reporter_grp.add_argument(
             "--ignore",
             nargs="*",
-            default=list(self.IGNORE),
-            help="Space separated list of issue types to ignore. Valid options: %s"
-            " (default: %s)" % (" ".join(self.IGNORABLE), " ".join(self.IGNORE)),
+            choices=self.IGNORABLE,
+            default=self.DEFAULT_IGNORE,
+            metavar="IGNORABLE",
+            help="Space-separated list of ignorable types. Pass zero args to disable."
+            " Available: %s (default: %s)"
+            % (" ".join(self.IGNORABLE), " ".join(self.DEFAULT_IGNORE)),
         )
         self.reporter_grp.add_argument(
             "-l",
             "--logs",
-            default=getcwd(),
-            help="Location to save logs and test cases. (default: %(default)r)",
+            default=Path.cwd(),
+            type=Path,
+            help="Location to save logs and test cases. (default: %(default)s)",
         )
         self.reporter_grp.add_argument(
             "--tool",
@@ -200,29 +205,19 @@ def parse_args(self, argv=None):
         return args
 
     def sanity_check(self, args):
-        targets = scan_plugins("grizzly_targets")
-        if not targets:
-            self.parser.error("No Platforms (Targets) are installed")
-
         if "binary" not in self._sanity_skip and not isfile(args.binary):
             self.parser.error("file not found: %r" % (args.binary,))
 
-        # sanitize ignore list
-        args.ignore = {arg.lower() for arg in args.ignore}
-        for ignore in args.ignore:
-            if ignore not in self.IGNORABLE:
-                self.parser.error("Unrecognized ignore value %r" % (ignore,))
-
-        # check log level
-        log_level = self._level_map.get(args.log_level.upper(), None)
-        if log_level is None:
-            self.parser.error("Invalid log-level %r" % (args.log_level,))
-        args.log_level = log_level
+        args.log_level = self._level_map[args.log_level]
 
         if args.log_limit < 0:
             self.parser.error("--log-limit must be >= 0")
         args.log_limit *= 1_048_576
 
+        # if logs is specified, we need it to be a directory (whether existent or not)
+        if args.logs and args.logs.is_file():
+            self.parser.error("--logs cannot be a file")
+
         if args.memory < 0:
             self.parser.error("--memory must be >= 0")
         args.memory *= 1_048_576
@@ -237,9 +232,6 @@ def sanity_check(self, args):
             if value > 1:
                 self.parser.error("rr needs %s <= 1, but it is %d" % (settings, value))
 
-        if args.platform not in targets:
-            self.parser.error("Platform %r not installed" % (args.platform,))
-
         # TODO: remove deprecated 'extension' from args
         if args.extension:  # pragma: no cover
             args.asset.append(["extension", args.extension])
@@ -275,11 +267,14 @@ def sanity_check(self, args):
 class GrizzlyArgs(CommonArgs):
     def __init__(self):
         super().__init__()
+
+        adapters = scan_plugins("grizzly_adapters")
+        if not adapters:
+            self.parser.error("No Adapters are installed")
+
         self._sanity_skip.add("tool")
         self.parser.add_argument(
-            "adapter",
-            help="Installed Adapters: %s"
-            % ", ".join(sorted(scan_plugins("grizzly_adapters"))),
+            "adapter", choices=sorted(adapters), help="Adapter to use."
         )
         self.parser.add_argument(
             "--enable-profiling",
@@ -288,13 +283,16 @@ def __init__(self):
             " status reporter while running Grizzly.",
         )
         self.parser.add_argument(
-            "-i", "--input", help="Test case or directory containing test cases."
+            "-i",
+            "--input",
+            type=Path,
+            help="Test case or directory containing test cases.",
         )
         self.parser.add_argument(
             "--limit",
             type=int,
             default=0,
-            help="Maximum number of iterations to be performed. (default: no limit)",
+            help="Maximum number of iterations to be performed. (default: 'no limit')",
         )
         self.parser.add_argument(
             "--smoke-test",
@@ -350,12 +348,6 @@ def __init__(self):
 
     def sanity_check(self, args):
         super().sanity_check(args)
-        adapters = scan_plugins("grizzly_adapters")
-        if not adapters:
-            self.parser.error("No Adapters are installed")
-
-        if args.adapter not in adapters:
-            self.parser.error("Adapter %r is not installed" % (args.adapter,))
 
         if args.collect < 1:
             self.parser.error("--collect must be greater than 0")
@@ -365,8 +357,8 @@ def sanity_check(self, args):
                 "--fuzzmanager and --s3-fuzzmanager are mutually exclusive"
             )
 
-        if args.input and not exists(args.input):
-            self.parser.error("%r does not exist" % (args.input,))
+        if args.input and not args.input.exists():
+            self.parser.error("'%s' does not exist" % (args.input,))
 
         if args.limit < 0:
             self.parser.error("--limit must be >= 0")
diff --git a/grizzly/main.py b/grizzly/main.py
index df49db11..27f070c8 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -4,7 +4,6 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import DEBUG, getLogger
 from os import getpid
-from pathlib import Path
 
 from sapphire import Sapphire
 
@@ -104,7 +103,7 @@ def main(args):
             )
             reporter = S3FuzzManagerReporter(tool=args.tool)
         else:
-            reporter = FilesystemReporter(Path(args.logs) / "results")
+            reporter = FilesystemReporter(args.logs / "results")
             LOG.info("Results will be stored in %r", str(reporter.report_path))
         reporter.display_logs = args.smoke_test or reporter.display_logs
 
@@ -140,7 +139,7 @@ def main(args):
             session.run(
                 args.ignore,
                 time_limit,
-                input_path=args.input,
+                input_path=str(args.input),
                 iteration_limit=iteration_limit,
                 result_limit=1 if args.smoke_test else 0,
                 runtime_limit=args.runtime,
diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 7b522e66..c92cdd4c 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -24,10 +24,7 @@ def __init__(self):
         super().__init__()
 
         # these arguments have other defaults vs how they are defined in ReplayArgs
-        self.parser.set_defaults(
-            include_test=True,
-            logs=".",
-        )
+        self.parser.set_defaults(include_test=True, logs=Path.cwd())
 
         reduce_args = self.parser.add_argument_group("Reduce Arguments")
         reduce_args.add_argument(
@@ -49,6 +46,7 @@ def __init__(self):
         reduce_args.add_argument(
             "--strategy",
             nargs="+",
+            choices=STRATEGIES,
             default=DEFAULT_STRATEGIES,
             metavar="STRATEGY",
             dest="strategies",
@@ -67,15 +65,6 @@ def sanity_check(self, args):
         """
         super().sanity_check(args)
 
-        # if logs is specified, we need it to be a directory (whether existent or not)
-        if Path(args.logs).is_file():
-            self.parser.error("'--logs' cannot be a file")
-
-        # check that specified strategies exist
-        for strategy in args.strategies:
-            if strategy not in STRATEGIES:
-                self.parser.error("Unrecognized '--strategy': '%s'" % (strategy,))
-
         if args.report_period is not None:
             if args.report_period <= 0:
                 self.parser.error("Invalid --report-period (value is in seconds)")
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 5fc482b0..62010fb8 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -786,7 +786,7 @@ def main(cls, args):
 
             try:
                 testcases, assets, env_vars = ReplayManager.load_testcases(
-                    args.input, subset=args.test_index
+                    str(args.input), subset=args.test_index
                 )
             except TestCaseLoadFailure as exc:
                 LOG.error("Error: %s", str(exc))
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index 2840feed..f107f74d 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -45,14 +45,6 @@ def test_args_02(tmp_path):
     # test invalid strategy
     with raises(SystemExit):
         ReduceArgs().parse_args([str(exe), str(inp), "--strategy", "cosmic_radiation"])
-    # test --logs must be dir
-    logs_file = tmp_path / "logs1"
-    logs_file.touch()
-    with raises(SystemExit):
-        ReduceArgs().parse_args([str(exe), str(inp), "--logs", str(logs_file)])
-    logs_dir = tmp_path / "logs2"
-    logs_dir.mkdir()
-    ReduceArgs().parse_args([str(exe), str(inp), "--logs", str(logs_dir)])
     # test no-analysis
     ReduceArgs().parse_args(
         [str(exe), str(inp), "--no-analysis", "--repeat", "99", "--min-crashes", "99"]
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index 3e119429..46cefd4b 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -3,7 +3,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from argparse import SUPPRESS
-from os.path import exists, isfile
+from pathlib import Path
 
 from ..args import CommonArgs
 
@@ -14,6 +14,7 @@ def __init__(self):
         self.parser.set_defaults(logs=None)
         self.parser.add_argument(
             "input",
+            type=Path,
             help="Accepted input includes: "
             "1) A directory containing testcase data. "
             "2) A directory with one or more subdirectories containing testcase data. "
@@ -56,11 +57,7 @@ def __init__(self):
             help="Don't use the harness for redirection. Implies '--relaunch=1'.",
         )
         # hidden argument to add original crash ID as metadata when reported
-        replay_args.add_argument(
-            "--original-crash-id",
-            type=int,
-            help=SUPPRESS,
-        )
+        replay_args.add_argument("--original-crash-id", type=int, help=SUPPRESS)
         replay_args.add_argument(
             "--repeat",
             type=int,
@@ -68,7 +65,9 @@ def __init__(self):
             help="Run the testcase n times."
             " Helpful for intermittent testcases (default: %(default)sx)",
         )
-        replay_args.add_argument("--sig", help="Signature (JSON) file to match.")
+        replay_args.add_argument(
+            "--sig", type=Path, help="Signature (JSON) file to match."
+        )
         replay_args.add_argument(
             "--test-index",
             type=int,
@@ -93,8 +92,8 @@ def sanity_check(self, args):
         if args.idle_threshold and args.idle_delay <= 0:
             self.parser.error("--idle-delay value must be positive")
 
-        if "input" not in self._sanity_skip and not exists(args.input):
-            self.parser.error("%r does not exist" % (args.input,))
+        if "input" not in self._sanity_skip and not args.input.exists():
+            self.parser.error("'%s' does not exist" % (args.input,))
 
         if args.min_crashes < 1:
             self.parser.error("--min-crashes value must be positive")
@@ -102,8 +101,8 @@ def sanity_check(self, args):
         if args.repeat < 1:
             self.parser.error("--repeat value must be positive")
 
-        if args.sig is not None and not isfile(args.sig):
-            self.parser.error("signature file not found: %r" % (args.sig,))
+        if args.sig and not args.sig.is_file():
+            self.parser.error("signature file not found: '%s'" % (args.sig,))
 
     def update_arg(self, name, new_type, help_msg):
         # madhax alert!
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index d8a92a70..3df29d59 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -185,14 +185,13 @@ def report_to_filesystem(path, results, tests=None):
         known location.
 
         Args:
-            path (str): Location to write data.
+            path (Path): Location to write data.
             results (iterable): ReplayResult to output.
             tests (iterable): Testcases to output.
 
         Returns:
             None
         """
-        path = Path(path)
         others = list(x.report for x in results if not x.expected)
         if others:
             reporter = FilesystemReporter(path / "other_reports", major_bucket=False)
@@ -564,7 +563,7 @@ def main(cls, args):
 
         try:
             testcases, assets, env_vars = cls.load_testcases(
-                args.input, subset=args.test_index
+                str(args.input), subset=args.test_index
             )
         except TestCaseLoadFailure as exc:
             LOG.error("Error: %s", str(exc))
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 0899ca70..93739dc7 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -64,7 +64,7 @@ def test_main_01(mocker, tmp_path):
         idle_threshold=0,
         ignore=["fake", "timeout"],
         input=str(tmp_path / "testcase"),
-        logs=str(log_path),
+        logs=log_path,
         min_crashes=2,
         no_harness=False,
         pernosco=False,
@@ -288,7 +288,7 @@ def test_main_05(mocker, tmp_path):
         valgrind=False,
     )
     log_path = tmp_path / "logs"
-    args.logs = str(log_path)
+    args.logs = log_path
     input_path = tmp_path / "input"
     input_path.mkdir()
     # build a test case
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index 70e23e3d..3ac2c2a3 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -2,7 +2,6 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-# pylint: disable=protected-access
 from platform import system
 
 from pytest import mark, raises
@@ -10,27 +9,31 @@
 from .args import CommonArgs, GrizzlyArgs
 
 
-def test_common_args_01(capsys, mocker, tmp_path):
-    """test CommonArgs.parse_args()"""
-    scan_plugins = mocker.patch("grizzly.args.scan_plugins", autospec=True)
-    scan_plugins.return_value = []
-    # test help
-    with raises(SystemExit):
-        CommonArgs().parse_args(argv=["-h"])
-    assert "For addition help check out the wiki" in capsys.readouterr()[0]
-    # test empty args
-    with raises(SystemExit):
-        CommonArgs().parse_args(argv=[])
-    assert "the following arguments are required: binary" in capsys.readouterr()[-1]
-    # test with missing bin
-    scan_plugins.return_value = ["targ1"]
+def test_common_args_01(mocker, tmp_path):
+    """test CommonArgs.parse_args() - success"""
+    mocker.patch("grizzly.args.scan_plugins", return_value=["targ"])
     fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
+    CommonArgs().parse_args(argv=[str(fake_bin), "--platform", "targ"])
+
+
+@mark.parametrize(
+    "args, msg, idx",
+    [
+        # test help
+        (["-h"], "For addition help check out the wiki", 0),
+        # test without args
+        ([], "the following arguments are required: binary", -1),
+        # test with missing bin
+        (["missing-bin"], "error: file not found: 'missing-bin'", -1),
+    ],
+)
+def test_common_args_02(capsys, mocker, args, msg, idx):
+    """test CommonArgs.parse_args()"""
+    mocker.patch("grizzly.args.scan_plugins", return_value=["x"])
     with raises(SystemExit):
-        CommonArgs().parse_args(argv=["missing-bin"])
-    assert "error: file not found: 'missing-bin'" in capsys.readouterr()[-1]
-    # test success
-    CommonArgs().parse_args(argv=[str(fake_bin), "--platform", "targ1"])
+        CommonArgs().parse_args(argv=args)
+    assert msg in capsys.readouterr()[idx]
 
 
 @mark.parametrize(
@@ -38,18 +41,12 @@ def test_common_args_01(capsys, mocker, tmp_path):
     [
         # test no installed platforms
         ([], "error: No Platforms (Targets) are installed", []),
-        # test invalid ignore value
-        (["--ignore", "bad"], "error: Unrecognized ignore value 'bad'", ["targ1"]),
-        # test invalid log level
-        (["--log-level", "bad"], "error: Invalid log-level 'bad'", ["targ1"]),
         # test invalid log limit
         (["--log-limit", "-1"], "error: --log-limit must be >= 0", ["targ1"]),
         # test invalid memory limit
         (["--memory", "-1"], "error: --memory must be >= 0", ["targ1"]),
         # test invalid relaunch value
         (["--relaunch", "0"], "error: --relaunch must be >= 1", ["targ1"]),
-        # test invalid platform/target
-        (["--platform", "bad"], "error: Platform 'bad' not installed", ["targ1"]),
         # test invalid asset
         (
             ["--platform", "targ1", "--asset", "bad", "a"],
@@ -82,7 +79,7 @@ def test_common_args_01(capsys, mocker, tmp_path):
         ),
     ],
 )
-def test_common_args_02(capsys, mocker, tmp_path, args, msg, targets):
+def test_common_args_03(capsys, mocker, tmp_path, args, msg, targets):
     """test CommonArgs.parse_args()"""
     mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=targets)
     mocker.patch(
@@ -98,49 +95,54 @@ def test_common_args_02(capsys, mocker, tmp_path, args, msg, targets):
     assert msg in capsys.readouterr()[-1]
 
 
-def test_grizzly_args_01(mocker, tmp_path):
-    """test GrizzlyArgs.parse_args() - success"""
+def test_common_args_04(tmp_path):
+    """test CommonArgs.parse_args() '--logs' must be dir"""
     fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
+    # test with file
+    with raises(SystemExit):
+        CommonArgs().parse_args([str(fake_bin), "--logs", str(fake_bin)])
+    # test with dir
+    CommonArgs().parse_args([str(fake_bin), "--logs", str(tmp_path)])
+
+
+def test_grizzly_args_01(mocker, tmp_path):
+    """test GrizzlyArgs.parse_args() - success"""
     mocker.patch(
         "grizzly.args.scan_plugins",
         autospec=True,
-        side_effect=(["targ1"], ["adpt1"], ["targ1"], ["adpt1"]),
-    )
-    assert GrizzlyArgs().parse_args(
-        argv=[str(fake_bin), "adpt1", "--platform", "targ1"]
+        side_effect=(["targ"], ["adpt"]),
     )
+    fake_bin = tmp_path / "fake.bin"
+    fake_bin.touch()
+    assert GrizzlyArgs().parse_args(argv=[str(fake_bin), "adpt", "--platform", "targ"])
 
 
-def test_grizzly_args_02(capsys, mocker):
-    """test GrizzlyArgs.parse_args() - handling binary"""
-    mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=["blah"])
-    # test missing required args
-    with raises(SystemExit):
-        GrizzlyArgs().parse_args(argv=[])
-    err = capsys.readouterr()[-1]
-    assert "the following arguments are required: binary, adapter" in err
-    # test missing binary
+@mark.parametrize(
+    "args, msg, idx",
+    [
+        # test help
+        (["-h"], "For addition help check out the wiki", 0),
+        # test without args
+        ([], "the following arguments are required: binary, adapter", -1),
+        # test missing binary
+        (["missing-bin", "x"], "error: file not found: 'missing-bin'", -1),
+    ],
+)
+def test_grizzly_args_02(capsys, mocker, args, msg, idx):
+    """test GrizzlyArgs.parse_args()"""
+    mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=["x"])
     with raises(SystemExit):
-        GrizzlyArgs().parse_args(argv=["missing_bin", "adapter"])
-    assert "error: file not found: 'missing_bin'" in capsys.readouterr()[-1]
+        GrizzlyArgs().parse_args(argv=args)
+    assert msg in capsys.readouterr()[idx]
 
 
-def test_grizzly_args_03(capsys, mocker, tmp_path):
-    """test GrizzlyArgs.parse_args() - handling Adapter"""
-    scan_plugins = mocker.patch("grizzly.args.scan_plugins", autospec=True)
-    fake_bin = tmp_path / "fake.bin"
-    fake_bin.touch()
-    # no adapters installed
-    scan_plugins.side_effect = (["targ1"], [], ["targ1"], [])
+def test_grizzly_args_03(capsys, mocker):
+    """test GrizzlyArgs.parse_args() - no adapters installed"""
+    mocker.patch("grizzly.args.scan_plugins", side_effect=(["t"], []))
     with raises(SystemExit):
-        GrizzlyArgs().parse_args(argv=[str(fake_bin), "adpt", "--platform", "targ1"])
+        GrizzlyArgs().parse_args(argv=["b", "a"])
     assert "error: No Adapters are installed" in capsys.readouterr()[-1]
-    # invalid adapter name
-    scan_plugins.side_effect = (["targ1"], ["a1", "a2"], ["targ1"], ["a1", "a2"])
-    with raises(SystemExit):
-        GrizzlyArgs().parse_args(argv=[str(fake_bin), "missing", "--platform", "targ1"])
-    assert "error: Adapter 'missing' is not installed" in capsys.readouterr()[-1]
 
 
 @mark.parametrize(
@@ -173,13 +175,13 @@ def test_grizzly_args_04(capsys, mocker, tmp_path, args, msg):
     mocker.patch(
         "grizzly.args.scan_plugins",
         autospec=True,
-        side_effect=["targ1", "adpt", "targ1", "adpt"],
+        side_effect=(["targ"], ["adpt"]),
     )
     fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
     with raises(SystemExit):
         GrizzlyArgs().parse_args(
-            argv=[str(fake_bin), "adpt", "--platform", "targ1"] + args
+            argv=[str(fake_bin), "adpt", "--platform", "targ"] + args
         )
     assert msg in capsys.readouterr()[-1]
 
@@ -200,13 +202,13 @@ def test_grizzly_args_05(capsys, mocker, tmp_path, args, msg):
     mocker.patch(
         "grizzly.args.scan_plugins",
         autospec=True,
-        side_effect=["targ1", "adpt", "targ1", "adpt"],
+        side_effect=(["targ"], ["adpt"]),
     )
     mocker.patch("grizzly.args.Path.read_text", autospec=True, return_value="99")
     fake_bin = tmp_path / "fake.bin"
     fake_bin.touch()
     with raises(SystemExit):
         GrizzlyArgs().parse_args(
-            argv=[str(fake_bin), "adpt", "--platform", "targ1"] + args
+            argv=[str(fake_bin), "adpt", "--platform", "targ"] + args
         )
     assert msg in capsys.readouterr()[-1]
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index dafe55e9..3cdd0e36 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -3,6 +3,8 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """test Grizzly main"""
+from pathlib import Path
+
 from pytest import mark
 
 from sapphire import Sapphire
@@ -28,7 +30,7 @@ def __init__(self):
         self.launch_timeout = 300
         self.limit = 0
         self.limit_reports = 0
-        self.logs = "."
+        self.logs = Path.cwd()
         self.log_level = 10  # 10 = DEBUG, 20 = INFO
         self.log_limit = 0
         self.memory = 0

From 5ead9e9836ba735b291a9faaee57be2b8421a50a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 2 Mar 2022 16:17:22 -0800
Subject: [PATCH 411/531] [ci] Update flake8 ignore list

---
 tox.ini | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tox.ini b/tox.ini
index fcf3187a..199fc16e 100644
--- a/tox.ini
+++ b/tox.ini
@@ -57,9 +57,11 @@ deps =
 skip_install = true
 
 [flake8]
-extend-ignore = E203
-per-file-ignores =
-    */__init__.py: F401
+ignore =
+    E203  # black compat
+    W503  # black compat
+enable =
+    W504  # black compat
 max-line-length = 88
 show-source = true
 statistics = true

From ab92b89d78ec24ba24959cc015a6cf9d7fef7603 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 2 Mar 2022 16:19:15 -0800
Subject: [PATCH 412/531] [ci] Add Python3.10

---
 .taskcluster.yml | 21 +++++++--------------
 tox.ini          |  2 +-
 2 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/.taskcluster.yml b/.taskcluster.yml
index 649a0af2..2964c984 100644
--- a/.taskcluster.yml
+++ b/.taskcluster.yml
@@ -51,20 +51,15 @@ tasks:
           - name: tests python 3.6
             version: "3.6"
             env:
-              TOXENV: py36
+              TOXENV: py36,lint
           - name: tests python 3.7
             version: "3.7"
             env:
-              TOXENV: py37
+              TOXENV: py37,lint
           - name: tests python 3.8
             version: "3.8"
             env:
-              TOXENV: py38
-          - name: test python 3.8 (macos)
-            version: "3.8"
-            platform: macos
-            env:
-              TOXENV: py38
+              TOXENV: py38,lint
           - name: test python 3.8 (windows)
             version: "3.8"
             platform: windows
@@ -73,18 +68,16 @@ tasks:
           - name: tests python 3.9
             version: "3.9"
             env:
-              TOXENV: py39
+              TOXENV: py39,lint
           - name: tests python 3.9 (macos)
             version: "3.9"
             platform: macos
             env:
               TOXENV: py39
-          - name: lint
-            version: "3.9"
+          - name: tests python 3.10
+            version: "3.10"
             env:
-              TOXENV: lint
-            script:
-              - tox
+              TOXENV: py310,lint
           - name: PyPI upload
             version: "3.8"
             env:
diff --git a/tox.ini b/tox.ini
index 199fc16e..bf228ba1 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,5 +1,5 @@
 [tox]
-envlist = py{36,37,38,39},lint
+envlist = py{36,37,38,39,310},lint
 skip_missing_interpreters = true
 tox_pip_extensions_ext_venv_update = true
 

From 820d0d38164731699720101759a0fdd3e0ca1aa6 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 2 Mar 2022 16:48:55 -0800
Subject: [PATCH 413/531] [ci] Update tools used by pre-commit

- Apply black format changes
---
 .pre-commit-config.yaml               | 10 +++++-----
 grizzly/common/test_reporter.py       |  2 +-
 grizzly/reduce/strategies/beautify.py |  4 ++--
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index f9210dfd..2aaa1112 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,22 +1,22 @@
 repos:
   - repo: https://github.com/pycqa/isort
-    rev: 5.9.2
+    rev: 5.10.1
     hooks:
       - id: isort
   - repo: https://github.com/asottile/yesqa
-    rev: v1.2.3
+    rev: v1.3.0
     hooks:
       - id: yesqa
   - repo: https://github.com/ambv/black
-    rev: 21.7b0
+    rev: 22.1.0
     hooks:
       - id: black
   - repo: https://gitlab.com/pycqa/flake8
-    rev: 3.9.2
+    rev: 4.0.1
     hooks:
       - id: flake8
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.0.1
+    rev: v4.1.0
     hooks:
       - id: check-ast
       - id: check-docstring-first
diff --git a/grizzly/common/test_reporter.py b/grizzly/common/test_reporter.py
index 93f71f90..809d5304 100644
--- a/grizzly/common/test_reporter.py
+++ b/grizzly/common/test_reporter.py
@@ -118,7 +118,7 @@ def test_filesystem_reporter_03(tmp_path):
     (log_path / "log_stderr.txt").write_bytes(b"STDERR log")
     (log_path / "log_stdout.txt").write_bytes(b"STDOUT log")
     reporter = FilesystemReporter(tmp_path / "reports")
-    reporter.min_space = 2 ** 50
+    reporter.min_space = 2**50
     with raises(RuntimeError, match="Running low on disk space"):
         reporter.submit([], Report(log_path, "fake_bin"))
 
diff --git a/grizzly/reduce/strategies/beautify.py b/grizzly/reduce/strategies/beautify.py
index 2243146f..87f66b4e 100644
--- a/grizzly/reduce/strategies/beautify.py
+++ b/grizzly/reduce/strategies/beautify.py
@@ -77,10 +77,10 @@ def __init__(self, testcases):
         self._current_feedback = None
         tag_bytes = self.tag_name.encode("ascii")
         self._re_tag_start = re.compile(
-            br"<\s*" + tag_bytes + br".*?>", flags=re.DOTALL | re.IGNORECASE
+            rb"<\s*" + tag_bytes + rb".*?>", flags=re.DOTALL | re.IGNORECASE
         )
         self._re_tag_end = re.compile(
-            br"</\s*" + tag_bytes + br"\s*>", flags=re.IGNORECASE
+            rb"</\s*" + tag_bytes + rb"\s*>", flags=re.IGNORECASE
         )
 
     @classmethod

From cc213f25ea98312076ce759ad3bed05e8b2ca17b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 2 Mar 2022 16:50:22 -0800
Subject: [PATCH 414/531] [tests] Remove unused logger

---
 grizzly/reduce/test_main.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index f107f74d..e5890bf1 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -3,7 +3,6 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """Unit tests for `grizzly.reduce.main`."""
-from logging import getLogger
 from unittest.mock import Mock
 
 from pytest import mark, raises
@@ -15,7 +14,6 @@
 from .args import ReduceArgs, ReduceFuzzManagerIDArgs, ReduceFuzzManagerIDQualityArgs
 from .exceptions import GrizzlyReduceBaseException
 
-LOG = getLogger(__name__)
 pytestmark = mark.usefixtures(
     "tmp_path_fm_config",
     "tmp_path_replay_status_db",

From ee1c68251e72a3d73c9bfa237e924bdfc25edc01 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 2 Mar 2022 16:53:18 -0800
Subject: [PATCH 415/531] [ci] Add .codecov.yml

---
 .codecov.yml | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 .codecov.yml

diff --git a/.codecov.yml b/.codecov.yml
new file mode 100644
index 00000000..9e3d0461
--- /dev/null
+++ b/.codecov.yml
@@ -0,0 +1,3 @@
+codecov:
+  ci:
+    - community-tc.services.mozilla.com

From 902bf9fbbd12e275c20b7d9007381a6591150ee4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 2 Mar 2022 17:18:36 -0800
Subject: [PATCH 416/531] [tests] Fix test_report_counter_02() on Python3.10

---
 grizzly/common/test_status.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 78557bfc..bc416d42 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -554,7 +554,8 @@ def test_report_counter_01(tmp_path, keys, counts, limit, local_only):
 
 def test_report_counter_02(mocker, tmp_path):
     """test ResultCounter multi instance functionality"""
-    mocker.patch("grizzly.common.status.time", autospec=True, return_value=1)
+    fake_time = mocker.patch("grizzly.common.status.time", autospec=True)
+    fake_time.return_value = 1
     db_path = str(tmp_path / "storage.db")
     counter_a = ResultCounter(1, db_file=db_path, freq_limit=0)
     counter_b = ResultCounter(2, db_file=db_path, freq_limit=1)
@@ -593,7 +594,7 @@ def test_report_counter_02(mocker, tmp_path):
     # local (counter_a, bucket x) count is 0, global (all counters) count is 0
     assert not counter_a.is_frequent("x")
     # remove 'expired' reports
-    mocker.patch("grizzly.common.status.time", autospec=True, return_value=1000)
+    fake_time.return_value = 1000
     counter_d = ResultCounter(4, db_file=db_path, freq_limit=2, exp_limit=10)
     # local (counter_d, bucket a) count is 0, global (all counters) count is 0
     assert not counter_d.is_frequent("a")

From 8de7c5a0f200a95293b3c6f0e8cd1630c43515c4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 11 Mar 2022 10:43:07 -0800
Subject: [PATCH 417/531] Handle startup crashes properly when using
 '--any-crash'

---
 grizzly/common/runner.py      | 43 +++++++++++++++++++++++++++--------
 grizzly/common/test_runner.py | 17 ++++++++------
 grizzly/replay/replay.py      | 28 +++++++++++++++--------
 grizzly/replay/test_replay.py | 37 +++++++++++++++++++++++-------
 grizzly/session.py            | 11 ++++-----
 grizzly/test_session.py       |  3 +++
 6 files changed, 97 insertions(+), 42 deletions(-)

diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index 12a8af39..a5c1577d 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -82,6 +82,7 @@ class Runner:
         "_server",
         "_target",
         "_tests_run",
+        "startup_failure",
     )
 
     def __init__(
@@ -100,6 +101,7 @@ def __init__(
         self._server = server  # a sapphire instance to serve the test case
         self._target = target  # target to run test case
         self._tests_run = 0  # number of tests run since target (re)launched
+        self.startup_failure = False  # failure before first test was served
 
     def launch(self, location, max_retries=3, retry_delay=0):
         """Launch a target and open `location`.
@@ -119,6 +121,7 @@ def launch(self, location, max_retries=3, retry_delay=0):
         assert retry_delay >= 0
         self._server.clear_backlog()
         self._tests_run = 0
+        self.startup_failure = False
         LOG.debug("launching target (timeout %ds)", self._target.launch_timeout)
         for retries in reversed(range(max_retries)):
             try:
@@ -130,6 +133,7 @@ def launch(self, location, max_retries=3, retry_delay=0):
                     exc.report.cleanup()
                     sleep(retry_delay)
                     continue
+                self.startup_failure = True
                 raise
             except TargetLaunchTimeout:
                 # A TargetLaunchTimeout likely has nothing to do with Grizzly but is
@@ -139,6 +143,7 @@ def launch(self, location, max_retries=3, retry_delay=0):
                     LOG.warning("Timeout detected during launch (retries %d)", retries)
                     sleep(retry_delay)
                     continue
+                self.startup_failure = True
                 raise
             break
 
@@ -168,6 +173,18 @@ def location(srv_path, srv_port, close_after=None, time_limit=None):
             return "?".join((location, "&".join(args)))
         return location
 
+    @property
+    def initial(self):
+        """Check if more than one test has been run since the previous relaunch.
+
+        Args:
+            None
+
+        Returns:
+            bool: True if at most one test has been run.
+        """
+        return self._tests_run < 2
+
     def run(
         self,
         ignore,
@@ -189,9 +206,10 @@ def run(
         Returns:
             RunResult: Files served, status and timeout flag from the run.
         """
+        self._tests_run += 1
         if self._idle is not None:
             self._idle.schedule_poll(initial=True)
-        if self._tests_run == self._relaunch - 1:
+        if self._tests_run == self._relaunch:
             # overwrite instead of replace 'grz_next_test' for consistency
             server_map.set_redirect("grz_next_test", "grz_empty", required=True)
             server_map.set_dynamic_response("grz_empty", lambda _: b"", required=True)
@@ -205,9 +223,12 @@ def run(
             server_map=server_map,
         )
         duration = time() - serve_start
-        result = RunResult(served, duration, timeout=server_status == Served.TIMEOUT)
-        result.attempted = testcase.landing_page in result.served
-        result.initial = self._tests_run == 0
+        result = RunResult(
+            served,
+            duration,
+            attempted=testcase.landing_page in served,
+            timeout=server_status == Served.TIMEOUT,
+        )
         # TODO: fix calling TestCase.add_batch() for multi-test replay
         # add all include files that were served
         for url, resource in server_map.include.items():
@@ -223,7 +244,6 @@ def run(
                 result.status = Result.IGNORED
             server_map.dynamic.pop("grz_empty", None)
         if result.attempted:
-            self._tests_run += 1
             if coverage and not result.timeout:
                 # dump_coverage() should be called before check_result()
                 # to help catch any coverage related issues.
@@ -257,6 +277,9 @@ def run(
             # previous iteration put target in a bad state?
             LOG.debug("landing page %r not served!", testcase.landing_page)
             self._target.close()
+            # detect startup failures
+            if self.initial:
+                self.startup_failure = True
         # detect results
         if result.status == Result.NONE:
             result.status = self._target.check_result(ignore)
@@ -284,18 +307,18 @@ class RunResult:
     Attributes:
         attempted (bool): Test landing page (entry point) was requested.
         duration (float): Time spent waiting for test contents to be served.
-        initial (bool): Target was (re)launched prior to run attempt.
         served (tuple(str)): Files that were served.
         status (int): Result status of test.
         timeout (bool): A timeout occurred waiting for test to complete.
     """
 
-    __slots__ = ("attempted", "duration", "initial", "served", "status", "timeout")
+    __slots__ = ("attempted", "duration", "served", "status", "timeout")
 
-    def __init__(self, served, duration, status=Result.NONE, timeout=False):
-        self.attempted = False
+    def __init__(
+        self, served, duration, attempted=False, status=Result.NONE, timeout=False
+    ):
+        self.attempted = attempted
         self.duration = duration
-        self.initial = False
         self.served = served
         self.status = status
         self.timeout = timeout
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index ba4d76f9..15ce3e2c 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -22,6 +22,8 @@ def test_runner_01(mocker):
     target = mocker.Mock(spec_set=Target)
     target.check_result.return_value = Result.NONE
     runner = Runner(server, target, relaunch=10)
+    assert runner.initial
+    assert not runner.startup_failure
     assert runner._idle is None
     assert runner._relaunch == 10
     assert runner._tests_run == 0
@@ -31,10 +33,10 @@ def test_runner_01(mocker):
     serv_map = ServerMap()
     server.serve_path.return_value = (Served.ALL, serv_files)
     result = runner.run([], serv_map, testcase)
-    assert result.attempted
+    assert runner.initial
     assert runner._tests_run == 1
+    assert result.attempted
     assert result.duration == 1
-    assert result.initial
     assert result.status == Result.NONE
     assert result.served == serv_files
     assert not result.timeout
@@ -46,9 +48,9 @@ def test_runner_01(mocker):
     serv_map = ServerMap()
     server.serve_path.return_value = (Served.ALL, serv_files)
     result = runner.run([], serv_map, testcase, coverage=True)
-    assert result.attempted
+    assert not runner.initial
     assert runner._tests_run == 2
-    assert not result.initial
+    assert result.attempted
     assert result.status == Result.NONE
     assert result.served == serv_files
     assert not result.timeout
@@ -74,8 +76,8 @@ def test_runner_02(mocker):
     assert runner._relaunch == 1
     smap = ServerMap()
     result = runner.run([], smap, testcase)
+    assert runner.initial
     assert result.attempted
-    assert result.initial
     assert target.close.call_count == 1
     assert target.is_idle.call_count > 0
     assert target.monitor.is_healthy.call_count > 0
@@ -96,7 +98,7 @@ def test_runner_02(mocker):
     assert target.monitor.is_healthy.call_count > 0
     target.reset_mock()
     testcase.reset_mock()
-    # multiple runs/iterations relaunch (is_healty exit)
+    # multiple runs/iterations relaunch (is_healthy exit)
     runner = Runner(server, target, relaunch=3)
     target.monitor.is_healthy.return_value = False
     for _ in range(2):
@@ -141,9 +143,10 @@ def test_runner_03(mocker, srv_result, served):
     testcase = mocker.Mock(spec_set=TestCase, landing_page="x", optional=[])
     runner = Runner(server, target)
     result = runner.run([], ServerMap(), testcase)
+    assert runner.initial
+    assert runner.startup_failure
     assert result.status == Result.NONE
     assert not result.attempted
-    assert result.initial
     assert set(result.served) == set(served)
     assert not result.timeout
     assert target.close.call_count == 1
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 3df29d59..7dad76df 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -291,7 +291,6 @@ def run(
                             close_after=relaunch * test_count,
                             time_limit=time_limit,
                         )
-                    startup_error = False
                     runner.launch(location)
                 # run tests
                 durations = list()
@@ -335,8 +334,7 @@ def run(
                         break
                 if not run_result.attempted:
                     LOG.warning("Test case was not served")
-                    if run_result.initial:
-                        startup_error = True
+                    if runner.initial:
                         if run_result.status == Result.FOUND:
                             # TODO: what is to best action to take in this case?
                             LOG.warning("Delayed startup failure detected")
@@ -364,7 +362,7 @@ def run(
 
                     # set active signature
                     if (
-                        not startup_error
+                        not runner.startup_failure
                         and not self._any_crash
                         and not run_result.timeout
                         and self._signature is None
@@ -374,7 +372,7 @@ def run(
                         self._signature = report.crash_signature
 
                     # bucket result
-                    if not startup_error and (
+                    if not runner.startup_failure and (
                         self._any_crash
                         or self.check_match(self._signature, report, expect_hang)
                     ):
@@ -459,22 +457,32 @@ def run(
                 # TODO: should we warn about large browser logs?
 
             # process results
-            results = list()
             if self._any_crash:
-                assert all(x.expected for x in reports.values())
-                if sum(x.count for x in reports.values()) >= min_results:
+                assert (
+                    all(x.expected for x in reports.values()) or runner.startup_failure
+                )
+                # add all results if min_results was reached
+                if sum(x.count for x in reports.values() if x.expected) >= min_results:
                     results = list(reports.values())
                 else:
+                    # add only unexpected results since min_results was not reached
+                    results = list()
+                    for report in reports.values():
+                        if report.expected:
+                            report.report.cleanup()
+                        else:
+                            results.append(report)
                     LOG.debug(
                         "%d (any_crash) less than minimum %d",
                         self.status.results.total,
                         min_results,
                     )
-                    for report in reports.values():
-                        report.report.cleanup()
+
             else:
+                # there should be at most one expected bucket
                 assert sum(x.expected for x in reports.values()) <= 1
                 # filter out unreliable expected results
+                results = list()
                 for crash_hash, report in reports.items():
                     if report.expected and report.count < min_results:
                         LOG.debug(
diff --git a/grizzly/replay/test_replay.py b/grizzly/replay/test_replay.py
index 304679e1..291b2c3b 100644
--- a/grizzly/replay/test_replay.py
+++ b/grizzly/replay/test_replay.py
@@ -461,6 +461,27 @@ def test_replay_12(mocker):
 
 
 def test_replay_13(mocker):
+    """test ReplayManager.run() - any crash - startup failure"""
+    server = mocker.Mock(spec_set=Sapphire, port=0x1337)
+    server.serve_path.return_value = (Served.NONE, [])
+    target = mocker.Mock(spec_set=Target, binary="fake_bin", launch_timeout=30)
+    target.check_result.return_value = Result.FOUND
+    target.save_logs = _fake_save_logs
+    target.monitor.is_healthy.return_value = False
+    testcases = [
+        mocker.Mock(spec_set=TestCase, env_vars={}, landing_page="a.html", optional=[])
+    ]
+    with ReplayManager([], server, target, any_crash=True, use_harness=False) as replay:
+        results = replay.run(testcases, 10, repeat=1, min_results=1)
+        assert results
+        assert not any(x.expected for x in results)
+        assert target.close.call_count == 2
+        assert replay.status.iteration == 1
+        assert replay.status.results.total == 0
+        assert replay.status.ignored == 1
+
+
+def test_replay_14(mocker):
     """test ReplayManager.run() - no signature - use first crash"""
     report_1 = mocker.Mock(
         spec_set=Report, crash_hash="hash1", major="0123", minor="9999"
@@ -503,7 +524,7 @@ def test_replay_13(mocker):
     assert report_3.cleanup.call_count == 1
 
 
-def test_replay_14(mocker):
+def test_replay_15(mocker):
     """test ReplayManager.run() - unexpected exception"""
     report_0 = mocker.Mock(
         spec_set=Report, crash_hash="hash1", major="0123abcd", minor="01239999"
@@ -533,7 +554,7 @@ def test_replay_14(mocker):
     assert report_0.cleanup.call_count == 1
 
 
-def test_replay_15(mocker):
+def test_replay_16(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
@@ -552,7 +573,7 @@ def test_replay_15(mocker):
     assert target.close.call_count == 2
 
 
-def test_replay_16(mocker):
+def test_replay_17(mocker):
     """test ReplayManager.run() - multiple TestCases - no repro - with repeats"""
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.return_value = (Served.ALL, ["a.html"])
@@ -576,7 +597,7 @@ def test_replay_16(mocker):
     assert target.monitor.is_healthy.call_count == 5
 
 
-def test_replay_17(mocker):
+def test_replay_18(mocker):
     """test ReplayManager.run() - multiple TestCases - successful repro"""
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
     server.serve_path.side_effect = (
@@ -611,7 +632,7 @@ def test_replay_17(mocker):
     assert len(results[0].durations) == len(testcases)
 
 
-def test_replay_18(mocker):
+def test_replay_19(mocker):
     """test ReplayManager.run() - multiple calls"""
     mocker.patch("grizzly.common.runner.sleep", autospec=True)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
@@ -629,7 +650,7 @@ def test_replay_18(mocker):
     assert server.serve_path.call_count == 3
 
 
-def test_replay_19(mocker, tmp_path):
+def test_replay_20(mocker, tmp_path):
     """test ReplayManager.report_to_filesystem()"""
     # no reports
     ReplayManager.report_to_filesystem(tmp_path, [])
@@ -679,7 +700,7 @@ def test_replay_19(mocker, tmp_path):
     assert (path / "reports" / "expected_logs").is_dir()
 
 
-def test_replay_20(mocker, tmp_path):
+def test_replay_21(mocker, tmp_path):
     """test ReplayManager.load_testcases()"""
     fake_load = mocker.patch("grizzly.replay.replay.TestCase.load")
     test0 = mocker.Mock(spec_set=TestCase, env_vars={"env": "var"})
@@ -745,7 +766,7 @@ def test_replay_20(mocker, tmp_path):
         (False, False, True, False, 1, 0),
     ],
 )
-def test_replay_21(mocker, expect_hang, is_hang, use_sig, match_sig, ignored, results):
+def test_replay_22(mocker, expect_hang, is_hang, use_sig, match_sig, ignored, results):
     """test ReplayManager.run() - detect hangs"""
     served = ["index.html"]
     server = mocker.Mock(spec_set=Sapphire, port=0x1337, timeout=10)
diff --git a/grizzly/session.py b/grizzly/session.py
index 434902dd..9e4007b2 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -172,7 +172,6 @@ def run(
             assert self.adapter.remaining > 0
             relaunch = min(relaunch, self.adapter.remaining)
         runner = Runner(self.server, self.target, relaunch=relaunch)
-        startup_error = False
         while True:
             self.status.report()
             self.status.iteration += 1
@@ -237,17 +236,13 @@ def run(
                 LOG.debug("ignoring test case since nothing was served")
                 if current_test.landing_page not in current_test.contents:
                     raise SessionError("Test case is missing landing page")
-                if result.initial:
+                if runner.initial:
                     # since this is the first iteration since the Target launched
                     # something is likely wrong with the Target or Adapter
                     if result.status == Result.FOUND:
                         LOG.warning("Delayed startup failure detected")
                     else:
                         LOG.warning("Timeout too short? System too busy?")
-                    # ignore this if it did not happen early on
-                    # to avoid aborting a fuzzing session unnecessarily
-                    if self.status.iteration < 100:
-                        startup_error = True
             else:
                 if self.adapter.IGNORE_UNSERVED:
                     LOG.debug("removing unserved files from the test case")
@@ -287,7 +282,9 @@ def run(
                 self.status.ignored += 1
                 LOG.info("Ignored - %d", self.status.ignored)
 
-            if startup_error:
+            # ignore startup failure if it did not happen early on
+            # to avoid aborting the fuzzing session unnecessarily
+            if runner.startup_failure and self.status.iteration < 100:
                 raise SessionError("Please check Adapter and Target")
 
             if self.adapter.remaining is not None and self.adapter.remaining < 1:
diff --git a/grizzly/test_session.py b/grizzly/test_session.py
index 0f7167ca..8db7d624 100644
--- a/grizzly/test_session.py
+++ b/grizzly/test_session.py
@@ -367,6 +367,7 @@ def test_session_08(mocker):
     result.attempted = True
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.run.return_value = result
+    runner.return_value.startup_failure = False
     adapter = mocker.Mock(spec_set=Adapter, remaining=None)
     adapter.IGNORE_UNSERVED = False
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
@@ -393,6 +394,7 @@ def test_session_09(mocker):
     report.crash_info.createShortSignature.return_value = "[@ sig]"
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.launch.side_effect = TargetLaunchError("test", report)
+    runner.return_value.startup_failure = True
     adapter = mocker.Mock(spec_set=Adapter, remaining=None)
     server = mocker.Mock(spec_set=Sapphire, port=0x1337)
     target = mocker.Mock(spec_set=Target)
@@ -411,6 +413,7 @@ def test_session_10(mocker):
     result.attempted = True
     runner = mocker.patch("grizzly.session.Runner", autospec=True)
     runner.return_value.run.return_value = result
+    runner.return_value.startup_failure = False
     adapter = mocker.Mock(spec_set=Adapter, remaining=None)
     report = mocker.Mock(spec_set=Report, major="major123", minor="minor456")
     reporter = mocker.Mock(spec_set=Reporter)

From 5669bd71ae4c0da6eae1d5476650bdca19250cdf Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 18 Mar 2022 15:12:12 -0700
Subject: [PATCH 418/531] Avoid closing the browser before finishing test

---
 grizzly/common/harness.html | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/grizzly/common/harness.html b/grizzly/common/harness.html
index 796cb10c..4ea12c67 100644
--- a/grizzly/common/harness.html
+++ b/grizzly/common/harness.html
@@ -47,16 +47,13 @@
               'Warning: Any additional open tabs can block browser from closing.')
     try { window.focus() } catch(e) { }
     let xhr = new XMLHttpRequest()
-    // indicate test is complete by requesting `/grz_next_test`
-    xhr.open('GET', '/grz_next_test', true)
-    // if web server goes away don't hang (sapphire times out)
-    xhr.timeout = 250
-    // close the harness to catch crashes that are triggered when the browser closes
-    xhr.onabort = () => { window.close() }
-    xhr.onerror = () => { window.close() }
-    xhr.onload = () => { setTimeout(window.close, 100) }
-    xhr.ontimeout = () => { window.close() }
-    xhr.send()
+    // indicate the test is complete by requesting `/grz_next_test`
+    // this allows Sapphire to finish with the current test
+    xhr.open('GET', '/grz_next_test', false)
+    xhr.send(null)
+    // close the harness to help catch browser shutdown issues
+    // allow a tiny bit more time for crash logs to begin
+    setTimeout(window.close, 100)
     return
   }
 
@@ -110,7 +107,7 @@
   if (limit_tmr !== undefined) {
     clearTimeout(limit_tmr)
   }
-  if (!sub.closed) {
+  if (sub && !sub.closed) {
     sub.close()
   }
 })

From 3434c1468e4be7e4963ef802f85808a63c0bd536 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 18 Mar 2022 15:15:34 -0700
Subject: [PATCH 419/531] Remove test time limit timer after test tab closes

---
 grizzly/common/harness.html | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/grizzly/common/harness.html b/grizzly/common/harness.html
index 4ea12c67..75a85478 100644
--- a/grizzly/common/harness.html
+++ b/grizzly/common/harness.html
@@ -41,6 +41,12 @@
     return
   }
 
+  // if limit_tmr is set, clear it before opening a new tab
+  if (limit_tmr !== undefined) {
+    clearTimeout(limit_tmr)
+    limit_tmr = undefined
+  }
+
   if ((close_after !== undefined) && (close_after-- < 1)) {
     grzDump('Iteration limit hit.')
     setBanner('Iteration limit hit. Browser should close momentarily...<br>' +
@@ -57,12 +63,6 @@
     return
   }
 
-  // if limit_tmr is set, clear it before opening a new tab
-  if (limit_tmr !== undefined) {
-    clearTimeout(limit_tmr)
-    limit_tmr = undefined
-  }
-
   // open test
   sub = open((sub !== null) ? '/grz_next_test' : '/grz_current_test', 'GrizzlyFuzz')
   if (sub === null) {

From bc4b605015e26b3cd7cc234038c5c9ba5f1ed16d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 25 Mar 2022 10:53:23 -0700
Subject: [PATCH 420/531] [replay] Require --logs with --pernosco or --rr

---
 grizzly/replay/args.py      |  3 +++
 grizzly/replay/test_args.py | 13 +++++++++++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index 46cefd4b..b2bdf022 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -95,6 +95,9 @@ def sanity_check(self, args):
         if "input" not in self._sanity_skip and not args.input.exists():
             self.parser.error("'%s' does not exist" % (args.input,))
 
+        if args.logs is None and (args.pernosco or args.rr):
+            self.parser.error("--logs must be set when using rr")
+
         if args.min_crashes < 1:
             self.parser.error("--min-crashes value must be positive")
 
diff --git a/grizzly/replay/test_args.py b/grizzly/replay/test_args.py
index 897620a6..b3b77bd0 100644
--- a/grizzly/replay/test_args.py
+++ b/grizzly/replay/test_args.py
@@ -5,7 +5,9 @@
 """
 unit tests for grizzly.replay.args
 """
-from pytest import mark, raises
+from platform import system
+
+from pytest import mark, param, raises
 
 from .args import ReplayArgs, ReplayFuzzManagerIDArgs, ReplayFuzzManagerIDQualityArgs
 
@@ -44,12 +46,19 @@ def test_replay_args_01(capsys, mocker, tmp_path):
         (["--min-crashes", "0"], "error: --min-crashes value must be positive"),
         # test invalid repeat value
         (["--repeat", "-1"], "error: --repeat value must be positive"),
+        # test running with rr without --logs set
+        param(
+            ["--rr"],
+            "error: --logs must be set when using rr",
+            marks=[mark.skipif(system() != "Linux", reason="Linux only")],
+        ),
         # test missing signature file
         (["--sig", "missing"], "error: signature file not found"),
     ],
 )
 def test_replay_args_02(capsys, mocker, tmp_path, args, msg):
-    """test CommonArgs.parse_args() - sanity checks"""
+    """test ReplayArgs.parse_args() - sanity checks"""
+    mocker.patch("grizzly.args.Path.read_text", autospec=True, return_value="0")
     target = "target1"
     mocker.patch("grizzly.args.scan_plugins", autospec=True, return_value=[target])
     fake_bin = tmp_path / "fake.bin"

From a73048e946fc4c8b2250b29f5869e3b1b0148db0 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 30 Mar 2022 16:49:15 -0700
Subject: [PATCH 421/531] [ci] Pin click version used by black

---
 .pre-commit-config.yaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 2aaa1112..3f878f24 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -11,6 +11,7 @@ repos:
     rev: 22.1.0
     hooks:
       - id: black
+        additional_dependencies: ['click==8.0.4']
   - repo: https://gitlab.com/pycqa/flake8
     rev: 4.0.1
     hooks:

From 7229c0334bee33e8324897cfa24ce45002c2ced4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 1 Apr 2022 15:38:28 -0700
Subject: [PATCH 422/531] [harness] Remove multiple return statements from
 main()

---
 grizzly/common/harness.html | 95 ++++++++++++++++---------------------
 1 file changed, 41 insertions(+), 54 deletions(-)

diff --git a/grizzly/common/harness.html b/grizzly/common/harness.html
index 75a85478..2e0bd28e 100644
--- a/grizzly/common/harness.html
+++ b/grizzly/common/harness.html
@@ -11,6 +11,15 @@
   console.log(`[grz harness][${new Date().toUTCString()}] ${msg}\n`)
 }
 
+let poll = () => {
+  // poll until sub is closed
+  // sub should be closed by either itself (test) or time limit
+  if (!sub || sub.closed)
+    setTimeout(main)
+  else
+    setTimeout(poll, 50)
+}
+
 let setBanner = (msg) => {
   try {
     document.getElementById('banner').innerHTML = msg
@@ -19,34 +28,17 @@
   }
 }
 
-let setTestTimeout = () => {
-  if (limit_tmr !== undefined) {
-    grzDump('Test case time limit already set')
-    return
-  }
-  limit_tmr = setTimeout(() => {
-    grzDump('Test case time limit exceeded')
-    if (!sub.closed){
-      grzDump('Closing test case')
-      sub.close()
-    }
-  }, time_limit)
-}
-
 let main = () => {
-  // poll sub and wait until closed
-  // sub should be closed by either the test case or setTestTimeout
-  if (sub && !sub.closed) {
-    setTimeout(main, 50)
-    return
-  }
-
-  // if limit_tmr is set, clear it before opening a new tab
+  // if limit_tmr is set, clear it
   if (limit_tmr !== undefined) {
     clearTimeout(limit_tmr)
     limit_tmr = undefined
   }
 
+  if (sub && !sub.closed) {
+    grzDump('Something is wrong, the harness is in a bad state!')
+  }
+
   if ((close_after !== undefined) && (close_after-- < 1)) {
     grzDump('Iteration limit hit.')
     setBanner('Iteration limit hit. Browser should close momentarily...<br>' +
@@ -58,31 +50,36 @@
     xhr.open('GET', '/grz_next_test', false)
     xhr.send(null)
     // close the harness to help catch browser shutdown issues
-    // allow a tiny bit more time for crash logs to begin
-    setTimeout(window.close, 100)
-    return
-  }
-
-  // open test
-  sub = open((sub !== null) ? '/grz_next_test' : '/grz_current_test', 'GrizzlyFuzz')
-  if (sub === null) {
-    setBanner('Error! Could not open window. Blocked by the popup blocker?')
-    grzDump('Could not open test! Blocked by the popup blocker?')
-    return
+    setTimeout(window.close)
   }
-
-  // set the test case time limit
-  if (time_limit > 0) {
-    grzDump(`Using test case time limit of ${time_limit}`)
-    sub.addEventListener('abort', setTestTimeout)
-    sub.addEventListener('error', setTestTimeout)
-    sub.addEventListener('load', setTestTimeout)
+  else {
+    // open test
+    sub = open((sub !== null) ? '/grz_next_test' : '/grz_current_test', 'GrizzlyFuzz')
+    if (sub === null) {
+      setBanner('Error! Could not open window. Blocked by the popup blocker?')
+      grzDump('Could not open test! Blocked by the popup blocker?')
+    }
+    else {
+      // set the test case time limit
+      if (time_limit > 0) {
+        grzDump(`Using test case time limit of ${time_limit}`)
+        limit_tmr = setTimeout(() => {
+          grzDump('Test case time limit exceeded')
+          if (sub && !sub.closed) {
+            grzDump('Closing test case')
+            // WARNING: simplify this setTimeout can break the harness!
+            setTimeout(() => { sub.close() })
+          }
+        }, time_limit)
+      }
+      // wait for test to complete
+      setTimeout(poll, 50)
+    }
   }
-
-  setTimeout(main, 50)
 }
 
 window.addEventListener('load', () => {
+  // parse arguments
   let args = window.location.search.replace('?', '')
   if (args) {
     for (let kv of args.split('&')) {
@@ -96,20 +93,10 @@
       }
     }
   }
-
   // update banner
   setBanner('&#x1f43b; &sdot; Grizzly Harness &sdot; &#x1f98a;')
-  main()
-})
-
-window.addEventListener('beforeunload', () => {
-  grzDump('Cleaning up')
-  if (limit_tmr !== undefined) {
-    clearTimeout(limit_tmr)
-  }
-  if (sub && !sub.closed) {
-    sub.close()
-  }
+  // begin iterations
+  setTimeout(main)
 })
 </script>
 </head>

From 38e6dc39863334f44e260e7cbb142d3c2642e853 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Sun, 10 Apr 2022 18:10:41 -0700
Subject: [PATCH 423/531] [sapphire] Track total number of workers launched

---
 sapphire/connection_manager.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/sapphire/connection_manager.py b/sapphire/connection_manager.py
index a0f9a7cd..545fb81d 100644
--- a/sapphire/connection_manager.py
+++ b/sapphire/connection_manager.py
@@ -95,6 +95,7 @@ def wait(self, timeout, continue_cb=None, poll=0.5):
     def listener(serv_sock, serv_job, max_workers, shutdown_delay=0):
         assert max_workers > 0
         assert shutdown_delay >= 0
+        total_launches = 0
         worker_pool = list()
         pool_size = 0
         LOG.debug("starting listener")
@@ -106,6 +107,7 @@ def listener(serv_sock, serv_job, max_workers, shutdown_delay=0):
                 if worker is not None:
                     worker_pool.append(worker)
                     pool_size += 1
+                    total_launches += 1
                 # manage worker pool
                 if pool_size >= max_workers:
                     LOG.debug(
@@ -132,9 +134,10 @@ def listener(serv_sock, serv_job, max_workers, shutdown_delay=0):
             serv_job.finish()
         finally:
             LOG.debug(
-                "shutting down listener, waiting %0.2fs for %d worker(s)...",
+                "shutting down listener, waiting %0.2fs for %d of %d worker(s)...",
                 shutdown_delay,
                 len(worker_pool),
+                total_launches,
             )
             # use shutdown_delay to avoid cutting off connections
             deadline = time() + shutdown_delay

From 356d141ccfe7608b697bf5ce45f1e73875520cb9 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 11 Apr 2022 09:52:06 -0700
Subject: [PATCH 424/531] [sapphire] Call socket.shutdown() when closing active
 workers

---
 sapphire/worker.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/sapphire/worker.py b/sapphire/worker.py
index 061f1c50..cc81028e 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -7,6 +7,7 @@
 """
 from logging import getLogger
 from re import compile as re_compile
+from socket import SHUT_RDWR
 from socket import error as sock_error
 from socket import timeout as sock_timeout
 from sys import exc_info
@@ -80,6 +81,8 @@ def _4xx_page(code, hdr_msg, close=-1, encoding="ascii"):
     def close(self):
         if not self.done:
             LOG.debug("closing socket while thread is running!")
+            # shutdown socket to avoid hang
+            self._conn.shutdown(SHUT_RDWR)
         self._conn.close()
         self.join(timeout=60)
         if self._thread is not None and self._thread.is_alive():

From d85574e87a3ec26410465cdca038bf09976df2e5 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 25 Apr 2022 16:06:38 -0700
Subject: [PATCH 425/531] Update README

---
 README.md | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 2f2c3691..41216ca2 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@ Grizzly
 [![Matrix](https://img.shields.io/badge/dynamic/json?color=green&label=chat&query=%24.chunk[%3F(%40.canonical_alias%3D%3D%22%23fuzzing%3Amozilla.org%22)].num_joined_members&suffix=%20users&url=https%3A%2F%2Fmozilla.modular.im%2F_matrix%2Fclient%2Fr0%2FpublicRooms&style=flat&logo=matrix)](https://riot.im/app/#/room/#fuzzing:mozilla.org)
 [![PyPI](https://img.shields.io/pypi/v/grizzly-framework)](https://pypi.org/project/grizzly-framework)
 
-Grizzly is a modular general purpose browser fuzzing framework. The goal is to create a platform that can be extended via the creation of plug-ins to support multiple combinations of browsers and fuzzers. An Adapter is used to add support for a fuzzer and a Target to add support for a browser.
+Grizzly is a modular general purpose browser fuzzing framework. The goal is to create a platform that can be extended via the creation of plug-ins to support multiple combinations of browsers and fuzzers. An Adapter is used to add support for a fuzzer and a Target to add support for a browser. Generated test cases are intended to be standalone and not require Grizzly.
 
 Cross platform compatibility is available for Windows, Linux and MacOS.
 However not all features may be available.
@@ -29,5 +29,3 @@ Install the latest version from PyPI. For more details see [getting started](htt
 **Replay** - [Grizzly Replay](https://github.com/MozillaSecurity/grizzly/wiki/Grizzly-Replay) can replay a test case with different builds and debuggers.
 
 ```python3 -m grizzly.replay <browser-binary> <testcase>```
-
-

From 3da0c12ac24c87dda4818edcb04ce30ffff9bc93 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 27 Apr 2022 11:46:01 -0700
Subject: [PATCH 426/531] [reduce] Add argument --no-repro-quality

This will allow reduction attempts on multiple platforms in automation.
---
 grizzly/reduce/args.py         | 19 ++++++++++++-------
 grizzly/reduce/crash.py        |  2 +-
 grizzly/reduce/test_main.py    |  8 ++------
 grizzly/reduce/test_main_fm.py |  8 +++++++-
 4 files changed, 22 insertions(+), 15 deletions(-)

diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index c92cdd4c..3ab80dd2 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -7,6 +7,7 @@
 from logging import getLogger
 from pathlib import Path
 
+from ..common.reporter import Quality
 from ..replay.args import ReplayArgs
 from .strategies import DEFAULT_STRATEGIES, STRATEGIES
 
@@ -92,17 +93,21 @@ def __init__(self):
         super().__init__()
         self.update_arg("input", int, "FuzzManager ID to reduce")
 
+        self.parser.add_argument(
+            "--no-repro-quality",
+            choices=[x.value for x in Quality],
+            default=Quality.NOT_REPRODUCIBLE.value,
+            help="Quality value reported when issue does not reproduce "
+            "(default: %(default)s).",
+        )
+
 
 class ReduceFuzzManagerIDQualityArgs(ReduceFuzzManagerIDArgs):
     def __init__(self):
         """Initialize argument parser."""
         super().__init__()
         self.parser.add_argument(
-            "--quality", type=int, help="Only try crashes with a given quality value"
+            "--quality",
+            choices=[x.value for x in Quality],
+            help="Only try crashes with a given quality value.",
         )
-
-    def sanity_check(self, args):
-        super().sanity_check(args)
-
-        if args.quality is not None and args.quality < 0:
-            self.parser.error("'--quality' value cannot be negative")
diff --git a/grizzly/reduce/crash.py b/grizzly/reduce/crash.py
index deefd1c5..bd894c34 100644
--- a/grizzly/reduce/crash.py
+++ b/grizzly/reduce/crash.py
@@ -44,7 +44,7 @@ def main(args):
                 Exit.ERROR: Quality.REDUCER_ERROR,
                 Exit.ABORT: Quality(crash.testcase_quality),
                 Exit.SUCCESS: Quality.ORIGINAL,
-                Exit.FAILURE: Quality.NOT_REPRODUCIBLE,
+                Exit.FAILURE: Quality(args.no_repro_quality),
             }.get(result, Quality.UNREDUCED)
             # don't ever set things back to REDUCING, default to UNREDUCED in that case.
             # REDUCING is only used in automation, so ABORT should never happen.
diff --git a/grizzly/reduce/test_main.py b/grizzly/reduce/test_main.py
index e5890bf1..31116651 100644
--- a/grizzly/reduce/test_main.py
+++ b/grizzly/reduce/test_main.py
@@ -64,15 +64,11 @@ def test_args_03(tmp_path):
     ReduceFuzzManagerIDArgs().parse_args([str(exe), "123"])
 
 
-def test_args_04(capsys, tmp_path):
+def test_args_04(tmp_path):
     """test ReduceFuzzManagerIDQualityArgs"""
     exe = tmp_path / "binary"
     exe.touch()
-    with raises(SystemExit):
-        ReduceFuzzManagerIDQualityArgs().parse_args(
-            [str(exe), "123", "--quality", "-1"]
-        )
-    assert "error: '--quality' value cannot be negative" in capsys.readouterr()[-1]
+    ReduceFuzzManagerIDQualityArgs().parse_args([str(exe), "123"])
 
 
 @mark.parametrize(
diff --git a/grizzly/reduce/test_main_fm.py b/grizzly/reduce/test_main_fm.py
index 7124d6d4..14d955d8 100644
--- a/grizzly/reduce/test_main_fm.py
+++ b/grizzly/reduce/test_main_fm.py
@@ -26,6 +26,7 @@
         (Exit.ABORT, Quality.REDUCED, Quality.REDUCED),
         (Exit.LAUNCH_FAILURE, Quality.REQUEST_SPECIFIC, Quality.UNREDUCED),
         (Exit.FAILURE, Quality.UNREDUCED, Quality.NOT_REPRODUCIBLE),
+        (Exit.FAILURE, Quality.UNREDUCED, Quality.REQUEST_SPECIFIC),
     ],
 )
 def test_crash_main_quality(mocker, exit_code, pre_quality, post_quality):
@@ -34,7 +35,12 @@ def test_crash_main_quality(mocker, exit_code, pre_quality, post_quality):
     crash = mocker.Mock(testcase_quality=pre_quality, crash_id=1)
     load_fm_data = mocker.patch("grizzly.reduce.crash.load_fm_data")
     load_fm_data.return_value.__enter__ = mocker.Mock(return_value=(crash, None))
-    args = mocker.Mock(input=12345, sig=None, tool=None)
+    args = mocker.Mock(
+        input=12345,
+        no_repro_quality=post_quality.value,
+        sig=None,
+        tool=None,
+    )
     assert crash_main(args) == exit_code
     # verify testcase quality was updated
     assert crash.testcase_quality == post_quality

From 7107077c09fc1eeda290b33cc9ba583252af7ad6 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 27 Apr 2022 14:06:08 -0700
Subject: [PATCH 427/531] [reduce] Quality args should be ints

---
 grizzly/reduce/args.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/grizzly/reduce/args.py b/grizzly/reduce/args.py
index 3ab80dd2..90486fff 100644
--- a/grizzly/reduce/args.py
+++ b/grizzly/reduce/args.py
@@ -97,6 +97,7 @@ def __init__(self):
             "--no-repro-quality",
             choices=[x.value for x in Quality],
             default=Quality.NOT_REPRODUCIBLE.value,
+            type=int,
             help="Quality value reported when issue does not reproduce "
             "(default: %(default)s).",
         )
@@ -109,5 +110,6 @@ def __init__(self):
         self.parser.add_argument(
             "--quality",
             choices=[x.value for x in Quality],
+            type=int,
             help="Only try crashes with a given quality value.",
         )

From 88bc878e7395114eb127c01c6c62e9da9414f0fc Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 29 Apr 2022 11:19:37 -0700
Subject: [PATCH 428/531] Remove lower limit from launch timeout

---
 grizzly/target/target.py      | 3 ++-
 grizzly/target/test_target.py | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/grizzly/target/target.py b/grizzly/target/target.py
index 6553d657..97a80c55 100644
--- a/grizzly/target/target.py
+++ b/grizzly/target/target.py
@@ -60,6 +60,7 @@ class Target(metaclass=ABCMeta):
     )
 
     def __init__(self, binary, launch_timeout, log_limit, memory_limit, assets=None):
+        assert launch_timeout > 0
         assert log_limit >= 0
         assert memory_limit >= 0
         assert binary is not None and isfile(binary)
@@ -69,7 +70,7 @@ def __init__(self, binary, launch_timeout, log_limit, memory_limit, assets=None)
         self._monitor = None
         self.binary = binary
         self.environ = self.scan_environment(dict(environ), self.TRACKED_ENVVARS)
-        self.launch_timeout = max(launch_timeout, 300)
+        self.launch_timeout = launch_timeout
         self.log_limit = log_limit
         self.memory_limit = memory_limit
 
diff --git a/grizzly/target/test_target.py b/grizzly/target/test_target.py
index e0c3f9f9..b4a8cd57 100644
--- a/grizzly/target/test_target.py
+++ b/grizzly/target/test_target.py
@@ -45,7 +45,7 @@ def test_target_01(tmp_path):
     """test creating a simple Target"""
     fake_file = tmp_path / "fake"
     fake_file.touch()
-    with SimpleTarget(str(fake_file), 321, 2, 3) as target:
+    with SimpleTarget(str(fake_file), 10, 2, 3) as target:
         assert target.binary == str(fake_file)
         assert target.assets
         org_path = target.assets.path
@@ -54,7 +54,7 @@ def test_target_01(tmp_path):
         assert not target.environ
         assert not target.filtered_environ()
         assert not target.is_idle(0)
-        assert target.launch_timeout == 321
+        assert target.launch_timeout == 10
         assert target.log_size() == 0
         assert target.log_limit == 2
         assert target.memory_limit == 3

From 12b0c2d1084ded959de641b68e26c2946f3e9ac1 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Wed, 11 May 2022 15:02:12 -0400
Subject: [PATCH 429/531] [reduce] Normalize line-endings to \n before
 beautification.

Also leave "weird" line-endings alone. Characters like \v can randomly
appear in generated strings, and should not result in line breaks that
might break syntax and therefore beautification.
---
 grizzly/reduce/strategies/beautify.py      | 74 ++++++++++++----------
 grizzly/reduce/test_strategies_beautify.py | 46 ++++++++------
 2 files changed, 66 insertions(+), 54 deletions(-)

diff --git a/grizzly/reduce/strategies/beautify.py b/grizzly/reduce/strategies/beautify.py
index 87f66b4e..f84c6276 100644
--- a/grizzly/reduce/strategies/beautify.py
+++ b/grizzly/reduce/strategies/beautify.py
@@ -8,7 +8,6 @@
     HAVE_CSSBEAUTIFIER (bool): True if `cssbeautifier` module is available.
     HAVE_JSBEAUTIFIER (bool): True if `jsbeautifier` module is available.
 """
-import os
 import re
 from abc import ABC, abstractmethod
 from logging import getLogger
@@ -17,6 +16,7 @@
 
 try:
     import cssbeautifier
+    import cssbeautifier.css.options
 
     HAVE_CSSBEAUTIFIER = True
 except ImportError:  # pragma: no cover
@@ -34,6 +34,22 @@
 LOG = getLogger(__name__)
 
 
+def _split_normal_lines(data):
+    """Like str.splitlines but only respect \n, \r\n, and \r .. leave other
+    potential line break characters intact.
+
+    Arguments:
+        data (bytes): Input line to process.
+
+    Returns:
+        generator[bytes]: Yield lines split from data, not including line endings.
+    """
+    for win_line in data.split(b"\r\n"):
+        for mac_line in win_line.split(b"\r"):
+            for unix_line in mac_line.split(b"\n"):
+                yield unix_line
+
+
 class _BeautifyStrategy(Strategy, ABC):
     """A strategy that beautifies code in the testcase to make it more reducible.
 
@@ -119,12 +135,11 @@ def update(self, success, served=None):
 
     @classmethod
     @abstractmethod
-    def beautify_bytes(cls, data, linesep=b"\n"):
+    def beautify_bytes(cls, data):
         """Perform beautification on a code buffer.
 
         Arguments:
             data (bytes): The code data to be beautified.
-            linesep (bytes): Newline sequence used in this testcase.
 
         Returns:
             bytes: The beautified result.
@@ -209,18 +224,12 @@ def __iter__(self):
             )
 
             # Use Lithium just to split the file at DDBEGIN/END.
-            # Lithium already has the right logic for DDBEGIN/END and line endings.
+            # Lithium already has the right logic for DDBEGIN/END.
             lith_tc = TestcaseLine()
             lith_tc.load(file)
-            raw = b"".join(lith_tc.parts)
-
-            # try to determine line-endings from testcase before resorting to os.linesep
-            if b"\r\n" in lith_tc.before or b"\r\n" in lith_tc.after or b"\r\n" in raw:
-                linesep = b"\r\n"
-            elif b"\n" in lith_tc.before or b"\n" in lith_tc.after or b"\n" in raw:
-                linesep = b"\n"
-            else:
-                linesep = os.linesep.encode("utf-8")
+            lith_tc.before = b"\n".join(_split_normal_lines(lith_tc.before))
+            lith_tc.after = b"\n".join(_split_normal_lines(lith_tc.after))
+            raw = b"\n".join(_split_normal_lines(b"".join(lith_tc.parts)))
 
             with file.open("wb") as testcase_fp:
                 last = 0
@@ -231,13 +240,13 @@ def __iter__(self):
                     testcase_fp.write(before)
                     to_beautify = raw[start:end]
                     LOG.debug("before: %r", to_beautify)
-                    beautified = self.beautify_bytes(to_beautify, linesep)
+                    beautified = self.beautify_bytes(to_beautify)
                     LOG.debug("after: %r", beautified)
                     if beautified:
-                        if before and not before.endswith(linesep):
-                            beautified = linesep + beautified
-                        if not beautified.endswith(linesep):
-                            beautified = beautified + linesep
+                        if before and not before.endswith(b"\n"):
+                            beautified = b"\n" + beautified
+                        if not beautified.endswith(b"\n"):
+                            beautified = beautified + b"\n"
 
                         testcase_fp.write(beautified)
                         if beautified == to_beautify:
@@ -303,23 +312,21 @@ class CSSBeautify(_BeautifyStrategy):
     tag_name = "style"
 
     @classmethod
-    def beautify_bytes(cls, data, linesep=b"\n"):
+    def beautify_bytes(cls, data):
         """Perform CSS beautification on a code buffer.
 
         Arguments:
             data (bytes): The code data to be beautified.
-            linesep (bytes): Newline sequence used in this testcase.
 
         Returns:
             bytes: The beautified result.
         """
         assert cls.import_available
-        linesep_u = linesep.decode("utf-8")
         data = data.decode("utf-8", errors="surrogateescape")
-        beautified = cssbeautifier.beautify(data, cls.opts)
-        return linesep_u.join(beautified.splitlines()).encode(
-            "utf-8", errors="surrogateescape"
-        )
+        opts = cssbeautifier.css.options.BeautifierOptions(cls.opts)
+        opts.eol = "\n"
+        beautified = cssbeautifier.beautify(data, opts)
+        return beautified.encode("utf-8", errors="surrogateescape")
 
 
 class JSBeautify(_BeautifyStrategy):
@@ -334,28 +341,29 @@ class JSBeautify(_BeautifyStrategy):
     import_name = "jsbeautifier"
     name = "jsbeautify"
     native_extension = ".js"
-    opts = None
+    opts = (
+        ("end_with_newline", False),
+        ("preserve_newlines", False),
+    )
     tag_name = "script"
     try_catch_re = re.compile(r"(\s*try {)\r?\n\s*(.*)\r?\n\s*(}\s*catch.*)")
 
     @classmethod
-    def beautify_bytes(cls, data, linesep=b"\n"):
+    def beautify_bytes(cls, data):
         """Perform JS beautification on a code buffer.
 
         Arguments:
             data (bytes): The code data to be beautified.
-            linesep (bytes): Newline sequence used in this testcase.
 
         Returns:
             bytes: The beautified result.
         """
         assert HAVE_JSBEAUTIFIER
-        linesep_u = linesep.decode("utf-8")
         data = data.decode("utf-8", errors="surrogateescape")
-        beautified = jsbeautifier.beautify(data, cls.opts)
+        opts = jsbeautifier.BeautifierOptions(cls.opts)
+        opts.eol = "\n"
+        beautified = jsbeautifier.beautify(data, opts)
         # All try/catch pairs will be expanded on their own lines
         # Collapse these pairs when only a single instruction is contained within
         beautified = cls.try_catch_re.sub(r"\1 \2 \3", beautified)
-        return linesep_u.join(beautified.splitlines()).encode(
-            "utf-8", errors="surrogateescape"
-        )
+        return beautified.encode("utf-8", errors="surrogateescape")
diff --git a/grizzly/reduce/test_strategies_beautify.py b/grizzly/reduce/test_strategies_beautify.py
index 5dfbe27c..839a412f 100644
--- a/grizzly/reduce/test_strategies_beautify.py
+++ b/grizzly/reduce/test_strategies_beautify.py
@@ -5,7 +5,6 @@
 # pylint: disable=protected-access
 """Unit tests for `grizzly.reduce.strategies.beautify`."""
 from logging import getLogger
-from os import linesep
 
 import pytest
 
@@ -68,8 +67,8 @@ def _interesting(testcases):
         ),
         pytest.param(
             "try{\r\n'a';'R'}catch(e){}\n",
-            "try {\r\n    'a';\r\n    'R'\r\n} catch (e) {}\r\n",
-            id="#2: test that mixed crlf/lf gets converted to crlf",
+            "try {\n    'a';\n    'R'\n} catch (e) {}\n",
+            id="#2: test that mixed crlf/lf gets converted to lf",
         ),
         pytest.param(
             "try{\r'a';'R'}catch(e){}\n",
@@ -77,9 +76,14 @@ def _interesting(testcases):
             id="#3: test that mixed cr/lf gets converted to lf",
         ),
         pytest.param(
-            "try{'a';'R'}catch(e){}\x1e",
-            linesep.join(("try {", "    'a';", "    'R'", "} catch (e) {}", "")),
-            id="#4: test that other line-ending gets converted to lf",
+            "try{'a\v';'R'}catch(e){}\n",
+            "try {\n    'a\v';\n    'R'\n} catch (e) {}\n",
+            id="#4: test beautify with a string containing a \v",
+        ),
+        pytest.param(
+            "try{'a';'R'}\n\ncatch(e){}\n",
+            "try {\n    'a';\n    'R'\n} catch (e) {}\n",
+            id="#5: test that existing newlines are not preserved",
         ),
     ],
 )
@@ -95,7 +99,7 @@ def test_beautify_js_1(test_data, reduced, mocker):
         pytest.param(
             "try{'a';'R'+'R'}catch(e){}\n",
             "try{'a';'R'+'R'}catch(e){}\n",
-            id="#5: test beautify js where beautification breaks",
+            id="#6: test beautify js where beautification breaks",
         ),
     ],
 )
@@ -111,50 +115,50 @@ def test_beautify_js_2(test_data, reduced, mocker):
         pytest.param(
             "<script>try{'a';'R'}catch(e){}</script>\n",
             "<script>\ntry {\n    'a';\n    'R'\n} catch (e) {}\n</script>\n",
-            id="#6: test beautify js embedded in html",
+            id="#7: test beautify js embedded in html",
         ),
         pytest.param(
             "<script>try{'a';'R'}catch(e){}\n",
             "<script>\ntry {\n    'a';\n    'R'\n} catch (e) {}\n",
-            id="#7: test beautify js embedded in html with no end",
+            id="#8: test beautify js embedded in html with no end",
         ),
         pytest.param(
             "<!--DDBEGIN-->\n<script>\ntry{'a';'R'}catch(e){}\n</script><!--DDEND-->\n",
             "<!--DDBEGIN-->\n<script>\ntry {\n    'a';\n    'R'\n"
             "} catch (e) {}\n</script><!--DDEND-->\n",
-            id="#8: test DDBEGIN/END respected for js embedded in html, "
+            id="#9: test DDBEGIN/END respected for js embedded in html, "
             "DD outside <script>",
         ),
         pytest.param(
             "<script>try{\n//DDBEGIN\n'a';'R'\n//DDEND\n}catch(e){}</script>\n",
             "<script>try{\n//DDBEGIN\n'a';\n'R'\n//DDEND\n}catch(e){}</script>\n",
-            id="#9: test DDBEGIN/END respected for js embedded in html, "
+            id="#10: test DDBEGIN/END respected for js embedded in html, "
             "DD inside <script>",
         ),
         pytest.param(
             "<!--DDBEGIN-->\n<script>\ntry{'a';'R'}catch(e){}\n//DDEND\n",
             "<!--DDBEGIN-->\n<script>\ntry {\n    'a';\n    'R'\n"
             "} catch (e) {}\n//DDEND\n",
-            id="#10: test DDBEGIN/END respected for js embedded in html, "
+            id="#11: test DDBEGIN/END respected for js embedded in html, "
             "DD straddle before <script>",
         ),
         pytest.param(
             "<script>\n//DDBEGIN\ntry{'a';'R'}catch(e){}\n//DDEND\n",
             "<script>\n//DDBEGIN\ntry {\n    'a';\n    'R'\n} catch (e) {}\n//DDEND\n",
-            id="#11: test DDBEGIN/END respected for js embedded in html, "
+            id="#12: test DDBEGIN/END respected for js embedded in html, "
             "DD straddle after <script>",
         ),
         pytest.param(
             "<script>\n//DDBEGIN\ntry{'a';'R'}catch(e){}\n</script>\n<!--DDEND-->\n",
             "<script>\n//DDBEGIN\ntry {\n    'a';\n    'R'\n"
             "} catch (e) {}\n</script>\n<!--DDEND-->\n",
-            id="#12: test DDBEGIN/END respected for js embedded in html, "
+            id="#13: test DDBEGIN/END respected for js embedded in html, "
             "DD straddle after </script>",
         ),
         pytest.param(
             "try{'a';'R'}catch(e){}\n",
             "try{'a';'R'}catch(e){}\n",
-            id="#13: test beautify js embedded in html (no <script>)",
+            id="#14: test beautify js embedded in html (no <script>)",
         ),
     ],
 )
@@ -171,7 +175,7 @@ def test_beautify_js_3(test_data, reduced, mocker):
             "<script>try{'a';'R'}catch(e){}</script><script>'a';'Q'</script>\n",
             "<script>\ntry {\n    'a';\n    'R'\n} catch (e) {}\n</script>"
             "<script>\n'a';\n'Q'\n</script>\n",
-            id="#14: test beautify multiple js embedded in html",
+            id="#15: test beautify multiple js embedded in html",
         ),
     ],
 )
@@ -196,8 +200,8 @@ def test_beautify_js_4(test_data, reduced, mocker):
         ),
         pytest.param(
             "*,\r\n#a{a:0;R:1}\n",
-            "*,\r\n#a {\r\n  a: 0;\r\n  R: 1\r\n}\r\n",
-            id="#1: test that mixed crlf/lf gets converted to crlf",
+            "*,\n#a {\n  a: 0;\n  R: 1\n}\n",
+            id="#1: test that mixed crlf/lf gets converted to lf",
         ),
         pytest.param(
             "*,\r#a{a:0;R:1}\n",
@@ -205,9 +209,9 @@ def test_beautify_js_4(test_data, reduced, mocker):
             id="#2: test that mixed cr/lf gets converted to lf",
         ),
         pytest.param(
-            "*,\x1e#a{a:0;R:1}\x1e",
-            linesep.join(("*,", "#a {", "  a: 0;", "  R: 1", "}", "")),
-            id="#3: test that other line-ending gets converted to lf",
+            "*,#a{a:0;\n\nR:1}\n",
+            "*,\n#a {\n  a: 0;\n  R: 1\n}\n",
+            id="#3: test that existing newlines are not preserved",
         ),
     ],
 )

From 692f00eef52b24363e0f835862d213162b145fcc Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 27 Jul 2022 14:17:51 -0700
Subject: [PATCH 430/531] [ci] Update macOS workers to use macos-latest

---
 .github/workflows/taskcluster-pr.yml      | 2 +-
 .github/workflows/taskcluster-push.yml    | 2 +-
 .github/workflows/taskcluster-release.yml | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/taskcluster-pr.yml b/.github/workflows/taskcluster-pr.yml
index 642e7736..50b32240 100644
--- a/.github/workflows/taskcluster-pr.yml
+++ b/.github/workflows/taskcluster-pr.yml
@@ -2,7 +2,7 @@ name: taskcluster PR worker
 on: [pull_request]
 jobs:
   osx-tc-worker-pr:
-    runs-on: macos-10.15
+    runs-on: macos-latest
     env:
       TASKCLUSTER_ACCESS_TOKEN: ${{ secrets.TASKCLUSTER_ACCESS_TOKEN }}
       TC_WORKER_ID: "gh-grizzly-pr-${{ github.run_id }}-${{ github.run_attempt }}"
diff --git a/.github/workflows/taskcluster-push.yml b/.github/workflows/taskcluster-push.yml
index ea8a9aff..b5600a61 100644
--- a/.github/workflows/taskcluster-push.yml
+++ b/.github/workflows/taskcluster-push.yml
@@ -2,7 +2,7 @@ name: taskcluster push worker
 on: [push]
 jobs:
   osx-tc-worker-push:
-    runs-on: macos-10.15
+    runs-on: macos-latest
     env:
       TASKCLUSTER_ACCESS_TOKEN: ${{ secrets.TASKCLUSTER_ACCESS_TOKEN }}
       TC_WORKER_ID: "gh-grizzly-push-${{ github.run_id }}-${{ github.run_attempt }}"
diff --git a/.github/workflows/taskcluster-release.yml b/.github/workflows/taskcluster-release.yml
index 4c73528e..919fe05b 100644
--- a/.github/workflows/taskcluster-release.yml
+++ b/.github/workflows/taskcluster-release.yml
@@ -2,7 +2,7 @@ name: taskcluster release worker
 on: [release]
 jobs:
   osx-tc-worker-release:
-    runs-on: macos-10.15
+    runs-on: macos-latest
     env:
       TASKCLUSTER_ACCESS_TOKEN: ${{ secrets.TASKCLUSTER_ACCESS_TOKEN }}
       TC_WORKER_ID: "gh-grizzly-release-${{ github.run_id }}-${{ github.run_attempt }}"

From f41f4ac260b0b779d6e32378658fb07061d56da3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 20 Jul 2022 15:31:17 -0700
Subject: [PATCH 431/531] Remove an invalid assertion

---
 grizzly/replay/replay.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 7dad76df..f14b5737 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -336,7 +336,7 @@ def run(
                     LOG.warning("Test case was not served")
                     if runner.initial:
                         if run_result.status == Result.FOUND:
-                            # TODO: what is to best action to take in this case?
+                            # TODO: what is the best action to take in this case?
                             LOG.warning("Delayed startup failure detected")
                         else:
                             LOG.warning("Timeout too short? System too busy?")
@@ -458,9 +458,6 @@ def run(
 
             # process results
             if self._any_crash:
-                assert (
-                    all(x.expected for x in reports.values()) or runner.startup_failure
-                )
                 # add all results if min_results was reached
                 if sum(x.count for x in reports.values() if x.expected) >= min_results:
                     results = list(reports.values())
@@ -477,7 +474,6 @@ def run(
                         self.status.results.total,
                         min_results,
                     )
-
             else:
                 # there should be at most one expected bucket
                 assert sum(x.expected for x in reports.values()) <= 1

From 08924f186ab1e39018350b75be6a3b246e8f27bd Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 28 Jul 2022 10:26:17 -0700
Subject: [PATCH 432/531] [ci] Update Black to 22.6.0

---
 .pre-commit-config.yaml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 3f878f24..30279aa9 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -8,10 +8,9 @@ repos:
     hooks:
       - id: yesqa
   - repo: https://github.com/ambv/black
-    rev: 22.1.0
+    rev: 22.6.0
     hooks:
       - id: black
-        additional_dependencies: ['click==8.0.4']
   - repo: https://gitlab.com/pycqa/flake8
     rev: 4.0.1
     hooks:

From 1dac7c1f0cc273484020ab1f8a51d71004469d38 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 28 Jul 2022 10:48:53 -0700
Subject: [PATCH 433/531] Add support for built in browser headless mode

Add --headless argument
---
 grizzly/args.py                 | 16 +++++++++++++++-
 grizzly/main.py                 |  6 +++---
 grizzly/reduce/core.py          |  6 +++---
 grizzly/replay/replay.py        |  6 +++---
 grizzly/target/puppet_target.py |  2 +-
 grizzly/test_main.py            |  4 ++--
 setup.cfg                       |  2 +-
 7 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index a3eedd64..2824f5e6 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -87,6 +87,17 @@ def __init__(self):
             help="DEPRECATED. Install an extension. Specify the path to the xpi or the"
             " directory containing the unpacked extension.",
         )
+        headless_choices = ["default"]
+        if system().startswith("Linux"):
+            headless_choices.append("xvfb")
+        self.launcher_grp.add_argument(
+            "--headless",
+            choices=headless_choices,
+            const="default",
+            default=None,
+            nargs="?",
+            help="Headless mode. 'default' uses browser's built-in headless mode.",
+        )
         self.launcher_grp.add_argument(
             "--launch-timeout",
             type=int,
@@ -145,7 +156,7 @@ def __init__(self):
         )
         if system().startswith("Linux"):
             self.launcher_grp.add_argument(
-                "--xvfb", action="store_true", help="Use Xvfb."
+                "--xvfb", action="store_true", help="DEPRECATED. Use Xvfb."
             )
         else:
             self.parser.set_defaults(xvfb=False)
@@ -263,6 +274,9 @@ def sanity_check(self, args):
             if args.tool is not None and not args.fuzzmanager:
                 self.parser.error("--tool can only be given with --fuzzmanager")
 
+        if args.xvfb:  # pragma: no cover
+            args.headless = "xvfb"
+
 
 class GrizzlyArgs(CommonArgs):
     def __init__(self):
diff --git a/grizzly/main.py b/grizzly/main.py
index 27f070c8..71a8e168 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -33,10 +33,10 @@ def main(args):
     elif args.s3_fuzzmanager:
         S3FuzzManagerReporter.sanity_check(args.binary)
 
+    if args.headless:
+        LOG.info("Running browser headless (%s)", args.headless)
     if args.ignore:
         LOG.info("Ignoring: %s", ", ".join(args.ignore))
-    if args.xvfb:
-        LOG.info("Running with Xvfb")
     if args.pernosco:
         LOG.info("Running with RR (Pernosco mode)")
     elif args.rr:
@@ -83,10 +83,10 @@ def main(args):
             args.launch_timeout,
             args.log_limit,
             args.memory,
+            headless=args.headless,
             pernosco=args.pernosco,
             rr=args.rr,
             valgrind=args.valgrind,
-            xvfb=args.xvfb,
         )
         # add specified assets
         target.assets.add_batch(args.asset)
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index 62010fb8..cd1229db 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -760,10 +760,10 @@ def main(cls, args):
 
         LOG.info("Starting Grizzly Reduce")
 
+        if args.headless:
+            LOG.info("Running browser headless (%s)", args.headless)
         if args.ignore:
             LOG.info("Ignoring: %s", ", ".join(args.ignore))
-        if args.xvfb:
-            LOG.info("Running with Xvfb")
         if args.pernosco:
             LOG.info("Running with RR (Pernosco mode)")
         elif args.rr:
@@ -826,10 +826,10 @@ def main(cls, args):
                 args.log_limit,
                 args.memory,
                 assets=assets,
+                headless=args.headless,
                 pernosco=args.pernosco,
                 rr=args.rr,
                 valgrind=args.valgrind,
-                xvfb=args.xvfb,
             )
             # local environ takes priority over environ loaded from test case
             if env_vars is not None:
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index f14b5737..287dbaf3 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -549,10 +549,10 @@ def main(cls, args):
 
         LOG.info("Starting Grizzly Replay")
 
+        if args.headless:
+            LOG.info("Running browser headless (%s)", args.headless)
         if args.ignore:
             LOG.info("Ignoring: %s", ", ".join(args.ignore))
-        if args.xvfb:
-            LOG.info("Running with Xvfb")
         if args.pernosco:
             LOG.info("Running with RR (Pernosco mode)")
         elif args.rr:
@@ -608,10 +608,10 @@ def main(cls, args):
                 args.log_limit,
                 args.memory,
                 assets=assets,
+                headless=args.headless,
                 pernosco=args.pernosco,
                 rr=args.rr,
                 valgrind=args.valgrind,
-                xvfb=args.xvfb,
             )
             # local environ takes priority over environ loaded from test case
             if env_vars is not None:
diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 431a691c..d2edfb70 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -84,7 +84,7 @@ def __init__(self, binary, launch_timeout, log_limit, memory_limit, **kwds):
         # create Puppet object
         self._puppet = FFPuppet(
             debugger=debugger,
-            use_xvfb=kwds.pop("xvfb", False),
+            headless=kwds.pop("headless", None),
             working_path=grz_tmp("target"),
         )
         if kwds:
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 3cdd0e36..7c4b3ef5 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -26,6 +26,7 @@ def __init__(self):
         self.enable_profiling = False
         self.extension = None
         self.fuzzmanager = False
+        self.headless = None
         self.ignore = list()
         self.launch_timeout = 300
         self.limit = 0
@@ -47,7 +48,6 @@ def __init__(self):
         self.tool = None
         self.valgrind = False
         self.verbose = False
-        self.xvfb = False
 
 
 @mark.parametrize(
@@ -90,13 +90,13 @@ def test_main_01(mocker, cov, adpt_relaunch, limit, runtime, smoke_test, verbose
         ["fake", "fake"],
     ]
     args.adapter = "fake"
+    args.headless = "xvfb"
     args.ignore = ["fake", "fake"]
     args.limit = limit
     args.runtime = runtime
     args.rr = True
     args.smoke_test = smoke_test
     args.valgrind = True
-    args.xvfb = True
     args.verbose = verbose
     if not verbose:
         args.log_level = 20
diff --git a/setup.cfg b/setup.cfg
index 32aa8c3e..5bca3a14 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -22,7 +22,7 @@ include_package_data = True
 install_requires =
     cssbeautifier
     fasteners
-    ffpuppet >= 0.8.7
+    ffpuppet >= 0.9.1
     FuzzManager
     jsbeautifier
     lithium-reducer >= 0.5.3

From f5f758f1a4fc42b22867d3a2309d335f49524054 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 9 Aug 2022 11:08:57 -0700
Subject: [PATCH 434/531] Avoid sending SIGUSR1 to debugger when running with
 --coverage

---
 grizzly/target/puppet_target.py | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index d2edfb70..d72b513d 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -221,7 +221,16 @@ def dump_coverage(self, timeout=15):
         # If at this point, the browser is in a good state, i.e. no crashes
         # or hangs, so signal the browser to dump coverage.
         try:
-            for child in Process(pid).children(recursive=True):
+            parent_proc = Process(pid)
+            # avoid sending SIGUSR1 to debugger
+            if parent_proc.exe().endswith(Path(self.binary).name):
+                LOG.debug("Sending SIGUSR1 to %d (parent)", pid)
+                try:
+                    kill(pid, SIGUSR1)
+                except OSError:
+                    LOG.warning("Failed to send SIGUSR1 to pid %d", pid)
+            # send SIGUSR1 to child processes
+            for child in parent_proc.children(recursive=True):
                 LOG.debug("Sending SIGUSR1 to %d (child)", child.pid)
                 try:
                     kill(child.pid, SIGUSR1)
@@ -229,25 +238,20 @@ def dump_coverage(self, timeout=15):
                     LOG.warning("Failed to send SIGUSR1 to pid %d", child.pid)
         except (AccessDenied, NoSuchProcess):  # pragma: no cover
             pass
-        LOG.debug("Sending SIGUSR1 to %d (parent)", pid)
-        try:
-            kill(pid, SIGUSR1)
-        except OSError:
-            LOG.warning("Failed to send SIGUSR1 to pid %d", pid)
         start_time = time()
         gcda_found = False
         delay = 0.1
-        # wait for processes to write .gcno files
+        # wait for processes to write .gcda files
         # this should typically take less than 1 second
         while True:
             for proc in process_iter(attrs=["pid", "ppid", "open_files"]):
-                # check if proc is the target or child process
+                # filter out unrelated processes
                 if pid in (proc.info["pid"], proc.info["ppid"]):
                     if proc.info["open_files"] is None:
                         continue
                     if any(x.path.endswith(".gcda") for x in proc.info["open_files"]):
                         gcda_found = True
-                        # get the pid of the process that has the file open
+                        # get the pid of the process with the file open
                         gcda_open = proc.info["pid"]
                         break
             else:
@@ -274,7 +278,7 @@ def dump_coverage(self, timeout=15):
                     # increase delay to a maximum of 1 second
                     delay = min(1.0, delay + 0.1)
             elif elapsed >= 3:
-                # assume we missed the process writing .gcno files
+                # assume we missed the process writing .gcda files
                 LOG.warning("No gcda files seen after %0.2fs", elapsed)
                 break
             if not self._puppet.is_healthy():

From 2992569efd7d4c018bc17e391cd43fe59ec0bfae Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 9 Aug 2022 11:13:03 -0700
Subject: [PATCH 435/531] Use wait_procs() after sending SIGABRT to hung
 process

---
 grizzly/target/puppet_target.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index d72b513d..c7e98700 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -19,7 +19,7 @@
 from ffpuppet import BrowserTimeoutError, Debugger, FFPuppet, LaunchError, Reason
 from ffpuppet.sanitizer_util import SanitizerOptions
 from prefpicker import PrefPicker
-from psutil import AccessDenied, NoSuchProcess, Process, process_iter
+from psutil import AccessDenied, NoSuchProcess, Process, process_iter, wait_procs
 
 from ..common.reporter import Report
 from ..common.utils import grz_tmp
@@ -269,9 +269,9 @@ def dump_coverage(self, timeout=15):
                     )
                     try:
                         kill(gcda_open, SIGABRT)
-                    except OSError:
+                        wait_procs([Process(gcda_open)], timeout=15)
+                    except (AccessDenied, NoSuchProcess, OSError):
                         pass
-                    sleep(1)
                     self.close()
                     break
                 if delay < 1.0:

From b39a72e5946b6514106ea5177b96f10e7a9832a5 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 10 Aug 2022 09:14:04 -0700
Subject: [PATCH 436/531] Only send SIGUSR1 to browser processes when using
 --coverage

Also refactor checking signaled processes for open files
---
 grizzly/target/puppet_target.py      | 56 ++++++++++++++--------------
 grizzly/target/test_puppet_target.py | 38 +++++++------------
 2 files changed, 43 insertions(+), 51 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index c7e98700..a64aec8d 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -2,6 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from itertools import chain
 from logging import getLogger
 from os import kill
 from os.path import isfile
@@ -220,40 +221,41 @@ def dump_coverage(self, timeout=15):
             return
         # If at this point, the browser is in a good state, i.e. no crashes
         # or hangs, so signal the browser to dump coverage.
+        signaled_pids = list()
         try:
+            # send SIGUSR1 to browser processes
             parent_proc = Process(pid)
-            # avoid sending SIGUSR1 to debugger
-            if parent_proc.exe().endswith(Path(self.binary).name):
-                LOG.debug("Sending SIGUSR1 to %d (parent)", pid)
-                try:
-                    kill(pid, SIGUSR1)
-                except OSError:
-                    LOG.warning("Failed to send SIGUSR1 to pid %d", pid)
-            # send SIGUSR1 to child processes
-            for child in parent_proc.children(recursive=True):
-                LOG.debug("Sending SIGUSR1 to %d (child)", child.pid)
-                try:
-                    kill(child.pid, SIGUSR1)
-                except OSError:
-                    LOG.warning("Failed to send SIGUSR1 to pid %d", child.pid)
+            for proc in chain([parent_proc], parent_proc.children(recursive=True)):
+                # avoid sending SIGUSR1 to non-browser processes
+                if proc.exe().endswith(Path(self.binary).name):
+                    LOG.debug(
+                        "Sending SIGUSR1 to %d (%s)",
+                        proc.pid,
+                        "parent" if proc.pid == pid else "child",
+                    )
+                    try:
+                        kill(proc.pid, SIGUSR1)
+                        signaled_pids.append(proc.pid)
+                    except OSError:
+                        LOG.warning("Failed to send SIGUSR1 to pid %d", proc.pid)
         except (AccessDenied, NoSuchProcess):  # pragma: no cover
             pass
         start_time = time()
         gcda_found = False
         delay = 0.1
-        # wait for processes to write .gcda files
-        # this should typically take less than 1 second
+        # wait for processes to write .gcda files (typically takes <1 second)
         while True:
-            for proc in process_iter(attrs=["pid", "ppid", "open_files"]):
-                # filter out unrelated processes
-                if pid in (proc.info["pid"], proc.info["ppid"]):
-                    if proc.info["open_files"] is None:
-                        continue
-                    if any(x.path.endswith(".gcda") for x in proc.info["open_files"]):
-                        gcda_found = True
-                        # get the pid of the process with the file open
-                        gcda_open = proc.info["pid"]
-                        break
+            for proc in process_iter(attrs=["pid", "open_files"]):
+                # scan signaled processes for open .gcda files
+                if (
+                    proc.info["pid"] in signaled_pids
+                    and proc.info["open_files"]
+                    and any(x.path.endswith(".gcda") for x in proc.info["open_files"])
+                ):
+                    gcda_found = True
+                    # collect pid of process with open .gcda file
+                    gcda_open = proc.info["pid"]
+                    break
             else:
                 gcda_open = None
             elapsed = time() - start_time
@@ -270,7 +272,7 @@ def dump_coverage(self, timeout=15):
                     try:
                         kill(gcda_open, SIGABRT)
                         wait_procs([Process(gcda_open)], timeout=15)
-                    except (AccessDenied, NoSuchProcess, OSError):
+                    except (AccessDenied, NoSuchProcess, OSError):  # pragma: no cover
                         pass
                     self.close()
                     break
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 720d54ab..4282e141 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -144,8 +144,10 @@ def test_puppet_target_04(mocker, tmp_path, healthy, usage, os_name, killed):
 @mark.skipif(system() == "Windows", reason="Unsupported on Windows")
 def test_puppet_target_05(mocker, tmp_path):
     """test PuppetTarget.dump_coverage()"""
+    mocker.patch("grizzly.target.puppet_target.wait_procs", autospec=True)
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
     fake_proc = mocker.patch("grizzly.target.puppet_target.Process", autospec=True)
+    fake_proc.return_value.pid = 100
     fake_proc.return_value.children.return_value = (mocker.Mock(pid=101),)
     fake_proc_iter = mocker.patch(
         "grizzly.target.puppet_target.process_iter", autospec=True
@@ -189,15 +191,14 @@ def test_puppet_target_05(mocker, tmp_path):
     fake_ffp.return_value.is_healthy.side_effect = None
     fake_ffp.return_value.get_pid.return_value = 100
     fake_proc_iter.return_value = (
-        mocker.Mock(
-            info={"pid": 100, "ppid": 0, "open_files": (mocker.Mock(path="a.gcda"),)}
-        ),
+        mocker.Mock(info={"pid": 101, "open_files": (mocker.Mock(path="a.gcda"),)}),
     )
     fake_time.side_effect = (0, 1, 20, 20)
     target.dump_coverage(timeout=15)
     assert fake_kill.call_count == 3
     assert fake_proc_iter.call_count == 2
     assert fake_ffp.return_value.is_healthy.call_count == 2
+    assert fake_ffp.return_value.close.call_count == 1
     fake_ffp.reset_mock()
     fake_kill.reset_mock()
     fake_proc_iter.reset_mock()
@@ -206,43 +207,32 @@ def test_puppet_target_05(mocker, tmp_path):
     fake_time.side_effect = None
     fake_time.return_value = 1.0
     fake_proc_iter.side_effect = (
+        # 1st call
         (
             mocker.Mock(
                 info={
                     "pid": 100,
-                    "ppid": 0,
                     "open_files": (
                         mocker.Mock(path="a.bin"),
                         mocker.Mock(path="/a/s/d"),
                     ),
                 }
             ),
-            mocker.Mock(info={"pid": 101, "ppid": 100, "open_files": None}),
-            mocker.Mock(info={"pid": 999, "ppid": 0, "open_files": None}),
+            mocker.Mock(info={"pid": 101, "open_files": None}),
+            mocker.Mock(info={"pid": 999, "open_files": None}),
         ),
+        # 2nd call
+        (mocker.Mock(info={"pid": 100, "open_files": (mocker.Mock(path="a.gcda"),)}),),
+        # 3rd call
         (
+            mocker.Mock(info={"pid": 100, "open_files": (mocker.Mock(path="a.bin"),)}),
             mocker.Mock(
-                info={
-                    "pid": 100,
-                    "ppid": 0,
-                    "open_files": (mocker.Mock(path="a.gcda"),),
-                }
-            ),
-        ),
-        (
-            mocker.Mock(
-                info={"pid": 100, "ppid": 0, "open_files": (mocker.Mock(path="a.bin"),)}
-            ),
-            mocker.Mock(
-                info={
-                    "pid": 999,
-                    "ppid": 0,
-                    "open_files": (mocker.Mock(path="ignore.gcda"),),
-                }
+                info={"pid": 999, "open_files": (mocker.Mock(path="ignore.gcda"),)}
             ),
         ),
     )
     target.dump_coverage()
+    assert fake_ffp.return_value.close.call_count == 0
     assert fake_proc_iter.call_count == 3
     assert fake_kill.call_count == 2
     fake_ffp.reset_mock()
@@ -255,7 +245,7 @@ def test_puppet_target_05(mocker, tmp_path):
     fake_proc_iter.side_effect = None
     fake_time.side_effect = count()
     target.dump_coverage()
-    assert fake_kill.call_count == 3
+    assert fake_kill.call_count == 2
     fake_ffp.reset_mock()
     fake_kill.reset_mock()
     fake_proc_iter.reset_mock()

From fd70361bd36d7e481a4937b16e6d9fbb96e18773 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 10 Aug 2022 10:01:45 -0700
Subject: [PATCH 437/531] Only scan for open gcda files if SIGUSR1 was sent

---
 grizzly/target/puppet_target.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index a64aec8d..9cd9041b 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -240,6 +240,9 @@ def dump_coverage(self, timeout=15):
                         LOG.warning("Failed to send SIGUSR1 to pid %d", proc.pid)
         except (AccessDenied, NoSuchProcess):  # pragma: no cover
             pass
+        if not signaled_pids:
+            LOG.warning("SIGUSR1 not sent, browser processes not detected")
+            return
         start_time = time()
         gcda_found = False
         delay = 0.1

From c1b89e9be3de05d1079866007f73cd3d1e27e809 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 10 Aug 2022 10:02:16 -0700
Subject: [PATCH 438/531] Increase timeouts in dump_coverage()

---
 grizzly/target/puppet_target.py      | 8 +++++---
 grizzly/target/test_puppet_target.py | 2 +-
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 9cd9041b..05984516 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -213,7 +213,7 @@ def handle_hang(self, ignore_idle=True):
         self.close()
         return was_idle
 
-    def dump_coverage(self, timeout=15):
+    def dump_coverage(self, timeout=90):
         assert SIGUSR1 is not None
         pid = self._puppet.get_pid()
         if pid is None or not self._puppet.is_healthy():
@@ -268,7 +268,7 @@ def dump_coverage(self, timeout=15):
                     LOG.debug("gcda dump took %0.2fs", elapsed)
                     break
                 if elapsed >= timeout:
-                    # timeout failure
+                    # timeout waiting for .gnco file to be written
                     LOG.warning(
                         "gcda file open by pid %d after %0.2fs", gcda_open, elapsed
                     )
@@ -281,8 +281,10 @@ def dump_coverage(self, timeout=15):
                     break
                 if delay < 1.0:
                     # increase delay to a maximum of 1 second
+                    # it is increased when waiting for the .gcno files to be written
+                    # this decreases the number of calls to process_iter()
                     delay = min(1.0, delay + 0.1)
-            elif elapsed >= 3:
+            elif elapsed >= 10:
                 # assume we missed the process writing .gcda files
                 LOG.warning("No gcda files seen after %0.2fs", elapsed)
                 break
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 4282e141..381c36a8 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -193,7 +193,7 @@ def test_puppet_target_05(mocker, tmp_path):
     fake_proc_iter.return_value = (
         mocker.Mock(info={"pid": 101, "open_files": (mocker.Mock(path="a.gcda"),)}),
     )
-    fake_time.side_effect = (0, 1, 20, 20)
+    fake_time.side_effect = (0, 1, 20)
     target.dump_coverage(timeout=15)
     assert fake_kill.call_count == 3
     assert fake_proc_iter.call_count == 2

From 7a18dde029e072399c5921227438922541dd8781 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 19 Aug 2022 16:49:45 -0700
Subject: [PATCH 439/531] Fix process executable name check in dump_coverage()

---
 grizzly/target/puppet_target.py      | 10 ++++++++--
 grizzly/target/test_puppet_target.py |  5 ++++-
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/grizzly/target/puppet_target.py b/grizzly/target/puppet_target.py
index 05984516..04c8639e 100644
--- a/grizzly/target/puppet_target.py
+++ b/grizzly/target/puppet_target.py
@@ -225,9 +225,10 @@ def dump_coverage(self, timeout=90):
         try:
             # send SIGUSR1 to browser processes
             parent_proc = Process(pid)
+            running_procs = 0
             for proc in chain([parent_proc], parent_proc.children(recursive=True)):
                 # avoid sending SIGUSR1 to non-browser processes
-                if proc.exe().endswith(Path(self.binary).name):
+                if Path(proc.exe()).name.startswith("firefox"):
                     LOG.debug(
                         "Sending SIGUSR1 to %d (%s)",
                         proc.pid,
@@ -238,10 +239,15 @@ def dump_coverage(self, timeout=90):
                         signaled_pids.append(proc.pid)
                     except OSError:
                         LOG.warning("Failed to send SIGUSR1 to pid %d", proc.pid)
+                if proc.is_running():
+                    running_procs += 1
         except (AccessDenied, NoSuchProcess):  # pragma: no cover
             pass
         if not signaled_pids:
-            LOG.warning("SIGUSR1 not sent, browser processes not detected")
+            LOG.warning(
+                "SIGUSR1 not sent, no browser processes found (%d process(es) running)",
+                running_procs,
+            )
             return
         start_time = time()
         gcda_found = False
diff --git a/grizzly/target/test_puppet_target.py b/grizzly/target/test_puppet_target.py
index 381c36a8..929fa0d6 100644
--- a/grizzly/target/test_puppet_target.py
+++ b/grizzly/target/test_puppet_target.py
@@ -146,9 +146,12 @@ def test_puppet_target_05(mocker, tmp_path):
     """test PuppetTarget.dump_coverage()"""
     mocker.patch("grizzly.target.puppet_target.wait_procs", autospec=True)
     fake_ffp = mocker.patch("grizzly.target.puppet_target.FFPuppet", autospec=True)
+    child_proc = mocker.Mock(pid=101)
+    child_proc.exe.return_value = "firefox-bin"
     fake_proc = mocker.patch("grizzly.target.puppet_target.Process", autospec=True)
     fake_proc.return_value.pid = 100
-    fake_proc.return_value.children.return_value = (mocker.Mock(pid=101),)
+    fake_proc.return_value.children.return_value = (child_proc,)
+    fake_proc.return_value.exe.return_value = "firefox-bin"
     fake_proc_iter = mocker.patch(
         "grizzly.target.puppet_target.process_iter", autospec=True
     )

From 1dd39eb8f25a1afdcbf968e1756dd3e09687d966 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 2 Sep 2022 15:22:14 -0700
Subject: [PATCH 440/531] Add --launch-attempts argument

---
 grizzly/args.py             | 10 ++++++++++
 grizzly/main.py             |  1 +
 grizzly/reduce/core.py      | 10 ++++++++--
 grizzly/replay/replay.py    |  6 +++++-
 grizzly/replay/test_main.py |  5 +++++
 grizzly/session.py          |  6 +++++-
 grizzly/test_args.py        |  6 ++++++
 grizzly/test_main.py        |  1 +
 8 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/grizzly/args.py b/grizzly/args.py
index 2824f5e6..334f98fc 100644
--- a/grizzly/args.py
+++ b/grizzly/args.py
@@ -98,6 +98,13 @@ def __init__(self):
             nargs="?",
             help="Headless mode. 'default' uses browser's built-in headless mode.",
         )
+        self.launcher_grp.add_argument(
+            "--launch-attempts",
+            type=int,
+            default=3,
+            help="Number of attempts to launch the browser before LaunchError is raised"
+            " (default: %(default)s)",
+        )
         self.launcher_grp.add_argument(
             "--launch-timeout",
             type=int,
@@ -219,6 +226,9 @@ def sanity_check(self, args):
         if "binary" not in self._sanity_skip and not isfile(args.binary):
             self.parser.error("file not found: %r" % (args.binary,))
 
+        if args.launch_attempts < 1:
+            self.parser.error("--launch-attempts must be >= 1")
+
         args.log_level = self._level_map[args.log_level]
 
         if args.log_limit < 0:
diff --git a/grizzly/main.py b/grizzly/main.py
index 71a8e168..8a199275 100644
--- a/grizzly/main.py
+++ b/grizzly/main.py
@@ -144,6 +144,7 @@ def main(args):
                 result_limit=1 if args.smoke_test else 0,
                 runtime_limit=args.runtime,
                 display_mode=display_mode,
+                launch_attempts=args.launch_attempts,
             )
 
     except KeyboardInterrupt:
diff --git a/grizzly/reduce/core.py b/grizzly/reduce/core.py
index cd1229db..57a295f9 100644
--- a/grizzly/reduce/core.py
+++ b/grizzly/reduce/core.py
@@ -423,11 +423,12 @@ def testcase_size(self):
         """
         return sum(tc.data_size for tc in self.testcases)
 
-    def run(self, repeat=1, min_results=1):
+    def run(self, repeat=1, launch_attempts=3, min_results=1):
         """Run testcase reduction.
 
         Args:
             repeat (int): Maximum number of times to run the TestCase.
+            launch_attempts (int): Number of attempts to launch the browser.
             min_results (int): Minimum number of results needed before run can
                                be considered successful.
 
@@ -504,6 +505,7 @@ def run(self, repeat=1, min_results=1):
                                     expect_hang=self._expect_hang,
                                     idle_delay=self._idle_delay,
                                     idle_threshold=self._idle_threshold,
+                                    launch_attempts=launch_attempts,
                                     min_results=min_results,
                                     repeat=repeat,
                                     on_iteration_cb=self._on_replay_iteration,
@@ -866,7 +868,11 @@ def main(cls, args):
                     use_analysis=not args.no_analysis,
                     use_harness=not args.no_harness,
                 )
-                return_code = mgr.run(repeat=args.repeat, min_results=args.min_crashes)
+                return_code = mgr.run(
+                    repeat=args.repeat,
+                    launch_attempts=args.launch_attempts,
+                    min_results=args.min_crashes,
+                )
             return return_code
 
         except ConfigError as exc:
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 287dbaf3..49beab95 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -219,6 +219,7 @@ def run(
         expect_hang=False,
         idle_delay=0,
         idle_threshold=0,
+        launch_attempts=3,
         on_iteration_cb=None,
     ):
         """Run testcase replay.
@@ -237,6 +238,7 @@ def run(
                                performed.
             idle_delay (int): Number of seconds to wait before polling for idle.
             idle_threshold (int): CPU usage threshold to mark the process as idle.
+            launch_attempts (int): Number of attempts to launch the browser.
             on_iteration_cb (callable): called every time a single iteration is run
 
         Returns:
@@ -244,6 +246,7 @@ def run(
         """
         assert idle_delay >= 0
         assert idle_threshold >= 0
+        assert launch_attempts > 0
         assert min_results > 0
         assert repeat > 0
         assert repeat >= min_results
@@ -291,7 +294,7 @@ def run(
                             close_after=relaunch * test_count,
                             time_limit=time_limit,
                         )
-                    runner.launch(location)
+                    runner.launch(location, max_retries=launch_attempts)
                 # run tests
                 durations = list()
                 served = list()
@@ -642,6 +645,7 @@ def main(cls, args):
                         expect_hang=expect_hang,
                         idle_delay=args.idle_delay,
                         idle_threshold=args.idle_threshold,
+                        launch_attempts=args.launch_attempts,
                         min_results=args.min_crashes,
                         repeat=repeat,
                     )
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 93739dc7..3518c85f 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -64,6 +64,7 @@ def test_main_01(mocker, tmp_path):
         idle_threshold=0,
         ignore=["fake", "timeout"],
         input=str(tmp_path / "testcase"),
+        launch_attempts=3,
         logs=log_path,
         min_crashes=2,
         no_harness=False,
@@ -118,6 +119,7 @@ def test_main_02(mocker, tmp_path):
         idle_threshold=0,
         ignore=["fake", "timeout"],
         input=str(tmp_path / "test.html"),
+        launch_attempts=3,
         min_crashes=2,
         no_harness=True,
         pernosco=False,
@@ -275,6 +277,7 @@ def test_main_05(mocker, tmp_path):
         idle_delay=0,
         idle_threshold=0,
         ignore=list(),
+        launch_attempts=3,
         min_crashes=1,
         no_harness=True,
         pernosco=False,
@@ -361,6 +364,7 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
         idle_threshold=0,
         ignore=["timeout"],
         input=str(replay_path),
+        launch_attempts=3,
         min_crashes=2,
         no_harness=True,
         pernosco=False,
@@ -417,6 +421,7 @@ def test_main_07(mocker, tmp_path, pernosco, rr, valgrind, no_harness):
         idle_threshold=0,
         ignore=["fake", "timeout"],
         input=str(tmp_path / "test.html"),
+        launch_attempts=3,
         min_crashes=2,
         no_harness=no_harness,
         pernosco=pernosco,
diff --git a/grizzly/session.py b/grizzly/session.py
index 9e4007b2..0d0e2037 100644
--- a/grizzly/session.py
+++ b/grizzly/session.py
@@ -144,8 +144,10 @@ def run(
         result_limit=0,
         runtime_limit=0,
         display_mode=DISPLAY_NORMAL,
+        launch_attempts=3,
     ):
         assert iteration_limit >= 0
+        assert launch_attempts > 0
         assert runtime_limit >= 0
         assert time_limit > 0
 
@@ -194,7 +196,9 @@ def run(
                     )
                 try:
                     with self.status.measure("launch"):
-                        runner.launch(location, max_retries=3, retry_delay=0)
+                        runner.launch(
+                            location, max_retries=launch_attempts, retry_delay=0
+                        )
                 except TargetLaunchError as exc:
                     short_sig = exc.report.crash_info.createShortSignature()
                     LOG.info(
diff --git a/grizzly/test_args.py b/grizzly/test_args.py
index 3ac2c2a3..f74cc8e9 100644
--- a/grizzly/test_args.py
+++ b/grizzly/test_args.py
@@ -77,6 +77,12 @@ def test_common_args_02(capsys, mocker, args, msg, idx):
             "error: --tool can only be given with --fuzzmanager",
             ["targ1"],
         ),
+        # test invalid launch-attempts value
+        (
+            ["--launch-attempts", "0"],
+            "error: --launch-attempts must be >= 1",
+            ["targ1"],
+        ),
     ],
 )
 def test_common_args_03(capsys, mocker, tmp_path, args, msg, targets):
diff --git a/grizzly/test_main.py b/grizzly/test_main.py
index 7c4b3ef5..97d85376 100644
--- a/grizzly/test_main.py
+++ b/grizzly/test_main.py
@@ -28,6 +28,7 @@ def __init__(self):
         self.fuzzmanager = False
         self.headless = None
         self.ignore = list()
+        self.launch_attempts = 3
         self.launch_timeout = 300
         self.limit = 0
         self.limit_reports = 0

From 9e13457f7fd9b18e77b63b1fd09a45233ae9b1f5 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 7 Sep 2022 22:34:21 -0700
Subject: [PATCH 441/531] [replay] Add --post-launch-delay argument

This adds the ability to schedule a delay after the browser
is launched but before a test is loaded to allow time to
attach debuggers, etc.
---
 grizzly/common/post_launch_delay.html | 62 +++++++++++++++++++++++++++
 grizzly/common/runner.py              | 46 +++++++++++++++++++-
 grizzly/common/test_runner.py         | 15 +++++++
 grizzly/replay/args.py                | 11 +++++
 grizzly/replay/replay.py              | 14 +++++-
 grizzly/replay/test_args.py           |  5 +++
 grizzly/replay/test_main.py           |  7 +++
 7 files changed, 156 insertions(+), 4 deletions(-)
 create mode 100644 grizzly/common/post_launch_delay.html

diff --git a/grizzly/common/post_launch_delay.html b/grizzly/common/post_launch_delay.html
new file mode 100644
index 00000000..a1dd6a09
--- /dev/null
+++ b/grizzly/common/post_launch_delay.html
@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html>
+<meta charset=UTF-8>
+<title>Grizzly &sdot; Post Launch Delay</title>
+<head>
+<script>
+const args = window.location.search.replace('?', '')
+const target = args ? `/grz_continue?${args}` : '/grz_continue'
+let countInterval = null
+
+// parse args
+let limit = 300
+if (args) {
+    for (let kv of args.split('&')) {
+        let [k, v] = kv.split('=')
+        if (k === 'post_launch_delay') {
+            limit = Math.max(Number.parseInt(v), 0)
+            break
+        }
+    }
+}
+let remaining = limit
+
+function countDown() {
+    remaining -= 1
+    setTimeout(updateDisplay, 0)
+    if (remaining <= 0)
+        setTimeout(next, 0)
+}
+
+function next() {
+    if (countInterval) {
+        clearInterval(countInterval)
+    }
+    setTimeout(() => {
+        window.location = target
+    }, 0)
+}
+
+function updateDisplay() {
+    remainingSeconds = Math.max(remaining, 0)
+    let o = document.getElementById('msg')
+    o.innerText = `Test will run automatically in: ${remainingSeconds}s`
+}
+
+window.onload = () => {
+    setTimeout(updateDisplay, 0)
+    if (remaining) {
+        countInterval = setInterval(countDown, 1000)
+    }
+    else {
+        setTimeout(countDown, 0)
+    }
+}
+</script>
+</head>
+<body style='background-color:#E5E4E2'>
+<div>Connect debugger, etc...</div>
+<div id='msg'></div>
+<button onclick='next()'>Run Test</button>
+</body>
+</html>
\ No newline at end of file
diff --git a/grizzly/common/runner.py b/grizzly/common/runner.py
index a5c1577d..f5431c33 100644
--- a/grizzly/common/runner.py
+++ b/grizzly/common/runner.py
@@ -3,11 +3,13 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from logging import getLogger
+from pathlib import Path
 from time import sleep, time
 
-from sapphire import Served
+from sapphire import Served, ServerMap
 
 from ..target import Result, TargetLaunchError, TargetLaunchTimeout
+from .storage import TestCase
 
 __all__ = ("Runner", "RunResult")
 __author__ = "Tyson Smith"
@@ -148,13 +150,16 @@ def launch(self, location, max_retries=3, retry_delay=0):
             break
 
     @staticmethod
-    def location(srv_path, srv_port, close_after=None, time_limit=None):
+    def location(
+        srv_path, srv_port, close_after=None, post_launch_delay=None, time_limit=None
+    ):
         """Build a valid URL to pass to a browser.
 
         Args:
             srv_path (str): Path segment of the URL
             srv_port (int): Server listening port
             close_after (int): Harness argument.
+            post_launch_delay (int): Post-launch delay page argument.
             time_limit (int): Harness argument.
 
         Returns:
@@ -169,6 +174,9 @@ def location(srv_path, srv_port, close_after=None, time_limit=None):
         if time_limit:
             assert time_limit > 0
             args.append("time_limit=%d" % (time_limit * 1000,))
+        if post_launch_delay is not None:
+            assert post_launch_delay >= 0
+            args.append("post_launch_delay=%d" % (post_launch_delay,))
         if args:
             return "?".join((location, "&".join(args)))
         return location
@@ -185,6 +193,40 @@ def initial(self):
         """
         return self._tests_run < 2
 
+    def post_launch(self, delay=None):
+        """Perform actions after launching browser before loading test cases.
+
+        Args:
+            post_launch_delay (int): Amount of time in seconds before the target will
+                                     redirect to test case.
+
+        Returns:
+            None
+        """
+        if delay is not None and not self.startup_failure:
+            assert delay >= 0
+            with TestCase("post_launch_delay.html", None, "None") as content:
+                content.add_from_file(
+                    Path(__file__).parent / "post_launch_delay.html",
+                    content.landing_page,
+                    copy=True,
+                )
+                srv_map = ServerMap()
+                srv_map.set_redirect("grz_start", content.landing_page, required=False)
+                srv_map.set_redirect("grz_continue", "grz_start", required=True)
+                # temporarily disable server timeout
+                srv_timeout = self._server.timeout
+                self._server.timeout = 0
+                LOG.info("Browser launched, continuing in %ds...", delay)
+                # serve prompt page
+                self._server.serve_path(
+                    content.data_path,
+                    continue_cb=self._target.monitor.is_healthy,
+                    server_map=srv_map,
+                )
+                # re-enable server timeout
+                self._server.timeout = srv_timeout
+
     def run(
         self,
         ignore,
diff --git a/grizzly/common/test_runner.py b/grizzly/common/test_runner.py
index 15ce3e2c..187ae5ce 100644
--- a/grizzly/common/test_runner.py
+++ b/grizzly/common/test_runner.py
@@ -270,6 +270,8 @@ def test_runner_08():
     assert result == "http://127.0.0.1:9999/a.html?time_limit=60000"
     result = Runner.location("a.html", 9999, close_after=10, time_limit=60)
     assert result == "http://127.0.0.1:9999/a.html?close_after=10&time_limit=60000"
+    result = Runner.location("a.html", 9999, post_launch_delay=10)
+    assert result == "http://127.0.0.1:9999/a.html?post_launch_delay=10"
 
 
 def test_runner_09(mocker):
@@ -329,6 +331,19 @@ def test_runner_10(mocker, tmp_path):
         assert "test/inc_file3.txt" in tcase.contents
 
 
+def test_runner_11(mocker):
+    """test Runner.post_launch()"""
+    server = mocker.Mock(spec_set=Sapphire, timeout=1)
+    target = mocker.Mock(spec_set=Target, launch_timeout=30)
+    runner = Runner(server, target)
+    # successful launch
+    runner.launch("http://a/")
+    runner.post_launch(delay=10)
+    assert target.launch.call_count == 1
+    assert server.timeout == 1
+    assert server.serve_path.call_count == 1
+
+
 def test_idle_check_01(mocker):
     """test simple _IdleChecker"""
     fake_time = mocker.patch("grizzly.common.runner.time", autospec=True)
diff --git a/grizzly/replay/args.py b/grizzly/replay/args.py
index b2bdf022..a2afcd4b 100644
--- a/grizzly/replay/args.py
+++ b/grizzly/replay/args.py
@@ -77,6 +77,14 @@ def __init__(self):
             "0 == Oldest, n-1 == Newest (default: run all testcases)",
         )
 
+        self.launcher_grp.add_argument(
+            "--post-launch-delay",
+            type=int,
+            default=None,
+            help="Number of seconds to wait after launching browser before "
+            " running the test. This provides an opportunity to connect debuggers. ",
+        )
+
         self.reporter_grp.add_argument(
             "--include-test",
             action="store_true",
@@ -101,6 +109,9 @@ def sanity_check(self, args):
         if args.min_crashes < 1:
             self.parser.error("--min-crashes value must be positive")
 
+        if args.post_launch_delay is not None and args.post_launch_delay < 0:
+            self.parser.error("--post-launch-delay value must be positive")
+
         if args.repeat < 1:
             self.parser.error("--repeat value must be positive")
 
diff --git a/grizzly/replay/replay.py b/grizzly/replay/replay.py
index 49beab95..d7570bcb 100644
--- a/grizzly/replay/replay.py
+++ b/grizzly/replay/replay.py
@@ -221,6 +221,7 @@ def run(
         idle_threshold=0,
         launch_attempts=3,
         on_iteration_cb=None,
+        post_launch_delay=None,
     ):
         """Run testcase replay.
 
@@ -239,7 +240,9 @@ def run(
             idle_delay (int): Number of seconds to wait before polling for idle.
             idle_threshold (int): CPU usage threshold to mark the process as idle.
             launch_attempts (int): Number of attempts to launch the browser.
-            on_iteration_cb (callable): called every time a single iteration is run
+            on_iteration_cb (callable): Called every time a single iteration is run.
+            post_launch_delay (int): Time in seconds before test case is loaded after
+                                     the browser is launched.
 
         Returns:
             list: ReplayResults that were found running testcases.
@@ -286,15 +289,21 @@ def run(
                     on_iteration_cb()
                 if self.target.closed:
                     if self._harness is None:
-                        location = runner.location("/grz_start", self.server.port)
+                        location = runner.location(
+                            "/grz_start",
+                            self.server.port,
+                            post_launch_delay=post_launch_delay,
+                        )
                     else:
                         location = runner.location(
                             "/grz_start",
                             self.server.port,
                             close_after=relaunch * test_count,
+                            post_launch_delay=post_launch_delay,
                             time_limit=time_limit,
                         )
                     runner.launch(location, max_retries=launch_attempts)
+                    runner.post_launch(delay=post_launch_delay)
                 # run tests
                 durations = list()
                 served = list()
@@ -647,6 +656,7 @@ def main(cls, args):
                         idle_threshold=args.idle_threshold,
                         launch_attempts=args.launch_attempts,
                         min_results=args.min_crashes,
+                        post_launch_delay=args.post_launch_delay,
                         repeat=repeat,
                     )
             # handle results
diff --git a/grizzly/replay/test_args.py b/grizzly/replay/test_args.py
index b3b77bd0..39201026 100644
--- a/grizzly/replay/test_args.py
+++ b/grizzly/replay/test_args.py
@@ -44,6 +44,11 @@ def test_replay_args_01(capsys, mocker, tmp_path):
         ),
         # test invalid min-crashes value
         (["--min-crashes", "0"], "error: --min-crashes value must be positive"),
+        # test invalid post-launch-delay value
+        (
+            ["--post-launch-delay", "-1"],
+            "error: --post-launch-delay value must be positive",
+        ),
         # test invalid repeat value
         (["--repeat", "-1"], "error: --repeat value must be positive"),
         # test running with rr without --logs set
diff --git a/grizzly/replay/test_main.py b/grizzly/replay/test_main.py
index 3518c85f..1c23382b 100644
--- a/grizzly/replay/test_main.py
+++ b/grizzly/replay/test_main.py
@@ -69,6 +69,7 @@ def test_main_01(mocker, tmp_path):
         min_crashes=2,
         no_harness=False,
         pernosco=False,
+        post_launch_delay=None,
         relaunch=1,
         repeat=4,
         rr=False,
@@ -123,6 +124,7 @@ def test_main_02(mocker, tmp_path):
         min_crashes=2,
         no_harness=True,
         pernosco=False,
+        post_launch_delay=None,
         relaunch=1,
         repeat=1,
         rr=False,
@@ -154,6 +156,7 @@ def test_main_03(mocker):
         min_crashes=1,
         no_harness=True,
         pernosco=False,
+        post_launch_delay=None,
         relaunch=1,
         repeat=1,
         rr=False,
@@ -222,6 +225,7 @@ def test_main_04(mocker, tmp_path):
         input="test",
         min_crashes=1,
         no_harness=True,
+        post_launch_delay=None,
         pernosco=False,
         relaunch=1,
         repeat=1,
@@ -281,6 +285,7 @@ def test_main_05(mocker, tmp_path):
         min_crashes=1,
         no_harness=True,
         pernosco=False,
+        post_launch_delay=None,
         relaunch=1,
         repeat=1,
         rr=False,
@@ -368,6 +373,7 @@ def test_main_06(mocker, tmp_path, arg_timelimit, arg_timeout, test_timelimit, r
         min_crashes=2,
         no_harness=True,
         pernosco=False,
+        post_launch_delay=None,
         relaunch=1,
         repeat=1,
         rr=False,
@@ -425,6 +431,7 @@ def test_main_07(mocker, tmp_path, pernosco, rr, valgrind, no_harness):
         min_crashes=2,
         no_harness=no_harness,
         pernosco=pernosco,
+        post_launch_delay=None,
         relaunch=1,
         repeat=1,
         rr=rr,

From fca2ce430442c5752959466176a8d5192393528c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 12 Sep 2022 12:56:50 -0700
Subject: [PATCH 442/531] [sapphire] Wait for window.onload on 404 page

---
 sapphire/test_worker.py | 2 +-
 sapphire/worker.py      | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/sapphire/test_worker.py b/sapphire/test_worker.py
index b3fcc711..bdff5a86 100644
--- a/sapphire/test_worker.py
+++ b/sapphire/test_worker.py
@@ -122,4 +122,4 @@ def test_response_data_04():
     output = Worker._4xx_page(404, "Not Found", close=10)
     assert b"Content-Length: " in output
     assert b"HTTP/1.1 404 Not Found" in output
-    assert b"<script>window.setTimeout(window.close, 10000)</script>" in output
+    assert b"window.onload = () => { window.setTimeout(window.close, 10000) }" in output
diff --git a/sapphire/worker.py b/sapphire/worker.py
index cc81028e..65220ed5 100644
--- a/sapphire/worker.py
+++ b/sapphire/worker.py
@@ -65,7 +65,9 @@ def _4xx_page(code, hdr_msg, close=-1, encoding="ascii"):
             content = "<h3>%d!</h3>" % (code,)
         else:
             content = (
-                "<script>window.setTimeout(window.close, %d)</script>\n"
+                "<script>\n"
+                "window.onload = () => { window.setTimeout(window.close, %d) }\n"
+                "</script>\n"
                 '<body style="background-color:#ffffe0">\n'
                 "<h3>%d! - Calling window.close() in %d seconds</h3>\n"
                 "</body>\n" % (close * 1000, code, close)

From 494bbc256649dc951f2607d6a4f61dec94da0621 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 12 Sep 2022 12:58:39 -0700
Subject: [PATCH 443/531] [harness] Use requestIdleCallback to close harness if
 available

---
 grizzly/common/harness.html | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/grizzly/common/harness.html b/grizzly/common/harness.html
index 2e0bd28e..d7796c9a 100644
--- a/grizzly/common/harness.html
+++ b/grizzly/common/harness.html
@@ -50,7 +50,11 @@
     xhr.open('GET', '/grz_next_test', false)
     xhr.send(null)
     // close the harness to help catch browser shutdown issues
-    setTimeout(window.close)
+    if ('requestIdleCallback' in window) {
+      window.requestIdleCallback(window.close, {timeout: 500})
+    } else {
+      setTimeout(window.close)
+    }
   }
   else {
     // open test
@@ -67,8 +71,10 @@
           grzDump('Test case time limit exceeded')
           if (sub && !sub.closed) {
             grzDump('Closing test case')
-            // WARNING: simplify this setTimeout can break the harness!
-            setTimeout(() => { sub.close() })
+            // WARNING: simplifying this setTimeout can break the harness!
+            setTimeout(() => {
+              try { sub.close() } catch (e) { }
+            })
           }
         }, time_limit)
       }

From e2786bf2e72b6fe8ad5daccee42f3a39e028f119 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 12 Sep 2022 19:12:17 -0700
Subject: [PATCH 444/531] Fix missing results in status reports

---
 grizzly/common/status.py      | 85 +++++++++++++++++++++++------------
 grizzly/common/test_status.py | 41 +++++++++++++++--
 2 files changed, 93 insertions(+), 33 deletions(-)

diff --git a/grizzly/common/status.py b/grizzly/common/status.py
index 515056fd..b380835b 100644
--- a/grizzly/common/status.py
+++ b/grizzly/common/status.py
@@ -23,8 +23,10 @@
 DB_TIMEOUT = 30
 # used to track changes to the database layout
 DB_VERSION = 2
-# default expiration limit for entries in the database
-EXP_LIMIT = 86400
+# default expiration limit for report entries in the database (24 hours)
+REPORT_EXP_LIMIT = 86400
+# default expiration limit for result entries in the database (30 days)
+RESULT_EXP_LIMIT = 2592000
 LOG = getLogger(__name__)
 
 ProfileEntry = namedtuple("ProfileEntry", "count max min name total")
@@ -109,7 +111,7 @@ def __init__(
         db_file=None,
         enable_profiling=False,
         start_time=None,
-        exp_limit=EXP_LIMIT,
+        exp_limit=REPORT_EXP_LIMIT,
         pid=None,
         report_limit=0,
     ):
@@ -164,7 +166,6 @@ def __init__(
             self.results = ResultCounter(
                 pid,
                 db_file=db_file,
-                exp_limit=EXP_LIMIT,
                 freq_limit=report_limit,
             )
 
@@ -203,26 +204,38 @@ def loadall(cls, db_file=STATUS_DB, time_limit=300):
             cur = con.cursor()
             # collect entries
             try:
-                cur.execute(
-                    """SELECT pid,
-                             _profiles,
-                             ignored,
-                             iteration,
-                             log_size,
-                             start_time,
-                             timestamp
-                       FROM status
-                       WHERE timestamp > ?;""",
-                    (time() - time_limit,),
-                )
+                if time_limit:
+                    cur.execute(
+                        """SELECT pid,
+                                _profiles,
+                                ignored,
+                                iteration,
+                                log_size,
+                                start_time,
+                                timestamp
+                           FROM status
+                           WHERE timestamp > ?;""",
+                        (time() - time_limit,),
+                    )
+                else:
+                    cur.execute(
+                        """SELECT pid,
+                                  _profiles,
+                                  ignored,
+                                  iteration,
+                                  log_size,
+                                  start_time,
+                                  timestamp
+                           FROM status;"""
+                    )
                 entries = cur.fetchall()
             except OperationalError as exc:
                 if not str(exc).startswith("no such table:"):
                     raise  # pragma: no cover
                 entries = ()
 
-        results = ResultCounter.load(db_file, time_limit)
-
+        # Load all results
+        results = ResultCounter.load(db_file, 0)
         for entry in entries:
             status = cls(pid=entry[0])
             status._profiles = loads(entry[1])
@@ -433,7 +446,7 @@ class ResultCounter:
         "pid",
     )
 
-    def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=0):
+    def __init__(self, pid, db_file=None, exp_limit=RESULT_EXP_LIMIT, freq_limit=0):
         assert exp_limit >= 0
         assert freq_limit >= 0
         assert pid >= 0
@@ -469,6 +482,15 @@ def __init__(self, pid, db_file=None, exp_limit=EXP_LIMIT, freq_limit=0):
                         )
                     # avoid (unlikely) pid reuse collision
                     cur.execute("""DELETE FROM results WHERE pid = ?;""", (pid,))
+                    # remove results for jobs that have been removed
+                    try:
+                        cur.execute(
+                            """DELETE FROM results
+                               WHERE pid NOT IN (SELECT pid FROM status);"""
+                        )
+                    except OperationalError as exc:
+                        if not str(exc).startswith("no such table:"):
+                            raise  # pragma: no cover
 
     def all(self):
         """Yield all result data.
@@ -546,15 +568,20 @@ def load(cls, db_file, time_limit):
             cur = con.cursor()
             try:
                 # collect entries
-                cur.execute(
-                    """SELECT pid,
-                              result_id,
-                              description,
-                              count
-                       FROM results
-                       WHERE timestamp > ?;""",
-                    (int(time()) - time_limit,),
-                )
+                if time_limit:
+                    cur.execute(
+                        """SELECT pid,
+                                result_id,
+                                description,
+                                count
+                           FROM results
+                           WHERE timestamp > ?;""",
+                        (int(time()) - time_limit,),
+                    )
+                else:
+                    cur.execute(
+                        """SELECT pid, result_id, description, count FROM results"""
+                    )
                 entries = cur.fetchall()
             except OperationalError as exc:
                 if not str(exc).startswith("no such table:"):
@@ -667,7 +694,7 @@ def __init__(
         db_file=None,
         pid=None,
         tool=None,
-        exp_limit=EXP_LIMIT,
+        exp_limit=REPORT_EXP_LIMIT,
     ):
         """Initialize a ReductionStatus instance.
 
diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index bc416d42..1f3f7f39 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -82,7 +82,7 @@ def test_status_03(tmp_path):
 
 
 def test_status_04(mocker, tmp_path):
-    """test Status.loadall()"""
+    """test Status.loadall() - multiple entries"""
     getpid = mocker.patch("grizzly.common.status.getpid", autospec=True)
     db_file = str(tmp_path / "status.db")
     for pid in range(5):
@@ -92,6 +92,39 @@ def test_status_04(mocker, tmp_path):
 
 
 def test_status_05(mocker, tmp_path):
+    """test Status.loadall() - filter entries by time"""
+    fake_time = mocker.patch("grizzly.common.status.time", autospec=True)
+    fake_time.return_value = 1.0
+    db_file = str(tmp_path / "status.db")
+    # load from empty db
+    assert not any(Status.loadall(db_file))
+    # create entry
+    status = Status.start(db_file)
+    status.results.count("uid1", "sig1")
+    assert status.results.total == 1
+    status.report(force=True)
+    # load entry
+    assert any(Status.loadall(db_file, time_limit=60))
+    # load with expired entry
+    fake_time.return_value = 1200.0
+    assert not any(Status.loadall(db_file, time_limit=60))
+    # load with no limit
+    assert any(Status.loadall(db_file, time_limit=0))
+    # load long running entry with a one month old result
+    fake_time.return_value = 2592000.0
+    status.report(force=True)
+    loaded = next(Status.loadall(db_file, time_limit=60))
+    assert status.start_time == loaded.start_time
+    assert status.timestamp == loaded.timestamp
+    assert status.runtime >= loaded.runtime
+    assert status.ignored == loaded.ignored
+    assert status.iteration == loaded.iteration
+    assert status.log_size == loaded.log_size
+    assert status.pid == loaded.pid
+    assert loaded.results.get("uid1") == ("uid1", 1, "sig1")
+
+
+def test_status_06(mocker, tmp_path):
     """test Status.runtime and Status.rate calculations"""
     fake_time = mocker.patch("grizzly.common.status.time", autospec=True)
     fake_time.return_value = 1.0
@@ -140,7 +173,7 @@ def _client_writer(db_file, begin, count):
         5,
     ],
 )
-def test_status_06(tmp_path, loads_in_parallel):
+def test_status_07(tmp_path, loads_in_parallel):
     """test Status.loadall() with multiple active clients in parallel"""
     begin = Event()
     clients = 10
@@ -177,7 +210,7 @@ def test_status_06(tmp_path, loads_in_parallel):
             proc.join()
 
 
-def test_status_07(tmp_path):
+def test_status_08(tmp_path):
     """test Status.measure() and Status.record() - profiling support"""
     db_file = str(tmp_path / "status.db")
     # profiling disabled
@@ -266,7 +299,7 @@ def test_status_07(tmp_path):
         ([("uid1", "sig1", 99), ("uid2", "sig2", 10)], 1000, 100, 2),
     ],
 )
-def test_status_08(tmp_path, buckets, ratio, iterations, blockers):
+def test_status_09(tmp_path, buckets, ratio, iterations, blockers):
     """test Status.blockers()"""
     status = Status.start(str(tmp_path / "status.db"))
     status.iteration = iterations

From 14c4d6daa979654855fc87553cc91f4d1470ef0d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 13 Sep 2022 09:47:43 -0700
Subject: [PATCH 445/531] [tests] Purge expired Status entries

---
 grizzly/common/test_status.py | 27 ++++++++++++++++++++++++---
 1 file changed, 24 insertions(+), 3 deletions(-)

diff --git a/grizzly/common/test_status.py b/grizzly/common/test_status.py
index 1f3f7f39..19e0218c 100644
--- a/grizzly/common/test_status.py
+++ b/grizzly/common/test_status.py
@@ -62,6 +62,8 @@ def test_status_02(tmp_path):
 def test_status_03(tmp_path):
     """test Status.loadall()"""
     db_file = str(tmp_path / "status.db")
+    # load from empty db
+    assert not any(Status.loadall(db_file))
     # create simple entry
     status = Status.start(db_file, enable_profiling=True)
     status.results.count("uid1", "sig1")
@@ -96,8 +98,6 @@ def test_status_05(mocker, tmp_path):
     fake_time = mocker.patch("grizzly.common.status.time", autospec=True)
     fake_time.return_value = 1.0
     db_file = str(tmp_path / "status.db")
-    # load from empty db
-    assert not any(Status.loadall(db_file))
     # create entry
     status = Status.start(db_file)
     status.results.count("uid1", "sig1")
@@ -311,6 +311,27 @@ def test_status_09(tmp_path, buckets, ratio, iterations, blockers):
     assert len(tuple(status.blockers(iters_per_result=ratio))) == blockers
 
 
+def test_status_10(mocker, tmp_path):
+    """test Status() - purge expired entries"""
+    fake_time = mocker.patch("grizzly.common.status.time", autospec=True)
+    db_file = str(tmp_path / "status.db")
+    # purge due to exp_limit
+    fake_time.return_value = 1.0
+    status = Status(db_file=db_file, start_time=1.0, pid=123, exp_limit=10)
+    status.report(force=True)
+    assert any(Status.loadall(db_file, time_limit=60))
+    fake_time.return_value = 20.0
+    Status(db_file=db_file, start_time=20.0, pid=456, exp_limit=10)
+    assert not any(Status.loadall(db_file, time_limit=60))
+    # purge due matching pid
+    fake_time.return_value = 1.0
+    status = Status(db_file=db_file, start_time=1.0, pid=123, exp_limit=10)
+    status.report(force=True)
+    assert any(Status.loadall(db_file, time_limit=60))
+    Status(db_file=db_file, start_time=1.0, pid=123, exp_limit=10)
+    assert not any(Status.loadall(db_file, time_limit=60))
+
+
 def test_reduce_status_01(mocker, tmp_path):
     """test ReductionStatus()"""
     mocker.patch("grizzly.common.status.time", autospec=True, return_value=1.0)
@@ -672,7 +693,7 @@ def test_report_counter_03(mocker, tmp_path):
 
 
 def test_report_counter_04(mocker, tmp_path):
-    """test ResultCounter remove old entries"""
+    """test ResultCounter remove expired entries"""
     fake_time = mocker.patch("grizzly.common.status.time", autospec=True)
     fake_time.return_value = 1
     db_path = str(tmp_path / "storage.db")

From 59f3c7ecb337cf263fe3155bd92fd84d7b95395b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 1 May 2019 13:31:54 -0700
Subject: [PATCH 446/531] Add Android support

---
 grizzly/target/adb_device/__init__.py    |   6 +
 grizzly/target/adb_device/device.py      | 885 +++++++++++++++++++++++
 grizzly/target/adb_device/fake_aapt.py   |  68 ++
 grizzly/target/adb_device/fake_adb.py    | 341 +++++++++
 grizzly/target/adb_device/test_device.py | 385 ++++++++++
 grizzly/target/adb_target.py             | 143 ++++
 grizzly/target/test_adb_target.py        |  34 +
 setup.cfg                                |   1 +
 8 files changed, 1863 insertions(+)
 create mode 100644 grizzly/target/adb_device/__init__.py
 create mode 100644 grizzly/target/adb_device/device.py
 create mode 100755 grizzly/target/adb_device/fake_aapt.py
 create mode 100755 grizzly/target/adb_device/fake_adb.py
 create mode 100644 grizzly/target/adb_device/test_device.py
 create mode 100644 grizzly/target/adb_target.py
 create mode 100644 grizzly/target/test_adb_target.py

diff --git a/grizzly/target/adb_device/__init__.py b/grizzly/target/adb_device/__init__.py
new file mode 100644
index 00000000..49cf0bc4
--- /dev/null
+++ b/grizzly/target/adb_device/__init__.py
@@ -0,0 +1,6 @@
+from .device import ADBProcess, ADBSession
+
+__all__ = ("ADBProcess", "ADBSession")
+
+__author__ = "Tyson Smith"
+__credits__ = ["Tyson Smith"]
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
new file mode 100644
index 00000000..172b08fe
--- /dev/null
+++ b/grizzly/target/adb_device/device.py
@@ -0,0 +1,885 @@
+import argparse
+import glob
+import logging
+import os
+import random
+import shutil
+import socket
+import subprocess
+import sys
+import tempfile
+import time
+
+from ffpuppet.helpers import append_prefs, Bootstrapper, create_profile
+from ffpuppet.minidump_parser import process_minidumps
+from ffpuppet.puppet_logger import PuppetLogger
+
+log = logging.getLogger("adb_device")  # pylint: disable=invalid-name
+
+__author__ = "Tyson Smith"
+__credits__ = ["Tyson Smith"]
+
+
+# TODO:
+# - Add ability to collect ASan logs
+
+
+class DeviceProcess(object):
+    def __init__(self, memory, name, pid, ppid):
+        self.memory = memory
+        self.name = name
+        self.pid = pid
+        self.ppid = ppid
+
+    @classmethod
+    def from_ps_line(cls, line):
+        try:
+            _, pid, ppid, _, memory, _, _, _, name = line.split()
+        except ValueError:
+            log.debug("invalid ps line %r", line)
+            return None
+        try:
+            return cls(int(memory), name, int(pid), int(ppid))
+        except ValueError:
+            log.debug("invalid ps line values")
+            return None
+
+
+class ADBCommandError(RuntimeError):
+    pass
+
+class ADBSessionError(RuntimeError):
+    pass
+
+class ADBLaunchError(ADBSessionError):
+    pass
+
+class ADBNoDevice(ADBSessionError):
+    pass
+
+
+class ADBSession(object):
+    BIN_AAPT = None
+    BIN_ADB = None
+
+    def __init__(self, ip_addr=None, port=5555):
+        self.connected = False
+        self.symbols = dict()
+        self._root = False
+        self._ip_addr = None  # target device IP address
+        self._port = None  # ADB listening port
+
+        log.debug("creating IP based session: %r", ip_addr is not None)
+        if ip_addr is not None:
+            try:
+                if ip_addr != "localhost":
+                    socket.inet_aton(ip_addr)
+            except (socket.error, TypeError):
+                raise ValueError("IP Address is invalid")
+            self._ip_addr = ip_addr
+            if not isinstance(port, int) or not (port > 1024 and port < 0x10000):
+                raise ValueError("Port must be valid integer between 1025 and 65535")
+            self._port = port
+
+        suggested_adb = os.path.expanduser("~/.android/sdk/platform-tools/adb")
+        if self.BIN_ADB is None:
+            if os.path.isfile(suggested_adb):
+                self.BIN_ADB = suggested_adb
+            else:
+                try:
+                    self.BIN_ADB = subprocess.check_output(["which", "adb"]).strip()
+                except subprocess.CalledProcessError:
+                    raise EnvironmentError("Please install ADB")
+            # TODO: update this to check adb version
+            if os.path.realpath(self.BIN_ADB) != os.path.realpath(suggested_adb):
+                log.warning("You are not using the recommended ADB install!")
+                log.warning("Either run the setup script or proceed with caution.")
+                time.sleep(5)
+
+
+    @classmethod
+    def create(cls, ip_addr=None, port=5555, as_root=True, max_attempts=10):
+        session = cls(ip_addr, port)
+        if session.connect(as_root=as_root, max_attempts=max_attempts):
+            return session
+        return None
+
+
+    @staticmethod
+    def _call_adb(cmd, timeout=None):
+        with tempfile.TemporaryFile() as out_fp:
+            if timeout is not None:
+                assert timeout > 0
+                end_time = time.time() + timeout
+                adb_proc = subprocess.Popen(cmd, stderr=out_fp, stdout=out_fp)
+                while adb_proc.poll() is None:
+                    time.sleep(0.05)
+                    if time.time() > end_time:
+                        log.warning("adb call timeout!")
+                        adb_proc.terminate()
+                        break
+                ret_code = adb_proc.wait()
+            else:
+                ret_code = subprocess.call(cmd, stderr=out_fp, stdout=out_fp)
+            out_fp.seek(0)
+            return ret_code, out_fp.read().decode("utf-8", "ignore").strip()
+
+
+    def call(self, cmd, require_device=True, timeout=None):
+        assert isinstance(cmd, list) and cmd
+        cmd = [self.BIN_ADB] + cmd
+        log.debug("calling: %s", " ".join(cmd))
+        if not self.connected and cmd[1] not in ("connect", "devices", "disconnect"):
+            raise ADBSessionError("ADB session is not connected!")
+        ret_code, output = self._call_adb(cmd, timeout=timeout)
+        log.debug("=== adb start ===\n%s\n=== adb end, returned %d ===", output, ret_code)
+        if ret_code != 0:
+            if output.startswith("Android Debug Bridge version"):
+                raise ADBCommandError("Invalid ADB command '%s'" % " ".join(cmd[1:]))
+            elif output.startswith("adb: usage:"):
+                raise ADBCommandError(output.strip())
+            elif require_device and (output.startswith("error: closed") or
+                                     output.startswith("error: device offline") or
+                                     output.startswith("error: no devices/emulators found")):
+                self.connected = False
+                raise ADBNoDevice("No device detected!")
+        return (ret_code, output)
+
+
+    def clear_logs(self):
+        log.debug("clear_logs()")
+        return self.call(["logcat", "--clear"], timeout=10)[0] == 0
+
+
+    def connect(self, as_root=True, max_attempts=10):
+        max_attempts = max(1, max_attempts)
+        attempt = 0
+        root_called = False
+        while attempt < max_attempts:
+            attempt += 1
+            if not self.connected and self._ip_addr is not None:
+                addr = ":".join([self._ip_addr, str(self._port)])
+                log.debug("connecting to %s", addr)
+                if self.call(["connect", addr])[0] != 0:
+                    log.warning("connection attempt #%d failed", attempt)
+                    time.sleep(0.25)
+                    continue
+            elif not self._devices_available(self.call(["devices"])[1]):
+                log.warning("No device detected (attempt %d/%d)", attempt, max_attempts)
+                time.sleep(1)
+                continue
+            self.connected = True
+
+            # verify we are connected
+            ret_code, user = self.call(["shell", "whoami"], require_device=False)
+            if (ret_code != 0 or not user) and attempt < max_attempts:
+                time.sleep(0.25)
+                continue
+
+            if ret_code != 0 or not user:
+                raise ADBSessionError("Device in a bad state, try disconnect & reboot")
+            user = user.splitlines()[-1]
+            if user == "root":
+                self._root = True
+
+            if not as_root or self._root:
+                break  # connected
+
+            # enable root
+            assert as_root, "Should not be here if root is not requested"
+            if self.call(["root"])[0] == 0:
+                self.connected = False
+                if not root_called:
+                    root_called = True
+                    attempt -= 1  # remove attempt used to call root
+                    continue
+
+            time.sleep(0.25)  # wait for adbd to restart on device
+
+        if self.connected and as_root and not self._root:
+            raise ADBSessionError("Could not enable root")
+
+        return self.connected
+
+
+    def collect_logs(self, pid=None):
+        log.debug("collect_logs()")
+        if not self.connected:
+            log.debug("device not connected cannot collect logs")
+            return ""
+        cmd = ["logcat", "-d", "*:I"]
+        if pid is not None:
+            cmd += ["--pid=%d" % pid]
+        return self.call(cmd, timeout=10)[1].encode("utf-8", "ignore")
+
+
+    @staticmethod
+    def _devices_available(adb_output):
+        entries = adb_output.strip().splitlines()
+        if len(entries) < 2:
+            return False
+        return entries[-1].endswith("device")
+
+
+    def disconnect(self, unroot=True):
+        if not self.connected:
+            log.debug("already disconnected")
+            return True
+        if self._root and unroot:
+            try:
+                if self.call(["unroot"])[0] == 0:
+                    self.connected = False
+                    self._root = False
+                    return True
+                log.warning("'unroot' failed")
+            except ADBCommandError:
+                log.warning("'unroot' not support by ADB")
+        elif self._ip_addr is not None:
+            self.call(["disconnect", ":".join([self._ip_addr, str(self._port)])])
+        self.connected = False
+        return True
+
+
+    def listdir(self, path):
+        log.debug("listdir(%r)", path)
+        ret_val, output = self.call(["shell", "ls", "-A", path])
+        if ret_val != 0:
+            raise IOError("%r does not exist" % path)
+        return output.splitlines()
+
+
+    def realpath(self, path):
+        log.debug("realpath(%r)", path)
+        ret_val, output = self.call(["shell", "realpath", path])
+        if ret_val != 0:
+            raise IOError("%r does not exist" % path)
+        return output.strip()
+
+
+    def reverse(self, remote, local):
+        # remote->device, local->desktop
+        assert isinstance(local, int) and local > 1024 and local < 0x10000
+        assert isinstance(remote, int) and remote > 1024 and remote < 0x10000
+        return self.call(["reverse", "tcp:%d" % remote, "tcp:%d" % local])[0] == 0
+
+
+    def reverse_remove(self, remote=None):
+        # remote->device
+        cmd = ["reverse"]
+        if remote is not None:
+            assert isinstance(remote, int) and remote > 1024 and remote < 0x10000
+            cmd.append("--remove")
+            cmd.append("tcp:%d" % remote)
+        else:
+            cmd.append("--remove-all")
+        return self.call(cmd)[0] == 0
+
+
+    def uninstall(self, package):
+        if not self.connected:
+            log.debug("already disconnected")
+            return False
+        return self.call(["uninstall", package], timeout=60)[0] == 0
+
+
+    def install(self, apk_path):
+        log.debug("installing %r", apk_path)
+        if not os.path.isfile(apk_path):
+            raise IOError("APK does not exist %r" % apk_path)
+        # check if package is installed
+        if self.call(["install", "-r", apk_path], timeout=120)[0] != 0:
+            raise ADBSessionError("Failed to install %r" % apk_path)
+
+        # unpack and lookup package name
+        package_name = self.get_package_name(apk_path)
+
+        # set permissions
+        self.call(["shell", "pm", "grant", package_name, "android.permission.READ_EXTERNAL_STORAGE"])
+        self.call(["shell", "pm", "grant", package_name, "android.permission.WRITE_EXTERNAL_STORAGE"])
+
+        log.debug("installed package %r (%r)", package_name, apk_path)
+        return package_name
+
+
+    def install_asan(self, ndk_base, asan_options=None):
+        if not os.path.isdir(ndk_base):
+            raise IOError("NDK does not exist %r" % ndk_base)
+        self.call(["remount"])
+
+        clang_path = os.path.join(
+            ndk_base, "toolchains", "llvm", "prebuilt", "linux-x86_64", "lib64",
+            "clang", "*", "lib", "linux")
+        for cpath in glob.glob(clang_path):
+            asan_rt = os.path.join(cpath, "libclang_rt.asan-i686-android.so")
+            asan_rt64 = os.path.join(cpath, "libclang_rt.asan-x86_64-android.so")
+            if os.path.isfile(asan_rt) and os.path.isfile(asan_rt64):
+                break
+        else:
+            raise IOError("Cannot find libclang_rt.asan-*-android.so")
+
+        ctx = "u:object_r:zygote_exec:s0"
+        self.call(["shell", "setenforce", "0"])
+
+        self.call(["shell", "mv", "/system/bin/app_process32.real", "/system/bin/app_process32"])
+        self.call(["shell", "mv", "/system/bin/app_process32", "/system/bin/app_process32.real"])
+        self.call(["shell", "chcon", ctx, "/system/bin/app_process32.real"])
+        self.call(["shell", "mv", "/system/bin/app_process64.real", "/system/bin/app_process64"])
+        self.call(["shell", "mv", "/system/bin/app_process64", "/system/bin/app_process64.real"])
+        self.call(["shell", "chcon", ctx, "/system/bin/app_process64.real"])
+
+        self.install_file(asan_rt, "/system/lib", "644")
+        self.install_file(asan_rt64, "/system/lib64", "644")
+
+        addition_options = [
+            "allow_user_segv_handler=1",
+            "detect_container_overflow=0",
+            "malloc_context_size=0",
+            "start_deactivated=1"]
+        if asan_options:
+            existing_opts = [opt for opt in asan_options.split(":") if opt]
+        else:
+            existing_opts = []
+        asan_options = ":".join(existing_opts + addition_options)
+
+        tmpd = tempfile.mkdtemp()
+        try:
+            fname = os.path.join(tmpd, "app_process32")
+            with open(fname, "w") as out_fp:
+                out_fp.write("#!/system/bin/sh-from-zygote\n")
+                out_fp.write("ASAN_OPTIONS=%s \\\n" % asan_options)
+                out_fp.write("ASAN_ACTIVATION_OPTIONS=include_if_exists=/data/local/tmp/asan.options.%b \\\n")
+                out_fp.write("LD_PRELOAD=symlink-to-libclang_rt.asan \\\n")
+                out_fp.write("exec /system/bin/app_process32.real \"$@\"\n")
+            self.install_file(fname, "/system/bin", "755", ctx)
+
+            fname = os.path.join(tmpd, "app_process64")
+            with open(fname, "w") as out_fp:
+                out_fp.write("#!/system/bin/sh-from-zygote\n")
+                out_fp.write("ASAN_OPTIONS=%s \\\n" % asan_options)
+                out_fp.write("ASAN_ACTIVATION_OPTIONS=include_if_exists=/data/local/tmp/asan.options.%b \\\n")
+                out_fp.write("LD_PRELOAD=symlink-to-libclang_rt.asan \\\n")
+                out_fp.write("exec /system/bin/app_process64.real \"$@\"\n")
+            self.install_file(fname, "/system/bin", "755", ctx)
+
+            fname = os.path.join(tmpd, "asanwrapper")
+            with open(fname, "w") as out_fp:
+                out_fp.write("#!/system/bin/sh\n")
+                out_fp.write("LD_PRELOAD=symlink-to-libclang_rt.asan \\\n")
+                out_fp.write("exec \"$@\"\n")
+            self.install_file(fname, "/system/bin", "755")
+
+            fname = os.path.join(tmpd, "asanwrapper64")
+            with open(fname, "w") as out_fp:
+                out_fp.write("#!/system/bin/sh\n")
+                out_fp.write("LD_PRELOAD=symlink-to-libclang_rt.asan \\\n")
+                out_fp.write("exec \"$@\"\n")
+            self.install_file(fname, "/system/bin", "755")
+        finally:
+            shutil.rmtree(tmpd, ignore_errors=True)
+
+        llvm_symer = os.path.join(
+            ndk_base, "toolchains", "llvm", "prebuilt", "android-x86_64",
+            "llvm-symbolizer", "llvm-symbolizer")
+        self.install_file(llvm_symer, "/system/bin", "755", ctx)
+
+        # set-up asan symlinks
+        self.call(["shell", "ln", "-s", "/system/lib/libclang_rt.asan-i686-android.so", "/system/lib/symlink-to-libclang_rt.asan"])
+        self.call(["shell", "ln", "-s", "/system/lib64/libclang_rt.asan-x86_64-android.so", "/system/lib64/symlink-to-libclang_rt.asan"])
+
+        self.call(["shell", "cp", "/system/bin/sh", "/system/bin/sh-from-zygote"])
+        self.call(["shell", "chcon", ctx, "/system/bin/sh-from-zygote"])
+
+        self.call(["shell", "setenforce", "1"])
+        self.call(["shell", "stop"])
+        self.call(["shell", "start"])
+
+
+    def install_file(self, src, dst, mode=None, context=None):
+        basename = os.path.basename(src)
+        full_dst = os.path.join(dst, basename)
+        self.push(src, full_dst)
+        self.call(["shell", "chown", "root.shell", full_dst])
+        if mode is not None:
+            self.call(["shell", "chmod", mode, full_dst])
+        if context is not None:
+            self.call(["shell", "chcon", context, full_dst])
+
+
+    @staticmethod
+    def get_package_name(apk_path):
+        # unpack and lookup package name
+        aapt = ADBSession.BIN_AAPT
+        if aapt is None:
+            aapt = os.path.expanduser("~/.android/sdk/android-9/aapt")
+            if not os.path.isfile(aapt):
+                # fall back to system version
+                aapt = subprocess.check_output(["which", "aapt"]).strip()
+        apk_info = subprocess.check_output([aapt, "dump", "badging", apk_path])
+        for line in apk_info.splitlines():
+            if line.startswith("package: name="):
+                package_name = line.split()[1][5:].strip("'")
+                break
+        else:
+            raise RuntimeError("Could not find APK package name")
+        return package_name
+
+
+    def get_packages(self):
+        # TODO: should this be by pid or package?
+        cmd = ["shell", "pm", "list", "packages"]
+        return [line[8:] for line in self.call(cmd)[1].splitlines() if line.startswith("package:")]
+
+
+    def get_open_files(self, pid=None, children=False, files=None):
+        log.debug("get_open_files(pid=%r, children=%r, files=%r", pid, children, files)
+        pids = list()
+        if pid is not None:
+            pids.append(str(pid))
+        if children:
+            assert pid is not None, "Cannot request child open files without specifying pid"
+            for proc in self._get_procs(pid_children=pid):
+                pids.append(str(proc.pid))
+        cmd = ["shell", "lsof"]
+        if pids:
+            cmd += ["-p", ",".join(pids)]
+        if files:
+            cmd.extend(list(files))
+        open_files = list()
+        for line in self.call(cmd)[1].splitlines():
+            if line.endswith("Permission denied)"):
+                continue
+            # I believe we only care about regular files
+            if " REG " not in line:
+                continue
+            try:
+                file_info = line.split()
+                file_name = file_info[-1]
+                if pid is not None and file_info[1] not in pids:
+                    continue
+                # add tuple containing pid and filename
+                open_files.append((int(file_info[1]), file_name))
+            except ValueError:
+                pass
+
+        return open_files
+
+
+    def get_pid(self, package_name):
+        # NOTE: pidof is not supported pre-Android 6
+        procs = self._get_procs()
+        pids = [proc.pid for proc in procs if proc.name == package_name]
+        if not pids:
+            return None
+        count = len(pids)
+        if count > 1:
+            log.debug("get_pid() %d proc(s) found", count)
+            # TODO: use procs and use the ppid of the procs the determine the parent
+            pids.sort()
+        return int(pids[0])
+
+
+    def process_exists(self, pid):
+        return True if self._get_procs(pid=pid) else False
+
+
+    def _get_procs(self, pid=None, pid_children=None):
+        # default list all procs
+        cmd = ["shell", "ps"]
+        if pid is not None:
+            cmd.append(str(pid))
+        if pid_children is not None:
+            cmd += ["--ppid", str(pid_children)]
+        procs = list()
+        for line in self.call(cmd)[1].splitlines()[1:]:
+            proc = DeviceProcess.from_ps_line(line)
+            if proc is not None:
+                procs.append(proc)
+        return procs
+
+
+    def is_installed(self, package_name):
+        return package_name in self.get_packages()
+
+
+    def pull(self, src, dst):
+        log.debug("pull(%r, %r)", src, dst)
+        return self.call(["pull", src, dst])[0] == 0
+
+
+    def push(self, src, dst):
+        log.debug("push(%r, %r)", src, dst)
+        if not os.path.exists(src):
+            raise IOError("%r does not exist" % src)
+        return self.call(["push", src, dst])[0] == 0
+
+
+    def symbols_path(self, package_name):
+        return self.symbols.get(package_name, "")
+
+
+    def set_airplane_mode(self, mode=True):
+        cmd = ["shell", "settings", "put", "global", "airplane_mode_on"]
+        cmd += ["1" if mode else "0"]
+        self.call(cmd)
+        cmd = ["shell", "su", "root", "am", "broadcast", "-a", "android.intent.action.AIRPLANE_MODE"]
+        self.call(cmd)
+
+
+
+class ADBProcess(object):
+    # TODO: reason codes match FFPuppet
+    RC_ALERT = "ALERT"  # target crashed/aborted/triggered an assertion failure etc...
+    RC_CLOSED = "CLOSED"  # target was closed by call to FFPuppet close()
+    RC_EXITED = "EXITED"  # target exited
+    #RC_WORKER = "WORKER"  # target was closed by worker thread
+    # TODO: 
+    #  def save_logs(self, *args, **kwargs):
+    #  def clone_log(self, log_id, offset=0):
+    #  def log_data(self, log_id, offset=0):
+    #  def log_length(self, log_id):... likely not going to happen because of overhead
+    def __init__(self, package_name, session, use_profile=None):
+        assert isinstance(session, ADBSession), "Expecting ADBSession"
+        if not session.is_installed(package_name):
+            raise ADBSessionError("Package %r not installed" % package_name)
+        self._launches = 0  # number of successful browser launches
+        self._package = package_name  # package to use as target process
+        self._pid = None  # pid of current target process
+        self._profile_template = use_profile  # profile that is used as a template
+        self._session = session  # ADB session with device
+        self._working_path = "/sdcard/ADBProc_%08X" % random.getrandbits(32)
+        self.logs = None
+        self.profile = None
+        self.reason = self.RC_CLOSED
+
+
+    def cleanup(self):
+        if self._launches < 0:
+            log.debug("clean_up() call ignored")
+            return
+        if self.reason is None:
+            self.close()
+        self._remove_logs()
+        # negative 'self._launches' indicates clean_up() has been called
+        self._launches = -1
+
+
+    def clone_log(self):
+        # TODO: dump logs for all browser processes
+        if self._session is None:
+            # TODO: better error?
+            return "ADB session does not exist!"
+        return self._session.collect_logs(pid=self._pid)
+
+
+    def close(self):
+        assert self._launches > -1, "clean_up() has been called"
+        if self.reason is not None:
+            log.debug("already closed!")
+            return
+        try:
+            if self._session is not None:
+                crash_reports = self.find_crashreports()
+                # set reason code
+                if crash_reports:
+                    self.reason = self.RC_ALERT
+                    self.wait_on_files(crash_reports)
+                elif self.is_running():
+                    self.reason = self.RC_CLOSED
+                else:
+                    self.reason = self.RC_EXITED
+                self._terminate()
+                self.wait()
+                self._process_logs(crash_reports)
+                self._session.call(["shell", "rm", "-rf", self._working_path])
+        except ADBSessionError:
+            log.warning("No device detected while closing process")
+        self._pid = None
+        self.profile = None
+        if self.reason is None:
+            self.reason = self.RC_CLOSED
+
+
+    def find_crashreports(self):
+        reports = list()
+        # TODO: Add ASan support
+        if self.profile:
+            # check for minidumps
+            md_path = os.path.join(self.profile, "minidumps")
+            try:
+                contents = self._session.listdir(md_path)
+                md_path
+                for fname in contents:
+                    if ".dmp" in fname or ".extra" in fname:
+                        reports.append(os.path.join(md_path, fname))
+            except IOError:
+                log.debug("%s does not exist", md_path)
+
+        return reports
+
+
+    def is_healthy(self):
+        if not self.is_running():
+            return False
+        return not self.find_crashreports()
+
+
+    def is_running(self):
+        assert self._session, "Device not connected"
+        assert self._package, "Package not specified"
+        if self._pid is None or self.reason is not None:
+            return False
+        return self._session.process_exists(self._pid)
+
+
+    def launch(self, url, env_mod=None, extension=None, prefs_js=None):
+        log.debug("launching %r", url)
+        assert self._launches > -1, "clean_up() has been called"
+        assert self._session, "Device not connected"
+        assert self._package, "Package not specified"
+        assert self._pid is None, "Process is already running"
+        assert self.reason is not None, "Process is already running"
+
+        self._session.clear_logs()
+        self._remove_logs()
+        self.reason = None
+        local_profile = create_profile(
+            extension=extension,
+            prefs_js=prefs_js,
+            template=self._profile_template)
+
+        bootstrapper = Bootstrapper(poll_wait=0.5)
+        try:
+            try:
+                prefs = {
+                    "capability.policy.policynames": "'localfilelinks'",
+                    "capability.policy.localfilelinks.sites": "'%s'" % bootstrapper.location,
+                    "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'"}
+                append_prefs(local_profile, prefs)
+                self.profile = "/".join([self._working_path, os.path.basename(local_profile)])
+                if os.listdir(local_profile):
+                    if not self._session.push(local_profile, self.profile):
+                        raise ADBLaunchError("Could not upload %r" % local_profile)
+                else:
+                    log.debug("creating empty profile on device: %s", self.profile)
+                    self._session.call(["shell", "mkdir", "-p", self.profile])
+            finally:
+                if os.path.exists(local_profile):
+                    shutil.rmtree(local_profile) # TODO: temporary
+
+            # TODO: Is call needed and if so should it happen somewhere else?
+            # disable selinux
+            self._session.call(["shell", "setenforce", "0"])
+            if not self._session.reverse(bootstrapper.port, bootstrapper.port):
+                raise ADBLaunchError("Could not reverse port: %d" % bootstrapper.port)
+            cmd = [
+                "shell", "am", "start", "-W", "-n",
+                "/".join([self._package, "org.mozilla.gecko.BrowserApp"]),
+                "-a", "android.intent.action.VIEW", "-d", bootstrapper.location,
+                "--es", "args", "-profile\\ %s" % self.profile]
+
+            env_mod = dict(env_mod or {})
+            env_mod.setdefault("MOZ_SKIA_DISABLE_ASSERTS", "1")
+            for var_num, (var_name, var_val) in enumerate(env_mod.items()):
+                if var_val is None:
+                    continue
+                cmd.append("--es")
+                cmd.append("env%d" % var_num)
+                cmd.append("%s=%s" % (var_name, var_val))
+
+            if "Status: ok" not in self._session.call(cmd)[1].splitlines():
+                raise ADBLaunchError("Could not launch %r" % self._package)
+            self._pid = self._session.get_pid(self._package)
+            bootstrapper.wait(self.is_healthy, url=url)
+        finally:
+            self._session.reverse_remove(bootstrapper.port)
+            bootstrapper.close()
+        self._launches += 1
+
+        return self._pid is not None
+
+
+    @property
+    def launches(self):
+        """
+        Get the number of successful launches
+
+        @rtype: int
+        @return: successful launch count
+        """
+
+        assert self._launches > -1, "clean_up() has been called"
+        return self._launches
+
+
+    def _process_logs(self, crash_reports):
+        assert self.logs is None
+        self.logs = tempfile.mkdtemp(prefix="adb_logs_")
+        unprocessed = os.path.join(self.logs, "unprocessed")
+        os.mkdir(unprocessed)
+
+        with open(os.path.join(self.logs, "log_logcat.txt"), "wb") as log_fp:
+            # TODO: should this filter by pid or not?
+            log_fp.write(self._session.collect_logs())
+            #log_fp.write(self._session.collect_logs(pid=self._pid))
+
+        if not crash_reports:
+            return
+
+        # copy crash logs from the device
+        for fname in crash_reports:
+            self._session.pull(fname, unprocessed)
+
+        logger = PuppetLogger()
+        try:
+            syms_path = self._session.symbols_path(self._package)
+            process_minidumps(unprocessed, syms_path, logger.add_log)
+            logger.close()
+            logger.save_logs(self.logs)
+        finally:
+            logger.clean_up()
+
+
+    def _remove_logs(self):
+        if self.logs is not None and os.path.isdir(self.logs):
+            shutil.rmtree(self.logs)
+            self.logs = None
+
+
+    @staticmethod
+    def _split_logcat(log_path):
+        # Roughly split out stderr and stdout from logcat
+        # This is to support FuzzManager. The original logcat output is also
+        # included in the report so nothing is lost.
+        logcat = os.path.join(log_path, "log_logcat.txt")
+        if not os.path.isfile(logcat):
+            log.warning("log_logcat.txt does not exist!")
+            return None
+        err_log = os.path.join(log_path, "log_stderr.txt")
+        if os.path.isfile(err_log):
+            log.warning("log_stderr.txt already exist! Overwriting...")
+        out_log = os.path.join(log_path, "log_stdout.txt")
+        if os.path.isfile(out_log):
+            log.warning("log_stdout.txt already exist! Overwriting...")
+        with open(logcat, "rb") as lc_fp, open(err_log, "w") as e_fp, open(out_log, "w") as o_fp:
+            for line in lc_fp:
+                if b"Gecko" not in line and b"MOZ_" not in line:
+                    continue
+                line = line[33:].decode("ascii", "ignore")
+                if line.startswith("GeckoDump"):
+                    o_fp.write(line.split(": ", 1)[-1])
+                elif line.startswith("Gecko") or line.startswith("MOZ_"):
+                    e_fp.write(line.split(": ", 1)[-1])
+
+
+    def save_logs(self, log_path, meta=False):
+        assert self.logs is not None
+        assert self.reason is not None, "Call close() first!"
+        assert self._launches > -1, "clean_up() has been called"
+        # copy logs to location specified by log_file
+        if not os.path.isdir(log_path):
+            os.makedirs(log_path)
+        log_path = os.path.abspath(log_path)
+
+        for fname in os.listdir(self.logs):
+            full_name = os.path.join(self.logs, fname)
+            # skip directories
+            if not os.path.isfile(full_name):
+                continue
+            shutil.copy(full_name, log_path)
+        self._split_logcat(log_path)
+
+
+    def wait_on_files(self, wait_files, poll_rate=0.5, timeout=60):
+        assert poll_rate >= 0, "Invalid poll_rate %d, must be greater than or equal to 0" % poll_rate
+        assert timeout >= 0, "Invalid timeout %d, must be greater than or equal to 0" % timeout
+        assert poll_rate <= timeout, "poll_rate must be less then or equal to timeout"
+        wait_end = time.time() + timeout
+        wait_files = set(self._session.realpath(x) for x in wait_files)
+
+        while wait_files:
+            open_files = set(x for _, x in self._session.get_open_files())
+            # check if any open files are in the wait file list
+            if not wait_files.intersection(open_files):
+                break
+            elif wait_end <= time.time():
+                log.debug("Timeout waiting for: %s", ", ".join(x for x in open_files if x in wait_files))
+                return False
+            time.sleep(poll_rate)
+        return True
+
+
+    def _terminate(self):
+        assert self._package is not None
+        assert self._session, "Device not connected"
+        # TODO: is this the best way???
+        self._session.call(["shell", "am", "force-stop", self._package])
+
+
+    def wait(self):
+        while self.is_running():
+            time.sleep(0.25)
+
+
+def main(argv=None):  # pylint: disable=missing-docstring
+    parser = argparse.ArgumentParser(description="ADB Device Wrapper")
+    parser.add_argument(
+        "--airplane-mode", default=None, type=int,
+        help="Enable(1) or disable(0) airplane mode")
+    parser.add_argument(
+        "--install", help="Path to APK to install")
+    parser.add_argument(
+        "--install-asan", help="Path to NDK")
+    parser.add_argument(
+        "--launch", help="Path to APK to launch")
+    parser.add_argument(
+        "--logs", help="Location to save logs")
+    parser.add_argument(
+        "--ip", help="IP address of target device")
+    parser.add_argument(
+        "--port", default=5555, type=int,
+        help="ADB listening port on target device")
+    args = parser.parse_args(argv)
+
+    log.info("Opening a session")
+    session = ADBSession.create(args.ip, args.port, as_root=True)
+    if session is None:
+        log.error("Failed to connect to IP:%r port:%r", args.ip, args.port)
+        return 1
+
+    if args.install is not None:
+        log.info("Installing %r ...", args.install)
+        package = session.install(args.install)
+        if not package:
+            log.error("Could not install %r", args.install)
+            return 1
+        log.info("Installed %r", package)
+    elif args.install_asan is not None:
+        log.info("Installing ASan from %r ...", args.install_asan)
+        session.install_asan(args.install_asan)
+        log.info("Device reboot required")
+    elif args.airplane_mode is not None:
+        session.set_airplane_mode(mode=args.airplane_mode > 0)
+    elif args.launch:
+        package = ADBSession.get_package_name(args.launch)
+        if not package:
+            log.error("APK not installed")
+            return 1
+        proc = ADBProcess(package, session)
+        try:
+            proc.launch("about:blank")
+            assert proc.is_running(), "browser not running?!"
+            log.info("Launched")
+            proc.wait()
+        finally:
+            proc.close()
+            if args.logs:
+                proc.save_logs(args.logs)
+            proc.cleanup()
+    else:
+        parser.print_help()
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/grizzly/target/adb_device/fake_aapt.py b/grizzly/target/adb_device/fake_aapt.py
new file mode 100755
index 00000000..9f8d0a69
--- /dev/null
+++ b/grizzly/target/adb_device/fake_aapt.py
@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+# pylint: disable=missing-docstring
+import argparse
+
+
+def parse_args(argv=None):
+    parser = argparse.ArgumentParser(
+        description="Android Asset Packaging Tool ... Well really it's Fake AAPT")
+    parser.add_argument(
+        "cmd",
+        help="ADB command to execute")
+    parser.add_argument(
+        "extra", action="append", default=list(), nargs=argparse.REMAINDER,
+        help="Extra args")
+    return parser.parse_args(argv)
+
+
+def main(argv=None):
+    parse_args(argv)
+    print("package: name='org.mozilla.fennec_aurora' versionCode='2015624653' versionName='68.0a1' platformBuildVersionName=''")
+    print("install-location:'internalOnly'")
+    print("sdkVersion:'16'")
+    print("targetSdkVersion:'28'")
+    print("uses-permission: name='android.permission.READ_SYNC_SETTINGS'")
+    print("uses-permission: name='org.mozilla.fennec_aurora_fxaccount.permission.PER_ACCOUNT_TYPE'")
+    print("uses-permission: name='com.google.android.c2dm.permission.RECEIVE'")
+    print("uses-permission: name='org.mozilla.fennec_aurora.permission.C2D_MESSAGE'")
+    print("uses-permission: name='com.samsung.android.providers.context.permission.WRITE_USE_APP_FEATURE_SURVEY'")
+    print("uses-permission: name='android.permission.MODIFY_AUDIO_SETTINGS'")
+    print("application-label:'Firefox Nightly'")
+    print("application-label-en-GB:'Firefox Nightly'")
+    print("application-icon-240:'res/mipmap-anydpi-v26/ic_launcher.xml'")
+    print("application-icon-320:'res/mipmap-anydpi-v26/ic_launcher.xml'")
+    print("application-icon-480:'res/mipmap-anydpi-v26/ic_launcher.xml'")
+    print("application-icon-640:'res/mipmap-anydpi-v26/ic_launcher.xml'")
+    print("application-icon-65534:'res/mipmap-anydpi-v26/ic_launcher.xml'")
+    print("application-icon-65535:'res/mipmap-anydpi-v26/ic_launcher.xml'")
+    print("application: label='Firefox Nightly' icon='res/mipmap-anydpi-v26/ic_launcher.xml'")
+    print("application-debuggable")
+    print("feature-group: label=''")
+    print("  uses-gl-es: '0x20000'")
+    print("  uses-feature-not-required: name='android.hardware.audio.low_latency'")
+    print("  uses-feature-not-required: name='android.hardware.camera'")
+    print("  uses-feature-not-required: name='android.hardware.camera.any'")
+    print("  uses-feature-not-required: name='android.hardware.camera.autofocus'")
+    print("  uses-feature-not-required: name='android.hardware.location'")
+    print("  uses-feature-not-required: name='android.hardware.location.gps'")
+    print("  uses-feature-not-required: name='android.hardware.microphone'")
+    print("  uses-feature-not-required: name='android.hardware.nfc'")
+    print("  uses-feature: name='android.hardware.touchscreen'")
+    print("  uses-feature: name='android.hardware.location.network'")
+    print("  uses-implied-feature: name='android.hardware.location.network' reason='requested android.permission.ACCESS_COARSE_LOCATION permission'")
+    print("  uses-feature: name='android.hardware.wifi'")
+    print("  uses-implied-feature: name='android.hardware.wifi' reason='requested android.permission.ACCESS_WIFI_STATE permission, and requested android.permission.CHANGE_WIFI_STATE permission'")
+    print("provides-component:'app-widget'")
+    print("main")
+    print("other-activities")
+    print("other-receivers")
+    print("other-services")
+    print("supports-screens: 'small' 'normal' 'large' 'xlarge'")
+    print("supports-any-density: 'true'")
+    print("locales: '--_--' 'ca' ' 'en-GB' 'zh-HK' 'zh-CN' 'en-IN' 'pt-BR' 'es-US' 'pt-PT' 'en-AU' 'zh-TW'")
+    print("densities: '120' '160' '240' '320' '480' '640' '65534' '65535'")
+    print("native-code: 'x86'")
+
+
+if __name__ == "__main__":
+    exit(main())
diff --git a/grizzly/target/adb_device/fake_adb.py b/grizzly/target/adb_device/fake_adb.py
new file mode 100755
index 00000000..47af259d
--- /dev/null
+++ b/grizzly/target/adb_device/fake_adb.py
@@ -0,0 +1,341 @@
+#!/usr/bin/env python
+
+import argparse
+import json
+import multiprocessing
+import os
+import socket
+
+
+def parse_args(argv=None):
+    parser = argparse.ArgumentParser(
+        description="Android Debug Bridge version ... Well really it's Fake ADB")
+    parser.add_argument(
+        "cmd",
+        help="ADB command to execute")
+    parser.add_argument(
+        "extra", action="append", default=list(), nargs=argparse.REMAINDER,
+        help="Extra args")
+    return parser.parse_args(argv)
+
+
+class FakeADBState(object):
+    STATE_FILE = os.path.join(os.path.dirname(__file__), "fake-adb-state.json")
+
+    def __init__(self):
+        self.connected = False
+        self.devices = True  # devices command will return devices
+        self.root_allowed = True
+        self.root_enabled = False
+        self.unavailable = False
+
+    @classmethod
+    def load(cls):
+        state = cls()
+        if not os.path.isfile(cls.STATE_FILE):
+            if "DEBUG" in os.environ:
+                print("=== FakeADB State FILE NOT FOUND: %r ===" % cls.STATE_FILE)
+            return state
+        with open(cls.STATE_FILE, "r") as jfp:
+            loaded = json.load(jfp)
+        if "connected" in loaded:
+            state.connected = loaded["connected"]
+        if "root_allowed" in loaded:
+            state.root_allowed = loaded["root_allowed"]
+        if "root_enabled" in loaded:
+            state.root_enabled = loaded["root_enabled"]
+        if "unavailable" in loaded:
+            state.unavailable = loaded["unavailable"]
+        if "DEBUG_FAKEADB" in os.environ:
+            print("=== FakeADB State Loaded START===")
+            print("> connected: %r" % state.connected)
+            print("> root_allowed: %r" % state.root_allowed)
+            print("> root_enabled: %r" % state.root_enabled)
+            print("> unavailable: %r" % state.unavailable)
+            print("=== FakeADB State Loaded END===")
+        return state
+
+    def save(self):
+        with open(self.STATE_FILE, "w") as jfp:
+            json.dump({
+                "connected":self.connected,
+                "root_allowed":self.root_allowed,
+                "root_enabled":self.root_enabled,
+                "unavailable":self.unavailable}, jfp, indent=2)
+
+
+def main(argv=None):  # pylint: disable=missing-docstring
+    args = parse_args(argv)
+    state = FakeADBState.load()
+
+    #print(args)
+    if args.cmd == "connect":
+        # sanity check
+        if len(args.extra[0]) != 1:
+            print("invalid arg count for %r" % args.cmd)
+            print("unable to connect")  # adb response
+            return 1
+        ip_addr, port = args.extra[0][0].split(":")
+        if ip_addr != "localhost" and len(ip_addr.split(".")) != 4:
+            print("invalid ip")
+            print("unable to connect")  # adb response
+            return 1
+        if int(port) > 65535 or int(port) < 1024:
+            print("invalid port")
+            print("unable to connect")  # adb response
+            return 1
+        if state.connected:
+            # TODO: get full message
+            print("already connected")
+        elif state.unavailable:
+            # TODO: get full message
+            print("unable to connect")
+            return 1
+        state.connected = True
+        state.save()
+        return 0
+
+    elif args.cmd == "devices":
+        if args.extra[0]:
+            print("invalid arg count for %r" % args.cmd)
+            return 1
+        print("List of devices attached")
+        print("* daemon not running; starting now at tcp:5037")
+        print("* daemon started successfully")
+        if state.devices:
+            print("emulator-5554   device")
+        return 0
+
+    elif args.cmd == "disconnect":
+        if len(args.extra[0]) != 1:
+            print("invalid arg count for %r" % args.cmd)
+            print("No such device")  # adb response
+            return 1
+        state.connected = False
+        state.save()
+        return 0
+
+    elif args.cmd == "install":
+        if len(args.extra[0]) != 2:
+            print("invalid arg count for %r" % args.cmd)
+            print("unable to connect")  # adb response
+            return 1
+        if args.extra[0][0] != "-r":
+            return 1
+        if len(args.extra[0][1]) < 1:
+            return 1
+        print("Success")
+        return 0
+
+    elif args.cmd == "logcat":
+        if len(args.extra[0]) == 1 and args.extra[0][0] == "--clear":
+            return 0
+        if len(args.extra[0]) == 2 or len(args.extra[0]) == 3 and args.extra[0][2] == "--pid=9990":
+            print("07-27 12:10:15.414  9990  9990 W art     : Unexpected CPU variant for X86 using defaults: x86")
+            print("07-27 12:10:15.430  9990  9990 I GeckoApplication: zerdatime 3349725 - application start")
+            print("07-27 12:10:15.442  9990  4714 I GeckoThread: preparing to run Gecko")
+            print("07-27 12:10:15.442  9990  4714 E GeckoLibLoad: Load sqlite start")
+            print("07-27 12:10:15.496  9990  9990 I GRALLOC-DRM: create pipe for driver vmwgfx")
+            print("07-27 12:10:15.505  9990  4713 E GeckoApp: An error occurred during restore, switching to backup file")
+            print("07-27 12:10:15.520  9990  4719 I EGL-DRI2: found extension DRI_Core version 1")
+            print("07-27 12:10:15.521  9990  4719 I OpenGLRenderer: Initialized EGL, version 1.4")
+            print("07-27 12:10:15.528  9990  4714 E GeckoLibLoad: Load sqlite done")
+            print("07-27 12:10:15.529  9990  4707 W art     : Suspending all threads took: 8.966ms")
+            print("07-27 12:10:15.533  9990  4714 E GeckoLibLoad: Load nss done")
+        if len(args.extra[0]) == 2: # all
+            print("07-27 12:39:27.188  3049  3049 W Finsky  : [1] com.google.android.finsky.wear.dx.run(8): Dropping command=auto_uninstall due to Gms not connected")
+            print("07-27 12:39:27.239  1887  1994 I InputReader: Reconfiguring input devices.  changes=0x00000010")
+            print("07-27 12:39:27.286  2767  7142 I Icing   : Usage reports ok 0, Failed Usage reports 0, indexed 0, re")
+            print("07-27 12:39:27.440  7128  7128 E android.os.Debug: failed to load memtrack module: -2")
+            print("07-27 12:39:27.441  7128  7128 I Radio-JNI: register_android_hardware_Radio DONE")
+        return 0
+
+    elif args.cmd == "pull":
+        if len(args.extra[0]) != 2:
+            print("invalid arg count for %r" % args.cmd)
+            print("unable to connect")  # adb response
+            return 1
+        print(" pulled. ")
+        return 0
+
+    elif args.cmd == "push":
+        if len(args.extra[0]) != 2:
+            print("invalid arg count for %r" % args.cmd)
+            print("unable to connect")  # adb response
+            return 1
+        print(" pushed. ")
+        return 0
+
+    elif args.cmd == "reverse":
+        if len(args.extra[0]) < 2:
+            print("invalid arg count for %r" % args.cmd)
+            return 1
+        return 0
+
+    elif args.cmd == "root":
+        if args.extra[0]:
+            print("invalid arg count for %r" % args.cmd)
+            return 1
+        if state.root_allowed:
+            if not state.root_enabled:
+                print("restarting adbd as root")
+                state.connected = False
+                state.root_enabled = True
+                state.save()
+                return 0
+        return 0
+
+    elif args.cmd == "shell" and args.extra[0][0] == "am" and args.extra[0][1] == "start":
+        if len(args.extra[0]) < 5:
+            print("invalid arg count for %r" % args.cmd)
+            return 1
+        # only "successfully" launch org.mozilla.fennec_aurora
+        if args.extra[0][4].startswith("org.mozilla.fennec_aurora"):
+            print("Status: ok")
+            host, port = args.extra[0][8].split("//")[-1].split(":")
+            def handle_bootstrap(host, port):
+                soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                try:
+                    soc.connect((host, port))
+                    soc.settimeout(5)  # just in case
+                    soc.sendall(b"welp")
+                    while soc.recv():
+                        pass
+                finally:
+                    soc.close()
+            # launch fake browser
+            proc = multiprocessing.Process(target=handle_bootstrap, args=(host, int(port)))
+            proc.start()
+            return 0
+        return 1
+
+    elif args.cmd == "shell" and args.extra[0][0] == "am" and args.extra[0][1] == "force-stop":
+        if args.extra[0][2] != "org.mozilla.fennec_aurora":
+            return 1
+        return 0
+
+    elif args.cmd == "shell" and args.extra[0][0] == "setenforce":
+        return 0
+
+    elif args.cmd == "shell" and args.extra[0][0] == "ls" and args.extra[0][1] == "-A":
+        if args.extra[0][2] == "missing-dir":
+            return 1
+        #print(".")
+        #print("..")
+        print("test")
+        return 0
+
+    elif args.cmd == "shell" and args.extra[0][0] == "lsof":
+        print("COMMAND     PID       USER   FD      TYPE             DEVICE  SIZE/OFF       NODE NAME")
+        if len(args.extra[0]) == 1:
+            print("init          1       root  cwd   unknown                                         /proc/1/cwd (readlink: Permission denied)")
+            print("lsof      15988      shell  cwd       DIR               0,13       780       4234 /")
+            print("lsof      15988      shell  txt       REG                8,1    432284    1696174 /system/bin/toybox")
+            print("lsof      15988      shell    4r      DIR                0,4         0     120901 /proc/15988/fd")
+        if len(args.extra[0]) == 1 or (args.extra[0][1] == "-p" and "9991" in args.extra[0][2].split(",")):
+            print("a.fennec_  9991     u0_a80   98r      REG                8,1    306672    1696611 /system/fonts/blah.ttf")
+        if len(args.extra[0]) == 1 or (args.extra[0][1] == "-p" and "9990" in args.extra[0][2].split(",")):
+            print("a.fennec_  9990     u0_a80  cwd       DIR               0,13       780       4234 /")
+            print("a.fennec_  9990     u0_a80  txt       REG                8,1     17948    1695879 /system/bin/app_process32")
+            print("a.fennec_  9990     u0_a80  mem   unknown                                         /dev/ashmem/dalvik-main space (deleted)")
+            print("a.fennec_  9990     u0_a80  mem       CHR              10,58                 4485 /dev/binder")
+            print("a.fennec_  9990     u0_a80  mem   unknown                                         /dev/ashmem/dalvik-allocspace zygote / non moving space live-bitmap 0 (deleted)")
+            print("a.fennec_  9990     u0_a80  mem       REG                8,1    152888    1704079 /system/lib/libexpat.so")
+            print("a.fennec_  9990     u0_a80   54u      REG                8,1    329632    1769879 /data/data/org.mozilla.fennec_aurora/files/mozilla/0kjujtli.default/browser.db-wal")
+            print("a.fennec_  9990     u0_a80   55u     IPv6                          0t0      44549 TCP []:49232->[]:443 (ESTABLISHED)")
+            print("a.fennec_  9990     u0_a80   75w     FIFO                0,9       0t0      44634 pipe:[44634]")
+            print("a.fennec_  9990     u0_a80   76u     sock                          0t0      44659 socket:[44659]")
+            print("a.fennec_  9990     u0_a80   95u      REG                8,1     98304    1769930 /data/data/org.mozilla.fennec_aurora/files/mozilla/0kjujtli.default/permissions.sqlite")
+            print("a.fennec_  9990     u0_a80   98r      REG                8,1    306672    1696611 /system/fonts/Roboto-Regular.ttf")
+            print("a.fennec_  9990     u0_a80  122u      CHR              10,59       0t0       4498 /dev/ashmem")
+            print("a.fennec_  9990     u0_a80  123u     IPv4                          0t0      44706 UDP :1900->:0")
+            print("a.fennec_  9990     u0_a80  125u     0000               0,10       0t0       3655 anon_inode:[eventpoll]")
+            print("a.fennec_  9990     u0_a80  126u     IPv4                          0t0      44773 TCP :58190->:443 (ESTABLISHED)")
+            print("a.fennec_  9990     u0_a80  128u     unix                          0t0      44747 socket")
+            print("a.fennec_  9990     u0_a80  130u     IPv4                          0t0      44840 TCP :35274->:443 (SYN_SENT)")
+        print("")
+        return 0
+
+    elif args.cmd == "shell" and args.extra[0][0] == "mkdir":
+        print("")
+        return 0
+
+    elif args.cmd == "shell" and args.extra[0][0] == "pm" and args.extra[0][1] == "grant":
+        if len(args.extra[0]) != 4:
+            return 1
+        print("")
+        return 0
+
+
+    elif (args.cmd == "shell" and args.extra[0][0] == "pm" and
+          args.extra[0][1] == "list" and args.extra[0][2] == "packages"):
+        print("package:org.mozilla.fennec_aurora")
+        print("package:org.test.preinstalled")
+        print("package:com.android.phone")
+        print("package:com.android.shell")
+        return 0
+
+    elif args.cmd == "shell" and args.extra[0][0] == "ps":
+        # TODO: add root and non-root output
+        print("USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME")
+        if len(args.extra[0]) == 1:
+            print("root      1     0     8896   2208  SyS_epoll_ 00000000 S /init")
+            print("root      1242  2     0      0         kswapd 00000000 S kswapd0")
+            print("test      1337  1772  1024   1024 SyS_epoll_ 00000000 S org.test.preinstalled")
+            print("test      1338  1337  1024   1024 SyS_epoll_ 00000000 S org.test.child")
+            print("root      1772  1     1620804 122196 poll_sched 00000000 S zygote")
+            print("media_rw  2158  1758  0      0              0 00000000 Z sdcard")
+            print("audioserver 1773  1     34000  9624  binder_thr 00000000 S /system/bin/audioserver")
+            print("root      5847  1     315992 2348  poll_sched 00000000 S /sbin/adbd")
+            print("u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora")
+            print("root      5944  5847  6280   2360           0 00000000 R ps")
+        if len(args.extra[0]) == 3 and args.extra[0][1] == "--ppid" and args.extra[0][2] == "9990":
+            print("u0_a80    9991  9990  3332   3331 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora")
+        elif len(args.extra[0]) == 2 and args.extra[0][1] == "9990":
+            print("u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora")
+        print("")
+        return 0
+
+    elif args.cmd == "shell" and args.extra[0][0] == "realpath":
+        print(args.extra[0][1])
+        return 0
+
+    elif args.cmd == "shell" and args.extra[0][0] == "rm":
+        print("")
+        return 0
+
+    elif args.cmd == "shell" and args.extra[0][0] == "whoami":
+        if state.root_enabled:
+            print("root")
+        else:
+            print("shell")
+        return 0
+
+    elif args.cmd == "uninstall":
+        if len(args.extra[0]) != 1:
+            print("invalid arg count for %r" % args.cmd)
+            print("unable to connect")
+            return 1
+        if args.extra[0][0] == "org.test.preinstalled":
+            print("Success")
+        return 0
+
+    elif args.cmd == "unroot":
+        if args.extra[0]:
+            print("invalid arg count for %r" % args.cmd)
+            return 1
+        if state.root_enabled:
+            print("restarting adbd as non root")
+            state.connected = False
+            state.root_enabled = False
+            state.save()
+        return 0
+
+
+    print("Android Debug Bridge version 1.0.XX")
+    print("Fake ADB: UNKNOWN COMMAND %r" % args.extra)
+    return 1
+
+
+if __name__ == "__main__":
+    exit(main())
diff --git a/grizzly/target/adb_device/test_device.py b/grizzly/target/adb_device/test_device.py
new file mode 100644
index 00000000..a77b4129
--- /dev/null
+++ b/grizzly/target/adb_device/test_device.py
@@ -0,0 +1,385 @@
+import logging
+import os
+import shutil
+import tempfile
+import unittest
+import zipfile
+
+from .device import ADBCommandError, ADBProcess, ADBSession, ADBSessionError, ADBLaunchError
+from .fake_adb import FakeADBState
+
+# set output verbosity
+if bool(os.getenv("DEBUG")):
+    logging.basicConfig(
+        format="%(levelname).1s %(name)s [%(asctime)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        level=logging.DEBUG)
+else:
+    logging.basicConfig(
+        format="[%(asctime)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        level=logging.INFO)
+
+CWD = os.path.realpath(os.path.dirname(__file__))
+
+class ADBSessionTests(unittest.TestCase):  # pylint: disable=too-many-public-methods
+
+    def setUp(self):
+        ADBSession.BIN_ADB = os.path.join(CWD, "fake_adb.py")
+        if os.path.isfile(FakeADBState.STATE_FILE):
+            os.remove(FakeADBState.STATE_FILE)
+        self.tmpdir = tempfile.mkdtemp(prefix="adbdev_test")
+
+    def tearDown(self):
+        if os.path.isdir(self.tmpdir):
+            shutil.rmtree(self.tmpdir)
+        if os.path.isfile(FakeADBState.STATE_FILE):
+            os.remove(FakeADBState.STATE_FILE)
+
+    def test_01(self):
+        "test creating a session with invalid args"
+        with self.assertRaises(ValueError):
+            ADBSession("invalid.ip")
+        with self.assertRaises(ValueError):
+            ADBSession("127.0.0.1", port=7)
+        with self.assertRaises(ValueError):
+            ADBSession("127.0.0.1", port="bad")
+
+    def test_02(self):
+        "test simple session"
+        test_ip = "127.0.0.1"
+        test_port = 5556
+        session = ADBSession(test_ip, test_port)
+        self.assertFalse(session.connected)
+        self.assertFalse(session._root)  # pylint: disable=protected-access
+        self.assertEqual(session._ip_addr, test_ip)  # pylint: disable=protected-access
+        self.assertEqual(session._port, test_port)  # pylint: disable=protected-access
+
+    def test_03(self):
+        "test _devices_available()"
+        adb_output = [
+            "List of devices attached",
+            "* daemon not running; starting now at tcp:5037",
+            "* daemon started successfully",
+            "emulator-5554   device"]
+        self.assertFalse(ADBSession._devices_available("\n".join(adb_output[:-1])))  # pylint: disable=protected-access
+        self.assertTrue(ADBSession._devices_available("\n".join(adb_output)))  # pylint: disable=protected-access
+
+    def test_04(self):
+        "test create()"
+        test_ip = "localhost"
+        test_port = 5555
+        session = ADBSession.create(test_ip, test_port)
+        self.assertIsNotNone(session)
+        self.assertTrue(session.connected)
+        self.assertTrue(session._root)  # pylint: disable=protected-access
+        self.assertEqual(session._ip_addr, test_ip)  # pylint: disable=protected-access
+        self.assertEqual(session._port, test_port)  # pylint: disable=protected-access
+        session.disconnect()
+        self.assertFalse(session.connected)
+        self.assertFalse(session._root)  # pylint: disable=protected-access
+        # test without IP
+        if os.path.isfile(FakeADBState.STATE_FILE):
+            os.remove(FakeADBState.STATE_FILE)
+        session = ADBSession.create()
+        self.assertIsNone(session._ip_addr)  # pylint: disable=protected-access
+        self.assertIsNone(session._port)  # pylint: disable=protected-access
+        self.assertIsNotNone(session)
+        self.assertTrue(session.connected)
+        self.assertTrue(session._root)  # pylint: disable=protected-access
+        session.disconnect()
+        self.assertFalse(session.connected)
+        self.assertFalse(session._root)  # pylint: disable=protected-access
+
+    def test_05(self):
+        "test connect() and disconnect()"
+        session = ADBSession("127.0.0.1")
+        self.assertFalse(session.connected)
+        self.assertFalse(session._root)  # pylint: disable=protected-access
+        session.disconnect()
+        # connect and enable root
+        state = FakeADBState()
+        state.connected = False
+        state.root_enabled = False
+        state.save()
+        self.assertTrue(session.connect(max_attempts=1))
+        self.assertTrue(session.connected)
+        self.assertTrue(session._root)  # pylint: disable=protected-access
+        session.disconnect()
+        self.assertFalse(session.connected)
+        self.assertFalse(session._root)  # pylint: disable=protected-access
+        # connect and do not enable root
+        state = FakeADBState()
+        state.connected = False
+        state.root_enabled = False
+        state.save()
+        self.assertTrue(session.connect(as_root=False))
+        self.assertTrue(session.connected)
+        self.assertFalse(session._root)  # pylint: disable=protected-access
+        session.disconnect()
+        self.assertFalse(session.connected)
+        self.assertFalse(session._root)  # pylint: disable=protected-access
+        # connect() x2 (already connected)
+        state = FakeADBState()
+        state.connected = False
+        state.root_enabled = False
+        state.save()
+        self.assertTrue(session.connect())
+        self.assertTrue(session.connected)
+        self.assertTrue(session.connect())
+        self.assertTrue(session.connected)
+        self.assertTrue(session._root)  # pylint: disable=protected-access
+        session.disconnect()
+        self.assertFalse(session.connected)
+        self.assertFalse(session._root)  # pylint: disable=protected-access
+
+    def test_06(self):
+        "test connect() with unavailable device"
+        session = ADBSession("127.0.0.1")
+        # connect to
+        state = FakeADBState()
+        state.connected = False
+        state.unavailable = True
+        state.save()
+        self.assertFalse(session.connect(max_attempts=1))
+        self.assertFalse(session.connected)
+        self.assertFalse(session._root)  # pylint: disable=protected-access
+        session.disconnect()
+        self.assertFalse(session.connected)
+        self.assertFalse(session._root)  # pylint: disable=protected-access
+
+    def test_07(self):
+        "test call() with invalid command"
+        session = ADBSession.create("127.0.0.1", 5555)
+        with self.assertRaises(ADBCommandError):
+            session.call(["unknown-cmd"])  # pylint: disable=protected-access
+        session.disconnect()
+
+    def test_08(self):
+        "test install()"
+        def _fake_get_package_name(apk_path):
+            with zipfile.ZipFile(apk_file, mode="r")as zfp:
+                with zfp.open("package-name.txt", "r") as pfp:
+                    return pfp.read().strip()
+
+        pkg_name = "test-package.blah.foo\n"
+        session = ADBSession("127.0.0.1")
+        session.get_package_name = _fake_get_package_name
+        # connect and do not enable root
+        self.assertTrue(session.connect())
+        with self.assertRaises(IOError):
+            session.install("fake_path")
+
+        pkg_file = os.path.join(self.tmpdir, "package-name.txt")
+        apk_file = os.path.join(self.tmpdir, "test.apk")
+        syms_path = os.path.join(self.tmpdir, "symbols")
+        os.makedirs(syms_path)
+        with open(pkg_file, "w") as out_fp:
+            out_fp.write(pkg_name)
+        with zipfile.ZipFile(apk_file, mode="w")as z_out:
+            z_out.write(pkg_file, "package-name.txt")
+        self.assertFalse(session.symbols_path(apk_file))
+        self.assertTrue(session.install(apk_file))
+        session.symbols[apk_file] = syms_path
+        self.assertEqual(session.symbols_path(apk_file), syms_path)
+        session.disconnect()
+        # TODO: test failed to install, failed to get package name
+
+    def test_09(self):
+        "test uninstall()"
+        session = ADBSession("127.0.0.1")
+        self.assertFalse(session.uninstall("org.test.unknown"))
+        self.assertTrue(session.connect())
+        self.assertTrue(session.uninstall("org.test.unknown"))
+        self.assertTrue(session.uninstall("org.test.preinstalled"))
+        session.disconnect()
+
+    def test_10(self):
+        "test get_pid()"
+        session = ADBSession("127.0.0.1")
+        with self.assertRaises(ADBSessionError):
+            session.get_pid("org.test.unknown")
+        self.assertTrue(session.connect())
+        self.assertIsNone(session.get_pid("org.test.unknown"))
+        self.assertEqual(session.get_pid("org.test.preinstalled"), 1337)
+        session.disconnect()
+
+    def test_11(self):
+        "test is_installed()"
+        session = ADBSession("127.0.0.1")
+        self.assertTrue(session.connect())
+        self.assertFalse(session.is_installed("org.test.unknown"))
+        self.assertTrue(session.is_installed("org.test.preinstalled"))
+        session.disconnect()
+
+    def test_12(self):
+        "test get_packages()"
+        session = ADBSession("127.0.0.1")
+        self.assertTrue(session.connect())
+        pkgs = session.get_packages()
+        self.assertEqual(len(pkgs), 4)
+        self.assertNotIn("org.test.unknown", pkgs)
+        self.assertIn("org.test.preinstalled", pkgs)
+        session.disconnect()
+
+    def test_13(self):
+        "test collect_logs()"
+        session = ADBSession("127.0.0.1")
+        self.assertTrue(session.connect())
+        self.assertEqual(len(session.collect_logs().splitlines()), 16)
+        self.assertEqual(len(session.collect_logs(9990).splitlines()), 11)
+        self.assertEqual(len(session.collect_logs(1111).splitlines()), 0)
+        session.disconnect()
+
+    def test_14(self):
+        "test get_open_files()"
+        session = ADBSession("127.0.0.1")
+        self.assertTrue(session.connect())
+        # list all open files
+        self.assertEqual(len(session.get_open_files()), 7)
+        # list process specific open files
+        self.assertEqual(len(session.get_open_files(pid=9990)), 5)
+        # list process and children specific open files
+        self.assertEqual(len(session.get_open_files(pid=9990, children=True)), 6)
+        with self.assertRaises(AssertionError):
+            session.get_open_files(pid=None, children=True)
+        session.disconnect()
+
+    def test_15(self):
+        "test _get_procs()"
+        session = ADBSession("127.0.0.1")
+        self.assertTrue(session.connect())
+        self.assertEqual(len(session._get_procs()), 10)  # pylint: disable=protected-access
+        dev_procs = session._get_procs(pid_children=9990)  # pylint: disable=protected-access
+        self.assertTrue(len(dev_procs), 1)
+        self.assertEqual(dev_procs[0].pid, 9991)
+        session.disconnect()
+
+    def test_16(self):
+        "test push()"
+        session = ADBSession("127.0.0.1")
+        self.assertTrue(session.connect())
+        with self.assertRaises(IOError):
+            session.push("not_a_file", "dst")
+        self.assertTrue(session.push(ADBSession.BIN_ADB, "dst"))
+        session.disconnect()
+
+    def test_17(self):
+        "test pull()"
+        session = ADBSession("127.0.0.1")
+        self.assertTrue(session.connect())
+        self.assertTrue(session.pull("src", "dst"))
+        session.disconnect()
+
+    def test_18(self):
+        "test clear_log()"
+        session = ADBSession("127.0.0.1")
+        self.assertTrue(session.connect())
+        self.assertTrue(session.clear_logs())
+        session.disconnect()
+
+    def test_19(self):
+        "test listdir()"
+        session = ADBSession("127.0.0.1")
+        self.assertTrue(session.connect())
+        with self.assertRaises(IOError):
+            session.listdir("missing-dir")
+        dir_list = session.listdir("fake-dir")
+        self.assertEqual(len(dir_list), 1)
+        self.assertIn("test", session.listdir("fake-dir"))
+        session.disconnect()
+
+    def test_20(self):
+        "test process_exists()"
+        session = ADBSession("127.0.0.1")
+        self.assertTrue(session.connect())
+        self.assertTrue(session.process_exists(9990))
+        session.disconnect()
+
+# TODO:
+# reverse
+
+
+class ADBProcessTests(unittest.TestCase):  # pylint: disable=too-many-public-methods
+
+    def setUp(self):
+        ADBSession.BIN_ADB = os.path.join(CWD, "fake_adb.py")
+        if os.path.isfile(FakeADBState.STATE_FILE):
+            os.remove(FakeADBState.STATE_FILE)
+        self.tmpdir = tempfile.mkdtemp(prefix="adbdev_test")
+        self.session = ADBSession.create("127.0.0.1", 5566)
+
+    def tearDown(self):
+        if os.path.isdir(self.tmpdir):
+            shutil.rmtree(self.tmpdir)
+        if os.path.isfile(FakeADBState.STATE_FILE):
+            os.remove(FakeADBState.STATE_FILE)
+        self.session.disconnect()
+
+    def test_01(self):
+        "test creating a simple device"
+        test_pkg = "org.test.preinstalled"
+        proc = ADBProcess(test_pkg, self.session)
+        self.addCleanup(proc.cleanup)
+        self.assertTrue(isinstance(proc._session, ADBSession))  # pylint: disable=protected-access
+        self.assertEqual(proc._package, test_pkg)  # pylint: disable=protected-access
+        self.assertIsNone(proc.logs)
+        self.assertIsNone(proc.profile)
+        self.assertEqual(proc.reason, proc.RC_CLOSED)
+        self.assertIsNone(proc._pid)  # pylint: disable=protected-access
+        proc.close()
+        self.assertFalse(proc.logs)  # should not have logs
+
+    def test_02(self):
+        "test creating device with unknown package"
+        with self.assertRaises(ADBSessionError):
+            ADBProcess("org.test.unknown", self.session)
+
+    def test_03(self):
+        "test failed launch() and is_running()"
+        proc = ADBProcess("org.test.preinstalled", self.session)
+        self.addCleanup(proc.cleanup)
+        self.assertFalse(proc.is_running())
+        with self.assertRaises(ADBLaunchError):
+            proc.launch("fake.url")
+        self.assertFalse(proc.is_running())
+        proc.cleanup()
+        self.assertIsNone(proc.logs)
+
+    def test_04(self):
+        "test launch(), is_running() and is_healthy()"
+        proc = ADBProcess("org.mozilla.fennec_aurora", self.session)
+        self.addCleanup(proc.cleanup)
+        self.assertFalse(proc.is_running())
+        self.assertTrue(proc.launch("fake.url"))
+        self.assertTrue(proc.is_running())
+        self.assertTrue(proc.is_healthy())
+        proc.close()
+        self.assertIsNone(proc._pid)  # pylint: disable=protected-access
+        self.assertGreater(len(proc.logs), 0)
+
+    def test_05(self):
+        "test launch() with environment variables"
+        proc = ADBProcess("org.mozilla.fennec_aurora", self.session)
+        self.addCleanup(proc.cleanup)
+        env = {"test1":"1", "test2": "2"}
+        self.assertTrue(proc.launch("fake.url", env_mod=env))
+        self.assertTrue(proc.is_running())
+        proc.close()
+
+    def test_06(self):
+        "test wait_on_files()"
+        proc = ADBProcess("org.mozilla.fennec_aurora", self.session)
+        self.addCleanup(proc.cleanup)
+        self.assertTrue(proc.wait_on_files(["not_running"]))
+        self.assertTrue(proc.launch("fake.url"))
+        self.assertTrue(proc.wait_on_files([]))  # is running but empty list
+        self.assertFalse(proc.wait_on_files(
+            ["/system/fonts/Roboto-Regular.ttf"],
+            poll_rate=0.1,
+            timeout=0.3))
+        proc.close()
+
+# TODO:
+# _process_logs
+# save_logs
diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
new file mode 100644
index 00000000..6e24be53
--- /dev/null
+++ b/grizzly/target/adb_target.py
@@ -0,0 +1,143 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+import logging
+import os
+
+from ffpuppet import LaunchError
+
+from .adb_device import ADBProcess, ADBSession
+from .target import Target
+from .target_monitor import TargetMonitor
+
+__author__ = "Tyson Smith"
+__credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
+
+log = logging.getLogger("grizzly")  # pylint: disable=invalid-name
+
+
+class ADBTarget(Target):
+    def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, prefs, relaunch, **kwds):
+        super(ADBTarget, self).__init__(binary, extension, launch_timeout, log_limit,
+                                        memory_limit, prefs, relaunch)
+        self.forced_close = True  # app will not close itself on Android
+        self.use_rr = False
+
+        if kwds.pop("rr", False):
+            log.warning("ADBTarget ignoring 'rr': not supported")
+        if kwds.pop("valgrind", False):
+            log.warning("ADBTarget ignoring 'valgrind': not supported")
+        if kwds.pop("xvfb", False):
+            log.warning("ADBTarget ignoring 'xvfb': not supported")
+        if kwds:
+            log.warning("ADBTarget ignoring unsupported arguments: %s", ", ".join(kwds))
+
+        log.debug("opening a session and setting up the environment")
+        self._session = ADBSession.create(as_root=True)
+        if self._session is None:
+            raise RuntimeError("Could not create ADB Session!")
+        self._package = ADBSession.get_package_name(self.binary)
+        self._proc = ADBProcess(self._package, self._session)
+        self._session.symbols[self._package] = os.path.join(os.path.dirname(self.binary), "symbols")
+
+    def cleanup(self):
+        with self._lock:
+            if self._proc is not None:
+                self._proc.cleanup()
+            if self._session.connected:
+                self._session.reverse_remove()
+            self._session.disconnect()
+
+    def close(self):
+        with self._lock:
+            if self._proc is not None:
+                self._proc.close()
+
+    @property
+    def closed(self):
+        return self._proc.reason is not None
+
+    def detect_failure(self, ignored, was_timeout):
+        status = self.RESULT_NONE
+        is_healthy = self._proc.is_healthy()
+        # check if there has been a crash, hang, etc...
+        if not is_healthy or was_timeout:
+            if self._proc.is_running():
+                log.info("Terminating browser...")
+            self._proc.close()
+        # if something has happened figure out what
+        if not is_healthy:
+            if self._proc.reason == ADBProcess.RC_CLOSED:
+                log.info("target.close() was called")
+            elif self._proc.reason == ADBProcess.RC_EXITED:
+                log.info("Target closed itself")
+            else:
+                log.debug("failure detected")
+                status = self.RESULT_FAILURE
+        elif was_timeout:
+            log.debug("timeout detected, potential browser hang")
+            if ignored and "timeout" in ignored:
+                status = self.RESULT_IGNORED
+                log.info("Timed out")
+            else:
+                status = self.RESULT_FAILURE
+        return status
+
+    def launch(self, location, env_mod=None):
+        self.rl_countdown = self.rl_reset
+        env_mod = dict(env_mod or [])  # if passed, make a copy so modifications aren't passed out
+
+        # This may be used to disabled network connections during testing, e.g.
+        env_mod["MOZ_IN_AUTOMATION"] = "1"
+        # prevent crash reporter from touching the dmp files
+        env_mod["MOZ_CRASHREPORTER"] = "1"
+        env_mod["MOZ_CRASHREPORTER_NO_REPORT"] = "1"
+        env_mod["MOZ_CRASHREPORTER_SHUTDOWN"] = "1"
+        # do not allow network connections to non local endpoints
+        env_mod["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1"
+
+        try:
+            self._proc.launch(
+                env_mod=env_mod,
+                prefs_js=self.prefs,
+                url=location)
+        except LaunchError:
+            self._proc.close()
+            raise
+
+    @property
+    def monitor(self):
+        if self._monitor is None:
+            class _ADBMonitor(TargetMonitor):
+                # pylint: disable=no-self-argument,protected-access
+                def clone_log(_, *_a, **_k):  # pylint: disable=arguments-differ
+                    log_file = self._proc.clone_log()
+                    if log_file is None:
+                        return None
+                    try:
+                        with open(log_file, "rb") as log_fp:
+                            return log_fp.read()
+                    finally:
+                        os.remove(log_file)
+                def is_running(_):
+                    return self._proc.is_running()
+                def is_healthy(_):
+                    return self._proc.is_healthy()
+                @property
+                def launches(_):
+                    return self._proc.launches
+                def log_length(_, *_a):  # pylint: disable=arguments-differ
+                    # TODO: This needs to be implemented
+                    return 0
+
+            self._monitor = _ADBMonitor()
+
+        return self._monitor
+
+    def reverse(self, remote, local):
+        # remote->device, local->desktop
+        self._session.reverse(remote, local)
+
+    def save_logs(self, *args, **kwargs):
+        self._proc.save_logs(*args, **kwargs)
diff --git a/grizzly/target/test_adb_target.py b/grizzly/target/test_adb_target.py
new file mode 100644
index 00000000..9fd0afef
--- /dev/null
+++ b/grizzly/target/test_adb_target.py
@@ -0,0 +1,34 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+import os
+import tempfile
+import unittest
+
+from .adb_device import ADBSession
+from .adb_target import ADBTarget
+from .target import Target
+
+
+class ADBTargetTests(unittest.TestCase):
+    def setUp(self):
+        bin_path = os.path.join(os.path.dirname(__file__), "adb_device")
+        ADBSession.BIN_AAPT = os.path.join(bin_path, "fake_aapt.py")
+        ADBSession.BIN_ADB = os.path.join(bin_path, "fake_adb.py")
+        _fd, self.tmpfn = tempfile.mkstemp(prefix="grz_test_")
+        os.close(_fd)
+
+    def tearDown(self):
+        if os.path.isfile(self.tmpfn):
+            os.remove(self.tmpfn)
+
+    def test_01(self):
+        "test creating a simple ADBTarget"
+        target = ADBTarget(self.tmpfn, None, 300, 25, 5000, None, 25)
+        self.addCleanup(target.cleanup)
+        self.assertTrue(target.closed)
+        self.assertTrue(target.forced_close)
+        self.assertIsNotNone(target.monitor)
+        self.assertEqual(target.detect_failure([], None), Target.RESULT_NONE)
+        self.assertEqual(target.log_size(), 0)
+        target.check_relaunch()
diff --git a/setup.cfg b/setup.cfg
index 5bca3a14..b5a60c9c 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -47,6 +47,7 @@ console_scripts =
 grizzly_adapters =
     no-op = grizzly.adapter.no_op_adapter:NoOpAdapter
 grizzly_targets =
+    adb = grizzly.target.adb_target:ADBTarget
     ffpuppet = grizzly.target.puppet_target:PuppetTarget
 grizzly_reduce_strategies =
     attrs = grizzly.reduce.strategies.lithium:MinimizeAttrs

From 81dfcfa5ad75de5108c017d684958544337c23a2 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 29 May 2019 09:50:28 -0700
Subject: [PATCH 447/531] Add adb target/device launch timeout

---
 grizzly/target/adb_device/device.py | 15 ++++++++++++---
 grizzly/target/adb_target.py        |  3 ++-
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index 172b08fe..320cf597 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -631,7 +631,7 @@ def is_running(self):
         return self._session.process_exists(self._pid)
 
 
-    def launch(self, url, env_mod=None, extension=None, prefs_js=None):
+    def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=None):
         log.debug("launching %r", url)
         assert self._launches > -1, "clean_up() has been called"
         assert self._session, "Device not connected"
@@ -686,7 +686,7 @@ def launch(self, url, env_mod=None, extension=None, prefs_js=None):
                 cmd.append("env%d" % var_num)
                 cmd.append("%s=%s" % (var_name, var_val))
 
-            if "Status: ok" not in self._session.call(cmd)[1].splitlines():
+            if "Status: ok" not in self._session.call(cmd, timeout=launch_timeout)[1].splitlines():
                 raise ADBLaunchError("Could not launch %r" % self._package)
             self._pid = self._session.get_pid(self._package)
             bootstrapper.wait(self.is_healthy, url=url)
@@ -821,6 +821,15 @@ def wait(self):
 
 
 def main(argv=None):  # pylint: disable=missing-docstring
+    # set output verbosity
+    if bool(os.getenv("DEBUG")):
+        log_level = logging.DEBUG
+        log_fmt = "%(levelname).1s %(name)s [%(asctime)s] %(message)s"
+    else:
+        log_level = logging.INFO
+        log_fmt = "[%(asctime)s] %(message)s"
+    logging.basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
+
     parser = argparse.ArgumentParser(description="ADB Device Wrapper")
     parser.add_argument(
         "--airplane-mode", default=None, type=int,
@@ -866,7 +875,7 @@ def main(argv=None):  # pylint: disable=missing-docstring
             return 1
         proc = ADBProcess(package, session)
         try:
-            proc.launch("about:blank")
+            proc.launch("about:blank", launch_timeout=60)
             assert proc.is_running(), "browser not running?!"
             log.info("Launched")
             proc.wait()
diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index 6e24be53..e6f031dc 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -86,7 +86,7 @@ def detect_failure(self, ignored, was_timeout):
 
     def launch(self, location, env_mod=None):
         self.rl_countdown = self.rl_reset
-        env_mod = dict(env_mod or [])  # if passed, make a copy so modifications aren't passed out
+        env_mod = dict(env_mod or [])
 
         # This may be used to disabled network connections during testing, e.g.
         env_mod["MOZ_IN_AUTOMATION"] = "1"
@@ -100,6 +100,7 @@ def launch(self, location, env_mod=None):
         try:
             self._proc.launch(
                 env_mod=env_mod,
+                launch_timeout=self.launch_timeout,
                 prefs_js=self.prefs,
                 url=location)
         except LaunchError:

From 93b051705dbf9d0ca1cb7aab5ff09d31561166a0 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Fri, 7 Jun 2019 17:03:23 -0400
Subject: [PATCH 448/531] Fixes for --install-asan

---
 grizzly/target/adb_device/device.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index 320cf597..fcfa95df 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -378,7 +378,7 @@ def install_asan(self, ndk_base, asan_options=None):
             shutil.rmtree(tmpd, ignore_errors=True)
 
         llvm_symer = os.path.join(
-            ndk_base, "toolchains", "llvm", "prebuilt", "android-x86_64",
+            ndk_base, "prebuilt", "android-x86_64",
             "llvm-symbolizer", "llvm-symbolizer")
         self.install_file(llvm_symer, "/system/bin", "755", ctx)
 
@@ -389,7 +389,7 @@ def install_asan(self, ndk_base, asan_options=None):
         self.call(["shell", "cp", "/system/bin/sh", "/system/bin/sh-from-zygote"])
         self.call(["shell", "chcon", ctx, "/system/bin/sh-from-zygote"])
 
-        self.call(["shell", "setenforce", "1"])
+        # restart the zygote
         self.call(["shell", "stop"])
         self.call(["shell", "start"])
 

From 922f8ba09eb1d7365f4b083845cca4be4d548fbe Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 24 Jul 2019 15:14:44 -0700
Subject: [PATCH 449/531] Update adb device tests and split up files

---
 grizzly/target/adb_device/adb_process.py      | 304 +++++++
 grizzly/target/adb_device/adb_session.py      | 805 +++++++++++++++++
 grizzly/target/adb_device/device.py           | 821 +-----------------
 grizzly/target/adb_device/test_adb_process.py | 117 +++
 grizzly/target/adb_device/test_adb_session.py | 618 +++++++++++++
 grizzly/target/adb_device/test_device.py      | 385 --------
 6 files changed, 1850 insertions(+), 1200 deletions(-)
 create mode 100644 grizzly/target/adb_device/adb_process.py
 create mode 100644 grizzly/target/adb_device/adb_session.py
 create mode 100644 grizzly/target/adb_device/test_adb_process.py
 create mode 100644 grizzly/target/adb_device/test_adb_session.py
 delete mode 100644 grizzly/target/adb_device/test_device.py

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
new file mode 100644
index 00000000..f808785e
--- /dev/null
+++ b/grizzly/target/adb_device/adb_process.py
@@ -0,0 +1,304 @@
+import logging
+import os
+import random
+import shutil
+import tempfile
+import time
+
+from ffpuppet.helpers import append_prefs, Bootstrapper, create_profile
+from ffpuppet.minidump_parser import process_minidumps
+from ffpuppet.puppet_logger import PuppetLogger
+
+from .adb_session import ADBSession
+
+log = logging.getLogger("adb_device")  # pylint: disable=invalid-name
+
+__author__ = "Tyson Smith"
+__credits__ = ["Tyson Smith"]
+
+
+class ADBCommandError(RuntimeError):
+    pass
+
+class ADBSessionError(RuntimeError):
+    pass
+
+class ADBLaunchError(ADBSessionError):
+    pass
+
+class ADBNoDevice(ADBSessionError):
+    pass
+
+
+class ADBProcess(object):
+    # TODO: reason codes match FFPuppet
+    RC_ALERT = "ALERT"  # target crashed/aborted/triggered an assertion failure etc...
+    RC_CLOSED = "CLOSED"  # target was closed by call to FFPuppet close()
+    RC_EXITED = "EXITED"  # target exited
+    #RC_WORKER = "WORKER"  # target was closed by worker thread
+    # TODO: 
+    #  def save_logs(self, *args, **kwargs):
+    #  def clone_log(self, log_id, offset=0):
+    #  def log_data(self, log_id, offset=0):
+    #  def log_length(self, log_id):... likely not going to happen because of overhead
+    def __init__(self, package_name, session, use_profile=None):
+        assert isinstance(session, ADBSession), "Expecting ADBSession"
+        if not session.is_installed(package_name):
+            raise ADBSessionError("Package %r not installed" % package_name)
+        self._launches = 0  # number of successful browser launches
+        self._package = package_name  # package to use as target process
+        self._pid = None  # pid of current target process
+        self._profile_template = use_profile  # profile that is used as a template
+        self._session = session  # ADB session with device
+        self._working_path = "/sdcard/ADBProc_%08X" % random.getrandbits(32)
+        self.logs = None
+        self.profile = None
+        self.reason = self.RC_CLOSED
+
+    def cleanup(self):
+        if self._launches < 0:
+            log.debug("clean_up() call ignored")
+            return
+        if self.reason is None:
+            self.close()
+        self._remove_logs()
+        # negative 'self._launches' indicates clean_up() has been called
+        self._launches = -1
+
+    def clone_log(self):
+        # TODO: dump logs for all browser processes
+        if self._session is None:
+            # TODO: better error?
+            return "ADB session does not exist!"
+        return self._session.collect_logs(pid=self._pid)
+
+    def close(self):
+        assert self._launches > -1, "clean_up() has been called"
+        if self.reason is not None:
+            log.debug("already closed!")
+            return
+        try:
+            if self._session is not None:
+                crash_reports = self.find_crashreports()
+                # set reason code
+                if crash_reports:
+                    self.reason = self.RC_ALERT
+                    self.wait_on_files(crash_reports)
+                elif self.is_running():
+                    self.reason = self.RC_CLOSED
+                else:
+                    self.reason = self.RC_EXITED
+                self._terminate()
+                self.wait()
+                self._process_logs(crash_reports)
+                self._session.call(["shell", "rm", "-rf", self._working_path])
+        except ADBSessionError:
+            log.warning("No device detected while closing process")
+        self._pid = None
+        self.profile = None
+        if self.reason is None:
+            self.reason = self.RC_CLOSED
+
+    def find_crashreports(self):
+        reports = list()
+        # TODO: Add ASan support
+        if self.profile:
+            # check for minidumps
+            md_path = os.path.join(self.profile, "minidumps")
+            try:
+                contents = self._session.listdir(md_path)
+                for fname in contents:
+                    if ".dmp" in fname or ".extra" in fname:
+                        reports.append(os.path.join(md_path, fname))
+            except IOError:
+                log.debug("%s does not exist", md_path)
+
+        return reports
+
+    def is_healthy(self):
+        if not self.is_running():
+            return False
+        return not self.find_crashreports()
+
+    def is_running(self):
+        assert self._session, "Device not connected"
+        assert self._package, "Package not specified"
+        if self._pid is None or self.reason is not None:
+            return False
+        return self._session.process_exists(self._pid)
+
+    def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=None):
+        log.debug("launching %r", url)
+        assert self._launches > -1, "clean_up() has been called"
+        assert self._session, "Device not connected"
+        assert self._package, "Package not specified"
+        assert self._pid is None, "Process is already running"
+        assert self.reason is not None, "Process is already running"
+
+        self._session.clear_logs()
+        self._remove_logs()
+        self.reason = None
+        local_profile = create_profile(
+            extension=extension,
+            prefs_js=prefs_js,
+            template=self._profile_template)
+
+        bootstrapper = Bootstrapper(poll_wait=0.5)
+        try:
+            try:
+                prefs = {
+                    "capability.policy.policynames": "'localfilelinks'",
+                    "capability.policy.localfilelinks.sites": "'%s'" % bootstrapper.location,
+                    "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'"}
+                append_prefs(local_profile, prefs)
+                self.profile = "/".join([self._working_path, os.path.basename(local_profile)])
+                if os.listdir(local_profile):
+                    if not self._session.push(local_profile, self.profile):
+                        raise ADBLaunchError("Could not upload %r" % local_profile)
+                else:
+                    log.debug("creating empty profile on device: %s", self.profile)
+                    self._session.call(["shell", "mkdir", "-p", self.profile])
+            finally:
+                if os.path.exists(local_profile):
+                    shutil.rmtree(local_profile) # TODO: temporary
+            if not self._session.reverse(bootstrapper.port, bootstrapper.port):
+                raise ADBLaunchError("Could not reverse port: %d" % bootstrapper.port)
+            cmd = [
+                "shell", "am", "start", "-W", "-n",
+                "/".join([self._package, "org.mozilla.gecko.BrowserApp"]),
+                "-a", "android.intent.action.VIEW", "-d", bootstrapper.location,
+                "--es", "args", "-profile\\ %s" % self.profile]
+
+            env_mod = dict(env_mod or {})
+            env_mod.setdefault("MOZ_SKIA_DISABLE_ASSERTS", "1")
+            for var_num, (var_name, var_val) in enumerate(env_mod.items()):
+                if var_val is None:
+                    continue
+                cmd.append("--es")
+                cmd.append("env%d" % var_num)
+                cmd.append("%s=%s" % (var_name, var_val))
+
+            if "Status: ok" not in self._session.call(cmd, timeout=launch_timeout)[1].splitlines():
+                raise ADBLaunchError("Could not launch %r" % self._package)
+            self._pid = self._session.get_pid(self._package)
+            bootstrapper.wait(self.is_healthy, url=url)
+        finally:
+            self._session.reverse_remove(bootstrapper.port)
+            bootstrapper.close()
+        self._launches += 1
+
+        return self._pid is not None
+
+    @property
+    def launches(self):
+        """
+        Get the number of successful launches
+
+        @rtype: int
+        @return: successful launch count
+        """
+
+        assert self._launches > -1, "clean_up() has been called"
+        return self._launches
+
+    def _process_logs(self, crash_reports):
+        assert self.logs is None
+        self.logs = tempfile.mkdtemp(prefix="adb_logs_")
+        unprocessed = os.path.join(self.logs, "unprocessed")
+        os.mkdir(unprocessed)
+
+        with open(os.path.join(self.logs, "log_logcat.txt"), "wb") as log_fp:
+            # TODO: should this filter by pid or not?
+            log_fp.write(self._session.collect_logs())
+            #log_fp.write(self._session.collect_logs(pid=self._pid))
+
+        if not crash_reports:
+            return
+
+        # copy crash logs from the device
+        for fname in crash_reports:
+            self._session.pull(fname, unprocessed)
+
+        logger = PuppetLogger()
+        try:
+            syms_path = self._session.symbols_path(self._package)
+            process_minidumps(unprocessed, syms_path, logger.add_log)
+            logger.close()
+            logger.save_logs(self.logs)
+        finally:
+            logger.clean_up()
+
+    def _remove_logs(self):
+        if self.logs is not None and os.path.isdir(self.logs):
+            shutil.rmtree(self.logs)
+            self.logs = None
+
+    @staticmethod
+    def _split_logcat(log_path):
+        # Roughly split out stderr and stdout from logcat
+        # This is to support FuzzManager. The original logcat output is also
+        # included in the report so nothing is lost.
+        logcat = os.path.join(log_path, "log_logcat.txt")
+        if not os.path.isfile(logcat):
+            log.warning("log_logcat.txt does not exist!")
+            return
+        err_log = os.path.join(log_path, "log_stderr.txt")
+        if os.path.isfile(err_log):
+            log.warning("log_stderr.txt already exist! Overwriting...")
+        out_log = os.path.join(log_path, "log_stdout.txt")
+        if os.path.isfile(out_log):
+            log.warning("log_stdout.txt already exist! Overwriting...")
+        with open(logcat, "rb") as lc_fp, open(err_log, "w") as e_fp, open(out_log, "w") as o_fp:
+            for line in lc_fp:
+                if b"Gecko" not in line and b"MOZ_" not in line:
+                    continue
+                line = line[33:].decode("ascii", "ignore")
+                if line.startswith("GeckoDump"):
+                    o_fp.write(line.split(": ", 1)[-1])
+                elif line.startswith("Gecko") or line.startswith("MOZ_"):
+                    e_fp.write(line.split(": ", 1)[-1])
+
+    def save_logs(self, log_path, meta=False):
+        assert self.logs is not None
+        assert self.reason is not None, "Call close() first!"
+        assert self._launches > -1, "clean_up() has been called"
+        # copy logs to location specified by log_file
+        if not os.path.isdir(log_path):
+            os.makedirs(log_path)
+        log_path = os.path.abspath(log_path)
+
+        for fname in os.listdir(self.logs):
+            full_name = os.path.join(self.logs, fname)
+            # skip directories
+            if not os.path.isfile(full_name):
+                continue
+            shutil.copy(full_name, log_path)
+        self._split_logcat(log_path)
+
+    def wait_on_files(self, wait_files, poll_rate=0.5, timeout=60):
+        assert poll_rate >= 0, "Invalid poll_rate %d, must be greater than or equal to 0" % poll_rate
+        assert timeout >= 0, "Invalid timeout %d, must be greater than or equal to 0" % timeout
+        assert poll_rate <= timeout, "poll_rate must be less then or equal to timeout"
+        wait_end = time.time() + timeout
+        wait_files = set(self._session.realpath(x) for x in wait_files)
+
+        while wait_files:
+            open_files = set(x for _, x in self._session.get_open_files())
+            # check if any open files are in the wait file list
+            if not wait_files.intersection(open_files):
+                break
+            elif wait_end <= time.time():
+                log.debug("Timeout waiting for: %s", ", ".join(x for x in open_files if x in wait_files))
+                return False
+            time.sleep(poll_rate)
+        return True
+
+    def _terminate(self):
+        assert self._package is not None
+        assert self._session, "Device not connected"
+        # TODO: is this the best way???
+        self._session.call(["shell", "am", "force-stop", self._package])
+
+    def wait(self):
+        while self.is_running():
+            time.sleep(0.25)
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
new file mode 100644
index 00000000..80b23e95
--- /dev/null
+++ b/grizzly/target/adb_device/adb_session.py
@@ -0,0 +1,805 @@
+import argparse
+import logging
+import os
+import random
+import shutil
+import socket
+import subprocess
+import sys
+import tempfile
+import time
+
+from ffpuppet.helpers import append_prefs, Bootstrapper, create_profile
+from ffpuppet.minidump_parser import process_minidumps
+from ffpuppet.puppet_logger import PuppetLogger
+
+log = logging.getLogger("adb_device")  # pylint: disable=invalid-name
+
+__author__ = "Tyson Smith"
+__credits__ = ["Tyson Smith"]
+
+
+# TODO:
+# - Add ability to collect ASan logs
+
+
+class DeviceProcess(object):
+    def __init__(self, memory, name, pid, ppid):
+        self.memory = memory
+        self.name = name
+        self.pid = pid
+        self.ppid = ppid
+
+    @classmethod
+    def from_ps_line(cls, line):
+        try:
+            _, pid, ppid, _, memory, _, _, _, name = line.split()
+        except ValueError:
+            log.debug("invalid ps line %r", line)
+            return None
+        try:
+            return cls(int(memory), name, int(pid), int(ppid))
+        except ValueError:
+            log.debug("invalid ps line values")
+            return None
+
+
+class ADBCommandError(RuntimeError):
+    pass
+
+class ADBSessionError(RuntimeError):
+    pass
+
+class ADBLaunchError(ADBSessionError):
+    pass
+
+class ADBNoDevice(ADBSessionError):
+    pass
+
+
+class ADBSession(object):
+    BIN_AAPT = None
+    BIN_ADB = None
+
+    def __init__(self, ip_addr=None, port=5555):
+        self.connected = False
+        self.symbols = dict()
+        self._root = False
+        self._ip_addr = None  # target device IP address
+        self._port = None  # ADB listening port
+
+        log.debug("creating IP based session: %r", ip_addr is not None)
+        if ip_addr is not None:
+            try:
+                if ip_addr != "localhost":
+                    socket.inet_aton(ip_addr)
+            except (socket.error, TypeError):
+                raise ValueError("IP Address is invalid")
+            self._ip_addr = ip_addr
+            if not isinstance(port, int) or not (port > 1024 and port < 0x10000):
+                raise ValueError("Port must be valid integer between 1025 and 65535")
+            self._port = port
+
+        suggested_adb = os.path.expanduser("~/.android/sdk/platform-tools/adb")
+        if self.BIN_ADB is None:
+            if os.path.isfile(suggested_adb):
+                self.BIN_ADB = suggested_adb
+            else:
+                try:
+                    self.BIN_ADB = subprocess.check_output(["which", "adb"]).strip()
+                except subprocess.CalledProcessError:
+                    raise EnvironmentError("Please install ADB")
+            # TODO: update this to check adb version
+            if os.path.realpath(self.BIN_ADB) != os.path.realpath(suggested_adb):
+                log.warning("You are not using the recommended ADB install!")
+                log.warning("Either run the setup script or proceed with caution.")
+                time.sleep(5)
+
+
+    @classmethod
+    def create(cls, ip_addr=None, port=5555, as_root=True, max_attempts=10):
+        session = cls(ip_addr, port)
+        if session.connect(as_root=as_root, max_attempts=max_attempts):
+            return session
+        return None
+
+
+    @staticmethod
+    def _call_adb(cmd, timeout=None):
+        with tempfile.TemporaryFile() as out_fp:
+            if timeout is not None:
+                assert timeout > 0
+                end_time = time.time() + timeout
+                adb_proc = subprocess.Popen(cmd, stderr=out_fp, stdout=out_fp)
+                while adb_proc.poll() is None:
+                    time.sleep(0.05)
+                    if time.time() > end_time:
+                        log.warning("adb call timeout!")
+                        adb_proc.terminate()
+                        break
+                ret_code = adb_proc.wait()
+            else:
+                ret_code = subprocess.call(cmd, stderr=out_fp, stdout=out_fp)
+            out_fp.seek(0)
+            return ret_code, out_fp.read().decode("utf-8", "ignore").strip()
+
+
+    def call(self, cmd, require_device=True, timeout=None):
+        assert isinstance(cmd, list) and cmd
+        cmd = [self.BIN_ADB] + cmd
+        log.debug("calling: %s", " ".join(cmd))
+        if not self.connected and cmd[1] not in ("connect", "devices", "disconnect"):
+            raise ADBSessionError("ADB session is not connected!")
+        ret_code, output = self._call_adb(cmd, timeout=timeout)
+        log.debug("=== adb start ===\n%s\n=== adb end, returned %d ===", output, ret_code)
+        if ret_code != 0:
+            if output.startswith("Android Debug Bridge version"):
+                raise ADBCommandError("Invalid ADB command '%s'" % " ".join(cmd[1:]))
+            if output.startswith("adb: usage:"):
+                raise ADBCommandError(output.strip())
+            if require_device and (output.startswith("error: closed") or
+                                   output.startswith("error: device offline") or
+                                   output.startswith("error: no devices/emulators found")):
+                self.connected = False
+                raise ADBNoDevice("No device detected!")
+        return (ret_code, output)
+
+
+    def clear_logs(self):
+        log.debug("clear_logs()")
+        return self.call(["logcat", "--clear"], timeout=10)[0] == 0
+
+
+    def connect(self, as_root=True, max_attempts=10):
+        max_attempts = max(1, max_attempts)
+        attempt = 0
+        root_called = False
+        while attempt < max_attempts:
+            attempt += 1
+            if not self.connected and self._ip_addr is not None:
+                addr = ":".join([self._ip_addr, str(self._port)])
+                log.debug("connecting to %s", addr)
+                if self.call(["connect", addr])[0] != 0:
+                    log.warning("connection attempt #%d failed", attempt)
+                    time.sleep(0.25)
+                    continue
+            elif not self._devices_available(self.call(["devices"])[1]):
+                log.warning("No device detected (attempt %d/%d)", attempt, max_attempts)
+                time.sleep(1)
+                continue
+            self.connected = True
+
+            # verify we are connected
+            ret_code, user = self.call(["shell", "whoami"], require_device=False)
+            if (ret_code != 0 or not user) and attempt < max_attempts:
+                time.sleep(0.25)
+                continue
+
+            if ret_code != 0 or not user:
+                raise ADBSessionError("Device in a bad state, try disconnect & reboot")
+            user = user.splitlines()[-1]
+            if user == "root":
+                self._root = True
+
+            if not as_root or self._root:
+                break  # connected
+
+            # enable root
+            assert as_root, "Should not be here if root is not requested"
+            if self.call(["root"])[0] == 0:
+                self.connected = False
+                if not root_called:
+                    root_called = True
+                    attempt -= 1  # remove attempt used to call root
+                    continue
+
+            time.sleep(0.25)  # wait for adbd to restart on device
+
+        if self.connected and as_root and not self._root:
+            raise ADBSessionError("Could not enable root")
+
+        if self.connected and self._root:
+            self.set_enforce(0)
+
+        return self.connected
+
+
+    def collect_logs(self, pid=None):
+        log.debug("collect_logs()")
+        if not self.connected:
+            log.debug("device not connected cannot collect logs")
+            return ""
+        cmd = ["logcat", "-d", "*:I"]
+        if pid is not None:
+            cmd += ["--pid=%d" % pid]
+        return self.call(cmd, timeout=10)[1].encode("utf-8", "ignore")
+
+
+    @staticmethod
+    def _devices_available(adb_output):
+        entries = adb_output.strip().splitlines()
+        if len(entries) < 2:
+            return False
+        return entries[-1].endswith("device")
+
+
+    def disconnect(self, unroot=True):
+        if not self.connected:
+            log.debug("already disconnected")
+            return True
+        if self._root and unroot:
+            try:
+                if self.call(["unroot"])[0] == 0:
+                    self.connected = False
+                    self._root = False
+                    return True
+                log.warning("'unroot' failed")
+            except ADBCommandError:
+                log.warning("'unroot' not support by ADB")
+        elif self._ip_addr is not None:
+            self.call(["disconnect", ":".join([self._ip_addr, str(self._port)])])
+        self.connected = False
+        return True
+
+
+    def listdir(self, path):
+        log.debug("listdir(%r)", path)
+        ret_val, output = self.call(["shell", "ls", "-A", path])
+        if ret_val != 0:
+            raise IOError("%r does not exist" % path)
+        return output.splitlines()
+
+
+    def realpath(self, path):
+        log.debug("realpath(%r)", path)
+        ret_val, output = self.call(["shell", "realpath", path])
+        if ret_val != 0:
+            raise IOError("%r does not exist" % path)
+        return output.strip()
+
+
+    def reverse(self, remote, local):
+        # remote->device, local->desktop
+        assert isinstance(local, int) and local > 1024 and local < 0x10000
+        assert isinstance(remote, int) and remote > 1024 and remote < 0x10000
+        return self.call(["reverse", "tcp:%d" % remote, "tcp:%d" % local])[0] == 0
+
+
+    def reverse_remove(self, remote=None):
+        # remote->device
+        cmd = ["reverse"]
+        if remote is not None:
+            assert isinstance(remote, int) and remote > 1024 and remote < 0x10000
+            cmd.append("--remove")
+            cmd.append("tcp:%d" % remote)
+        else:
+            cmd.append("--remove-all")
+        return self.call(cmd)[0] == 0
+
+
+    def uninstall(self, package):
+        if not self.connected:
+            log.debug("already disconnected")
+            return False
+        return self.call(["uninstall", package], timeout=60)[0] == 0
+
+
+    def install(self, apk_path):
+        log.debug("installing %r", apk_path)
+        if not os.path.isfile(apk_path):
+            raise IOError("APK does not exist %r" % apk_path)
+        # check if package is installed
+        if self.call(["install", "-r", apk_path], timeout=120)[0] != 0:
+            raise ADBSessionError("Failed to install %r" % apk_path)
+
+        # unpack and lookup package name
+        package_name = self.get_package_name(apk_path)
+
+        # set permissions
+        self.call(["shell", "pm", "grant", package_name, "android.permission.READ_EXTERNAL_STORAGE"])
+        self.call(["shell", "pm", "grant", package_name, "android.permission.WRITE_EXTERNAL_STORAGE"])
+
+        log.debug("installed package %r (%r)", package_name, apk_path)
+        return package_name
+
+
+    def install_file(self, src, dst, mode=None, context=None):
+        basename = os.path.basename(src)
+        full_dst = os.path.join(dst, basename)
+        self.push(src, full_dst)
+        self.call(["shell", "chown", "root.shell", full_dst])
+        if mode is not None:
+            self.call(["shell", "chmod", mode, full_dst])
+        if context is not None:
+            self.call(["shell", "chcon", context, full_dst])
+
+
+    @staticmethod
+    def get_package_name(apk_path):
+        # unpack and lookup package name
+        aapt = ADBSession.BIN_AAPT
+        if aapt is None:
+            aapt = os.path.expanduser("~/.android/sdk/android-9/aapt")
+            if not os.path.isfile(aapt):
+                # fall back to system version
+                aapt = subprocess.check_output(["which", "aapt"]).strip()
+        apk_info = subprocess.check_output([aapt, "dump", "badging", apk_path])
+        for line in apk_info.splitlines():
+            if line.startswith("package: name="):
+                package_name = line.split()[1][5:].strip("'")
+                break
+        else:
+            raise RuntimeError("Could not find APK package name")
+        return package_name
+
+
+    def get_packages(self):
+        # TODO: should this be by pid or package?
+        cmd = ["shell", "pm", "list", "packages"]
+        return [line[8:] for line in self.call(cmd)[1].splitlines() if line.startswith("package:")]
+
+
+    def get_open_files(self, pid=None, children=False, files=None):
+        log.debug("get_open_files(pid=%r, children=%r, files=%r", pid, children, files)
+        pids = list()
+        if pid is not None:
+            pids.append(str(pid))
+        if children:
+            assert pid is not None, "Cannot request child open files without specifying pid"
+            for proc in self._get_procs(pid_children=pid):
+                pids.append(str(proc.pid))
+        cmd = ["shell", "lsof"]
+        if pids:
+            cmd += ["-p", ",".join(pids)]
+        if files:
+            cmd.extend(list(files))
+        open_files = list()
+        for line in self.call(cmd)[1].splitlines():
+            if line.endswith("Permission denied)"):
+                continue
+            # I believe we only care about regular files
+            if " REG " not in line:
+                continue
+            try:
+                file_info = line.split()
+                file_name = file_info[-1]
+                if pid is not None and file_info[1] not in pids:
+                    continue
+                # add tuple containing pid and filename
+                open_files.append((int(file_info[1]), file_name))
+            except ValueError:
+                pass
+
+        return open_files
+
+
+    def get_pid(self, package_name):
+        # NOTE: pidof is not supported pre-Android 6
+        procs = self._get_procs()
+        pids = [proc.pid for proc in procs if proc.name == package_name]
+        if not pids:
+            return None
+        count = len(pids)
+        if count > 1:
+            log.debug("get_pid() %d proc(s) found", count)
+            # TODO: use procs and use the ppid of the procs the determine the parent
+            pids.sort()
+        return int(pids[0])
+
+
+    def process_exists(self, pid):
+        return bool(self._get_procs(pid=pid))
+
+
+    def _get_procs(self, pid=None, pid_children=None):
+        # default list all procs
+        cmd = ["shell", "ps"]
+        if pid is not None:
+            cmd.append(str(pid))
+        if pid_children is not None:
+            cmd += ["--ppid", str(pid_children)]
+        procs = list()
+        for line in self.call(cmd)[1].splitlines()[1:]:
+            proc = DeviceProcess.from_ps_line(line)
+            if proc is not None:
+                procs.append(proc)
+        return procs
+
+
+    def is_installed(self, package_name):
+        return package_name in self.get_packages()
+
+
+    def pull(self, src, dst):
+        log.debug("pull(%r, %r)", src, dst)
+        return self.call(["pull", src, dst])[0] == 0
+
+
+    def push(self, src, dst):
+        log.debug("push(%r, %r)", src, dst)
+        if not os.path.exists(src):
+            raise IOError("%r does not exist" % src)
+        return self.call(["push", src, dst])[0] == 0
+
+
+    def symbols_path(self, package_name):
+        return self.symbols.get(package_name, "")
+
+
+    def set_airplane_mode(self, mode=True):
+        cmd = ["shell", "settings", "put", "global", "airplane_mode_on"]
+        cmd += ["1" if mode else "0"]
+        self.call(cmd)
+        cmd = ["shell", "su", "root", "am", "broadcast", "-a", "android.intent.action.AIRPLANE_MODE"]
+        self.call(cmd)
+
+    def set_enforce(self, value):
+        assert value in (0, 1)
+        is_set = self.call(["shell", "getenforce"])[1] == "Enforcing"
+        if (is_set and value == 0) or (not is_set and value == 1):
+            self.call(["shell", "setenforce", str(value)])
+            self.call(["shell", "stop"])
+            self.call(["shell", "start"])
+
+
+class ADBProcess(object):
+    # TODO: reason codes match FFPuppet
+    RC_ALERT = "ALERT"  # target crashed/aborted/triggered an assertion failure etc...
+    RC_CLOSED = "CLOSED"  # target was closed by call to FFPuppet close()
+    RC_EXITED = "EXITED"  # target exited
+    #RC_WORKER = "WORKER"  # target was closed by worker thread
+    # TODO: 
+    #  def save_logs(self, *args, **kwargs):
+    #  def clone_log(self, log_id, offset=0):
+    #  def log_data(self, log_id, offset=0):
+    #  def log_length(self, log_id):... likely not going to happen because of overhead
+    def __init__(self, package_name, session, use_profile=None):
+        assert isinstance(session, ADBSession), "Expecting ADBSession"
+        if not session.is_installed(package_name):
+            raise ADBSessionError("Package %r not installed" % package_name)
+        self._launches = 0  # number of successful browser launches
+        self._package = package_name  # package to use as target process
+        self._pid = None  # pid of current target process
+        self._profile_template = use_profile  # profile that is used as a template
+        self._session = session  # ADB session with device
+        self._working_path = "/sdcard/ADBProc_%08X" % random.getrandbits(32)
+        self.logs = None
+        self.profile = None
+        self.reason = self.RC_CLOSED
+
+
+    def cleanup(self):
+        if self._launches < 0:
+            log.debug("clean_up() call ignored")
+            return
+        if self.reason is None:
+            self.close()
+        self._remove_logs()
+        # negative 'self._launches' indicates clean_up() has been called
+        self._launches = -1
+
+
+    def clone_log(self):
+        # TODO: dump logs for all browser processes
+        if self._session is None:
+            # TODO: better error?
+            return "ADB session does not exist!"
+        return self._session.collect_logs(pid=self._pid)
+
+
+    def close(self):
+        assert self._launches > -1, "clean_up() has been called"
+        if self.reason is not None:
+            log.debug("already closed!")
+            return
+        try:
+            if self._session is not None:
+                crash_reports = self.find_crashreports()
+                # set reason code
+                if crash_reports:
+                    self.reason = self.RC_ALERT
+                    self.wait_on_files(crash_reports)
+                elif self.is_running():
+                    self.reason = self.RC_CLOSED
+                else:
+                    self.reason = self.RC_EXITED
+                self._terminate()
+                self.wait()
+                self._process_logs(crash_reports)
+                self._session.call(["shell", "rm", "-rf", self._working_path])
+        except ADBSessionError:
+            log.warning("No device detected while closing process")
+        self._pid = None
+        self.profile = None
+        if self.reason is None:
+            self.reason = self.RC_CLOSED
+
+
+    def find_crashreports(self):
+        reports = list()
+        # TODO: Add ASan support
+        if self.profile:
+            # check for minidumps
+            md_path = os.path.join(self.profile, "minidumps")
+            try:
+                contents = self._session.listdir(md_path)
+                for fname in contents:
+                    if ".dmp" in fname or ".extra" in fname:
+                        reports.append(os.path.join(md_path, fname))
+            except IOError:
+                log.debug("%s does not exist", md_path)
+
+        return reports
+
+
+    def is_healthy(self):
+        if not self.is_running():
+            return False
+        return not self.find_crashreports()
+
+
+    def is_running(self):
+        assert self._session, "Device not connected"
+        assert self._package, "Package not specified"
+        if self._pid is None or self.reason is not None:
+            return False
+        return self._session.process_exists(self._pid)
+
+
+    def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=None):
+        log.debug("launching %r", url)
+        assert self._launches > -1, "clean_up() has been called"
+        assert self._session, "Device not connected"
+        assert self._package, "Package not specified"
+        assert self._pid is None, "Process is already running"
+        assert self.reason is not None, "Process is already running"
+
+        self._session.clear_logs()
+        self._remove_logs()
+        self.reason = None
+        local_profile = create_profile(
+            extension=extension,
+            prefs_js=prefs_js,
+            template=self._profile_template)
+
+        bootstrapper = Bootstrapper(poll_wait=0.5)
+        try:
+            try:
+                prefs = {
+                    "capability.policy.policynames": "'localfilelinks'",
+                    "capability.policy.localfilelinks.sites": "'%s'" % bootstrapper.location,
+                    "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'"}
+                append_prefs(local_profile, prefs)
+                self.profile = "/".join([self._working_path, os.path.basename(local_profile)])
+                if os.listdir(local_profile):
+                    if not self._session.push(local_profile, self.profile):
+                        raise ADBLaunchError("Could not upload %r" % local_profile)
+                else:
+                    log.debug("creating empty profile on device: %s", self.profile)
+                    self._session.call(["shell", "mkdir", "-p", self.profile])
+            finally:
+                if os.path.exists(local_profile):
+                    shutil.rmtree(local_profile) # TODO: temporary
+            if not self._session.reverse(bootstrapper.port, bootstrapper.port):
+                raise ADBLaunchError("Could not reverse port: %d" % bootstrapper.port)
+            cmd = [
+                "shell", "am", "start", "-W", "-n",
+                "/".join([self._package, "org.mozilla.gecko.BrowserApp"]),
+                "-a", "android.intent.action.VIEW", "-d", bootstrapper.location,
+                "--es", "args", "-profile\\ %s" % self.profile]
+
+            env_mod = dict(env_mod or {})
+            env_mod.setdefault("MOZ_SKIA_DISABLE_ASSERTS", "1")
+            for var_num, (var_name, var_val) in enumerate(env_mod.items()):
+                if var_val is None:
+                    continue
+                cmd.append("--es")
+                cmd.append("env%d" % var_num)
+                cmd.append("%s=%s" % (var_name, var_val))
+
+            if "Status: ok" not in self._session.call(cmd, timeout=launch_timeout)[1].splitlines():
+                raise ADBLaunchError("Could not launch %r" % self._package)
+            self._pid = self._session.get_pid(self._package)
+            bootstrapper.wait(self.is_healthy, url=url)
+        finally:
+            self._session.reverse_remove(bootstrapper.port)
+            bootstrapper.close()
+        self._launches += 1
+
+        return self._pid is not None
+
+
+    @property
+    def launches(self):
+        """
+        Get the number of successful launches
+
+        @rtype: int
+        @return: successful launch count
+        """
+
+        assert self._launches > -1, "clean_up() has been called"
+        return self._launches
+
+
+    def _process_logs(self, crash_reports):
+        assert self.logs is None
+        self.logs = tempfile.mkdtemp(prefix="adb_logs_")
+        unprocessed = os.path.join(self.logs, "unprocessed")
+        os.mkdir(unprocessed)
+
+        with open(os.path.join(self.logs, "log_logcat.txt"), "wb") as log_fp:
+            # TODO: should this filter by pid or not?
+            log_fp.write(self._session.collect_logs())
+            #log_fp.write(self._session.collect_logs(pid=self._pid))
+
+        if not crash_reports:
+            return
+
+        # copy crash logs from the device
+        for fname in crash_reports:
+            self._session.pull(fname, unprocessed)
+
+        logger = PuppetLogger()
+        try:
+            syms_path = self._session.symbols_path(self._package)
+            process_minidumps(unprocessed, syms_path, logger.add_log)
+            logger.close()
+            logger.save_logs(self.logs)
+        finally:
+            logger.clean_up()
+
+
+    def _remove_logs(self):
+        if self.logs is not None and os.path.isdir(self.logs):
+            shutil.rmtree(self.logs)
+            self.logs = None
+
+
+    @staticmethod
+    def _split_logcat(log_path):
+        # Roughly split out stderr and stdout from logcat
+        # This is to support FuzzManager. The original logcat output is also
+        # included in the report so nothing is lost.
+        logcat = os.path.join(log_path, "log_logcat.txt")
+        if not os.path.isfile(logcat):
+            log.warning("log_logcat.txt does not exist!")
+            return None
+        err_log = os.path.join(log_path, "log_stderr.txt")
+        if os.path.isfile(err_log):
+            log.warning("log_stderr.txt already exist! Overwriting...")
+        out_log = os.path.join(log_path, "log_stdout.txt")
+        if os.path.isfile(out_log):
+            log.warning("log_stdout.txt already exist! Overwriting...")
+        with open(logcat, "rb") as lc_fp, open(err_log, "w") as e_fp, open(out_log, "w") as o_fp:
+            for line in lc_fp:
+                if b"Gecko" not in line and b"MOZ_" not in line:
+                    continue
+                line = line[33:].decode("ascii", "ignore")
+                if line.startswith("GeckoDump"):
+                    o_fp.write(line.split(": ", 1)[-1])
+                elif line.startswith("Gecko") or line.startswith("MOZ_"):
+                    e_fp.write(line.split(": ", 1)[-1])
+
+
+    def save_logs(self, log_path, meta=False):
+        assert self.logs is not None
+        assert self.reason is not None, "Call close() first!"
+        assert self._launches > -1, "clean_up() has been called"
+        # copy logs to location specified by log_file
+        if not os.path.isdir(log_path):
+            os.makedirs(log_path)
+        log_path = os.path.abspath(log_path)
+
+        for fname in os.listdir(self.logs):
+            full_name = os.path.join(self.logs, fname)
+            # skip directories
+            if not os.path.isfile(full_name):
+                continue
+            shutil.copy(full_name, log_path)
+        self._split_logcat(log_path)
+
+
+    def wait_on_files(self, wait_files, poll_rate=0.5, timeout=60):
+        assert poll_rate >= 0, "Invalid poll_rate %d, must be greater than or equal to 0" % poll_rate
+        assert timeout >= 0, "Invalid timeout %d, must be greater than or equal to 0" % timeout
+        assert poll_rate <= timeout, "poll_rate must be less then or equal to timeout"
+        wait_end = time.time() + timeout
+        wait_files = set(self._session.realpath(x) for x in wait_files)
+
+        while wait_files:
+            open_files = set(x for _, x in self._session.get_open_files())
+            # check if any open files are in the wait file list
+            if not wait_files.intersection(open_files):
+                break
+            elif wait_end <= time.time():
+                log.debug("Timeout waiting for: %s", ", ".join(x for x in open_files if x in wait_files))
+                return False
+            time.sleep(poll_rate)
+        return True
+
+
+    def _terminate(self):
+        assert self._package is not None
+        assert self._session, "Device not connected"
+        # TODO: is this the best way???
+        self._session.call(["shell", "am", "force-stop", self._package])
+
+
+    def wait(self):
+        while self.is_running():
+            time.sleep(0.25)
+
+
+def main(argv=None):  # pylint: disable=missing-docstring
+    # set output verbosity
+    if bool(os.getenv("DEBUG")):
+        log_level = logging.DEBUG
+        log_fmt = "%(levelname).1s %(name)s [%(asctime)s] %(message)s"
+    else:
+        log_level = logging.INFO
+        log_fmt = "[%(asctime)s] %(message)s"
+    logging.basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
+
+    parser = argparse.ArgumentParser(description="ADB Device Wrapper")
+    parser.add_argument(
+        "--airplane-mode", default=None, type=int,
+        help="Enable(1) or disable(0) airplane mode")
+    parser.add_argument(
+        "--install", help="Path to APK to install")
+    parser.add_argument(
+        "--install-asan", help="Path to NDK")
+    parser.add_argument(
+        "--launch", help="Path to APK to launch")
+    parser.add_argument(
+        "--logs", help="Location to save logs")
+    parser.add_argument(
+        "--ip", help="IP address of target device")
+    parser.add_argument(
+        "--port", default=5555, type=int,
+        help="ADB listening port on target device")
+    args = parser.parse_args(argv)
+
+    log.info("Opening a session")
+    session = ADBSession.create(args.ip, args.port, as_root=True)
+    if session is None:
+        log.error("Failed to connect to IP:%r port:%r", args.ip, args.port)
+        return 1
+
+    if args.install is not None:
+        log.info("Installing %r ...", args.install)
+        package = session.install(args.install)
+        if not package:
+            log.error("Could not install %r", args.install)
+            return 1
+        log.info("Installed %r", package)
+    #elif args.install_asan is not None:
+    #    log.info("Installing ASan from %r ...", args.install_asan)
+    #    session.install_asan(args.install_asan)
+    #    log.info("Device reboot required")
+    elif args.airplane_mode is not None:
+        session.set_airplane_mode(mode=args.airplane_mode > 0)
+    elif args.launch:
+        package = ADBSession.get_package_name(args.launch)
+        if not package:
+            log.error("APK not installed")
+            return 1
+        proc = ADBProcess(package, session)
+        try:
+            proc.launch("about:blank", launch_timeout=60)
+            assert proc.is_running(), "browser not running?!"
+            log.info("Launched")
+            proc.wait()
+        finally:
+            proc.close()
+            if args.logs:
+                proc.save_logs(args.logs)
+            proc.cleanup()
+    else:
+        parser.print_help()
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index fcfa95df..c610bd04 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -1,18 +1,10 @@
 import argparse
-import glob
 import logging
 import os
-import random
-import shutil
-import socket
-import subprocess
 import sys
-import tempfile
-import time
 
-from ffpuppet.helpers import append_prefs, Bootstrapper, create_profile
-from ffpuppet.minidump_parser import process_minidumps
-from ffpuppet.puppet_logger import PuppetLogger
+from .adb_process import ADBProcess
+from .adb_session import ADBSession
 
 log = logging.getLogger("adb_device")  # pylint: disable=invalid-name
 
@@ -20,806 +12,6 @@
 __credits__ = ["Tyson Smith"]
 
 
-# TODO:
-# - Add ability to collect ASan logs
-
-
-class DeviceProcess(object):
-    def __init__(self, memory, name, pid, ppid):
-        self.memory = memory
-        self.name = name
-        self.pid = pid
-        self.ppid = ppid
-
-    @classmethod
-    def from_ps_line(cls, line):
-        try:
-            _, pid, ppid, _, memory, _, _, _, name = line.split()
-        except ValueError:
-            log.debug("invalid ps line %r", line)
-            return None
-        try:
-            return cls(int(memory), name, int(pid), int(ppid))
-        except ValueError:
-            log.debug("invalid ps line values")
-            return None
-
-
-class ADBCommandError(RuntimeError):
-    pass
-
-class ADBSessionError(RuntimeError):
-    pass
-
-class ADBLaunchError(ADBSessionError):
-    pass
-
-class ADBNoDevice(ADBSessionError):
-    pass
-
-
-class ADBSession(object):
-    BIN_AAPT = None
-    BIN_ADB = None
-
-    def __init__(self, ip_addr=None, port=5555):
-        self.connected = False
-        self.symbols = dict()
-        self._root = False
-        self._ip_addr = None  # target device IP address
-        self._port = None  # ADB listening port
-
-        log.debug("creating IP based session: %r", ip_addr is not None)
-        if ip_addr is not None:
-            try:
-                if ip_addr != "localhost":
-                    socket.inet_aton(ip_addr)
-            except (socket.error, TypeError):
-                raise ValueError("IP Address is invalid")
-            self._ip_addr = ip_addr
-            if not isinstance(port, int) or not (port > 1024 and port < 0x10000):
-                raise ValueError("Port must be valid integer between 1025 and 65535")
-            self._port = port
-
-        suggested_adb = os.path.expanduser("~/.android/sdk/platform-tools/adb")
-        if self.BIN_ADB is None:
-            if os.path.isfile(suggested_adb):
-                self.BIN_ADB = suggested_adb
-            else:
-                try:
-                    self.BIN_ADB = subprocess.check_output(["which", "adb"]).strip()
-                except subprocess.CalledProcessError:
-                    raise EnvironmentError("Please install ADB")
-            # TODO: update this to check adb version
-            if os.path.realpath(self.BIN_ADB) != os.path.realpath(suggested_adb):
-                log.warning("You are not using the recommended ADB install!")
-                log.warning("Either run the setup script or proceed with caution.")
-                time.sleep(5)
-
-
-    @classmethod
-    def create(cls, ip_addr=None, port=5555, as_root=True, max_attempts=10):
-        session = cls(ip_addr, port)
-        if session.connect(as_root=as_root, max_attempts=max_attempts):
-            return session
-        return None
-
-
-    @staticmethod
-    def _call_adb(cmd, timeout=None):
-        with tempfile.TemporaryFile() as out_fp:
-            if timeout is not None:
-                assert timeout > 0
-                end_time = time.time() + timeout
-                adb_proc = subprocess.Popen(cmd, stderr=out_fp, stdout=out_fp)
-                while adb_proc.poll() is None:
-                    time.sleep(0.05)
-                    if time.time() > end_time:
-                        log.warning("adb call timeout!")
-                        adb_proc.terminate()
-                        break
-                ret_code = adb_proc.wait()
-            else:
-                ret_code = subprocess.call(cmd, stderr=out_fp, stdout=out_fp)
-            out_fp.seek(0)
-            return ret_code, out_fp.read().decode("utf-8", "ignore").strip()
-
-
-    def call(self, cmd, require_device=True, timeout=None):
-        assert isinstance(cmd, list) and cmd
-        cmd = [self.BIN_ADB] + cmd
-        log.debug("calling: %s", " ".join(cmd))
-        if not self.connected and cmd[1] not in ("connect", "devices", "disconnect"):
-            raise ADBSessionError("ADB session is not connected!")
-        ret_code, output = self._call_adb(cmd, timeout=timeout)
-        log.debug("=== adb start ===\n%s\n=== adb end, returned %d ===", output, ret_code)
-        if ret_code != 0:
-            if output.startswith("Android Debug Bridge version"):
-                raise ADBCommandError("Invalid ADB command '%s'" % " ".join(cmd[1:]))
-            elif output.startswith("adb: usage:"):
-                raise ADBCommandError(output.strip())
-            elif require_device and (output.startswith("error: closed") or
-                                     output.startswith("error: device offline") or
-                                     output.startswith("error: no devices/emulators found")):
-                self.connected = False
-                raise ADBNoDevice("No device detected!")
-        return (ret_code, output)
-
-
-    def clear_logs(self):
-        log.debug("clear_logs()")
-        return self.call(["logcat", "--clear"], timeout=10)[0] == 0
-
-
-    def connect(self, as_root=True, max_attempts=10):
-        max_attempts = max(1, max_attempts)
-        attempt = 0
-        root_called = False
-        while attempt < max_attempts:
-            attempt += 1
-            if not self.connected and self._ip_addr is not None:
-                addr = ":".join([self._ip_addr, str(self._port)])
-                log.debug("connecting to %s", addr)
-                if self.call(["connect", addr])[0] != 0:
-                    log.warning("connection attempt #%d failed", attempt)
-                    time.sleep(0.25)
-                    continue
-            elif not self._devices_available(self.call(["devices"])[1]):
-                log.warning("No device detected (attempt %d/%d)", attempt, max_attempts)
-                time.sleep(1)
-                continue
-            self.connected = True
-
-            # verify we are connected
-            ret_code, user = self.call(["shell", "whoami"], require_device=False)
-            if (ret_code != 0 or not user) and attempt < max_attempts:
-                time.sleep(0.25)
-                continue
-
-            if ret_code != 0 or not user:
-                raise ADBSessionError("Device in a bad state, try disconnect & reboot")
-            user = user.splitlines()[-1]
-            if user == "root":
-                self._root = True
-
-            if not as_root or self._root:
-                break  # connected
-
-            # enable root
-            assert as_root, "Should not be here if root is not requested"
-            if self.call(["root"])[0] == 0:
-                self.connected = False
-                if not root_called:
-                    root_called = True
-                    attempt -= 1  # remove attempt used to call root
-                    continue
-
-            time.sleep(0.25)  # wait for adbd to restart on device
-
-        if self.connected and as_root and not self._root:
-            raise ADBSessionError("Could not enable root")
-
-        return self.connected
-
-
-    def collect_logs(self, pid=None):
-        log.debug("collect_logs()")
-        if not self.connected:
-            log.debug("device not connected cannot collect logs")
-            return ""
-        cmd = ["logcat", "-d", "*:I"]
-        if pid is not None:
-            cmd += ["--pid=%d" % pid]
-        return self.call(cmd, timeout=10)[1].encode("utf-8", "ignore")
-
-
-    @staticmethod
-    def _devices_available(adb_output):
-        entries = adb_output.strip().splitlines()
-        if len(entries) < 2:
-            return False
-        return entries[-1].endswith("device")
-
-
-    def disconnect(self, unroot=True):
-        if not self.connected:
-            log.debug("already disconnected")
-            return True
-        if self._root and unroot:
-            try:
-                if self.call(["unroot"])[0] == 0:
-                    self.connected = False
-                    self._root = False
-                    return True
-                log.warning("'unroot' failed")
-            except ADBCommandError:
-                log.warning("'unroot' not support by ADB")
-        elif self._ip_addr is not None:
-            self.call(["disconnect", ":".join([self._ip_addr, str(self._port)])])
-        self.connected = False
-        return True
-
-
-    def listdir(self, path):
-        log.debug("listdir(%r)", path)
-        ret_val, output = self.call(["shell", "ls", "-A", path])
-        if ret_val != 0:
-            raise IOError("%r does not exist" % path)
-        return output.splitlines()
-
-
-    def realpath(self, path):
-        log.debug("realpath(%r)", path)
-        ret_val, output = self.call(["shell", "realpath", path])
-        if ret_val != 0:
-            raise IOError("%r does not exist" % path)
-        return output.strip()
-
-
-    def reverse(self, remote, local):
-        # remote->device, local->desktop
-        assert isinstance(local, int) and local > 1024 and local < 0x10000
-        assert isinstance(remote, int) and remote > 1024 and remote < 0x10000
-        return self.call(["reverse", "tcp:%d" % remote, "tcp:%d" % local])[0] == 0
-
-
-    def reverse_remove(self, remote=None):
-        # remote->device
-        cmd = ["reverse"]
-        if remote is not None:
-            assert isinstance(remote, int) and remote > 1024 and remote < 0x10000
-            cmd.append("--remove")
-            cmd.append("tcp:%d" % remote)
-        else:
-            cmd.append("--remove-all")
-        return self.call(cmd)[0] == 0
-
-
-    def uninstall(self, package):
-        if not self.connected:
-            log.debug("already disconnected")
-            return False
-        return self.call(["uninstall", package], timeout=60)[0] == 0
-
-
-    def install(self, apk_path):
-        log.debug("installing %r", apk_path)
-        if not os.path.isfile(apk_path):
-            raise IOError("APK does not exist %r" % apk_path)
-        # check if package is installed
-        if self.call(["install", "-r", apk_path], timeout=120)[0] != 0:
-            raise ADBSessionError("Failed to install %r" % apk_path)
-
-        # unpack and lookup package name
-        package_name = self.get_package_name(apk_path)
-
-        # set permissions
-        self.call(["shell", "pm", "grant", package_name, "android.permission.READ_EXTERNAL_STORAGE"])
-        self.call(["shell", "pm", "grant", package_name, "android.permission.WRITE_EXTERNAL_STORAGE"])
-
-        log.debug("installed package %r (%r)", package_name, apk_path)
-        return package_name
-
-
-    def install_asan(self, ndk_base, asan_options=None):
-        if not os.path.isdir(ndk_base):
-            raise IOError("NDK does not exist %r" % ndk_base)
-        self.call(["remount"])
-
-        clang_path = os.path.join(
-            ndk_base, "toolchains", "llvm", "prebuilt", "linux-x86_64", "lib64",
-            "clang", "*", "lib", "linux")
-        for cpath in glob.glob(clang_path):
-            asan_rt = os.path.join(cpath, "libclang_rt.asan-i686-android.so")
-            asan_rt64 = os.path.join(cpath, "libclang_rt.asan-x86_64-android.so")
-            if os.path.isfile(asan_rt) and os.path.isfile(asan_rt64):
-                break
-        else:
-            raise IOError("Cannot find libclang_rt.asan-*-android.so")
-
-        ctx = "u:object_r:zygote_exec:s0"
-        self.call(["shell", "setenforce", "0"])
-
-        self.call(["shell", "mv", "/system/bin/app_process32.real", "/system/bin/app_process32"])
-        self.call(["shell", "mv", "/system/bin/app_process32", "/system/bin/app_process32.real"])
-        self.call(["shell", "chcon", ctx, "/system/bin/app_process32.real"])
-        self.call(["shell", "mv", "/system/bin/app_process64.real", "/system/bin/app_process64"])
-        self.call(["shell", "mv", "/system/bin/app_process64", "/system/bin/app_process64.real"])
-        self.call(["shell", "chcon", ctx, "/system/bin/app_process64.real"])
-
-        self.install_file(asan_rt, "/system/lib", "644")
-        self.install_file(asan_rt64, "/system/lib64", "644")
-
-        addition_options = [
-            "allow_user_segv_handler=1",
-            "detect_container_overflow=0",
-            "malloc_context_size=0",
-            "start_deactivated=1"]
-        if asan_options:
-            existing_opts = [opt for opt in asan_options.split(":") if opt]
-        else:
-            existing_opts = []
-        asan_options = ":".join(existing_opts + addition_options)
-
-        tmpd = tempfile.mkdtemp()
-        try:
-            fname = os.path.join(tmpd, "app_process32")
-            with open(fname, "w") as out_fp:
-                out_fp.write("#!/system/bin/sh-from-zygote\n")
-                out_fp.write("ASAN_OPTIONS=%s \\\n" % asan_options)
-                out_fp.write("ASAN_ACTIVATION_OPTIONS=include_if_exists=/data/local/tmp/asan.options.%b \\\n")
-                out_fp.write("LD_PRELOAD=symlink-to-libclang_rt.asan \\\n")
-                out_fp.write("exec /system/bin/app_process32.real \"$@\"\n")
-            self.install_file(fname, "/system/bin", "755", ctx)
-
-            fname = os.path.join(tmpd, "app_process64")
-            with open(fname, "w") as out_fp:
-                out_fp.write("#!/system/bin/sh-from-zygote\n")
-                out_fp.write("ASAN_OPTIONS=%s \\\n" % asan_options)
-                out_fp.write("ASAN_ACTIVATION_OPTIONS=include_if_exists=/data/local/tmp/asan.options.%b \\\n")
-                out_fp.write("LD_PRELOAD=symlink-to-libclang_rt.asan \\\n")
-                out_fp.write("exec /system/bin/app_process64.real \"$@\"\n")
-            self.install_file(fname, "/system/bin", "755", ctx)
-
-            fname = os.path.join(tmpd, "asanwrapper")
-            with open(fname, "w") as out_fp:
-                out_fp.write("#!/system/bin/sh\n")
-                out_fp.write("LD_PRELOAD=symlink-to-libclang_rt.asan \\\n")
-                out_fp.write("exec \"$@\"\n")
-            self.install_file(fname, "/system/bin", "755")
-
-            fname = os.path.join(tmpd, "asanwrapper64")
-            with open(fname, "w") as out_fp:
-                out_fp.write("#!/system/bin/sh\n")
-                out_fp.write("LD_PRELOAD=symlink-to-libclang_rt.asan \\\n")
-                out_fp.write("exec \"$@\"\n")
-            self.install_file(fname, "/system/bin", "755")
-        finally:
-            shutil.rmtree(tmpd, ignore_errors=True)
-
-        llvm_symer = os.path.join(
-            ndk_base, "prebuilt", "android-x86_64",
-            "llvm-symbolizer", "llvm-symbolizer")
-        self.install_file(llvm_symer, "/system/bin", "755", ctx)
-
-        # set-up asan symlinks
-        self.call(["shell", "ln", "-s", "/system/lib/libclang_rt.asan-i686-android.so", "/system/lib/symlink-to-libclang_rt.asan"])
-        self.call(["shell", "ln", "-s", "/system/lib64/libclang_rt.asan-x86_64-android.so", "/system/lib64/symlink-to-libclang_rt.asan"])
-
-        self.call(["shell", "cp", "/system/bin/sh", "/system/bin/sh-from-zygote"])
-        self.call(["shell", "chcon", ctx, "/system/bin/sh-from-zygote"])
-
-        # restart the zygote
-        self.call(["shell", "stop"])
-        self.call(["shell", "start"])
-
-
-    def install_file(self, src, dst, mode=None, context=None):
-        basename = os.path.basename(src)
-        full_dst = os.path.join(dst, basename)
-        self.push(src, full_dst)
-        self.call(["shell", "chown", "root.shell", full_dst])
-        if mode is not None:
-            self.call(["shell", "chmod", mode, full_dst])
-        if context is not None:
-            self.call(["shell", "chcon", context, full_dst])
-
-
-    @staticmethod
-    def get_package_name(apk_path):
-        # unpack and lookup package name
-        aapt = ADBSession.BIN_AAPT
-        if aapt is None:
-            aapt = os.path.expanduser("~/.android/sdk/android-9/aapt")
-            if not os.path.isfile(aapt):
-                # fall back to system version
-                aapt = subprocess.check_output(["which", "aapt"]).strip()
-        apk_info = subprocess.check_output([aapt, "dump", "badging", apk_path])
-        for line in apk_info.splitlines():
-            if line.startswith("package: name="):
-                package_name = line.split()[1][5:].strip("'")
-                break
-        else:
-            raise RuntimeError("Could not find APK package name")
-        return package_name
-
-
-    def get_packages(self):
-        # TODO: should this be by pid or package?
-        cmd = ["shell", "pm", "list", "packages"]
-        return [line[8:] for line in self.call(cmd)[1].splitlines() if line.startswith("package:")]
-
-
-    def get_open_files(self, pid=None, children=False, files=None):
-        log.debug("get_open_files(pid=%r, children=%r, files=%r", pid, children, files)
-        pids = list()
-        if pid is not None:
-            pids.append(str(pid))
-        if children:
-            assert pid is not None, "Cannot request child open files without specifying pid"
-            for proc in self._get_procs(pid_children=pid):
-                pids.append(str(proc.pid))
-        cmd = ["shell", "lsof"]
-        if pids:
-            cmd += ["-p", ",".join(pids)]
-        if files:
-            cmd.extend(list(files))
-        open_files = list()
-        for line in self.call(cmd)[1].splitlines():
-            if line.endswith("Permission denied)"):
-                continue
-            # I believe we only care about regular files
-            if " REG " not in line:
-                continue
-            try:
-                file_info = line.split()
-                file_name = file_info[-1]
-                if pid is not None and file_info[1] not in pids:
-                    continue
-                # add tuple containing pid and filename
-                open_files.append((int(file_info[1]), file_name))
-            except ValueError:
-                pass
-
-        return open_files
-
-
-    def get_pid(self, package_name):
-        # NOTE: pidof is not supported pre-Android 6
-        procs = self._get_procs()
-        pids = [proc.pid for proc in procs if proc.name == package_name]
-        if not pids:
-            return None
-        count = len(pids)
-        if count > 1:
-            log.debug("get_pid() %d proc(s) found", count)
-            # TODO: use procs and use the ppid of the procs the determine the parent
-            pids.sort()
-        return int(pids[0])
-
-
-    def process_exists(self, pid):
-        return True if self._get_procs(pid=pid) else False
-
-
-    def _get_procs(self, pid=None, pid_children=None):
-        # default list all procs
-        cmd = ["shell", "ps"]
-        if pid is not None:
-            cmd.append(str(pid))
-        if pid_children is not None:
-            cmd += ["--ppid", str(pid_children)]
-        procs = list()
-        for line in self.call(cmd)[1].splitlines()[1:]:
-            proc = DeviceProcess.from_ps_line(line)
-            if proc is not None:
-                procs.append(proc)
-        return procs
-
-
-    def is_installed(self, package_name):
-        return package_name in self.get_packages()
-
-
-    def pull(self, src, dst):
-        log.debug("pull(%r, %r)", src, dst)
-        return self.call(["pull", src, dst])[0] == 0
-
-
-    def push(self, src, dst):
-        log.debug("push(%r, %r)", src, dst)
-        if not os.path.exists(src):
-            raise IOError("%r does not exist" % src)
-        return self.call(["push", src, dst])[0] == 0
-
-
-    def symbols_path(self, package_name):
-        return self.symbols.get(package_name, "")
-
-
-    def set_airplane_mode(self, mode=True):
-        cmd = ["shell", "settings", "put", "global", "airplane_mode_on"]
-        cmd += ["1" if mode else "0"]
-        self.call(cmd)
-        cmd = ["shell", "su", "root", "am", "broadcast", "-a", "android.intent.action.AIRPLANE_MODE"]
-        self.call(cmd)
-
-
-
-class ADBProcess(object):
-    # TODO: reason codes match FFPuppet
-    RC_ALERT = "ALERT"  # target crashed/aborted/triggered an assertion failure etc...
-    RC_CLOSED = "CLOSED"  # target was closed by call to FFPuppet close()
-    RC_EXITED = "EXITED"  # target exited
-    #RC_WORKER = "WORKER"  # target was closed by worker thread
-    # TODO: 
-    #  def save_logs(self, *args, **kwargs):
-    #  def clone_log(self, log_id, offset=0):
-    #  def log_data(self, log_id, offset=0):
-    #  def log_length(self, log_id):... likely not going to happen because of overhead
-    def __init__(self, package_name, session, use_profile=None):
-        assert isinstance(session, ADBSession), "Expecting ADBSession"
-        if not session.is_installed(package_name):
-            raise ADBSessionError("Package %r not installed" % package_name)
-        self._launches = 0  # number of successful browser launches
-        self._package = package_name  # package to use as target process
-        self._pid = None  # pid of current target process
-        self._profile_template = use_profile  # profile that is used as a template
-        self._session = session  # ADB session with device
-        self._working_path = "/sdcard/ADBProc_%08X" % random.getrandbits(32)
-        self.logs = None
-        self.profile = None
-        self.reason = self.RC_CLOSED
-
-
-    def cleanup(self):
-        if self._launches < 0:
-            log.debug("clean_up() call ignored")
-            return
-        if self.reason is None:
-            self.close()
-        self._remove_logs()
-        # negative 'self._launches' indicates clean_up() has been called
-        self._launches = -1
-
-
-    def clone_log(self):
-        # TODO: dump logs for all browser processes
-        if self._session is None:
-            # TODO: better error?
-            return "ADB session does not exist!"
-        return self._session.collect_logs(pid=self._pid)
-
-
-    def close(self):
-        assert self._launches > -1, "clean_up() has been called"
-        if self.reason is not None:
-            log.debug("already closed!")
-            return
-        try:
-            if self._session is not None:
-                crash_reports = self.find_crashreports()
-                # set reason code
-                if crash_reports:
-                    self.reason = self.RC_ALERT
-                    self.wait_on_files(crash_reports)
-                elif self.is_running():
-                    self.reason = self.RC_CLOSED
-                else:
-                    self.reason = self.RC_EXITED
-                self._terminate()
-                self.wait()
-                self._process_logs(crash_reports)
-                self._session.call(["shell", "rm", "-rf", self._working_path])
-        except ADBSessionError:
-            log.warning("No device detected while closing process")
-        self._pid = None
-        self.profile = None
-        if self.reason is None:
-            self.reason = self.RC_CLOSED
-
-
-    def find_crashreports(self):
-        reports = list()
-        # TODO: Add ASan support
-        if self.profile:
-            # check for minidumps
-            md_path = os.path.join(self.profile, "minidumps")
-            try:
-                contents = self._session.listdir(md_path)
-                md_path
-                for fname in contents:
-                    if ".dmp" in fname or ".extra" in fname:
-                        reports.append(os.path.join(md_path, fname))
-            except IOError:
-                log.debug("%s does not exist", md_path)
-
-        return reports
-
-
-    def is_healthy(self):
-        if not self.is_running():
-            return False
-        return not self.find_crashreports()
-
-
-    def is_running(self):
-        assert self._session, "Device not connected"
-        assert self._package, "Package not specified"
-        if self._pid is None or self.reason is not None:
-            return False
-        return self._session.process_exists(self._pid)
-
-
-    def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=None):
-        log.debug("launching %r", url)
-        assert self._launches > -1, "clean_up() has been called"
-        assert self._session, "Device not connected"
-        assert self._package, "Package not specified"
-        assert self._pid is None, "Process is already running"
-        assert self.reason is not None, "Process is already running"
-
-        self._session.clear_logs()
-        self._remove_logs()
-        self.reason = None
-        local_profile = create_profile(
-            extension=extension,
-            prefs_js=prefs_js,
-            template=self._profile_template)
-
-        bootstrapper = Bootstrapper(poll_wait=0.5)
-        try:
-            try:
-                prefs = {
-                    "capability.policy.policynames": "'localfilelinks'",
-                    "capability.policy.localfilelinks.sites": "'%s'" % bootstrapper.location,
-                    "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'"}
-                append_prefs(local_profile, prefs)
-                self.profile = "/".join([self._working_path, os.path.basename(local_profile)])
-                if os.listdir(local_profile):
-                    if not self._session.push(local_profile, self.profile):
-                        raise ADBLaunchError("Could not upload %r" % local_profile)
-                else:
-                    log.debug("creating empty profile on device: %s", self.profile)
-                    self._session.call(["shell", "mkdir", "-p", self.profile])
-            finally:
-                if os.path.exists(local_profile):
-                    shutil.rmtree(local_profile) # TODO: temporary
-
-            # TODO: Is call needed and if so should it happen somewhere else?
-            # disable selinux
-            self._session.call(["shell", "setenforce", "0"])
-            if not self._session.reverse(bootstrapper.port, bootstrapper.port):
-                raise ADBLaunchError("Could not reverse port: %d" % bootstrapper.port)
-            cmd = [
-                "shell", "am", "start", "-W", "-n",
-                "/".join([self._package, "org.mozilla.gecko.BrowserApp"]),
-                "-a", "android.intent.action.VIEW", "-d", bootstrapper.location,
-                "--es", "args", "-profile\\ %s" % self.profile]
-
-            env_mod = dict(env_mod or {})
-            env_mod.setdefault("MOZ_SKIA_DISABLE_ASSERTS", "1")
-            for var_num, (var_name, var_val) in enumerate(env_mod.items()):
-                if var_val is None:
-                    continue
-                cmd.append("--es")
-                cmd.append("env%d" % var_num)
-                cmd.append("%s=%s" % (var_name, var_val))
-
-            if "Status: ok" not in self._session.call(cmd, timeout=launch_timeout)[1].splitlines():
-                raise ADBLaunchError("Could not launch %r" % self._package)
-            self._pid = self._session.get_pid(self._package)
-            bootstrapper.wait(self.is_healthy, url=url)
-        finally:
-            self._session.reverse_remove(bootstrapper.port)
-            bootstrapper.close()
-        self._launches += 1
-
-        return self._pid is not None
-
-
-    @property
-    def launches(self):
-        """
-        Get the number of successful launches
-
-        @rtype: int
-        @return: successful launch count
-        """
-
-        assert self._launches > -1, "clean_up() has been called"
-        return self._launches
-
-
-    def _process_logs(self, crash_reports):
-        assert self.logs is None
-        self.logs = tempfile.mkdtemp(prefix="adb_logs_")
-        unprocessed = os.path.join(self.logs, "unprocessed")
-        os.mkdir(unprocessed)
-
-        with open(os.path.join(self.logs, "log_logcat.txt"), "wb") as log_fp:
-            # TODO: should this filter by pid or not?
-            log_fp.write(self._session.collect_logs())
-            #log_fp.write(self._session.collect_logs(pid=self._pid))
-
-        if not crash_reports:
-            return
-
-        # copy crash logs from the device
-        for fname in crash_reports:
-            self._session.pull(fname, unprocessed)
-
-        logger = PuppetLogger()
-        try:
-            syms_path = self._session.symbols_path(self._package)
-            process_minidumps(unprocessed, syms_path, logger.add_log)
-            logger.close()
-            logger.save_logs(self.logs)
-        finally:
-            logger.clean_up()
-
-
-    def _remove_logs(self):
-        if self.logs is not None and os.path.isdir(self.logs):
-            shutil.rmtree(self.logs)
-            self.logs = None
-
-
-    @staticmethod
-    def _split_logcat(log_path):
-        # Roughly split out stderr and stdout from logcat
-        # This is to support FuzzManager. The original logcat output is also
-        # included in the report so nothing is lost.
-        logcat = os.path.join(log_path, "log_logcat.txt")
-        if not os.path.isfile(logcat):
-            log.warning("log_logcat.txt does not exist!")
-            return None
-        err_log = os.path.join(log_path, "log_stderr.txt")
-        if os.path.isfile(err_log):
-            log.warning("log_stderr.txt already exist! Overwriting...")
-        out_log = os.path.join(log_path, "log_stdout.txt")
-        if os.path.isfile(out_log):
-            log.warning("log_stdout.txt already exist! Overwriting...")
-        with open(logcat, "rb") as lc_fp, open(err_log, "w") as e_fp, open(out_log, "w") as o_fp:
-            for line in lc_fp:
-                if b"Gecko" not in line and b"MOZ_" not in line:
-                    continue
-                line = line[33:].decode("ascii", "ignore")
-                if line.startswith("GeckoDump"):
-                    o_fp.write(line.split(": ", 1)[-1])
-                elif line.startswith("Gecko") or line.startswith("MOZ_"):
-                    e_fp.write(line.split(": ", 1)[-1])
-
-
-    def save_logs(self, log_path, meta=False):
-        assert self.logs is not None
-        assert self.reason is not None, "Call close() first!"
-        assert self._launches > -1, "clean_up() has been called"
-        # copy logs to location specified by log_file
-        if not os.path.isdir(log_path):
-            os.makedirs(log_path)
-        log_path = os.path.abspath(log_path)
-
-        for fname in os.listdir(self.logs):
-            full_name = os.path.join(self.logs, fname)
-            # skip directories
-            if not os.path.isfile(full_name):
-                continue
-            shutil.copy(full_name, log_path)
-        self._split_logcat(log_path)
-
-
-    def wait_on_files(self, wait_files, poll_rate=0.5, timeout=60):
-        assert poll_rate >= 0, "Invalid poll_rate %d, must be greater than or equal to 0" % poll_rate
-        assert timeout >= 0, "Invalid timeout %d, must be greater than or equal to 0" % timeout
-        assert poll_rate <= timeout, "poll_rate must be less then or equal to timeout"
-        wait_end = time.time() + timeout
-        wait_files = set(self._session.realpath(x) for x in wait_files)
-
-        while wait_files:
-            open_files = set(x for _, x in self._session.get_open_files())
-            # check if any open files are in the wait file list
-            if not wait_files.intersection(open_files):
-                break
-            elif wait_end <= time.time():
-                log.debug("Timeout waiting for: %s", ", ".join(x for x in open_files if x in wait_files))
-                return False
-            time.sleep(poll_rate)
-        return True
-
-
-    def _terminate(self):
-        assert self._package is not None
-        assert self._session, "Device not connected"
-        # TODO: is this the best way???
-        self._session.call(["shell", "am", "force-stop", self._package])
-
-
-    def wait(self):
-        while self.is_running():
-            time.sleep(0.25)
-
-
 def main(argv=None):  # pylint: disable=missing-docstring
     # set output verbosity
     if bool(os.getenv("DEBUG")):
@@ -862,10 +54,10 @@ def main(argv=None):  # pylint: disable=missing-docstring
             log.error("Could not install %r", args.install)
             return 1
         log.info("Installed %r", package)
-    elif args.install_asan is not None:
-        log.info("Installing ASan from %r ...", args.install_asan)
-        session.install_asan(args.install_asan)
-        log.info("Device reboot required")
+    #elif args.install_asan is not None:
+    #    log.info("Installing ASan from %r ...", args.install_asan)
+    #    session.install_asan(args.install_asan)
+    #    log.info("Device reboot required")
     elif args.airplane_mode is not None:
         session.set_airplane_mode(mode=args.airplane_mode > 0)
     elif args.launch:
@@ -886,7 +78,6 @@ def main(argv=None):  # pylint: disable=missing-docstring
             proc.cleanup()
     else:
         parser.print_help()
-
     return 0
 
 
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
new file mode 100644
index 00000000..6d1a7e33
--- /dev/null
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -0,0 +1,117 @@
+# pylint: disable=protected-access
+import pytest
+
+from .device import ADBProcess, ADBSession, ADBSessionError, ADBLaunchError
+
+def test_adb_process_01(mocker):
+    """test creating a simple device"""
+    test_pkg = "org.test.preinstalled"
+    fake_session = mocker.Mock(spec=ADBSession)
+    proc = ADBProcess(test_pkg, fake_session)
+    try:
+        assert isinstance(proc._session, ADBSession)
+        assert proc._package == test_pkg
+        assert proc.logs is None
+        assert proc.profile is None
+        assert proc.reason == proc.RC_CLOSED
+        assert proc._pid is None
+        proc.close()
+        assert not proc.logs  # should not have logs
+    finally:
+        proc.cleanup()
+
+def test_adb_process_02(mocker):
+    """test creating device with unknown package"""
+    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.is_installed.side_effect = ADBSessionError("blah")
+    with pytest.raises(ADBSessionError):
+        ADBProcess("org.test.unknown", fake_session)
+
+def test_adb_process_03(mocker):
+    """test failed launch() and is_running()"""
+    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.call.return_value = (1, b"")
+    fake_session.collect_logs.return_value = b""
+    fake_session.listdir.return_value = ()
+    fake_session.process_exists.return_value = False
+    proc = ADBProcess("org.test.preinstalled", fake_session)
+    try:
+        assert not proc.is_running()
+        with pytest.raises(ADBLaunchError):
+            proc.launch("fake.url")
+        assert not proc.is_running()
+        proc.cleanup()
+        assert proc.logs is None
+    finally:
+        proc.cleanup()
+
+def test_adb_process_04(mocker):
+    """test launch(), is_running() and is_healthy()"""
+    fake_bs = mocker.patch("grizzly.target.adb_device.device.Bootstrapper", autospec=True)
+    fake_bs.return_value.location.return_value = "http://localhost"
+    fake_bs.return_value.port.return_value = 1234
+    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.call.return_value = (0, b"Status: ok")
+    fake_session.collect_logs.return_value = b""
+    fake_session.get_pid.return_value = 1337
+    fake_session.listdir.return_value = ()
+    #fake_session.process_exists.return_value = False
+    proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
+    try:
+        assert not proc.is_running()
+        assert proc.launch("fake.url")
+        assert proc.is_running()
+        assert proc.is_healthy()
+        proc.close()
+        assert proc._pid is None
+        assert proc.logs
+    finally:
+        proc.cleanup()
+    assert fake_bs.return_value.wait.call_count == 1
+    assert fake_bs.return_value.close.call_count == 1
+
+def test_adb_process_05(mocker):
+    """test launch() with environment variables"""
+    fake_bs = mocker.patch("grizzly.target.adb_device.device.Bootstrapper", autospec=True)
+    fake_bs.return_value.location.return_value = "http://localhost"
+    fake_bs.return_value.port.return_value = 1234
+    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.call.return_value = (0, b"Status: ok")
+    fake_session.collect_logs.return_value = b""
+    fake_session.get_pid.return_value = 1337
+    fake_session.listdir.return_value = ()
+    env = {"test1":"1", "test2": "2"}
+    proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
+    try:
+        assert proc.launch("fake.url", env_mod=env)
+        assert proc.is_running()
+        proc.close()
+    finally:
+        proc.cleanup()
+
+def test_adb_process_06(mocker):
+    """test wait_on_files()"""
+    fake_bs = mocker.patch("grizzly.target.adb_device.device.Bootstrapper", autospec=True)
+    fake_bs.return_value.location.return_value = "http://localhost"
+    fake_bs.return_value.port.return_value = 1234
+    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.call.return_value = (0, b"Status: ok")
+    fake_session.collect_logs.return_value = b""
+    fake_session.get_open_files.return_value = ((1, "some_file"),)
+    fake_session.get_pid.return_value = 1337
+    fake_session.listdir.return_value = ()
+    fake_session.realpath.side_effect = str.strip
+    proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
+    try:
+        proc.wait_on_files(["not_running"])
+        assert proc.launch("fake.url")
+        assert proc.wait_on_files([])
+        fake_session.get_open_files.return_value = ((1, "some_file"), (1, "/existing/file.txt"))
+        assert not proc.wait_on_files(["/existing/file.txt"], poll_rate=0.1, timeout=0.3)
+        proc.close()
+    finally:
+        proc.cleanup()
+
+# TODO:
+# _process_logs
+# save_logs
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
new file mode 100644
index 00000000..db45cc7f
--- /dev/null
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -0,0 +1,618 @@
+# pylint: disable=protected-access
+import os
+import subprocess
+import zipfile
+
+import pytest
+
+from .device import ADBCommandError, ADBSession, ADBSessionError
+
+def test_adb_session_01(mocker):
+    """test ADBSession._call_adb()"""
+    def fake_call(cmd, stderr=None, stdout=None):
+        assert cmd[0] == "test"
+        stderr.write("")
+        stdout.write("blah_out")
+        return 0
+    mocker.patch("subprocess.call", side_effect=fake_call)
+    ret, output = ADBSession._call_adb(["test"])
+    assert ret == 0
+    assert "blah_out" in output
+    # test with invalid timeout
+    with pytest.raises(AssertionError):
+        ADBSession._call_adb(["test"], timeout=-1)
+    # test with timeout
+    class FakeProc(object):
+        def __init__(self, cmd, stderr=None, stdout=None):
+            assert cmd[0] == "test"
+            self.stdout = stdout
+            stderr.write(b"")
+            stdout.write(b"init\n")
+        def wait(self):
+            self.stdout.write(b"wait\n")
+            return 1
+        def terminate(self):
+            self.stdout.write(b"terminate\n")
+        def poll(self):
+            self.stdout.write(b"poll\n")
+    mocker.patch("subprocess.Popen")
+    subprocess.Popen = FakeProc
+    ret, output = ADBSession._call_adb(["test"], timeout=0.5)
+    assert ret == 1
+    assert "init" in output
+    assert "poll" in output
+    assert "terminate" in output
+    assert "wait" in output
+
+def test_adb_session_02():
+    """test creating a session with invalid args"""
+    with pytest.raises(ValueError):
+        ADBSession("invalid.ip")
+    with pytest.raises(ValueError):
+        ADBSession("127.0.0.1", port=7)
+    with pytest.raises(ValueError):
+        ADBSession("127.0.0.1", port="bad")
+
+def test_adb_session_03():
+    """test simple ADBSession"""
+    test_ip = "127.0.0.1"
+    test_port = 5556
+    session = ADBSession(test_ip, test_port)
+    assert not session.connected
+    assert not session._root
+    assert session._ip_addr == test_ip
+    assert session._port == test_port
+
+def test_adb_session_04():
+    """test ADBSession._devices_available()"""
+    adb_output = (
+        "List of devices attached",
+        "* daemon not running; starting now at tcp:5037",
+        "* daemon started successfully",
+        "emulator-5554   device")
+    assert not ADBSession._devices_available("\n".join(adb_output[:-1]))
+    assert ADBSession._devices_available("\n".join(adb_output))
+
+def test_adb_session_05(mocker):
+    """test simple ADBSession.create()"""
+    test_ip = "localhost"
+    test_port = 5555
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "connect":
+            assert cmd[2] == ":".join([test_ip, str(test_port)])
+            return 0, ""
+        # already Permissive
+        if cmd[1] == "shell" and cmd[2] == "getenforce":
+            return 0, "Permissive"
+        # already root
+        if cmd[1] == "shell" and cmd[2] == "whoami":
+            return 0, "root"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession.create(test_ip, test_port)
+    assert session is not None
+    assert session.connected
+    assert session._root
+    assert session._ip_addr == test_ip
+    assert session._port == test_port
+
+def test_adb_session_06(mocker):
+    """test full ADBSession.create()"""
+    test_ip = "localhost"
+    test_port = 5555
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "connect":
+            if obj.connected:
+                return 0, "already connected"
+            assert cmd[2] == ":".join([test_ip, str(test_port)])
+            obj.connected = True
+            return 0, ""
+        if cmd[1] == "disconnect":
+            if not obj.connected:
+                return 0, "already disconnected"
+            assert cmd[2] == ":".join([test_ip, str(test_port)])
+            obj.connected = False
+            return 0, ""
+        if cmd[1] == "root":
+            obj._root = True
+            obj.connected = False
+            return 0, "restarting adbd as root"
+        if cmd[1] == "shell" and cmd[2] == "getenforce":
+            return 0, "Permissive"
+        if cmd[1] == "shell" and cmd[2] == "whoami":
+            if obj._root:
+                return 0, "root"
+            return 0, "shell"
+        if cmd[1] == "unroot":
+            obj._root = False
+            obj.connected = False
+            return 0, "restarting adbd as non root"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession.create(test_ip, test_port)
+    assert session is not None
+    assert session.connected
+    assert session._root
+    assert session._ip_addr == test_ip
+    assert session._port == test_port
+    session.disconnect()
+    assert not session.connected
+    assert not session._root
+
+def test_adb_session_07(mocker):
+    """test ADBSession.create() without IP"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "connect":
+            obj.connected = True
+            return 0, ""
+        if cmd[1] == "disconnect":
+            obj.connected = False
+            return 0, ""
+        if cmd[1] == "devices":
+            return 0, "\n".join(("List of devices attached",
+                                 "* daemon not running; starting now at tcp:5037",
+                                 "* daemon started successfully",
+                                 "emulator-5554   device"))
+        if cmd[1] == "shell" and cmd[2] == "getenforce":
+            return 0, "Permissive"
+        if cmd[1] == "shell" and cmd[2] == "whoami":
+            return 0, "shell"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession.create(as_root=False)
+    assert session is not None
+    assert session._ip_addr is None
+    assert session._port is None
+    assert session.connected
+    assert not session._root
+    session.disconnect()
+    assert not session.connected
+
+def test_adb_session_08(mocker):
+    """test ADBSession.connect() and ADBSession.disconnect()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "connect":
+            if obj.connected:
+                return 0, "already connected"
+            obj.connected = True
+            return 0, ""
+        if cmd[1] == "devices":
+            return 0, "\n".join(("List of devices attached",
+                                 "* daemon not running; starting now at tcp:5037",
+                                 "* daemon started successfully",
+                                 "emulator-5554   device"))
+        if cmd[1] == "disconnect":
+            if not obj.connected:
+                return 0, "already disconnected"
+            obj.connected = False
+            return 0, ""
+        if cmd[1] == "root":
+            obj._root = True
+            obj.connected = False
+            return 0, "restarting adbd as root"
+        if cmd[1] == "shell" and cmd[2] == "getenforce":
+            return 0, "Permissive"
+        if cmd[1] == "shell" and cmd[2] == "whoami":
+            if obj._root:
+                return 0, "root"
+            return 0, "shell"
+        if cmd[1] == "unroot":
+            obj._root = False
+            obj.connected = False
+            return 0, "restarting adbd as non root"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    assert not session.connected
+    assert not session._root
+    session.disconnect()
+    # connect and enable root
+    assert session.connect(max_attempts=1)
+    assert session.connected
+    assert session._root
+    session.disconnect()
+    assert not session.connected
+    assert not session._root
+    # connect and do not enable root
+    assert session.connect(as_root=False)
+    assert session.connected
+    assert not session._root
+    session.disconnect()
+    assert not session.connected
+    assert not session._root
+    # connect() x2 (already connected)
+    assert session.connect()
+    assert session.connected
+    assert session.connect()
+    assert session.connected
+    assert session._root
+    session.disconnect()
+    assert not session.connected
+    assert not session._root
+
+def test_adb_session_09(mocker):
+    """test ADBSession.connect() with unavailable device"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "connect":
+            return 1, "unable to connect"
+        if cmd[1] == "disconnect":
+            return 0, ""
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    assert not session.connected
+    assert not session._root
+    session.disconnect()
+    # connect and enable root
+    assert not session.connect(max_attempts=1)
+    assert not session.connected
+    assert not session._root
+
+def test_adb_session_10(mocker):
+    """test ADBSession.all() with unknown command"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        return 1, "Android Debug Bridge version 1.0.XX"
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    session._root = True
+    with pytest.raises(ADBCommandError):
+        session.call(["unknown-cmd"])
+
+def test_adb_session_11(tmp_path, mocker):
+    """test ADBSession.install()"""
+    def fake_get_package_name(_):
+        with zipfile.ZipFile(apk_file, mode="r")as zfp:
+            with zfp.open("package-name.txt", "r") as pfp:
+                return pfp.read().strip()
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "install":
+            assert cmd[2] == "-r"
+            assert "test.apk" in cmd[3]
+            return 0, "Success"
+        if cmd[1] == "shell":
+            assert cmd[2] == "pm"
+            assert cmd[3] == "grant"
+            assert cmd[4] == "test-package.blah.foo"
+            return 0, ""
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    session.get_package_name = fake_get_package_name
+    with pytest.raises(IOError):
+        session.install("fake_path")
+    pkg_file = tmp_path / "package-name.txt"
+    apk_file = str(tmp_path / "test.apk")
+    syms_path = str(tmp_path / "symbols")
+    os.makedirs(syms_path)
+    pkg_file.write_bytes(b"test-package.blah.foo\n")
+    with zipfile.ZipFile(apk_file, mode="w") as z_out:
+        z_out.write(str(pkg_file), "package-name.txt")
+    assert not session.symbols_path(apk_file)
+    assert session.install(apk_file)
+    session.symbols[apk_file] = syms_path
+    assert session.symbols_path(apk_file) == syms_path
+    # TODO: test failed to install, failed to get package name
+
+def test_adb_session_12(mocker):
+    """test ADBSession.uninstall()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "uninstall" and cmd[2] == "org.test.preinstalled":
+            return 0, "Success"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    assert not session.uninstall("org.test.unknown")
+    session.connected = True
+    #assert session.uninstall("org.test.unknown")
+    assert session.uninstall("org.test.preinstalled")
+
+def test_adb_session_13(mocker):
+    """test ADBSession.get_pid()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "shell" and cmd[2] == "ps":
+            output = (
+                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME",
+                "test      1337  1772  1024   1024 SyS_epoll_ 00000000 S org.test.preinstalled",
+                "root      5847  1     315992 2348  poll_sched 00000000 S /sbin/adbd",
+                "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora",
+                "root      5944  5847  6280   2360           0 00000000 R ps",
+                "")
+            return 0, "\n".join(output)
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    with pytest.raises(ADBSessionError):
+        session.get_pid("org.test.unknown")
+    session.connected = True
+    assert session.get_pid("org.test.unknown") is None
+    assert session.get_pid("org.test.preinstalled") == 1337
+
+def test_adb_session_14(mocker):
+    """test ADBSession.is_installed()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "shell" and cmd[2] == "pm":
+            assert cmd[3] == "list"
+            assert cmd[4] == "packages"
+            output = (
+                "package:org.mozilla.fennec_aurora",
+                "package:org.test.preinstalled",
+                "package:com.android.phone",
+                "package:com.android.shell")
+            return 0, "\n".join(output)
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    assert not session.is_installed("org.test.unknown")
+    assert session.is_installed("org.test.preinstalled")
+
+def test_adb_session_15(mocker):
+    """test ADBSession.get_packages()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "shell" and cmd[2] == "pm":
+            assert cmd[3] == "list"
+            assert cmd[4] == "packages"
+            output = (
+                "package:org.mozilla.fennec_aurora",
+                "package:org.test.preinstalled",
+                "package:com.android.phone",
+                "package:com.android.shell")
+            return 0, "\n".join(output)
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    pkgs = session.get_packages()
+    assert len(pkgs) == 4
+    assert "com.android.phone" in pkgs
+    assert "com.android.shell" in pkgs
+    assert "org.mozilla.fennec_aurora" in pkgs
+    assert "org.test.preinstalled" in pkgs
+
+def test_adb_session_16(mocker):
+    """test ADBSession.collect_logs()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "logcat":
+            assert cmd[2] == "-d"
+            assert cmd[3] == "*:I"
+            if len(cmd) == 5:
+                assert cmd[-1].startswith("--pid=")
+                pid = int(cmd[-1].split("=")[-1])
+            else:
+                pid = -1
+            output = []
+            if pid in (-1, 9990):
+                output += [
+                    "07-27 12:10:15.414  9990  9990 W fake log",
+                    "07-27 12:10:15.430  9990  9990 I fake log",
+                    "07-27 12:10:15.442  9990  4714 I fake log",
+                    "07-27 12:10:15.505  9990  4713 E fake log",
+                    "07-27 12:10:15.520  9990  4719 I fake log",
+                    "07-27 12:10:15.529  9990  4707 W fake log",
+                    "07-27 12:10:15.533  9990  4714 E fake log"]
+            if pid == -1:
+                output += [
+                    "07-27 12:39:27.188  3049  3049 W fake log",
+                    "07-27 12:39:27.239  1887  1994 I fake log",
+                    "07-27 12:39:27.286  2767  7142 I fake log",
+                    "07-27 12:39:27.441  7128  7128 I fake log"]
+            return 0, "\n".join(output)
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    assert len(session.collect_logs().splitlines()) == 11
+    assert len(session.collect_logs(9990).splitlines()) == 7
+    assert not session.collect_logs(1111).splitlines()
+
+def test_adb_session_17(mocker):
+    """test ADBSession.get_packages()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "shell" and cmd[2] == "lsof":
+            if len(cmd) == 5:
+                assert cmd[3].startswith("-p")
+                pids = {int(x) for x in cmd[-1].split(",")}
+            output = (
+                "COMMAND     PID    USER   FD      TYPE   DEVICE  SIZE/OFF       NODE NAME",
+                "init          1    root  cwd   unknown                               /proc/1/cwd (readlink: Permission denied)",
+                "lsof      15988   shell  cwd       DIR     0,13       780       4234 /",
+                "lsof      15988   shell  txt       REG      8,1    432284    1696174 /system/bin/toybox",
+                "lsof      15988   shell    4r      DIR      0,4         0     120901 /proc/15988/fd",
+                "a.fennec_  9991  u0_a80   98r      REG      8,1    306672    1696611 /system/fonts/blah.ttf",
+                "a.fennec_  9990  u0_a80  cwd       DIR     0,13       780       4234 /",
+                "a.fennec_  9990  u0_a80  txt       REG      8,1     17948    1695879 /system/bin/app_process32",
+                "a.fennec_  9990  u0_a80  mem   unknown                               /dev/ashmem/dalvik-main space (deleted)",
+                "a.fennec_  9990  u0_a80  mem       CHR    10,58                 4485 /dev/binder",
+                "a.fennec_  9990  u0_a80  mem   unknown                               /dev/ashmem/dalvik-allocspace zygote / x 0 (deleted)",
+                "a.fennec_  9990  u0_a80  mem       REG      8,1    152888    1704079 /system/lib/libexpat.so",
+                "a.fennec_  9990  u0_a80   54u      REG      8,1    329632    1769879 /data/data/org.mozilla.fennec_aurora/files/mozilla/a.default/browser.db-wal",
+                "a.fennec_  9990  u0_a80   55u     IPv6                0t0      44549 TCP []:49232->[]:443 (ESTABLISHED)",
+                "a.fennec_  9990  u0_a80   75w     FIFO      0,9       0t0      44634 pipe:[44634]",
+                "a.fennec_  9990  u0_a80   76u     sock                0t0      44659 socket:[44659]",
+                "a.fennec_  9990  u0_a80   95u      REG      8,1     98304    1769930 /data/data/org.mozilla.fennec_aurora/files/mozilla/a.default/permissions.sqlite",
+                "a.fennec_  9990  u0_a80   98r      REG      8,1    306672    1696611 /system/fonts/Roboto-Regular.ttf",
+                "a.fennec_  9990  u0_a80  122u      CHR    10,59       0t0       4498 /dev/ashmem",
+                "a.fennec_  9990  u0_a80  123u     IPv4                0t0      44706 UDP :1900->:0",
+                "a.fennec_  9990  u0_a80  125u     0000     0,10       0t0       3655 anon_inode:[eventpoll]",
+                "a.fennec_  9990  u0_a80  126u     IPv4                0t0      44773 TCP :58190->:443 (ESTABLISHED)",
+                "a.fennec_  9990  u0_a80  128u     unix                0t0      44747 socket",
+                "a.fennec_  9990  u0_a80  130u     IPv4                0t0      44840 TCP :35274->:443 (SYN_SENT)",
+                "")
+            return 0, "\n".join(output)
+        if cmd[1] == "shell" and cmd[2] == "ps":
+            assert cmd[3] == "--ppid"
+            assert cmd[4] == "9990"
+            output = (
+                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME",
+                "u0_a80    9991  9990  3332   3331 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora",
+                "")
+            return 0, "\n".join(output)
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    # list all open files
+    assert len(session.get_open_files()) == 7
+    # list process specific open files
+    assert len(session.get_open_files(pid=9990)) == 5
+    # list process and children specific open files
+    assert len(session.get_open_files(pid=9990, children=True)) == 6
+    with pytest.raises(AssertionError):
+        session.get_open_files(pid=None, children=True)
+
+def test_adb_session_18(mocker):
+    """test ADBSession._get_procs()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "shell" and cmd[2] == "ps":
+            print(cmd)
+            if len(cmd) == 5:
+                assert cmd[3] == "--ppid"
+                ppid = int(cmd[-1])
+            else:
+                ppid = None
+            output = [
+                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME"]
+            if ppid is None:
+                output += [
+                    "root      1     0     8896   2208  SyS_epoll_ 00000000 S /init",
+                    "root      1242  2     0      0         kswapd 00000000 S kswapd0",
+                    "test      1337  1772  1024   1024 SyS_epoll_ 00000000 S org.test.preinstalled",
+                    "test      1338  1337  1024   1024 SyS_epoll_ 00000000 S org.test.child",
+                    "root      1772  1     1620804 122196 poll_sched 00000000 S zygote",
+                    "media_rw  2158  1758  0      0              0 00000000 Z sdcard",
+                    "audioserver 1773  1     34000  9624  binder_thr 00000000 S /system/bin/audioserver",
+                    "root      5847  1     315992 2348  poll_sched 00000000 S /sbin/adbd",
+                    "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora",
+                    "root      5944  5847  6280   2360           0 00000000 R ps"]
+            elif ppid == 9990:
+                output += [
+                    "u0_a80    9991  9990  3332   3331 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora"]
+            output += [""]
+            return 0, "\n".join(output)
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    assert len(session._get_procs()) == 10
+    dev_procs = session._get_procs(pid_children=9990)
+    assert len(dev_procs) == 1
+    assert dev_procs[0].pid == 9991
+
+def test_adb_session_19(tmp_path, mocker):
+    """test ADBSession.push()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "push":
+            assert "test.txt" in cmd[2]
+            assert cmd[3] == "dst"
+            return 0, " pushed. "
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    with pytest.raises(IOError):
+        session.push("not_a_file", "dst")
+    push_file = tmp_path / "test.txt"
+    push_file.write_bytes(b"test\n")
+    assert session.push(str(push_file), "dst")
+
+def test_adb_session_20(mocker):
+    """test ADBSession.pull()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "pull":
+            assert cmd[2] == "src"
+            assert cmd[3] == "dst"
+            return 0, " pulled. "
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    assert session.pull("src", "dst")
+
+def test_adb_session_21(mocker):
+    """test ADBSession.clear_log()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "logcat":
+            assert cmd[2] == "--clear"
+            return 0, ""
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    assert session.clear_logs()
+
+def test_adb_session_22(mocker):
+    """test ADBSession.listdir()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "shell" and cmd[2] == "ls":
+            assert cmd[3] == "-A"
+            if cmd[4] == "missing-dir":
+                return 1, ""
+            return 0, "test"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    with pytest.raises(IOError):
+        session.listdir("missing-dir")
+    dir_list = session.listdir("fake-dir")
+    assert len(dir_list) == 1
+    assert "test" in session.listdir("fake-dir")
+
+def test_adb_session_23(mocker):
+    """test ADBSession.process_exists()"""
+    def fake_adb_call(obj, cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "shell" and cmd[2] == "ps":
+            assert cmd[3] == "9990"
+            output = (
+                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME",
+                "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora",
+                "")
+            return 0, "\n".join(output)
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    ADBSession._call_adb = fake_adb_call
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    assert session.process_exists(9990)
+
+# TODO:
+# reverse
diff --git a/grizzly/target/adb_device/test_device.py b/grizzly/target/adb_device/test_device.py
deleted file mode 100644
index a77b4129..00000000
--- a/grizzly/target/adb_device/test_device.py
+++ /dev/null
@@ -1,385 +0,0 @@
-import logging
-import os
-import shutil
-import tempfile
-import unittest
-import zipfile
-
-from .device import ADBCommandError, ADBProcess, ADBSession, ADBSessionError, ADBLaunchError
-from .fake_adb import FakeADBState
-
-# set output verbosity
-if bool(os.getenv("DEBUG")):
-    logging.basicConfig(
-        format="%(levelname).1s %(name)s [%(asctime)s] %(message)s",
-        datefmt="%Y-%m-%d %H:%M:%S",
-        level=logging.DEBUG)
-else:
-    logging.basicConfig(
-        format="[%(asctime)s] %(message)s",
-        datefmt="%Y-%m-%d %H:%M:%S",
-        level=logging.INFO)
-
-CWD = os.path.realpath(os.path.dirname(__file__))
-
-class ADBSessionTests(unittest.TestCase):  # pylint: disable=too-many-public-methods
-
-    def setUp(self):
-        ADBSession.BIN_ADB = os.path.join(CWD, "fake_adb.py")
-        if os.path.isfile(FakeADBState.STATE_FILE):
-            os.remove(FakeADBState.STATE_FILE)
-        self.tmpdir = tempfile.mkdtemp(prefix="adbdev_test")
-
-    def tearDown(self):
-        if os.path.isdir(self.tmpdir):
-            shutil.rmtree(self.tmpdir)
-        if os.path.isfile(FakeADBState.STATE_FILE):
-            os.remove(FakeADBState.STATE_FILE)
-
-    def test_01(self):
-        "test creating a session with invalid args"
-        with self.assertRaises(ValueError):
-            ADBSession("invalid.ip")
-        with self.assertRaises(ValueError):
-            ADBSession("127.0.0.1", port=7)
-        with self.assertRaises(ValueError):
-            ADBSession("127.0.0.1", port="bad")
-
-    def test_02(self):
-        "test simple session"
-        test_ip = "127.0.0.1"
-        test_port = 5556
-        session = ADBSession(test_ip, test_port)
-        self.assertFalse(session.connected)
-        self.assertFalse(session._root)  # pylint: disable=protected-access
-        self.assertEqual(session._ip_addr, test_ip)  # pylint: disable=protected-access
-        self.assertEqual(session._port, test_port)  # pylint: disable=protected-access
-
-    def test_03(self):
-        "test _devices_available()"
-        adb_output = [
-            "List of devices attached",
-            "* daemon not running; starting now at tcp:5037",
-            "* daemon started successfully",
-            "emulator-5554   device"]
-        self.assertFalse(ADBSession._devices_available("\n".join(adb_output[:-1])))  # pylint: disable=protected-access
-        self.assertTrue(ADBSession._devices_available("\n".join(adb_output)))  # pylint: disable=protected-access
-
-    def test_04(self):
-        "test create()"
-        test_ip = "localhost"
-        test_port = 5555
-        session = ADBSession.create(test_ip, test_port)
-        self.assertIsNotNone(session)
-        self.assertTrue(session.connected)
-        self.assertTrue(session._root)  # pylint: disable=protected-access
-        self.assertEqual(session._ip_addr, test_ip)  # pylint: disable=protected-access
-        self.assertEqual(session._port, test_port)  # pylint: disable=protected-access
-        session.disconnect()
-        self.assertFalse(session.connected)
-        self.assertFalse(session._root)  # pylint: disable=protected-access
-        # test without IP
-        if os.path.isfile(FakeADBState.STATE_FILE):
-            os.remove(FakeADBState.STATE_FILE)
-        session = ADBSession.create()
-        self.assertIsNone(session._ip_addr)  # pylint: disable=protected-access
-        self.assertIsNone(session._port)  # pylint: disable=protected-access
-        self.assertIsNotNone(session)
-        self.assertTrue(session.connected)
-        self.assertTrue(session._root)  # pylint: disable=protected-access
-        session.disconnect()
-        self.assertFalse(session.connected)
-        self.assertFalse(session._root)  # pylint: disable=protected-access
-
-    def test_05(self):
-        "test connect() and disconnect()"
-        session = ADBSession("127.0.0.1")
-        self.assertFalse(session.connected)
-        self.assertFalse(session._root)  # pylint: disable=protected-access
-        session.disconnect()
-        # connect and enable root
-        state = FakeADBState()
-        state.connected = False
-        state.root_enabled = False
-        state.save()
-        self.assertTrue(session.connect(max_attempts=1))
-        self.assertTrue(session.connected)
-        self.assertTrue(session._root)  # pylint: disable=protected-access
-        session.disconnect()
-        self.assertFalse(session.connected)
-        self.assertFalse(session._root)  # pylint: disable=protected-access
-        # connect and do not enable root
-        state = FakeADBState()
-        state.connected = False
-        state.root_enabled = False
-        state.save()
-        self.assertTrue(session.connect(as_root=False))
-        self.assertTrue(session.connected)
-        self.assertFalse(session._root)  # pylint: disable=protected-access
-        session.disconnect()
-        self.assertFalse(session.connected)
-        self.assertFalse(session._root)  # pylint: disable=protected-access
-        # connect() x2 (already connected)
-        state = FakeADBState()
-        state.connected = False
-        state.root_enabled = False
-        state.save()
-        self.assertTrue(session.connect())
-        self.assertTrue(session.connected)
-        self.assertTrue(session.connect())
-        self.assertTrue(session.connected)
-        self.assertTrue(session._root)  # pylint: disable=protected-access
-        session.disconnect()
-        self.assertFalse(session.connected)
-        self.assertFalse(session._root)  # pylint: disable=protected-access
-
-    def test_06(self):
-        "test connect() with unavailable device"
-        session = ADBSession("127.0.0.1")
-        # connect to
-        state = FakeADBState()
-        state.connected = False
-        state.unavailable = True
-        state.save()
-        self.assertFalse(session.connect(max_attempts=1))
-        self.assertFalse(session.connected)
-        self.assertFalse(session._root)  # pylint: disable=protected-access
-        session.disconnect()
-        self.assertFalse(session.connected)
-        self.assertFalse(session._root)  # pylint: disable=protected-access
-
-    def test_07(self):
-        "test call() with invalid command"
-        session = ADBSession.create("127.0.0.1", 5555)
-        with self.assertRaises(ADBCommandError):
-            session.call(["unknown-cmd"])  # pylint: disable=protected-access
-        session.disconnect()
-
-    def test_08(self):
-        "test install()"
-        def _fake_get_package_name(apk_path):
-            with zipfile.ZipFile(apk_file, mode="r")as zfp:
-                with zfp.open("package-name.txt", "r") as pfp:
-                    return pfp.read().strip()
-
-        pkg_name = "test-package.blah.foo\n"
-        session = ADBSession("127.0.0.1")
-        session.get_package_name = _fake_get_package_name
-        # connect and do not enable root
-        self.assertTrue(session.connect())
-        with self.assertRaises(IOError):
-            session.install("fake_path")
-
-        pkg_file = os.path.join(self.tmpdir, "package-name.txt")
-        apk_file = os.path.join(self.tmpdir, "test.apk")
-        syms_path = os.path.join(self.tmpdir, "symbols")
-        os.makedirs(syms_path)
-        with open(pkg_file, "w") as out_fp:
-            out_fp.write(pkg_name)
-        with zipfile.ZipFile(apk_file, mode="w")as z_out:
-            z_out.write(pkg_file, "package-name.txt")
-        self.assertFalse(session.symbols_path(apk_file))
-        self.assertTrue(session.install(apk_file))
-        session.symbols[apk_file] = syms_path
-        self.assertEqual(session.symbols_path(apk_file), syms_path)
-        session.disconnect()
-        # TODO: test failed to install, failed to get package name
-
-    def test_09(self):
-        "test uninstall()"
-        session = ADBSession("127.0.0.1")
-        self.assertFalse(session.uninstall("org.test.unknown"))
-        self.assertTrue(session.connect())
-        self.assertTrue(session.uninstall("org.test.unknown"))
-        self.assertTrue(session.uninstall("org.test.preinstalled"))
-        session.disconnect()
-
-    def test_10(self):
-        "test get_pid()"
-        session = ADBSession("127.0.0.1")
-        with self.assertRaises(ADBSessionError):
-            session.get_pid("org.test.unknown")
-        self.assertTrue(session.connect())
-        self.assertIsNone(session.get_pid("org.test.unknown"))
-        self.assertEqual(session.get_pid("org.test.preinstalled"), 1337)
-        session.disconnect()
-
-    def test_11(self):
-        "test is_installed()"
-        session = ADBSession("127.0.0.1")
-        self.assertTrue(session.connect())
-        self.assertFalse(session.is_installed("org.test.unknown"))
-        self.assertTrue(session.is_installed("org.test.preinstalled"))
-        session.disconnect()
-
-    def test_12(self):
-        "test get_packages()"
-        session = ADBSession("127.0.0.1")
-        self.assertTrue(session.connect())
-        pkgs = session.get_packages()
-        self.assertEqual(len(pkgs), 4)
-        self.assertNotIn("org.test.unknown", pkgs)
-        self.assertIn("org.test.preinstalled", pkgs)
-        session.disconnect()
-
-    def test_13(self):
-        "test collect_logs()"
-        session = ADBSession("127.0.0.1")
-        self.assertTrue(session.connect())
-        self.assertEqual(len(session.collect_logs().splitlines()), 16)
-        self.assertEqual(len(session.collect_logs(9990).splitlines()), 11)
-        self.assertEqual(len(session.collect_logs(1111).splitlines()), 0)
-        session.disconnect()
-
-    def test_14(self):
-        "test get_open_files()"
-        session = ADBSession("127.0.0.1")
-        self.assertTrue(session.connect())
-        # list all open files
-        self.assertEqual(len(session.get_open_files()), 7)
-        # list process specific open files
-        self.assertEqual(len(session.get_open_files(pid=9990)), 5)
-        # list process and children specific open files
-        self.assertEqual(len(session.get_open_files(pid=9990, children=True)), 6)
-        with self.assertRaises(AssertionError):
-            session.get_open_files(pid=None, children=True)
-        session.disconnect()
-
-    def test_15(self):
-        "test _get_procs()"
-        session = ADBSession("127.0.0.1")
-        self.assertTrue(session.connect())
-        self.assertEqual(len(session._get_procs()), 10)  # pylint: disable=protected-access
-        dev_procs = session._get_procs(pid_children=9990)  # pylint: disable=protected-access
-        self.assertTrue(len(dev_procs), 1)
-        self.assertEqual(dev_procs[0].pid, 9991)
-        session.disconnect()
-
-    def test_16(self):
-        "test push()"
-        session = ADBSession("127.0.0.1")
-        self.assertTrue(session.connect())
-        with self.assertRaises(IOError):
-            session.push("not_a_file", "dst")
-        self.assertTrue(session.push(ADBSession.BIN_ADB, "dst"))
-        session.disconnect()
-
-    def test_17(self):
-        "test pull()"
-        session = ADBSession("127.0.0.1")
-        self.assertTrue(session.connect())
-        self.assertTrue(session.pull("src", "dst"))
-        session.disconnect()
-
-    def test_18(self):
-        "test clear_log()"
-        session = ADBSession("127.0.0.1")
-        self.assertTrue(session.connect())
-        self.assertTrue(session.clear_logs())
-        session.disconnect()
-
-    def test_19(self):
-        "test listdir()"
-        session = ADBSession("127.0.0.1")
-        self.assertTrue(session.connect())
-        with self.assertRaises(IOError):
-            session.listdir("missing-dir")
-        dir_list = session.listdir("fake-dir")
-        self.assertEqual(len(dir_list), 1)
-        self.assertIn("test", session.listdir("fake-dir"))
-        session.disconnect()
-
-    def test_20(self):
-        "test process_exists()"
-        session = ADBSession("127.0.0.1")
-        self.assertTrue(session.connect())
-        self.assertTrue(session.process_exists(9990))
-        session.disconnect()
-
-# TODO:
-# reverse
-
-
-class ADBProcessTests(unittest.TestCase):  # pylint: disable=too-many-public-methods
-
-    def setUp(self):
-        ADBSession.BIN_ADB = os.path.join(CWD, "fake_adb.py")
-        if os.path.isfile(FakeADBState.STATE_FILE):
-            os.remove(FakeADBState.STATE_FILE)
-        self.tmpdir = tempfile.mkdtemp(prefix="adbdev_test")
-        self.session = ADBSession.create("127.0.0.1", 5566)
-
-    def tearDown(self):
-        if os.path.isdir(self.tmpdir):
-            shutil.rmtree(self.tmpdir)
-        if os.path.isfile(FakeADBState.STATE_FILE):
-            os.remove(FakeADBState.STATE_FILE)
-        self.session.disconnect()
-
-    def test_01(self):
-        "test creating a simple device"
-        test_pkg = "org.test.preinstalled"
-        proc = ADBProcess(test_pkg, self.session)
-        self.addCleanup(proc.cleanup)
-        self.assertTrue(isinstance(proc._session, ADBSession))  # pylint: disable=protected-access
-        self.assertEqual(proc._package, test_pkg)  # pylint: disable=protected-access
-        self.assertIsNone(proc.logs)
-        self.assertIsNone(proc.profile)
-        self.assertEqual(proc.reason, proc.RC_CLOSED)
-        self.assertIsNone(proc._pid)  # pylint: disable=protected-access
-        proc.close()
-        self.assertFalse(proc.logs)  # should not have logs
-
-    def test_02(self):
-        "test creating device with unknown package"
-        with self.assertRaises(ADBSessionError):
-            ADBProcess("org.test.unknown", self.session)
-
-    def test_03(self):
-        "test failed launch() and is_running()"
-        proc = ADBProcess("org.test.preinstalled", self.session)
-        self.addCleanup(proc.cleanup)
-        self.assertFalse(proc.is_running())
-        with self.assertRaises(ADBLaunchError):
-            proc.launch("fake.url")
-        self.assertFalse(proc.is_running())
-        proc.cleanup()
-        self.assertIsNone(proc.logs)
-
-    def test_04(self):
-        "test launch(), is_running() and is_healthy()"
-        proc = ADBProcess("org.mozilla.fennec_aurora", self.session)
-        self.addCleanup(proc.cleanup)
-        self.assertFalse(proc.is_running())
-        self.assertTrue(proc.launch("fake.url"))
-        self.assertTrue(proc.is_running())
-        self.assertTrue(proc.is_healthy())
-        proc.close()
-        self.assertIsNone(proc._pid)  # pylint: disable=protected-access
-        self.assertGreater(len(proc.logs), 0)
-
-    def test_05(self):
-        "test launch() with environment variables"
-        proc = ADBProcess("org.mozilla.fennec_aurora", self.session)
-        self.addCleanup(proc.cleanup)
-        env = {"test1":"1", "test2": "2"}
-        self.assertTrue(proc.launch("fake.url", env_mod=env))
-        self.assertTrue(proc.is_running())
-        proc.close()
-
-    def test_06(self):
-        "test wait_on_files()"
-        proc = ADBProcess("org.mozilla.fennec_aurora", self.session)
-        self.addCleanup(proc.cleanup)
-        self.assertTrue(proc.wait_on_files(["not_running"]))
-        self.assertTrue(proc.launch("fake.url"))
-        self.assertTrue(proc.wait_on_files([]))  # is running but empty list
-        self.assertFalse(proc.wait_on_files(
-            ["/system/fonts/Roboto-Regular.ttf"],
-            poll_rate=0.1,
-            timeout=0.3))
-        proc.close()
-
-# TODO:
-# _process_logs
-# save_logs

From c0ed67141b451092fde3045bf19afd2cb748298d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 24 Jul 2019 15:28:45 -0700
Subject: [PATCH 450/531] [tests] Fix adb tests

---
 grizzly/target/adb_device/adb_process.py      | 11 +----------
 grizzly/target/adb_device/adb_session.py      |  7 ++-----
 grizzly/target/adb_device/device.py           |  4 ----
 grizzly/target/adb_device/test_adb_process.py | 11 ++++++-----
 grizzly/target/adb_device/test_adb_session.py |  2 +-
 5 files changed, 10 insertions(+), 25 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index f808785e..b59b463e 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -9,7 +9,7 @@
 from ffpuppet.minidump_parser import process_minidumps
 from ffpuppet.puppet_logger import PuppetLogger
 
-from .adb_session import ADBSession
+from .adb_session import ADBSession, ADBSessionError
 
 log = logging.getLogger("adb_device")  # pylint: disable=invalid-name
 
@@ -17,18 +17,9 @@
 __credits__ = ["Tyson Smith"]
 
 
-class ADBCommandError(RuntimeError):
-    pass
-
-class ADBSessionError(RuntimeError):
-    pass
-
 class ADBLaunchError(ADBSessionError):
     pass
 
-class ADBNoDevice(ADBSessionError):
-    pass
-
 
 class ADBProcess(object):
     # TODO: reason codes match FFPuppet
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 80b23e95..1a9a0cb3 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -44,13 +44,10 @@ def from_ps_line(cls, line):
             return None
 
 
-class ADBCommandError(RuntimeError):
+class ADBCommandError(Exception):
     pass
 
-class ADBSessionError(RuntimeError):
-    pass
-
-class ADBLaunchError(ADBSessionError):
+class ADBSessionError(Exception):
     pass
 
 class ADBNoDevice(ADBSessionError):
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index c610bd04..1c0f220a 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -54,10 +54,6 @@ def main(argv=None):  # pylint: disable=missing-docstring
             log.error("Could not install %r", args.install)
             return 1
         log.info("Installed %r", package)
-    #elif args.install_asan is not None:
-    #    log.info("Installing ASan from %r ...", args.install_asan)
-    #    session.install_asan(args.install_asan)
-    #    log.info("Device reboot required")
     elif args.airplane_mode is not None:
         session.set_airplane_mode(mode=args.airplane_mode > 0)
     elif args.launch:
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 6d1a7e33..31d34986 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -1,7 +1,8 @@
 # pylint: disable=protected-access
 import pytest
 
-from .device import ADBProcess, ADBSession, ADBSessionError, ADBLaunchError
+from .adb_process import ADBProcess, ADBLaunchError
+from .adb_session import ADBSession, ADBSessionError
 
 def test_adb_process_01(mocker):
     """test creating a simple device"""
@@ -34,7 +35,7 @@ def test_adb_process_03(mocker):
     fake_session.collect_logs.return_value = b""
     fake_session.listdir.return_value = ()
     fake_session.process_exists.return_value = False
-    proc = ADBProcess("org.test.preinstalled", fake_session)
+    proc = ADBProcess("org.test.unknown", fake_session)
     try:
         assert not proc.is_running()
         with pytest.raises(ADBLaunchError):
@@ -47,7 +48,7 @@ def test_adb_process_03(mocker):
 
 def test_adb_process_04(mocker):
     """test launch(), is_running() and is_healthy()"""
-    fake_bs = mocker.patch("grizzly.target.adb_device.device.Bootstrapper", autospec=True)
+    fake_bs = mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_bs.return_value.location.return_value = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec=ADBSession)
@@ -72,7 +73,7 @@ def test_adb_process_04(mocker):
 
 def test_adb_process_05(mocker):
     """test launch() with environment variables"""
-    fake_bs = mocker.patch("grizzly.target.adb_device.device.Bootstrapper", autospec=True)
+    fake_bs = mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_bs.return_value.location.return_value = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec=ADBSession)
@@ -91,7 +92,7 @@ def test_adb_process_05(mocker):
 
 def test_adb_process_06(mocker):
     """test wait_on_files()"""
-    fake_bs = mocker.patch("grizzly.target.adb_device.device.Bootstrapper", autospec=True)
+    fake_bs = mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_bs.return_value.location.return_value = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec=ADBSession)
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index db45cc7f..eab2be3d 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -5,7 +5,7 @@
 
 import pytest
 
-from .device import ADBCommandError, ADBSession, ADBSessionError
+from .adb_session import ADBCommandError, ADBSession, ADBSessionError
 
 def test_adb_session_01(mocker):
     """test ADBSession._call_adb()"""

From 5080e800cda786ae367dc77885c9983ee027935a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 24 Jul 2019 17:41:54 -0700
Subject: [PATCH 451/531] Remove duplicate code

---
 grizzly/target/adb_device/adb_process.py |   2 +-
 grizzly/target/adb_device/adb_session.py | 407 +----------------------
 2 files changed, 3 insertions(+), 406 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index b59b463e..5d86ebc5 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -11,7 +11,7 @@
 
 from .adb_session import ADBSession, ADBSessionError
 
-log = logging.getLogger("adb_device")  # pylint: disable=invalid-name
+log = logging.getLogger("adb_process")  # pylint: disable=invalid-name
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 1a9a0cb3..a2ae0bf6 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -1,28 +1,17 @@
-import argparse
 import logging
 import os
-import random
-import shutil
 import socket
 import subprocess
-import sys
 import tempfile
 import time
 
-from ffpuppet.helpers import append_prefs, Bootstrapper, create_profile
-from ffpuppet.minidump_parser import process_minidumps
-from ffpuppet.puppet_logger import PuppetLogger
 
-log = logging.getLogger("adb_device")  # pylint: disable=invalid-name
+log = logging.getLogger("adb_session")  # pylint: disable=invalid-name
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
 
 
-# TODO:
-# - Add ability to collect ASan logs
-
-
 class DeviceProcess(object):
     def __init__(self, memory, name, pid, ppid):
         self.memory = memory
@@ -73,7 +62,7 @@ def __init__(self, ip_addr=None, port=5555):
             except (socket.error, TypeError):
                 raise ValueError("IP Address is invalid")
             self._ip_addr = ip_addr
-            if not isinstance(port, int) or not (port > 1024 and port < 0x10000):
+            if not isinstance(port, int) or not 0x10000 > port > 1024:
                 raise ValueError("Port must be valid integer between 1025 and 65535")
             self._port = port
 
@@ -92,7 +81,6 @@ def __init__(self, ip_addr=None, port=5555):
                 log.warning("Either run the setup script or proceed with caution.")
                 time.sleep(5)
 
-
     @classmethod
     def create(cls, ip_addr=None, port=5555, as_root=True, max_attempts=10):
         session = cls(ip_addr, port)
@@ -100,7 +88,6 @@ def create(cls, ip_addr=None, port=5555, as_root=True, max_attempts=10):
             return session
         return None
 
-
     @staticmethod
     def _call_adb(cmd, timeout=None):
         with tempfile.TemporaryFile() as out_fp:
@@ -120,7 +107,6 @@ def _call_adb(cmd, timeout=None):
             out_fp.seek(0)
             return ret_code, out_fp.read().decode("utf-8", "ignore").strip()
 
-
     def call(self, cmd, require_device=True, timeout=None):
         assert isinstance(cmd, list) and cmd
         cmd = [self.BIN_ADB] + cmd
@@ -141,12 +127,10 @@ def call(self, cmd, require_device=True, timeout=None):
                 raise ADBNoDevice("No device detected!")
         return (ret_code, output)
 
-
     def clear_logs(self):
         log.debug("clear_logs()")
         return self.call(["logcat", "--clear"], timeout=10)[0] == 0
 
-
     def connect(self, as_root=True, max_attempts=10):
         max_attempts = max(1, max_attempts)
         attempt = 0
@@ -200,7 +184,6 @@ def connect(self, as_root=True, max_attempts=10):
 
         return self.connected
 
-
     def collect_logs(self, pid=None):
         log.debug("collect_logs()")
         if not self.connected:
@@ -211,7 +194,6 @@ def collect_logs(self, pid=None):
             cmd += ["--pid=%d" % pid]
         return self.call(cmd, timeout=10)[1].encode("utf-8", "ignore")
 
-
     @staticmethod
     def _devices_available(adb_output):
         entries = adb_output.strip().splitlines()
@@ -219,7 +201,6 @@ def _devices_available(adb_output):
             return False
         return entries[-1].endswith("device")
 
-
     def disconnect(self, unroot=True):
         if not self.connected:
             log.debug("already disconnected")
@@ -238,7 +219,6 @@ def disconnect(self, unroot=True):
         self.connected = False
         return True
 
-
     def listdir(self, path):
         log.debug("listdir(%r)", path)
         ret_val, output = self.call(["shell", "ls", "-A", path])
@@ -246,7 +226,6 @@ def listdir(self, path):
             raise IOError("%r does not exist" % path)
         return output.splitlines()
 
-
     def realpath(self, path):
         log.debug("realpath(%r)", path)
         ret_val, output = self.call(["shell", "realpath", path])
@@ -254,14 +233,12 @@ def realpath(self, path):
             raise IOError("%r does not exist" % path)
         return output.strip()
 
-
     def reverse(self, remote, local):
         # remote->device, local->desktop
         assert isinstance(local, int) and local > 1024 and local < 0x10000
         assert isinstance(remote, int) and remote > 1024 and remote < 0x10000
         return self.call(["reverse", "tcp:%d" % remote, "tcp:%d" % local])[0] == 0
 
-
     def reverse_remove(self, remote=None):
         # remote->device
         cmd = ["reverse"]
@@ -273,14 +250,12 @@ def reverse_remove(self, remote=None):
             cmd.append("--remove-all")
         return self.call(cmd)[0] == 0
 
-
     def uninstall(self, package):
         if not self.connected:
             log.debug("already disconnected")
             return False
         return self.call(["uninstall", package], timeout=60)[0] == 0
 
-
     def install(self, apk_path):
         log.debug("installing %r", apk_path)
         if not os.path.isfile(apk_path):
@@ -288,18 +263,14 @@ def install(self, apk_path):
         # check if package is installed
         if self.call(["install", "-r", apk_path], timeout=120)[0] != 0:
             raise ADBSessionError("Failed to install %r" % apk_path)
-
         # unpack and lookup package name
         package_name = self.get_package_name(apk_path)
-
         # set permissions
         self.call(["shell", "pm", "grant", package_name, "android.permission.READ_EXTERNAL_STORAGE"])
         self.call(["shell", "pm", "grant", package_name, "android.permission.WRITE_EXTERNAL_STORAGE"])
-
         log.debug("installed package %r (%r)", package_name, apk_path)
         return package_name
 
-
     def install_file(self, src, dst, mode=None, context=None):
         basename = os.path.basename(src)
         full_dst = os.path.join(dst, basename)
@@ -310,7 +281,6 @@ def install_file(self, src, dst, mode=None, context=None):
         if context is not None:
             self.call(["shell", "chcon", context, full_dst])
 
-
     @staticmethod
     def get_package_name(apk_path):
         # unpack and lookup package name
@@ -329,13 +299,11 @@ def get_package_name(apk_path):
             raise RuntimeError("Could not find APK package name")
         return package_name
 
-
     def get_packages(self):
         # TODO: should this be by pid or package?
         cmd = ["shell", "pm", "list", "packages"]
         return [line[8:] for line in self.call(cmd)[1].splitlines() if line.startswith("package:")]
 
-
     def get_open_files(self, pid=None, children=False, files=None):
         log.debug("get_open_files(pid=%r, children=%r, files=%r", pid, children, files)
         pids = list()
@@ -369,7 +337,6 @@ def get_open_files(self, pid=None, children=False, files=None):
 
         return open_files
 
-
     def get_pid(self, package_name):
         # NOTE: pidof is not supported pre-Android 6
         procs = self._get_procs()
@@ -383,11 +350,9 @@ def get_pid(self, package_name):
             pids.sort()
         return int(pids[0])
 
-
     def process_exists(self, pid):
         return bool(self._get_procs(pid=pid))
 
-
     def _get_procs(self, pid=None, pid_children=None):
         # default list all procs
         cmd = ["shell", "ps"]
@@ -402,27 +367,22 @@ def _get_procs(self, pid=None, pid_children=None):
                 procs.append(proc)
         return procs
 
-
     def is_installed(self, package_name):
         return package_name in self.get_packages()
 
-
     def pull(self, src, dst):
         log.debug("pull(%r, %r)", src, dst)
         return self.call(["pull", src, dst])[0] == 0
 
-
     def push(self, src, dst):
         log.debug("push(%r, %r)", src, dst)
         if not os.path.exists(src):
             raise IOError("%r does not exist" % src)
         return self.call(["push", src, dst])[0] == 0
 
-
     def symbols_path(self, package_name):
         return self.symbols.get(package_name, "")
 
-
     def set_airplane_mode(self, mode=True):
         cmd = ["shell", "settings", "put", "global", "airplane_mode_on"]
         cmd += ["1" if mode else "0"]
@@ -437,366 +397,3 @@ def set_enforce(self, value):
             self.call(["shell", "setenforce", str(value)])
             self.call(["shell", "stop"])
             self.call(["shell", "start"])
-
-
-class ADBProcess(object):
-    # TODO: reason codes match FFPuppet
-    RC_ALERT = "ALERT"  # target crashed/aborted/triggered an assertion failure etc...
-    RC_CLOSED = "CLOSED"  # target was closed by call to FFPuppet close()
-    RC_EXITED = "EXITED"  # target exited
-    #RC_WORKER = "WORKER"  # target was closed by worker thread
-    # TODO: 
-    #  def save_logs(self, *args, **kwargs):
-    #  def clone_log(self, log_id, offset=0):
-    #  def log_data(self, log_id, offset=0):
-    #  def log_length(self, log_id):... likely not going to happen because of overhead
-    def __init__(self, package_name, session, use_profile=None):
-        assert isinstance(session, ADBSession), "Expecting ADBSession"
-        if not session.is_installed(package_name):
-            raise ADBSessionError("Package %r not installed" % package_name)
-        self._launches = 0  # number of successful browser launches
-        self._package = package_name  # package to use as target process
-        self._pid = None  # pid of current target process
-        self._profile_template = use_profile  # profile that is used as a template
-        self._session = session  # ADB session with device
-        self._working_path = "/sdcard/ADBProc_%08X" % random.getrandbits(32)
-        self.logs = None
-        self.profile = None
-        self.reason = self.RC_CLOSED
-
-
-    def cleanup(self):
-        if self._launches < 0:
-            log.debug("clean_up() call ignored")
-            return
-        if self.reason is None:
-            self.close()
-        self._remove_logs()
-        # negative 'self._launches' indicates clean_up() has been called
-        self._launches = -1
-
-
-    def clone_log(self):
-        # TODO: dump logs for all browser processes
-        if self._session is None:
-            # TODO: better error?
-            return "ADB session does not exist!"
-        return self._session.collect_logs(pid=self._pid)
-
-
-    def close(self):
-        assert self._launches > -1, "clean_up() has been called"
-        if self.reason is not None:
-            log.debug("already closed!")
-            return
-        try:
-            if self._session is not None:
-                crash_reports = self.find_crashreports()
-                # set reason code
-                if crash_reports:
-                    self.reason = self.RC_ALERT
-                    self.wait_on_files(crash_reports)
-                elif self.is_running():
-                    self.reason = self.RC_CLOSED
-                else:
-                    self.reason = self.RC_EXITED
-                self._terminate()
-                self.wait()
-                self._process_logs(crash_reports)
-                self._session.call(["shell", "rm", "-rf", self._working_path])
-        except ADBSessionError:
-            log.warning("No device detected while closing process")
-        self._pid = None
-        self.profile = None
-        if self.reason is None:
-            self.reason = self.RC_CLOSED
-
-
-    def find_crashreports(self):
-        reports = list()
-        # TODO: Add ASan support
-        if self.profile:
-            # check for minidumps
-            md_path = os.path.join(self.profile, "minidumps")
-            try:
-                contents = self._session.listdir(md_path)
-                for fname in contents:
-                    if ".dmp" in fname or ".extra" in fname:
-                        reports.append(os.path.join(md_path, fname))
-            except IOError:
-                log.debug("%s does not exist", md_path)
-
-        return reports
-
-
-    def is_healthy(self):
-        if not self.is_running():
-            return False
-        return not self.find_crashreports()
-
-
-    def is_running(self):
-        assert self._session, "Device not connected"
-        assert self._package, "Package not specified"
-        if self._pid is None or self.reason is not None:
-            return False
-        return self._session.process_exists(self._pid)
-
-
-    def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=None):
-        log.debug("launching %r", url)
-        assert self._launches > -1, "clean_up() has been called"
-        assert self._session, "Device not connected"
-        assert self._package, "Package not specified"
-        assert self._pid is None, "Process is already running"
-        assert self.reason is not None, "Process is already running"
-
-        self._session.clear_logs()
-        self._remove_logs()
-        self.reason = None
-        local_profile = create_profile(
-            extension=extension,
-            prefs_js=prefs_js,
-            template=self._profile_template)
-
-        bootstrapper = Bootstrapper(poll_wait=0.5)
-        try:
-            try:
-                prefs = {
-                    "capability.policy.policynames": "'localfilelinks'",
-                    "capability.policy.localfilelinks.sites": "'%s'" % bootstrapper.location,
-                    "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'"}
-                append_prefs(local_profile, prefs)
-                self.profile = "/".join([self._working_path, os.path.basename(local_profile)])
-                if os.listdir(local_profile):
-                    if not self._session.push(local_profile, self.profile):
-                        raise ADBLaunchError("Could not upload %r" % local_profile)
-                else:
-                    log.debug("creating empty profile on device: %s", self.profile)
-                    self._session.call(["shell", "mkdir", "-p", self.profile])
-            finally:
-                if os.path.exists(local_profile):
-                    shutil.rmtree(local_profile) # TODO: temporary
-            if not self._session.reverse(bootstrapper.port, bootstrapper.port):
-                raise ADBLaunchError("Could not reverse port: %d" % bootstrapper.port)
-            cmd = [
-                "shell", "am", "start", "-W", "-n",
-                "/".join([self._package, "org.mozilla.gecko.BrowserApp"]),
-                "-a", "android.intent.action.VIEW", "-d", bootstrapper.location,
-                "--es", "args", "-profile\\ %s" % self.profile]
-
-            env_mod = dict(env_mod or {})
-            env_mod.setdefault("MOZ_SKIA_DISABLE_ASSERTS", "1")
-            for var_num, (var_name, var_val) in enumerate(env_mod.items()):
-                if var_val is None:
-                    continue
-                cmd.append("--es")
-                cmd.append("env%d" % var_num)
-                cmd.append("%s=%s" % (var_name, var_val))
-
-            if "Status: ok" not in self._session.call(cmd, timeout=launch_timeout)[1].splitlines():
-                raise ADBLaunchError("Could not launch %r" % self._package)
-            self._pid = self._session.get_pid(self._package)
-            bootstrapper.wait(self.is_healthy, url=url)
-        finally:
-            self._session.reverse_remove(bootstrapper.port)
-            bootstrapper.close()
-        self._launches += 1
-
-        return self._pid is not None
-
-
-    @property
-    def launches(self):
-        """
-        Get the number of successful launches
-
-        @rtype: int
-        @return: successful launch count
-        """
-
-        assert self._launches > -1, "clean_up() has been called"
-        return self._launches
-
-
-    def _process_logs(self, crash_reports):
-        assert self.logs is None
-        self.logs = tempfile.mkdtemp(prefix="adb_logs_")
-        unprocessed = os.path.join(self.logs, "unprocessed")
-        os.mkdir(unprocessed)
-
-        with open(os.path.join(self.logs, "log_logcat.txt"), "wb") as log_fp:
-            # TODO: should this filter by pid or not?
-            log_fp.write(self._session.collect_logs())
-            #log_fp.write(self._session.collect_logs(pid=self._pid))
-
-        if not crash_reports:
-            return
-
-        # copy crash logs from the device
-        for fname in crash_reports:
-            self._session.pull(fname, unprocessed)
-
-        logger = PuppetLogger()
-        try:
-            syms_path = self._session.symbols_path(self._package)
-            process_minidumps(unprocessed, syms_path, logger.add_log)
-            logger.close()
-            logger.save_logs(self.logs)
-        finally:
-            logger.clean_up()
-
-
-    def _remove_logs(self):
-        if self.logs is not None and os.path.isdir(self.logs):
-            shutil.rmtree(self.logs)
-            self.logs = None
-
-
-    @staticmethod
-    def _split_logcat(log_path):
-        # Roughly split out stderr and stdout from logcat
-        # This is to support FuzzManager. The original logcat output is also
-        # included in the report so nothing is lost.
-        logcat = os.path.join(log_path, "log_logcat.txt")
-        if not os.path.isfile(logcat):
-            log.warning("log_logcat.txt does not exist!")
-            return None
-        err_log = os.path.join(log_path, "log_stderr.txt")
-        if os.path.isfile(err_log):
-            log.warning("log_stderr.txt already exist! Overwriting...")
-        out_log = os.path.join(log_path, "log_stdout.txt")
-        if os.path.isfile(out_log):
-            log.warning("log_stdout.txt already exist! Overwriting...")
-        with open(logcat, "rb") as lc_fp, open(err_log, "w") as e_fp, open(out_log, "w") as o_fp:
-            for line in lc_fp:
-                if b"Gecko" not in line and b"MOZ_" not in line:
-                    continue
-                line = line[33:].decode("ascii", "ignore")
-                if line.startswith("GeckoDump"):
-                    o_fp.write(line.split(": ", 1)[-1])
-                elif line.startswith("Gecko") or line.startswith("MOZ_"):
-                    e_fp.write(line.split(": ", 1)[-1])
-
-
-    def save_logs(self, log_path, meta=False):
-        assert self.logs is not None
-        assert self.reason is not None, "Call close() first!"
-        assert self._launches > -1, "clean_up() has been called"
-        # copy logs to location specified by log_file
-        if not os.path.isdir(log_path):
-            os.makedirs(log_path)
-        log_path = os.path.abspath(log_path)
-
-        for fname in os.listdir(self.logs):
-            full_name = os.path.join(self.logs, fname)
-            # skip directories
-            if not os.path.isfile(full_name):
-                continue
-            shutil.copy(full_name, log_path)
-        self._split_logcat(log_path)
-
-
-    def wait_on_files(self, wait_files, poll_rate=0.5, timeout=60):
-        assert poll_rate >= 0, "Invalid poll_rate %d, must be greater than or equal to 0" % poll_rate
-        assert timeout >= 0, "Invalid timeout %d, must be greater than or equal to 0" % timeout
-        assert poll_rate <= timeout, "poll_rate must be less then or equal to timeout"
-        wait_end = time.time() + timeout
-        wait_files = set(self._session.realpath(x) for x in wait_files)
-
-        while wait_files:
-            open_files = set(x for _, x in self._session.get_open_files())
-            # check if any open files are in the wait file list
-            if not wait_files.intersection(open_files):
-                break
-            elif wait_end <= time.time():
-                log.debug("Timeout waiting for: %s", ", ".join(x for x in open_files if x in wait_files))
-                return False
-            time.sleep(poll_rate)
-        return True
-
-
-    def _terminate(self):
-        assert self._package is not None
-        assert self._session, "Device not connected"
-        # TODO: is this the best way???
-        self._session.call(["shell", "am", "force-stop", self._package])
-
-
-    def wait(self):
-        while self.is_running():
-            time.sleep(0.25)
-
-
-def main(argv=None):  # pylint: disable=missing-docstring
-    # set output verbosity
-    if bool(os.getenv("DEBUG")):
-        log_level = logging.DEBUG
-        log_fmt = "%(levelname).1s %(name)s [%(asctime)s] %(message)s"
-    else:
-        log_level = logging.INFO
-        log_fmt = "[%(asctime)s] %(message)s"
-    logging.basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
-
-    parser = argparse.ArgumentParser(description="ADB Device Wrapper")
-    parser.add_argument(
-        "--airplane-mode", default=None, type=int,
-        help="Enable(1) or disable(0) airplane mode")
-    parser.add_argument(
-        "--install", help="Path to APK to install")
-    parser.add_argument(
-        "--install-asan", help="Path to NDK")
-    parser.add_argument(
-        "--launch", help="Path to APK to launch")
-    parser.add_argument(
-        "--logs", help="Location to save logs")
-    parser.add_argument(
-        "--ip", help="IP address of target device")
-    parser.add_argument(
-        "--port", default=5555, type=int,
-        help="ADB listening port on target device")
-    args = parser.parse_args(argv)
-
-    log.info("Opening a session")
-    session = ADBSession.create(args.ip, args.port, as_root=True)
-    if session is None:
-        log.error("Failed to connect to IP:%r port:%r", args.ip, args.port)
-        return 1
-
-    if args.install is not None:
-        log.info("Installing %r ...", args.install)
-        package = session.install(args.install)
-        if not package:
-            log.error("Could not install %r", args.install)
-            return 1
-        log.info("Installed %r", package)
-    #elif args.install_asan is not None:
-    #    log.info("Installing ASan from %r ...", args.install_asan)
-    #    session.install_asan(args.install_asan)
-    #    log.info("Device reboot required")
-    elif args.airplane_mode is not None:
-        session.set_airplane_mode(mode=args.airplane_mode > 0)
-    elif args.launch:
-        package = ADBSession.get_package_name(args.launch)
-        if not package:
-            log.error("APK not installed")
-            return 1
-        proc = ADBProcess(package, session)
-        try:
-            proc.launch("about:blank", launch_timeout=60)
-            assert proc.is_running(), "browser not running?!"
-            log.info("Launched")
-            proc.wait()
-        finally:
-            proc.close()
-            if args.logs:
-                proc.save_logs(args.logs)
-            proc.cleanup()
-    else:
-        parser.print_help()
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

From b640e6dd7b67004c549bd49550cdb93f41a0efa8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 25 Jul 2019 13:45:50 -0700
Subject: [PATCH 452/531] [tests] Fix Python3 test failures

---
 grizzly/target/adb_device/__init__.py         |  3 ++-
 grizzly/target/adb_device/adb_process.py      |  2 +-
 grizzly/target/adb_device/adb_session.py      |  5 +++--
 grizzly/target/adb_device/test_adb_process.py | 16 ++++++++--------
 grizzly/target/adb_device/test_adb_session.py | 10 +++++-----
 5 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/grizzly/target/adb_device/__init__.py b/grizzly/target/adb_device/__init__.py
index 49cf0bc4..b4447e4f 100644
--- a/grizzly/target/adb_device/__init__.py
+++ b/grizzly/target/adb_device/__init__.py
@@ -1,4 +1,5 @@
-from .device import ADBProcess, ADBSession
+from .adb_process import ADBProcess
+from .adb_session import ADBSession
 
 __all__ = ("ADBProcess", "ADBSession")
 
diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index 5d86ebc5..7a866223 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -198,7 +198,7 @@ def _process_logs(self, crash_reports):
         unprocessed = os.path.join(self.logs, "unprocessed")
         os.mkdir(unprocessed)
 
-        with open(os.path.join(self.logs, "log_logcat.txt"), "wb") as log_fp:
+        with open(os.path.join(self.logs, "log_logcat.txt"), "w") as log_fp:
             # TODO: should this filter by pid or not?
             log_fp.write(self._session.collect_logs())
             #log_fp.write(self._session.collect_logs(pid=self._pid))
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index a2ae0bf6..4455bbb4 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -290,10 +290,11 @@ def get_package_name(apk_path):
             if not os.path.isfile(aapt):
                 # fall back to system version
                 aapt = subprocess.check_output(["which", "aapt"]).strip()
+                aapt = aapt.decode("utf-8", errors="ignore")
         apk_info = subprocess.check_output([aapt, "dump", "badging", apk_path])
         for line in apk_info.splitlines():
-            if line.startswith("package: name="):
-                package_name = line.split()[1][5:].strip("'")
+            if line.startswith(b"package: name="):
+                package_name = line.split()[1][5:].strip("'").decode("utf-8", errors="ignore")
                 break
         else:
             raise RuntimeError("Could not find APK package name")
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 31d34986..50cb8221 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -31,8 +31,8 @@ def test_adb_process_02(mocker):
 def test_adb_process_03(mocker):
     """test failed launch() and is_running()"""
     fake_session = mocker.Mock(spec=ADBSession)
-    fake_session.call.return_value = (1, b"")
-    fake_session.collect_logs.return_value = b""
+    fake_session.call.return_value = (1, "")
+    fake_session.collect_logs.return_value = ""
     fake_session.listdir.return_value = ()
     fake_session.process_exists.return_value = False
     proc = ADBProcess("org.test.unknown", fake_session)
@@ -52,8 +52,8 @@ def test_adb_process_04(mocker):
     fake_bs.return_value.location.return_value = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec=ADBSession)
-    fake_session.call.return_value = (0, b"Status: ok")
-    fake_session.collect_logs.return_value = b""
+    fake_session.call.return_value = (0, "Status: ok")
+    fake_session.collect_logs.return_value = ""
     fake_session.get_pid.return_value = 1337
     fake_session.listdir.return_value = ()
     #fake_session.process_exists.return_value = False
@@ -77,8 +77,8 @@ def test_adb_process_05(mocker):
     fake_bs.return_value.location.return_value = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec=ADBSession)
-    fake_session.call.return_value = (0, b"Status: ok")
-    fake_session.collect_logs.return_value = b""
+    fake_session.call.return_value = (0, "Status: ok")
+    fake_session.collect_logs.return_value = ""
     fake_session.get_pid.return_value = 1337
     fake_session.listdir.return_value = ()
     env = {"test1":"1", "test2": "2"}
@@ -96,8 +96,8 @@ def test_adb_process_06(mocker):
     fake_bs.return_value.location.return_value = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec=ADBSession)
-    fake_session.call.return_value = (0, b"Status: ok")
-    fake_session.collect_logs.return_value = b""
+    fake_session.call.return_value = (0, "Status: ok")
+    fake_session.collect_logs.return_value = ""
     fake_session.get_open_files.return_value = ((1, "some_file"),)
     fake_session.get_pid.return_value = 1337
     fake_session.listdir.return_value = ()
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index eab2be3d..94274772 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -11,8 +11,8 @@ def test_adb_session_01(mocker):
     """test ADBSession._call_adb()"""
     def fake_call(cmd, stderr=None, stdout=None):
         assert cmd[0] == "test"
-        stderr.write("")
-        stdout.write("blah_out")
+        stderr.write(b"")
+        stdout.write(b"blah_out")
         return 0
     mocker.patch("subprocess.call", side_effect=fake_call)
     ret, output = ADBSession._call_adb(["test"])
@@ -274,9 +274,9 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_11(tmp_path, mocker):
     """test ADBSession.install()"""
     def fake_get_package_name(_):
-        with zipfile.ZipFile(apk_file, mode="r")as zfp:
+        with zipfile.ZipFile(apk_file, mode="r") as zfp:
             with zfp.open("package-name.txt", "r") as pfp:
-                return pfp.read().strip()
+                return pfp.read().strip().decode("utf-8", errors="ignore")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "install":
@@ -300,7 +300,7 @@ def fake_adb_call(obj, cmd, timeout=None):
     apk_file = str(tmp_path / "test.apk")
     syms_path = str(tmp_path / "symbols")
     os.makedirs(syms_path)
-    pkg_file.write_bytes(b"test-package.blah.foo\n")
+    pkg_file.write_text("test-package.blah.foo\n")
     with zipfile.ZipFile(apk_file, mode="w") as z_out:
         z_out.write(str(pkg_file), "package-name.txt")
     assert not session.symbols_path(apk_file)

From 1e3a41fbf1622720bcaf75499a0df8aefd515cbd Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 25 Jul 2019 13:48:45 -0700
Subject: [PATCH 453/531] [tests] Update adb_target tests

---
 grizzly/target/adb_target.py      |   6 +-
 grizzly/target/test_adb_target.py | 113 +++++++++++++++++++++++-------
 2 files changed, 90 insertions(+), 29 deletions(-)

diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index e6f031dc..85630f12 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -14,7 +14,7 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
-log = logging.getLogger("grizzly")  # pylint: disable=invalid-name
+log = logging.getLogger("adb_target")  # pylint: disable=invalid-name
 
 
 class ADBTarget(Target):
@@ -87,7 +87,6 @@ def detect_failure(self, ignored, was_timeout):
     def launch(self, location, env_mod=None):
         self.rl_countdown = self.rl_reset
         env_mod = dict(env_mod or [])
-
         # This may be used to disabled network connections during testing, e.g.
         env_mod["MOZ_IN_AUTOMATION"] = "1"
         # prevent crash reporter from touching the dmp files
@@ -96,7 +95,6 @@ def launch(self, location, env_mod=None):
         env_mod["MOZ_CRASHREPORTER_SHUTDOWN"] = "1"
         # do not allow network connections to non local endpoints
         env_mod["MOZ_DISABLE_NONLOCAL_CONNECTIONS"] = "1"
-
         try:
             self._proc.launch(
                 env_mod=env_mod,
@@ -131,9 +129,7 @@ def launches(_):
                 def log_length(_, *_a):  # pylint: disable=arguments-differ
                     # TODO: This needs to be implemented
                     return 0
-
             self._monitor = _ADBMonitor()
-
         return self._monitor
 
     def reverse(self, remote, local):
diff --git a/grizzly/target/test_adb_target.py b/grizzly/target/test_adb_target.py
index 9fd0afef..42f58814 100644
--- a/grizzly/target/test_adb_target.py
+++ b/grizzly/target/test_adb_target.py
@@ -1,34 +1,99 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-import os
-import tempfile
-import unittest
 
 from .adb_device import ADBSession
 from .adb_target import ADBTarget
 from .target import Target
 
+def test_adb_target_01(mocker, tmp_path):
+    """test creating a simple ADBTarget"""
+    fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
+    fake_process.RC_ALERT = "ALERT"
+    fake_process.RC_CLOSED = "CLOSED"
+    fake_process.RC_EXITED = "EXITED"
+    fake_process.return_value.is_healthy.return_value = False
+    fake_process.return_value.is_running.return_value = False
+    fake_process.return_value.launches = 0
+    fake_process.return_value.reason = fake_process.RC_CLOSED
+    fake_sess_obj = mocker.Mock(spec=ADBSession)
+    fake_sess_obj.connected = True
+    fake_sess_obj.symbols = {}
+    fake_session = mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
+    fake_session.create.return_value = fake_sess_obj
+    fake_session.get_package_name.return_value = "the_name"
+    fake_apk = tmp_path / "test.apk"
+    fake_apk.touch()
+    target = ADBTarget(str(fake_apk), None, 300, 25, 5000, None, 25)
+    try:
+        assert target.closed
+        assert target.forced_close
+        assert target.monitor is not None
+        assert target.detect_failure([], False) == Target.RESULT_NONE
+        assert not target.log_size()
+        target.check_relaunch()
+    finally:
+        target.cleanup()
+    assert not target.monitor.is_running()
+    assert not target.monitor.is_healthy()
+    assert target.monitor.launches == 0
+    assert fake_session.create.call_count == 1
+    assert fake_session.get_package_name.call_count == 1
+    assert "the_name" in fake_sess_obj.symbols
+    assert fake_sess_obj.reverse_remove.call_count == 1
+    assert fake_sess_obj.disconnect.call_count == 1
 
-class ADBTargetTests(unittest.TestCase):
-    def setUp(self):
-        bin_path = os.path.join(os.path.dirname(__file__), "adb_device")
-        ADBSession.BIN_AAPT = os.path.join(bin_path, "fake_aapt.py")
-        ADBSession.BIN_ADB = os.path.join(bin_path, "fake_adb.py")
-        _fd, self.tmpfn = tempfile.mkstemp(prefix="grz_test_")
-        os.close(_fd)
-
-    def tearDown(self):
-        if os.path.isfile(self.tmpfn):
-            os.remove(self.tmpfn)
+def test_adb_target_02(mocker, tmp_path):
+    """test ADBTarget.launch()"""
+    fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
+    fake_process.return_value.launches = 0
+    mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
+    fake_apk = tmp_path / "test.apk"
+    fake_apk.touch()
+    target = ADBTarget(str(fake_apk), None, 300, 25, 5000, None, 25)
+    target.launch("fake.url")
+    assert fake_process.return_value.launch.call_count == 1
+    assert target.monitor.is_running()
+    assert target.monitor.is_healthy()
 
-    def test_01(self):
-        "test creating a simple ADBTarget"
-        target = ADBTarget(self.tmpfn, None, 300, 25, 5000, None, 25)
-        self.addCleanup(target.cleanup)
-        self.assertTrue(target.closed)
-        self.assertTrue(target.forced_close)
-        self.assertIsNotNone(target.monitor)
-        self.assertEqual(target.detect_failure([], None), Target.RESULT_NONE)
-        self.assertEqual(target.log_size(), 0)
-        target.check_relaunch()
+def test_adb_target_03(mocker, tmp_path):
+    """test ADBTarget.launch()"""
+    fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
+    mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
+    fake_apk = tmp_path / "test.apk"
+    fake_apk.touch()
+    target = ADBTarget(str(fake_apk), None, 300, 25, 5000, None, 25)
+    # test everything is running
+    fake_process.return_value.is_healthy.return_value = True
+    fake_process.return_value.is_running.return_value = True
+    assert target.detect_failure([], False) == Target.RESULT_NONE
+    assert fake_process.return_value.close.call_count == 0
+    # test timeout case
+    assert target.detect_failure([], True) == Target.RESULT_FAILURE
+    assert fake_process.return_value.close.call_count == 1
+    fake_process.return_value.close.reset_mock()
+    # test ignored timeout case
+    assert target.detect_failure(["timeout"], True) == Target.RESULT_IGNORED
+    assert fake_process.return_value.close.call_count == 1
+    fake_process.return_value.close.reset_mock()
+    # test process not running
+    fake_process.return_value.is_healthy.return_value = False
+    fake_process.return_value.is_running.return_value = False
+    fake_process.return_value.reason = fake_process.RC_EXITED
+    assert target.detect_failure([], False) == Target.RESULT_NONE
+    assert fake_process.return_value.close.call_count == 1
+    fake_process.return_value.close.reset_mock()
+    # test process exited
+    fake_process.return_value.is_healthy.return_value = False
+    fake_process.return_value.is_running.return_value = False
+    fake_process.return_value.reason = fake_process.RC_CLOSED
+    assert target.detect_failure([], False) == Target.RESULT_NONE
+    assert fake_process.return_value.close.call_count == 1
+    fake_process.return_value.close.reset_mock()
+    # test process running but is_healthy() failed
+    fake_process.return_value.is_healthy.return_value = False
+    fake_process.return_value.is_running.return_value = True
+    fake_process.return_value.reason = fake_process.RC_ALERT
+    assert target.detect_failure([], False) == Target.RESULT_FAILURE
+    assert fake_process.return_value.close.call_count == 1
+    fake_process.return_value.close.reset_mock()

From 342822c89d590005a59190d13b274c932624ecd3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 25 Jul 2019 15:35:17 -0700
Subject: [PATCH 454/531] Refactor checks for required binaries

* Remove fake_aapt.py
* Update tests
---
 grizzly/target/adb_device/adb_session.py      |  81 ++++++++------
 grizzly/target/adb_device/fake_aapt.py        |  68 ------------
 grizzly/target/adb_device/test_adb_session.py | 105 +++++++++++++++++-
 3 files changed, 151 insertions(+), 103 deletions(-)
 delete mode 100755 grizzly/target/adb_device/fake_aapt.py

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 4455bbb4..befc8412 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -44,15 +44,13 @@ class ADBNoDevice(ADBSessionError):
 
 
 class ADBSession(object):
-    BIN_AAPT = None
-    BIN_ADB = None
-
     def __init__(self, ip_addr=None, port=5555):
         self.connected = False
         self.symbols = dict()
-        self._root = False
+        self._adb_bin = self._adb_check()
         self._ip_addr = None  # target device IP address
         self._port = None  # ADB listening port
+        self._root = False
 
         log.debug("creating IP based session: %r", ip_addr is not None)
         if ip_addr is not None:
@@ -66,20 +64,36 @@ def __init__(self, ip_addr=None, port=5555):
                 raise ValueError("Port must be valid integer between 1025 and 65535")
             self._port = port
 
-        suggested_adb = os.path.expanduser("~/.android/sdk/platform-tools/adb")
-        if self.BIN_ADB is None:
-            if os.path.isfile(suggested_adb):
-                self.BIN_ADB = suggested_adb
-            else:
-                try:
-                    self.BIN_ADB = subprocess.check_output(["which", "adb"]).strip()
-                except subprocess.CalledProcessError:
-                    raise EnvironmentError("Please install ADB")
-            # TODO: update this to check adb version
-            if os.path.realpath(self.BIN_ADB) != os.path.realpath(suggested_adb):
-                log.warning("You are not using the recommended ADB install!")
-                log.warning("Either run the setup script or proceed with caution.")
-                time.sleep(5)
+    @classmethod
+    def _aapt_check(cls):
+        aapt_bin = os.path.expanduser("~/.android/sdk/platform-tools/aapt")
+        if os.path.isfile(aapt_bin):
+            log.debug("using recommended aapt from %r", aapt_bin)
+            return aapt_bin
+        try:
+            aapt_bin = subprocess.check_output(["which", "aapt"]).strip().decode("utf-8", errors="ignore")
+        except subprocess.CalledProcessError:
+            raise EnvironmentError("Please install AAPT")
+        # TODO: update this to check aapt version
+        log.warning("Using aapt_bin from %r", aapt_bin)
+        return aapt_bin
+
+    @classmethod
+    def _adb_check(cls):
+        adb_bin = os.path.expanduser("~/.android/sdk/platform-tools/adb")
+        if os.path.isfile(adb_bin):
+            log.debug("using recommended adb from %r", adb_bin)
+            return adb_bin
+        try:
+            adb_bin = subprocess.check_output(["which", "adb"]).strip().decode("utf-8", errors="ignore")
+        except subprocess.CalledProcessError:
+            raise EnvironmentError("Please install ADB")
+        # TODO: update this to check adb version
+        log.warning("Using adb from %r", adb_bin)
+        log.warning("You are not using the recommended ADB install!")
+        log.warning("Either run the setup script or proceed with caution.")
+        time.sleep(5)
+        return adb_bin
 
     @classmethod
     def create(cls, ip_addr=None, port=5555, as_root=True, max_attempts=10):
@@ -109,7 +123,7 @@ def _call_adb(cmd, timeout=None):
 
     def call(self, cmd, require_device=True, timeout=None):
         assert isinstance(cmd, list) and cmd
-        cmd = [self.BIN_ADB] + cmd
+        cmd = [self._adb_bin] + cmd
         log.debug("calling: %s", " ".join(cmd))
         if not self.connected and cmd[1] not in ("connect", "devices", "disconnect"):
             raise ADBSessionError("ADB session is not connected!")
@@ -181,6 +195,8 @@ def connect(self, as_root=True, max_attempts=10):
 
         if self.connected and self._root:
             self.set_enforce(0)
+            if self.get_enforce():
+                raise ADBSessionError("set_enforce(0) failed!")
 
         return self.connected
 
@@ -281,20 +297,21 @@ def install_file(self, src, dst, mode=None, context=None):
         if context is not None:
             self.call(["shell", "chcon", context, full_dst])
 
-    @staticmethod
-    def get_package_name(apk_path):
-        # unpack and lookup package name
-        aapt = ADBSession.BIN_AAPT
-        if aapt is None:
-            aapt = os.path.expanduser("~/.android/sdk/android-9/aapt")
-            if not os.path.isfile(aapt):
-                # fall back to system version
-                aapt = subprocess.check_output(["which", "aapt"]).strip()
-                aapt = aapt.decode("utf-8", errors="ignore")
+    def get_enforce(self):
+        status = self.call(["shell", "getenforce"])[1]
+        if status == "Enforcing":
+            return True
+        if status != "Permissive":
+            log.warning("Unexpected SELinux state '%r'", status)
+        return False
+
+    @classmethod
+    def get_package_name(cls, apk_path):
+        aapt = cls._aapt_check()
         apk_info = subprocess.check_output([aapt, "dump", "badging", apk_path])
         for line in apk_info.splitlines():
             if line.startswith(b"package: name="):
-                package_name = line.split()[1][5:].strip("'").decode("utf-8", errors="ignore")
+                package_name = line.split()[1][5:].strip(b"'").decode("utf-8", errors="ignore")
                 break
         else:
             raise RuntimeError("Could not find APK package name")
@@ -393,8 +410,10 @@ def set_airplane_mode(self, mode=True):
 
     def set_enforce(self, value):
         assert value in (0, 1)
-        is_set = self.call(["shell", "getenforce"])[1] == "Enforcing"
+        is_set = self.get_enforce()
         if (is_set and value == 0) or (not is_set and value == 1):
             self.call(["shell", "setenforce", str(value)])
             self.call(["shell", "stop"])
             self.call(["shell", "start"])
+        else:
+            log.debug("set_enforce(%d) no action required", value)
diff --git a/grizzly/target/adb_device/fake_aapt.py b/grizzly/target/adb_device/fake_aapt.py
deleted file mode 100755
index 9f8d0a69..00000000
--- a/grizzly/target/adb_device/fake_aapt.py
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/usr/bin/env python
-# pylint: disable=missing-docstring
-import argparse
-
-
-def parse_args(argv=None):
-    parser = argparse.ArgumentParser(
-        description="Android Asset Packaging Tool ... Well really it's Fake AAPT")
-    parser.add_argument(
-        "cmd",
-        help="ADB command to execute")
-    parser.add_argument(
-        "extra", action="append", default=list(), nargs=argparse.REMAINDER,
-        help="Extra args")
-    return parser.parse_args(argv)
-
-
-def main(argv=None):
-    parse_args(argv)
-    print("package: name='org.mozilla.fennec_aurora' versionCode='2015624653' versionName='68.0a1' platformBuildVersionName=''")
-    print("install-location:'internalOnly'")
-    print("sdkVersion:'16'")
-    print("targetSdkVersion:'28'")
-    print("uses-permission: name='android.permission.READ_SYNC_SETTINGS'")
-    print("uses-permission: name='org.mozilla.fennec_aurora_fxaccount.permission.PER_ACCOUNT_TYPE'")
-    print("uses-permission: name='com.google.android.c2dm.permission.RECEIVE'")
-    print("uses-permission: name='org.mozilla.fennec_aurora.permission.C2D_MESSAGE'")
-    print("uses-permission: name='com.samsung.android.providers.context.permission.WRITE_USE_APP_FEATURE_SURVEY'")
-    print("uses-permission: name='android.permission.MODIFY_AUDIO_SETTINGS'")
-    print("application-label:'Firefox Nightly'")
-    print("application-label-en-GB:'Firefox Nightly'")
-    print("application-icon-240:'res/mipmap-anydpi-v26/ic_launcher.xml'")
-    print("application-icon-320:'res/mipmap-anydpi-v26/ic_launcher.xml'")
-    print("application-icon-480:'res/mipmap-anydpi-v26/ic_launcher.xml'")
-    print("application-icon-640:'res/mipmap-anydpi-v26/ic_launcher.xml'")
-    print("application-icon-65534:'res/mipmap-anydpi-v26/ic_launcher.xml'")
-    print("application-icon-65535:'res/mipmap-anydpi-v26/ic_launcher.xml'")
-    print("application: label='Firefox Nightly' icon='res/mipmap-anydpi-v26/ic_launcher.xml'")
-    print("application-debuggable")
-    print("feature-group: label=''")
-    print("  uses-gl-es: '0x20000'")
-    print("  uses-feature-not-required: name='android.hardware.audio.low_latency'")
-    print("  uses-feature-not-required: name='android.hardware.camera'")
-    print("  uses-feature-not-required: name='android.hardware.camera.any'")
-    print("  uses-feature-not-required: name='android.hardware.camera.autofocus'")
-    print("  uses-feature-not-required: name='android.hardware.location'")
-    print("  uses-feature-not-required: name='android.hardware.location.gps'")
-    print("  uses-feature-not-required: name='android.hardware.microphone'")
-    print("  uses-feature-not-required: name='android.hardware.nfc'")
-    print("  uses-feature: name='android.hardware.touchscreen'")
-    print("  uses-feature: name='android.hardware.location.network'")
-    print("  uses-implied-feature: name='android.hardware.location.network' reason='requested android.permission.ACCESS_COARSE_LOCATION permission'")
-    print("  uses-feature: name='android.hardware.wifi'")
-    print("  uses-implied-feature: name='android.hardware.wifi' reason='requested android.permission.ACCESS_WIFI_STATE permission, and requested android.permission.CHANGE_WIFI_STATE permission'")
-    print("provides-component:'app-widget'")
-    print("main")
-    print("other-activities")
-    print("other-receivers")
-    print("other-services")
-    print("supports-screens: 'small' 'normal' 'large' 'xlarge'")
-    print("supports-any-density: 'true'")
-    print("locales: '--_--' 'ca' ' 'en-GB' 'zh-HK' 'zh-CN' 'en-IN' 'pt-BR' 'es-US' 'pt-PT' 'en-AU' 'zh-TW'")
-    print("densities: '120' '160' '240' '320' '480' '640' '65534' '65535'")
-    print("native-code: 'x86'")
-
-
-if __name__ == "__main__":
-    exit(main())
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 94274772..d4aa93b9 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -44,8 +44,9 @@ def poll(self):
     assert "terminate" in output
     assert "wait" in output
 
-def test_adb_session_02():
+def test_adb_session_02(mocker):
     """test creating a session with invalid args"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check")
     with pytest.raises(ValueError):
         ADBSession("invalid.ip")
     with pytest.raises(ValueError):
@@ -53,8 +54,9 @@ def test_adb_session_02():
     with pytest.raises(ValueError):
         ADBSession("127.0.0.1", port="bad")
 
-def test_adb_session_03():
+def test_adb_session_03(mocker):
     """test simple ADBSession"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check")
     test_ip = "127.0.0.1"
     test_port = 5556
     session = ADBSession(test_ip, test_port)
@@ -75,6 +77,7 @@ def test_adb_session_04():
 
 def test_adb_session_05(mocker):
     """test simple ADBSession.create()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     test_ip = "localhost"
     test_port = 5555
     def fake_adb_call(obj, cmd, timeout=None):
@@ -100,6 +103,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_06(mocker):
     """test full ADBSession.create()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     test_ip = "localhost"
     test_port = 5555
     def fake_adb_call(obj, cmd, timeout=None):
@@ -145,6 +149,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_07(mocker):
     """test ADBSession.create() without IP"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
@@ -176,6 +181,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_08(mocker):
     """test ADBSession.connect() and ADBSession.disconnect()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
@@ -240,6 +246,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_09(mocker):
     """test ADBSession.connect() with unavailable device"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
@@ -260,6 +267,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_10(mocker):
     """test ADBSession.all() with unknown command"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         return 1, "Android Debug Bridge version 1.0.XX"
@@ -273,6 +281,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_11(tmp_path, mocker):
     """test ADBSession.install()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_get_package_name(_):
         with zipfile.ZipFile(apk_file, mode="r") as zfp:
             with zfp.open("package-name.txt", "r") as pfp:
@@ -300,7 +309,7 @@ def fake_adb_call(obj, cmd, timeout=None):
     apk_file = str(tmp_path / "test.apk")
     syms_path = str(tmp_path / "symbols")
     os.makedirs(syms_path)
-    pkg_file.write_text("test-package.blah.foo\n")
+    pkg_file.write_bytes(b"test-package.blah.foo\n")
     with zipfile.ZipFile(apk_file, mode="w") as z_out:
         z_out.write(str(pkg_file), "package-name.txt")
     assert not session.symbols_path(apk_file)
@@ -311,6 +320,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_12(mocker):
     """test ADBSession.uninstall()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "uninstall" and cmd[2] == "org.test.preinstalled":
@@ -326,6 +336,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_13(mocker):
     """test ADBSession.get_pid()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ps":
@@ -349,6 +360,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_14(mocker):
     """test ADBSession.is_installed()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "pm":
@@ -370,6 +382,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_15(mocker):
     """test ADBSession.get_packages()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "pm":
@@ -395,6 +408,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_16(mocker):
     """test ADBSession.collect_logs()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "logcat":
@@ -433,12 +447,12 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_17(mocker):
     """test ADBSession.get_packages()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "lsof":
             if len(cmd) == 5:
                 assert cmd[3].startswith("-p")
-                pids = {int(x) for x in cmd[-1].split(",")}
             output = (
                 "COMMAND     PID    USER   FD      TYPE   DEVICE  SIZE/OFF       NODE NAME",
                 "init          1    root  cwd   unknown                               /proc/1/cwd (readlink: Permission denied)",
@@ -490,6 +504,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_18(mocker):
     """test ADBSession._get_procs()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ps":
@@ -530,6 +545,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_19(tmp_path, mocker):
     """test ADBSession.push()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "push":
@@ -549,6 +565,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_20(mocker):
     """test ADBSession.pull()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "pull":
@@ -564,6 +581,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_21(mocker):
     """test ADBSession.clear_log()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "logcat":
@@ -578,6 +596,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_22(mocker):
     """test ADBSession.listdir()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ls":
@@ -598,6 +617,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_23(mocker):
     """test ADBSession.process_exists()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ps":
@@ -614,5 +634,82 @@ def fake_adb_call(obj, cmd, timeout=None):
     session.connected = True
     assert session.process_exists(9990)
 
+def test_adb_session_24(mocker, tmp_path):
+    """test ADBSession._aapt_check()"""
+    # use system aapt
+    mocker.patch("os.path.expanduser", return_value=b"/missing/aapt")
+    mocker.patch("subprocess.check_output", return_value=b"/fake_system/aapt")
+    assert ADBSession._aapt_check() == "/fake_system/aapt"
+    fake_aapt = tmp_path / "aapt"
+    fake_aapt.touch()
+    # use recommended aapt
+    mocker.patch("os.path.expanduser", return_value=str(fake_aapt))
+    mocker.patch("subprocess.check_output", return_value=b"/fake_system/aapt")
+    assert ADBSession._aapt_check() == str(fake_aapt)
+    # aapt not installed
+    mocker.patch("os.path.expanduser", return_value=b"/missing/aapt")
+    mocker.patch("subprocess.check_output", side_effect=subprocess.CalledProcessError(1, "test", "test"))
+    with pytest.raises(EnvironmentError, match=r"Please install AAPT"):
+        assert ADBSession._aapt_check()
+
+def test_adb_session_25(mocker, tmp_path):
+    """test ADBSession._adb_check()"""
+    mocker.patch("time.sleep")  # skip delay after warning message
+    # use system adb
+    mocker.patch("os.path.expanduser", return_value=b"/missing/adb")
+    mocker.patch("subprocess.check_output", return_value=b"/fake_system/adb")
+    assert ADBSession._adb_check() == "/fake_system/adb"
+    fake_adb = tmp_path / "adb"
+    fake_adb.touch()
+    # use recommended adb
+    mocker.patch("os.path.expanduser", return_value=str(fake_adb))
+    mocker.patch("subprocess.check_output", return_value=b"/fake_system/adb")
+    assert ADBSession._adb_check() == str(fake_adb)
+    # adb not installed
+    mocker.patch("os.path.expanduser", return_value=b"/missing/adb")
+    mocker.patch("subprocess.check_output", side_effect=subprocess.CalledProcessError(1, "test", "test"))
+    with pytest.raises(EnvironmentError, match=r"Please install ADB"):
+        assert ADBSession._adb_check()
+
+def test_adb_session_26(mocker):
+    """test ADBSession.get_package_name()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._aapt_check", return_value="/fake/aapt")
+    mocker.patch("subprocess.check_output", return_value=b"")
+    with pytest.raises(RuntimeError, match=r"Could not find APK package name"):
+        ADBSession.get_package_name("/fake/path")
+    output = (
+        b"package: name='org.mozilla.fennec_aurora' versionCode='2015624653' versionName='68.0a1' platformBuildVersionName=''",
+        b"install-location:'internalOnly'",
+        b"sdkVersion:'16'",
+        b"targetSdkVersion:'28'",
+        b"uses-permission: name='android.permission.READ_SYNC_SETTINGS'",
+        b"uses-permission: name='org.mozilla.fennec_aurora_fxaccount.permission.PER_ACCOUNT_TYPE'",
+        b"application-label:'Firefox Nightly'",
+        b"application-label-en-GB:'Firefox Nightly'",
+        b"application-icon-240:'res/mipmap-anydpi-v26/ic_launcher.xml'",
+        b"application-icon-65535:'res/mipmap-anydpi-v26/ic_launcher.xml'",
+        b"application: label='Firefox Nightly' icon='res/mipmap-anydpi-v26/ic_launcher.xml'",
+        b"application-debuggable",
+        b"feature-group: label=''",
+        b"  uses-gl-es: '0x20000'",
+        b"  uses-feature-not-required: name='android.hardware.audio.low_latency'",
+        b"  uses-feature: name='android.hardware.touchscreen'",
+        b"  uses-feature: name='android.hardware.location.network'",
+        b"  uses-implied-feature: name='android.hardware.location.network' reason='requested android.permission.ACCESS_COARSE_LOCATION permission'",
+        b"  uses-feature: name='android.hardware.wifi'",
+        b"  uses-implied-feature: name='android.hardware.wifi' reason='requested android.permission.ACCESS_WIFI_STATE permission, and requested android.permission.CHANGE_WIFI_STATE permission'",
+        b"provides-component:'app-widget'",
+        b"main",
+        b"other-activities",
+        b"other-receivers",
+        b"other-services",
+        b"supports-screens: 'small' 'normal' 'large' 'xlarge'",
+        b"supports-any-density: 'true'",
+        b"locales: '--_--' 'ca' ' 'en-GB' 'zh-HK' 'zh-CN' 'en-IN' 'pt-BR' 'es-US' 'pt-PT' 'en-AU' 'zh-TW'",
+        b"densities: '120' '160' '240' '320' '480' '640' '65534' '65535'",
+        b"native-code: 'x86'")
+    mocker.patch("subprocess.check_output", return_value=b"\n".join(output))
+    assert ADBSession.get_package_name("/fake/path") == "org.mozilla.fennec_aurora"
+
 # TODO:
 # reverse

From bc3758a2ae253ad22637e719a765a072ae72115a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 25 Jul 2019 16:38:05 -0700
Subject: [PATCH 455/531] [tests] Add get_enforce() and set_enforce() tests

---
 grizzly/target/adb_device/test_adb_session.py | 124 ++++++++++--------
 1 file changed, 71 insertions(+), 53 deletions(-)

diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index d4aa93b9..1fd56e44 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -35,8 +35,7 @@ def terminate(self):
             self.stdout.write(b"terminate\n")
         def poll(self):
             self.stdout.write(b"poll\n")
-    mocker.patch("subprocess.Popen")
-    subprocess.Popen = FakeProc
+    mocker.patch("subprocess.Popen", new=FakeProc)
     ret, output = ADBSession._call_adb(["test"], timeout=0.5)
     assert ret == 1
     assert "init" in output
@@ -92,7 +91,7 @@ def fake_adb_call(obj, cmd, timeout=None):
         if cmd[1] == "shell" and cmd[2] == "whoami":
             return 0, "root"
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     ADBSession._call_adb = fake_adb_call
     session = ADBSession.create(test_ip, test_port)
     assert session is not None
@@ -247,15 +246,14 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_09(mocker):
     """test ADBSession.connect() with unavailable device"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
             return 1, "unable to connect"
         if cmd[1] == "disconnect":
             return 0, ""
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     assert not session.connected
     assert not session._root
@@ -268,11 +266,9 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_10(mocker):
     """test ADBSession.all() with unknown command"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
-        assert cmd and cmd[0].endswith("adb")
-        return 1, "Android Debug Bridge version 1.0.XX"
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb",
+        return_value=(1, "Android Debug Bridge version 1.0.XX"))
     session = ADBSession("127.0.0.1")
     session.connected = True
     session._root = True
@@ -286,7 +282,7 @@ def fake_get_package_name(_):
         with zipfile.ZipFile(apk_file, mode="r") as zfp:
             with zfp.open("package-name.txt", "r") as pfp:
                 return pfp.read().strip().decode("utf-8", errors="ignore")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "install":
             assert cmd[2] == "-r"
@@ -298,11 +294,10 @@ def fake_adb_call(obj, cmd, timeout=None):
             assert cmd[4] == "test-package.blah.foo"
             return 0, ""
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+    mocker.patch("grizzly.target.adb_device.ADBSession.get_package_name", side_effect=fake_get_package_name)
     session = ADBSession("127.0.0.1")
     session.connected = True
-    session.get_package_name = fake_get_package_name
     with pytest.raises(IOError):
         session.install("fake_path")
     pkg_file = tmp_path / "package-name.txt"
@@ -321,23 +316,21 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_12(mocker):
     """test ADBSession.uninstall()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "uninstall" and cmd[2] == "org.test.preinstalled":
             return 0, "Success"
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     assert not session.uninstall("org.test.unknown")
     session.connected = True
-    #assert session.uninstall("org.test.unknown")
     assert session.uninstall("org.test.preinstalled")
 
 def test_adb_session_13(mocker):
     """test ADBSession.get_pid()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ps":
             output = (
@@ -349,8 +342,7 @@ def fake_adb_call(obj, cmd, timeout=None):
                 "")
             return 0, "\n".join(output)
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     with pytest.raises(ADBSessionError):
         session.get_pid("org.test.unknown")
@@ -361,7 +353,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_14(mocker):
     """test ADBSession.is_installed()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "pm":
             assert cmd[3] == "list"
@@ -373,8 +365,7 @@ def fake_adb_call(obj, cmd, timeout=None):
                 "package:com.android.shell")
             return 0, "\n".join(output)
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert not session.is_installed("org.test.unknown")
@@ -383,7 +374,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_15(mocker):
     """test ADBSession.get_packages()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "pm":
             assert cmd[3] == "list"
@@ -395,8 +386,7 @@ def fake_adb_call(obj, cmd, timeout=None):
                 "package:com.android.shell")
             return 0, "\n".join(output)
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
     pkgs = session.get_packages()
@@ -409,7 +399,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_16(mocker):
     """test ADBSession.collect_logs()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "logcat":
             assert cmd[2] == "-d"
@@ -437,8 +427,7 @@ def fake_adb_call(obj, cmd, timeout=None):
                     "07-27 12:39:27.441  7128  7128 I fake log"]
             return 0, "\n".join(output)
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert len(session.collect_logs().splitlines()) == 11
@@ -446,9 +435,9 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert not session.collect_logs(1111).splitlines()
 
 def test_adb_session_17(mocker):
-    """test ADBSession.get_packages()"""
+    """test ADBSession.get_open_files()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "lsof":
             if len(cmd) == 5:
@@ -489,8 +478,7 @@ def fake_adb_call(obj, cmd, timeout=None):
                 "")
             return 0, "\n".join(output)
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
     # list all open files
@@ -505,7 +493,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_18(mocker):
     """test ADBSession._get_procs()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ps":
             print(cmd)
@@ -534,8 +522,7 @@ def fake_adb_call(obj, cmd, timeout=None):
             output += [""]
             return 0, "\n".join(output)
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert len(session._get_procs()) == 10
@@ -546,15 +533,14 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_19(tmp_path, mocker):
     """test ADBSession.push()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "push":
             assert "test.txt" in cmd[2]
             assert cmd[3] == "dst"
             return 0, " pushed. "
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
     with pytest.raises(IOError):
@@ -566,15 +552,14 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_20(mocker):
     """test ADBSession.pull()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "pull":
             assert cmd[2] == "src"
             assert cmd[3] == "dst"
             return 0, " pulled. "
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert session.pull("src", "dst")
@@ -582,14 +567,13 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_21(mocker):
     """test ADBSession.clear_log()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "logcat":
             assert cmd[2] == "--clear"
             return 0, ""
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert session.clear_logs()
@@ -597,7 +581,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_22(mocker):
     """test ADBSession.listdir()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ls":
             assert cmd[3] == "-A"
@@ -605,8 +589,7 @@ def fake_adb_call(obj, cmd, timeout=None):
                 return 1, ""
             return 0, "test"
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
     with pytest.raises(IOError):
@@ -618,7 +601,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_23(mocker):
     """test ADBSession.process_exists()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ps":
             assert cmd[3] == "9990"
@@ -628,8 +611,7 @@ def fake_adb_call(obj, cmd, timeout=None):
                 "")
             return 0, "\n".join(output)
         raise RuntimeError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert session.process_exists(9990)
@@ -711,5 +693,41 @@ def test_adb_session_26(mocker):
     mocker.patch("subprocess.check_output", return_value=b"\n".join(output))
     assert ADBSession.get_package_name("/fake/path") == "org.mozilla.fennec_aurora"
 
+def test_adb_session_27(mocker):
+    """test ADBSession.get_enforce()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession.call", return_value=(0, "Enforcing"))
+    session = ADBSession("127.0.0.1")
+    assert session.get_enforce()
+    mocker.patch("grizzly.target.adb_device.ADBSession.call", return_value=(0, "Blah"))
+    session = ADBSession("127.0.0.1")
+    assert not session.get_enforce()
+
+def test_adb_session_28(mocker):
+    """test ADBSession.set_enforce()"""
+    # disable when enabled
+    fake_call = mocker.patch("grizzly.target.adb_device.ADBSession.call")
+    mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=True)
+    session = ADBSession("127.0.0.1")
+    session.set_enforce(0)
+    assert fake_call.call_count == 3
+    fake_call.reset_mock()
+    # disable when disabled
+    mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=False)
+    session = ADBSession("127.0.0.1")
+    session.set_enforce(0)
+    assert fake_call.call_count == 0
+    fake_call.reset_mock()
+    # enable when disabled
+    mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=False)
+    session = ADBSession("127.0.0.1")
+    session.set_enforce(1)
+    assert fake_call.call_count == 3
+    fake_call.reset_mock()
+    # enable when enabled
+    mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=True)
+    session = ADBSession("127.0.0.1")
+    session.set_enforce(1)
+    assert fake_call.call_count == 0
+
 # TODO:
 # reverse

From c9242580ef25b22e039a23f51238772e0854cd98 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 26 Jul 2019 09:40:43 -0700
Subject: [PATCH 456/531] Remove calls to shell stop/start from set_enforce()

---
 grizzly/target/adb_device/adb_session.py      | 11 ++++-------
 grizzly/target/adb_device/test_adb_session.py |  6 ++++--
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index befc8412..85106e48 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -402,18 +402,15 @@ def symbols_path(self, package_name):
         return self.symbols.get(package_name, "")
 
     def set_airplane_mode(self, mode=True):
-        cmd = ["shell", "settings", "put", "global", "airplane_mode_on"]
-        cmd += ["1" if mode else "0"]
-        self.call(cmd)
-        cmd = ["shell", "su", "root", "am", "broadcast", "-a", "android.intent.action.AIRPLANE_MODE"]
-        self.call(cmd)
+        self.call(["shell", "settings", "put", "global", "airplane_mode_on", "1" if mode else "0"])
+        self.call(["shell", "su", "root", "am", "broadcast", "-a", "android.intent.action.AIRPLANE_MODE"])
 
     def set_enforce(self, value):
         assert value in (0, 1)
         is_set = self.get_enforce()
         if (is_set and value == 0) or (not is_set and value == 1):
+            if not self._root:
+                log.warning("set_enforce requires root")
             self.call(["shell", "setenforce", str(value)])
-            self.call(["shell", "stop"])
-            self.call(["shell", "start"])
         else:
             log.debug("set_enforce(%d) no action required", value)
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 1fd56e44..18987577 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -695,6 +695,7 @@ def test_adb_session_26(mocker):
 
 def test_adb_session_27(mocker):
     """test ADBSession.get_enforce()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     mocker.patch("grizzly.target.adb_device.ADBSession.call", return_value=(0, "Enforcing"))
     session = ADBSession("127.0.0.1")
     assert session.get_enforce()
@@ -704,12 +705,13 @@ def test_adb_session_27(mocker):
 
 def test_adb_session_28(mocker):
     """test ADBSession.set_enforce()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     # disable when enabled
     fake_call = mocker.patch("grizzly.target.adb_device.ADBSession.call")
     mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=True)
     session = ADBSession("127.0.0.1")
     session.set_enforce(0)
-    assert fake_call.call_count == 3
+    assert fake_call.call_count == 1
     fake_call.reset_mock()
     # disable when disabled
     mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=False)
@@ -721,7 +723,7 @@ def test_adb_session_28(mocker):
     mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=False)
     session = ADBSession("127.0.0.1")
     session.set_enforce(1)
-    assert fake_call.call_count == 3
+    assert fake_call.call_count == 1
     fake_call.reset_mock()
     # enable when enabled
     mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=True)

From 2debf7895367366254c17fccd516ee975006493a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 26 Jul 2019 09:41:54 -0700
Subject: [PATCH 457/531] Add 'prep' option to device.py

---
 grizzly/target/adb_device/device.py | 81 +++++++++++++++++------------
 1 file changed, 49 insertions(+), 32 deletions(-)

diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index 1c0f220a..f4e91752 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -28,52 +28,69 @@ def main(argv=None):  # pylint: disable=missing-docstring
         help="Enable(1) or disable(0) airplane mode")
     parser.add_argument(
         "--install", help="Path to APK to install")
-    parser.add_argument(
-        "--install-asan", help="Path to NDK")
     parser.add_argument(
         "--launch", help="Path to APK to launch")
     parser.add_argument(
         "--logs", help="Location to save logs")
     parser.add_argument(
         "--ip", help="IP address of target device")
+    parser.add_argument(
+        "--non-root", action="store_true",
+        help="Connect as non-root user")
     parser.add_argument(
         "--port", default=5555, type=int,
         help="ADB listening port on target device")
+    parser.add_argument(
+        "--prep", help="Prepare the device for fuzzing. Path to APK")
     args = parser.parse_args(argv)
+    if not any((args.airplane_mode is not None, args.install, args.launch, args.prep)):
+        parser.error("No options selected")
+        return 1
 
-    log.info("Opening a session")
-    session = ADBSession.create(args.ip, args.port, as_root=True)
+    log.debug("opening a session")
+    session = ADBSession.create(args.ip, args.port, as_root=not args.non_root)
     if session is None:
         log.error("Failed to connect to IP:%r port:%r", args.ip, args.port)
         return 1
-
-    if args.install is not None:
-        log.info("Installing %r ...", args.install)
-        package = session.install(args.install)
-        if not package:
-            log.error("Could not install %r", args.install)
-            return 1
-        log.info("Installed %r", package)
-    elif args.airplane_mode is not None:
-        session.set_airplane_mode(mode=args.airplane_mode > 0)
-    elif args.launch:
-        package = ADBSession.get_package_name(args.launch)
-        if not package:
-            log.error("APK not installed")
-            return 1
-        proc = ADBProcess(package, session)
-        try:
-            proc.launch("about:blank", launch_timeout=60)
-            assert proc.is_running(), "browser not running?!"
-            log.info("Launched")
-            proc.wait()
-        finally:
-            proc.close()
-            if args.logs:
-                proc.save_logs(args.logs)
-            proc.cleanup()
-    else:
-        parser.print_help()
+    try:
+        if args.prep is not None:
+            log.info("Preparing device...")
+            session.set_enforce(0)
+            args.airplane_mode = True
+            args.install = args.prep
+        if args.airplane_mode is not None:
+            if args.airplane_mode > 0:
+                log.info("Enabling airplane mode...")
+            else:
+                log.info("Disabling airplane mode...")
+            session.set_airplane_mode(mode=args.airplane_mode > 0)
+            log.info("Done.")
+        if args.install is not None:
+            log.info("Installing %r ...", args.install)
+            package = session.install(args.install)
+            if not package:
+                log.error("Could not install %r", args.install)
+                return 1
+            log.info("Installed %r.", package)
+        if args.launch:
+            package = ADBSession.get_package_name(args.launch)
+            if not package:
+                log.error("APK not installed")
+                return 1
+            proc = ADBProcess(package, session)
+            try:
+                proc.launch("about:blank", launch_timeout=60)
+                assert proc.is_running(), "browser not running?!"
+                log.info("Launched.")
+                proc.wait()
+            finally:
+                proc.close()
+                if args.logs:
+                    proc.save_logs(args.logs)
+                proc.cleanup()
+                log.info("Closed.")
+    finally:
+        session.disconnect()
     return 0
 
 

From 276dd7eec8409db4ab96bc853dfd6dc493ffd771 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 26 Jul 2019 16:36:49 -0700
Subject: [PATCH 458/531] [tests] Increase adb_session.py test coverage

---
 grizzly/target/adb_device/adb_session.py      |  25 +--
 grizzly/target/adb_device/test_adb_session.py | 197 +++++++++++++++---
 2 files changed, 178 insertions(+), 44 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 85106e48..92209a2e 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -251,15 +251,15 @@ def realpath(self, path):
 
     def reverse(self, remote, local):
         # remote->device, local->desktop
-        assert isinstance(local, int) and local > 1024 and local < 0x10000
-        assert isinstance(remote, int) and remote > 1024 and remote < 0x10000
+        assert isinstance(local, int) and 1024 < local < 0x10000
+        assert isinstance(remote, int) and 1024 < remote < 0x10000
         return self.call(["reverse", "tcp:%d" % remote, "tcp:%d" % local])[0] == 0
 
     def reverse_remove(self, remote=None):
         # remote->device
         cmd = ["reverse"]
         if remote is not None:
-            assert isinstance(remote, int) and remote > 1024 and remote < 0x10000
+            assert isinstance(remote, int) and 1024 < remote < 0x10000
             cmd.append("--remove")
             cmd.append("tcp:%d" % remote)
         else:
@@ -287,15 +287,16 @@ def install(self, apk_path):
         log.debug("installed package %r (%r)", package_name, apk_path)
         return package_name
 
-    def install_file(self, src, dst, mode=None, context=None):
-        basename = os.path.basename(src)
-        full_dst = os.path.join(dst, basename)
-        self.push(src, full_dst)
-        self.call(["shell", "chown", "root.shell", full_dst])
-        if mode is not None:
-            self.call(["shell", "chmod", mode, full_dst])
-        if context is not None:
-            self.call(["shell", "chcon", context, full_dst])
+    # This is no longer required and I *think* it can be removed
+    #def install_file(self, src, dst, mode=None, context=None):
+    #    basename = os.path.basename(src)
+    #    full_dst = os.path.join(dst, basename)
+    #    self.push(src, full_dst)
+    #    self.call(["shell", "chown", "root.shell", full_dst])
+    #    if mode is not None:
+    #        self.call(["shell", "chmod", mode, full_dst])
+    #    if context is not None:
+    #        self.call(["shell", "chcon", context, full_dst])
 
     def get_enforce(self):
         status = self.call(["shell", "getenforce"])[1]
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 18987577..67dcad9d 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -5,7 +5,7 @@
 
 import pytest
 
-from .adb_session import ADBCommandError, ADBSession, ADBSessionError
+from .adb_session import ADBCommandError, ADBNoDevice, ADBSession, ADBSessionError, DeviceProcess
 
 def test_adb_session_01(mocker):
     """test ADBSession._call_adb()"""
@@ -44,6 +44,33 @@ def poll(self):
     assert "wait" in output
 
 def test_adb_session_02(mocker):
+    """test ADBSession.call()"""
+    # not connected
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="fake_adb")
+    session = ADBSession()
+    with pytest.raises(ADBSessionError, match="ADB session is not connected!"):
+        session.call(["test"])
+    # successful call
+    session.connected = True
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", return_value=(0, "pass"))
+    ret_code, output = session.call(["test"])
+    assert ret_code == 0
+    assert output == "pass"
+    # invalid command
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", return_value=(1, "Android Debug Bridge version"))
+    with pytest.raises(ADBCommandError, match="Invalid ADB command 'test'"):
+        session.call(["test"])
+    # invalid command
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", return_value=(1, "adb: usage:"))
+    with pytest.raises(ADBCommandError, match="adb: usage:"):
+        session.call(["test"])
+    # disconnected device
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", return_value=(1, "error: closed"))
+    with pytest.raises(ADBNoDevice, match="No device detected!"):
+        session.call(["test"])
+    assert not session.connected
+
+def test_adb_session_03(mocker):
     """test creating a session with invalid args"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check")
     with pytest.raises(ValueError):
@@ -53,7 +80,7 @@ def test_adb_session_02(mocker):
     with pytest.raises(ValueError):
         ADBSession("127.0.0.1", port="bad")
 
-def test_adb_session_03(mocker):
+def test_adb_session_04(mocker):
     """test simple ADBSession"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check")
     test_ip = "127.0.0.1"
@@ -64,7 +91,7 @@ def test_adb_session_03(mocker):
     assert session._ip_addr == test_ip
     assert session._port == test_port
 
-def test_adb_session_04():
+def test_adb_session_05():
     """test ADBSession._devices_available()"""
     adb_output = (
         "List of devices attached",
@@ -74,7 +101,7 @@ def test_adb_session_04():
     assert not ADBSession._devices_available("\n".join(adb_output[:-1]))
     assert ADBSession._devices_available("\n".join(adb_output))
 
-def test_adb_session_05(mocker):
+def test_adb_session_06(mocker):
     """test simple ADBSession.create()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     test_ip = "localhost"
@@ -100,7 +127,7 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert session._ip_addr == test_ip
     assert session._port == test_port
 
-def test_adb_session_06(mocker):
+def test_adb_session_07(mocker):
     """test full ADBSession.create()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     test_ip = "localhost"
@@ -146,7 +173,7 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert not session.connected
     assert not session._root
 
-def test_adb_session_07(mocker):
+def test_adb_session_08(mocker):
     """test ADBSession.create() without IP"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
@@ -178,7 +205,7 @@ def fake_adb_call(obj, cmd, timeout=None):
     session.disconnect()
     assert not session.connected
 
-def test_adb_session_08(mocker):
+def test_adb_session_09(mocker):
     """test ADBSession.connect() and ADBSession.disconnect()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
@@ -243,7 +270,7 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert not session.connected
     assert not session._root
 
-def test_adb_session_09(mocker):
+def test_adb_session_10(mocker):
     """test ADBSession.connect() with unavailable device"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -263,7 +290,7 @@ def fake_adb_call(cmd, timeout=None):
     assert not session.connected
     assert not session._root
 
-def test_adb_session_10(mocker):
+def test_adb_session_11(mocker):
     """test ADBSession.all() with unknown command"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     mocker.patch(
@@ -275,7 +302,7 @@ def test_adb_session_10(mocker):
     with pytest.raises(ADBCommandError):
         session.call(["unknown-cmd"])
 
-def test_adb_session_11(tmp_path, mocker):
+def test_adb_session_12(tmp_path, mocker):
     """test ADBSession.install()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_get_package_name(_):
@@ -286,8 +313,9 @@ def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "install":
             assert cmd[2] == "-r"
-            assert "test.apk" in cmd[3]
-            return 0, "Success"
+            if "test.apk" in cmd[3]:
+                return 0, "Success"
+            return 1, "Success"
         if cmd[1] == "shell":
             assert cmd[2] == "pm"
             assert cmd[3] == "grant"
@@ -298,8 +326,15 @@ def fake_adb_call(cmd, timeout=None):
     mocker.patch("grizzly.target.adb_device.ADBSession.get_package_name", side_effect=fake_get_package_name)
     session = ADBSession("127.0.0.1")
     session.connected = True
+    # missing apk
     with pytest.raises(IOError):
         session.install("fake_path")
+    # bad apk
+    apk_file = tmp_path / "bad.apk"
+    apk_file.touch()
+    with pytest.raises(ADBSessionError):
+        session.install(str(apk_file))
+    # good apk
     pkg_file = tmp_path / "package-name.txt"
     apk_file = str(tmp_path / "test.apk")
     syms_path = str(tmp_path / "symbols")
@@ -311,9 +346,9 @@ def fake_adb_call(cmd, timeout=None):
     assert session.install(apk_file)
     session.symbols[apk_file] = syms_path
     assert session.symbols_path(apk_file) == syms_path
-    # TODO: test failed to install, failed to get package name
+    # TODO: failed to get package name
 
-def test_adb_session_12(mocker):
+def test_adb_session_13(mocker):
     """test ADBSession.uninstall()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -327,7 +362,7 @@ def fake_adb_call(cmd, timeout=None):
     session.connected = True
     assert session.uninstall("org.test.preinstalled")
 
-def test_adb_session_13(mocker):
+def test_adb_session_14(mocker):
     """test ADBSession.get_pid()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -350,7 +385,7 @@ def fake_adb_call(cmd, timeout=None):
     assert session.get_pid("org.test.unknown") is None
     assert session.get_pid("org.test.preinstalled") == 1337
 
-def test_adb_session_14(mocker):
+def test_adb_session_15(mocker):
     """test ADBSession.is_installed()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -371,7 +406,7 @@ def fake_adb_call(cmd, timeout=None):
     assert not session.is_installed("org.test.unknown")
     assert session.is_installed("org.test.preinstalled")
 
-def test_adb_session_15(mocker):
+def test_adb_session_16(mocker):
     """test ADBSession.get_packages()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -396,7 +431,7 @@ def fake_adb_call(cmd, timeout=None):
     assert "org.mozilla.fennec_aurora" in pkgs
     assert "org.test.preinstalled" in pkgs
 
-def test_adb_session_16(mocker):
+def test_adb_session_17(mocker):
     """test ADBSession.collect_logs()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -434,7 +469,7 @@ def fake_adb_call(cmd, timeout=None):
     assert len(session.collect_logs(9990).splitlines()) == 7
     assert not session.collect_logs(1111).splitlines()
 
-def test_adb_session_17(mocker):
+def test_adb_session_18(mocker):
     """test ADBSession.get_open_files()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -490,7 +525,7 @@ def fake_adb_call(cmd, timeout=None):
     with pytest.raises(AssertionError):
         session.get_open_files(pid=None, children=True)
 
-def test_adb_session_18(mocker):
+def test_adb_session_19(mocker):
     """test ADBSession._get_procs()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -530,7 +565,7 @@ def fake_adb_call(cmd, timeout=None):
     assert len(dev_procs) == 1
     assert dev_procs[0].pid == 9991
 
-def test_adb_session_19(tmp_path, mocker):
+def test_adb_session_20(tmp_path, mocker):
     """test ADBSession.push()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -549,7 +584,7 @@ def fake_adb_call(cmd, timeout=None):
     push_file.write_bytes(b"test\n")
     assert session.push(str(push_file), "dst")
 
-def test_adb_session_20(mocker):
+def test_adb_session_21(mocker):
     """test ADBSession.pull()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -564,7 +599,7 @@ def fake_adb_call(cmd, timeout=None):
     session.connected = True
     assert session.pull("src", "dst")
 
-def test_adb_session_21(mocker):
+def test_adb_session_22(mocker):
     """test ADBSession.clear_log()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -578,7 +613,7 @@ def fake_adb_call(cmd, timeout=None):
     session.connected = True
     assert session.clear_logs()
 
-def test_adb_session_22(mocker):
+def test_adb_session_23(mocker):
     """test ADBSession.listdir()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -598,7 +633,7 @@ def fake_adb_call(cmd, timeout=None):
     assert len(dir_list) == 1
     assert "test" in session.listdir("fake-dir")
 
-def test_adb_session_23(mocker):
+def test_adb_session_24(mocker):
     """test ADBSession.process_exists()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -616,7 +651,7 @@ def fake_adb_call(cmd, timeout=None):
     session.connected = True
     assert session.process_exists(9990)
 
-def test_adb_session_24(mocker, tmp_path):
+def test_adb_session_25(mocker, tmp_path):
     """test ADBSession._aapt_check()"""
     # use system aapt
     mocker.patch("os.path.expanduser", return_value=b"/missing/aapt")
@@ -634,7 +669,7 @@ def test_adb_session_24(mocker, tmp_path):
     with pytest.raises(EnvironmentError, match=r"Please install AAPT"):
         assert ADBSession._aapt_check()
 
-def test_adb_session_25(mocker, tmp_path):
+def test_adb_session_26(mocker, tmp_path):
     """test ADBSession._adb_check()"""
     mocker.patch("time.sleep")  # skip delay after warning message
     # use system adb
@@ -653,7 +688,7 @@ def test_adb_session_25(mocker, tmp_path):
     with pytest.raises(EnvironmentError, match=r"Please install ADB"):
         assert ADBSession._adb_check()
 
-def test_adb_session_26(mocker):
+def test_adb_session_27(mocker):
     """test ADBSession.get_package_name()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._aapt_check", return_value="/fake/aapt")
     mocker.patch("subprocess.check_output", return_value=b"")
@@ -693,7 +728,7 @@ def test_adb_session_26(mocker):
     mocker.patch("subprocess.check_output", return_value=b"\n".join(output))
     assert ADBSession.get_package_name("/fake/path") == "org.mozilla.fennec_aurora"
 
-def test_adb_session_27(mocker):
+def test_adb_session_28(mocker):
     """test ADBSession.get_enforce()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     mocker.patch("grizzly.target.adb_device.ADBSession.call", return_value=(0, "Enforcing"))
@@ -703,7 +738,7 @@ def test_adb_session_27(mocker):
     session = ADBSession("127.0.0.1")
     assert not session.get_enforce()
 
-def test_adb_session_28(mocker):
+def test_adb_session_29(mocker):
     """test ADBSession.set_enforce()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     # disable when enabled
@@ -731,5 +766,103 @@ def test_adb_session_28(mocker):
     session.set_enforce(1)
     assert fake_call.call_count == 0
 
-# TODO:
-# reverse
+def test_adb_session_30(mocker):
+    """test ADBSession.realpath()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    def fake_adb_call(cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "shell" and cmd[2] == "realpath":
+            if cmd[3] == "missing/path":
+                return 1, ""
+            return 0, "existing/path"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    with pytest.raises(IOError):
+        session.realpath("missing/path")
+    assert session.realpath("existing/path") == "existing/path"
+
+def test_adb_session_31(mocker):
+    """test ADBSession.reverse()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    def fake_adb_call(cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "reverse":
+            return 0, ""
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    assert session.reverse(1234, 1235)
+    with pytest.raises(AssertionError):
+        session.reverse(1, 1235)
+    with pytest.raises(AssertionError):
+        session.reverse(1234, 1)
+    with pytest.raises(AssertionError):
+        session.reverse(65536, 1235)
+    with pytest.raises(AssertionError):
+        session.reverse(1234, 65536)
+
+def test_adb_session_32(mocker):
+    """test ADBSession.reverse_remove()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    def fake_adb_call(cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "reverse":
+            if cmd[2] == "--remove":
+                assert cmd[3].startswith("tcp:")
+            elif cmd[2] == "--remove-all":
+                pass
+            else:
+                raise RuntimeError("unexpected command %r" % (cmd,))
+            return 0, ""
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    assert session.reverse_remove()
+    assert session.reverse_remove(remote=1025)
+    with pytest.raises(AssertionError):
+        session.reverse_remove(remote=65536)
+    with pytest.raises(AssertionError):
+        session.reverse_remove(remote=1023)
+
+def test_adb_session_33(mocker):
+    """test ADBSession.set_airplane_mode()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    def fake_adb_call(cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "shell" and cmd[2] == "settings":
+            assert cmd[3] == "put"
+            assert cmd[4] == "global"
+            assert cmd[5] == "airplane_mode_on"
+            assert cmd[6] in "01"
+            return 0, ""
+        if cmd[1] == "shell" and cmd[2] == "su":
+            assert cmd[3] == "root"
+            assert cmd[4] == "am"
+            assert cmd[5] == "broadcast"
+            assert cmd[6] == "-a"
+            assert cmd[7] == "android.intent.action.AIRPLANE_MODE"
+            return 0, ""
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    session.set_airplane_mode()
+    session.set_airplane_mode(mode=False)
+
+def test_device_process_01():
+    """test DeviceProcess"""
+    # nothing to parse
+    assert DeviceProcess.from_ps_line("") is None
+    # invalid info
+    assert DeviceProcess.from_ps_line("a a a a a a a a a") is None
+    # valid info
+    proc = DeviceProcess.from_ps_line("a 1 2 a 3 a a a name")
+    assert proc is not None
+    assert proc.memory == 3
+    assert proc.name == "name"
+    assert proc.pid == 1
+    assert proc.ppid == 2

From 88dd54c7d19b04675bf0bae44cf2831fdf0bee44 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 26 Jul 2019 17:50:00 -0700
Subject: [PATCH 459/531] [tests] Add ADBProcess.save_logs() tests

---
 grizzly/target/adb_device/test_adb_process.py | 57 ++++++++++++++++---
 1 file changed, 48 insertions(+), 9 deletions(-)

diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 50cb8221..82ccaa53 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -1,4 +1,6 @@
 # pylint: disable=protected-access
+import os
+
 import pytest
 
 from .adb_process import ADBProcess, ADBLaunchError
@@ -29,7 +31,7 @@ def test_adb_process_02(mocker):
         ADBProcess("org.test.unknown", fake_session)
 
 def test_adb_process_03(mocker):
-    """test failed launch() and is_running()"""
+    """test failed ADBProcess.launch() and ADBProcess.is_running()"""
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.call.return_value = (1, "")
     fake_session.collect_logs.return_value = ""
@@ -47,7 +49,7 @@ def test_adb_process_03(mocker):
         proc.cleanup()
 
 def test_adb_process_04(mocker):
-    """test launch(), is_running() and is_healthy()"""
+    """test ADBProcess.launch(), ADBProcess.is_running() and ADBProcess.is_healthy()"""
     fake_bs = mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_bs.return_value.location.return_value = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
@@ -60,9 +62,11 @@ def test_adb_process_04(mocker):
     proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
     try:
         assert not proc.is_running()
+        assert proc.launches == 0
         assert proc.launch("fake.url")
         assert proc.is_running()
         assert proc.is_healthy()
+        assert proc.launches == 1
         proc.close()
         assert proc._pid is None
         assert proc.logs
@@ -72,7 +76,7 @@ def test_adb_process_04(mocker):
     assert fake_bs.return_value.close.call_count == 1
 
 def test_adb_process_05(mocker):
-    """test launch() with environment variables"""
+    """test ADBProcess.launch() with environment variables"""
     fake_bs = mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_bs.return_value.location.return_value = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
@@ -91,15 +95,12 @@ def test_adb_process_05(mocker):
         proc.cleanup()
 
 def test_adb_process_06(mocker):
-    """test wait_on_files()"""
-    fake_bs = mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
-    fake_bs.return_value.location.return_value = "http://localhost"
-    fake_bs.return_value.port.return_value = 1234
+    """test ADBProcess.wait_on_files()"""
+    mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = ""
     fake_session.get_open_files.return_value = ((1, "some_file"),)
-    fake_session.get_pid.return_value = 1337
     fake_session.listdir.return_value = ()
     fake_session.realpath.side_effect = str.strip
     proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
@@ -113,6 +114,44 @@ def test_adb_process_06(mocker):
     finally:
         proc.cleanup()
 
+def test_adb_process_07(mocker):
+    """test ADBProcess.find_crashreports()"""
+    mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
+    fake_session = mocker.Mock(spec=ADBSession)
+    proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
+    try:
+        mocker.patch.object(proc, "profile", return_value="profile_path")
+        # no dump files
+        fake_session.listdir.return_value = ("somefile.txt")
+        assert not proc.find_crashreports()
+        # contains dump file
+        fake_session.listdir.return_value = ("somefile.txt", "test.dmp")
+        assert proc.find_crashreports()
+        # contains missing path
+        fake_session.listdir.side_effect = IOError("test")
+        assert not proc.find_crashreports()
+    finally:
+        proc.cleanup()
+
+def test_adb_process_08(mocker, tmp_path):
+    """test ADBProcess.save_logs()"""
+    mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
+    fake_session = mocker.Mock(spec=ADBSession)
+    log_path = tmp_path / "src"
+    log_path.mkdir()
+    (log_path / "nested").mkdir()
+    fake_log = log_path / "fake.txt"
+    fake_log.touch()
+    dmp_path = tmp_path / "dst"
+    proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
+    proc.logs = str(log_path)
+    try:
+        proc.save_logs(str(dmp_path))
+    finally:
+        proc.cleanup()
+    assert "fake.txt" in os.listdir(str(dmp_path))
+
+
+
 # TODO:
 # _process_logs
-# save_logs

From 7392973c43c7fb1d0609036eda2c8dca9480bfd4 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 26 Jul 2019 19:24:22 -0700
Subject: [PATCH 460/531] [tests] Add ADBProcess._process_logs() tests

---
 grizzly/target/adb_device/test_adb_process.py | 33 ++++++++++++++++++-
 1 file changed, 32 insertions(+), 1 deletion(-)

diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 82ccaa53..94b0288c 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -1,5 +1,6 @@
 # pylint: disable=protected-access
 import os
+import shutil
 
 import pytest
 
@@ -120,7 +121,7 @@ def test_adb_process_07(mocker):
     fake_session = mocker.Mock(spec=ADBSession)
     proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
     try:
-        mocker.patch.object(proc, "profile", return_value="profile_path")
+        proc.profile = "profile_path"
         # no dump files
         fake_session.listdir.return_value = ("somefile.txt")
         assert not proc.find_crashreports()
@@ -151,6 +152,36 @@ def test_adb_process_08(mocker, tmp_path):
         proc.cleanup()
     assert "fake.txt" in os.listdir(str(dmp_path))
 
+def test_adb_process_09(mocker):
+    """test ADBProcess._process_logs()"""
+    mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
+    mocker.patch("grizzly.target.adb_device.adb_process.PuppetLogger", autospec=True)
+    fake_proc_md = mocker.patch("grizzly.target.adb_device.adb_process.process_minidumps", autospec=True)
+    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.collect_logs.return_value = "fake logcat data"
+    proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
+    try:
+        # no extra logs
+        proc._process_logs([])
+        assert os.path.isdir(proc.logs)
+        try:
+            assert "log_logcat.txt" in os.listdir(proc.logs)
+        finally:
+            shutil.rmtree(proc.logs)
+        proc.logs = None
+        assert fake_proc_md.call_count == 0
+        assert fake_session.pull.call_count == 0
+        # other logs available
+        proc._process_logs(["log.dmp", "asan_log.txt"])
+        assert os.path.isdir(proc.logs)
+        try:
+            assert "log_logcat.txt" in os.listdir(proc.logs)
+        finally:
+            shutil.rmtree(proc.logs)
+        assert fake_proc_md.call_count == 1
+        assert fake_session.pull.call_count == 2
+    finally:
+        proc.cleanup()
 
 
 # TODO:

From 80b87c086a36a0c543fc5bfcd7d45153b3d29a7c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 26 Jul 2019 20:09:27 -0700
Subject: [PATCH 461/531] Revert aapt path

---
 grizzly/target/adb_device/adb_session.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 92209a2e..6c85312f 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -66,7 +66,7 @@ def __init__(self, ip_addr=None, port=5555):
 
     @classmethod
     def _aapt_check(cls):
-        aapt_bin = os.path.expanduser("~/.android/sdk/platform-tools/aapt")
+        aapt_bin = os.path.expanduser("~/.android/sdk/android-9/aapt")
         if os.path.isfile(aapt_bin):
             log.debug("using recommended aapt from %r", aapt_bin)
             return aapt_bin

From b14ab1c072dca8dfc9d797a0a192a446d6c1963d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 31 Jul 2019 12:23:16 -0700
Subject: [PATCH 462/531] [adb_device] Uninstall existing APK before installing
 APK

---
 grizzly/target/adb_device/device.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index f4e91752..235785a1 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -56,7 +56,7 @@ def main(argv=None):  # pylint: disable=missing-docstring
         if args.prep is not None:
             log.info("Preparing device...")
             session.set_enforce(0)
-            args.airplane_mode = True
+            args.airplane_mode = 1
             args.install = args.prep
         if args.airplane_mode is not None:
             if args.airplane_mode > 0:
@@ -66,6 +66,8 @@ def main(argv=None):  # pylint: disable=missing-docstring
             session.set_airplane_mode(mode=args.airplane_mode > 0)
             log.info("Done.")
         if args.install is not None:
+            if session.uninstall(ADBSession.get_package_name(args.install)):
+                log.info("Uninstalled existing version")
             log.info("Installing %r ...", args.install)
             package = session.install(args.install)
             if not package:

From 501405001a77591610e0555d771dd311e86ff321 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 31 Jul 2019 15:17:38 -0700
Subject: [PATCH 463/531] Cleanup ADBSession.connect()

---
 grizzly/target/adb_device/adb_session.py | 32 ++++++++++++------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 6c85312f..cc299fec 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -151,34 +151,34 @@ def connect(self, as_root=True, max_attempts=10):
         root_called = False
         while attempt < max_attempts:
             attempt += 1
-            if not self.connected and self._ip_addr is not None:
-                addr = ":".join([self._ip_addr, str(self._port)])
-                log.debug("connecting to %s", addr)
-                if self.call(["connect", addr])[0] != 0:
-                    log.warning("connection attempt #%d failed", attempt)
-                    time.sleep(0.25)
+            if not self.connected:
+                if self._ip_addr is not None:
+                    addr = ":".join([self._ip_addr, str(self._port)])
+                    log.debug("connecting to %s", addr)
+                    if self.call(["connect", addr])[0] != 0:
+                        log.warning("connection attempt #%d failed", attempt)
+                        time.sleep(0.25)
+                        continue
+                elif not self._devices_available(self.call(["devices"])[1]):
+                    log.warning("No device detected (attempt %d/%d)", attempt, max_attempts)
+                    time.sleep(1)
                     continue
-            elif not self._devices_available(self.call(["devices"])[1]):
-                log.warning("No device detected (attempt %d/%d)", attempt, max_attempts)
-                time.sleep(1)
-                continue
-            self.connected = True
+                self.connected = True
 
             # verify we are connected
             ret_code, user = self.call(["shell", "whoami"], require_device=False)
-            if (ret_code != 0 or not user) and attempt < max_attempts:
+            if ret_code != 0 or not user:
+                self.connected = False
+                if attempt == max_attempts:
+                    raise ADBSessionError("Device in a bad state, try disconnect & reboot")
                 time.sleep(0.25)
                 continue
 
-            if ret_code != 0 or not user:
-                raise ADBSessionError("Device in a bad state, try disconnect & reboot")
             user = user.splitlines()[-1]
             if user == "root":
                 self._root = True
-
             if not as_root or self._root:
                 break  # connected
-
             # enable root
             assert as_root, "Should not be here if root is not requested"
             if self.call(["root"])[0] == 0:

From 37459caae194f0e5b33e1540da91d672ff8ec959 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 31 Jul 2019 15:18:58 -0700
Subject: [PATCH 464/531] [tests] Increase test coverage of adb_session.py

---
 grizzly/target/adb_device/test_adb_session.py | 90 +++++++++++++------
 1 file changed, 63 insertions(+), 27 deletions(-)

diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 67dcad9d..5d65903b 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -99,6 +99,7 @@ def test_adb_session_05():
         "* daemon started successfully",
         "emulator-5554   device")
     assert not ADBSession._devices_available("\n".join(adb_output[:-1]))
+    assert not ADBSession._devices_available("")
     assert ADBSession._devices_available("\n".join(adb_output))
 
 def test_adb_session_06(mocker):
@@ -206,6 +207,40 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert not session.connected
 
 def test_adb_session_09(mocker):
+    """test ADBSession.connect() no devices available"""
+    mocker.patch("time.sleep")  # skip delay after warning message
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    def fake_adb_call(cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "connect":
+            return 1, "unable to connect"
+        if cmd[1] == "devices":
+            return 0, "\n".join(("List of devices attached",
+                                 "* daemon not running; starting now at tcp:5037",
+                                 "* daemon started successfully"))
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+    assert not ADBSession().connect()
+    assert not ADBSession("127.0.0.1").connect()
+
+def test_adb_session_10(mocker):
+    """test ADBSession.connect() device in a bad state"""
+    mocker.patch("time.sleep")  # skip delays
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    def fake_adb_call(cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "connect":
+            return 0, ""
+        if cmd[1] == "devices":
+            return 0, "\n"
+        if cmd[1] == "shell" and cmd[2] == "whoami":
+            return 1, ""
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+    with pytest.raises(ADBSessionError, match="Device in a bad state, try disconnect & reboot"):
+        ADBSession("127.0.0.1").connect()
+
+def test_adb_session_11(mocker):
     """test ADBSession.connect() and ADBSession.disconnect()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(obj, cmd, timeout=None):
@@ -270,7 +305,7 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert not session.connected
     assert not session._root
 
-def test_adb_session_10(mocker):
+def test_adb_session_12(mocker):
     """test ADBSession.connect() with unavailable device"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -290,7 +325,7 @@ def fake_adb_call(cmd, timeout=None):
     assert not session.connected
     assert not session._root
 
-def test_adb_session_11(mocker):
+def test_adb_session_13(mocker):
     """test ADBSession.all() with unknown command"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     mocker.patch(
@@ -302,7 +337,7 @@ def test_adb_session_11(mocker):
     with pytest.raises(ADBCommandError):
         session.call(["unknown-cmd"])
 
-def test_adb_session_12(tmp_path, mocker):
+def test_adb_session_14(tmp_path, mocker):
     """test ADBSession.install()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_get_package_name(_):
@@ -348,7 +383,7 @@ def fake_adb_call(cmd, timeout=None):
     assert session.symbols_path(apk_file) == syms_path
     # TODO: failed to get package name
 
-def test_adb_session_13(mocker):
+def test_adb_session_15(mocker):
     """test ADBSession.uninstall()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -362,7 +397,7 @@ def fake_adb_call(cmd, timeout=None):
     session.connected = True
     assert session.uninstall("org.test.preinstalled")
 
-def test_adb_session_14(mocker):
+def test_adb_session_16(mocker):
     """test ADBSession.get_pid()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -385,7 +420,7 @@ def fake_adb_call(cmd, timeout=None):
     assert session.get_pid("org.test.unknown") is None
     assert session.get_pid("org.test.preinstalled") == 1337
 
-def test_adb_session_15(mocker):
+def test_adb_session_17(mocker):
     """test ADBSession.is_installed()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -406,7 +441,7 @@ def fake_adb_call(cmd, timeout=None):
     assert not session.is_installed("org.test.unknown")
     assert session.is_installed("org.test.preinstalled")
 
-def test_adb_session_16(mocker):
+def test_adb_session_18(mocker):
     """test ADBSession.get_packages()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -431,7 +466,7 @@ def fake_adb_call(cmd, timeout=None):
     assert "org.mozilla.fennec_aurora" in pkgs
     assert "org.test.preinstalled" in pkgs
 
-def test_adb_session_17(mocker):
+def test_adb_session_19(mocker):
     """test ADBSession.collect_logs()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -469,7 +504,7 @@ def fake_adb_call(cmd, timeout=None):
     assert len(session.collect_logs(9990).splitlines()) == 7
     assert not session.collect_logs(1111).splitlines()
 
-def test_adb_session_18(mocker):
+def test_adb_session_20(mocker):
     """test ADBSession.get_open_files()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -525,13 +560,12 @@ def fake_adb_call(cmd, timeout=None):
     with pytest.raises(AssertionError):
         session.get_open_files(pid=None, children=True)
 
-def test_adb_session_19(mocker):
+def test_adb_session_21(mocker):
     """test ADBSession._get_procs()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ps":
-            print(cmd)
             if len(cmd) == 5:
                 assert cmd[3] == "--ppid"
                 ppid = int(cmd[-1])
@@ -565,7 +599,7 @@ def fake_adb_call(cmd, timeout=None):
     assert len(dev_procs) == 1
     assert dev_procs[0].pid == 9991
 
-def test_adb_session_20(tmp_path, mocker):
+def test_adb_session_22(tmp_path, mocker):
     """test ADBSession.push()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -584,7 +618,7 @@ def fake_adb_call(cmd, timeout=None):
     push_file.write_bytes(b"test\n")
     assert session.push(str(push_file), "dst")
 
-def test_adb_session_21(mocker):
+def test_adb_session_23(mocker):
     """test ADBSession.pull()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -599,7 +633,7 @@ def fake_adb_call(cmd, timeout=None):
     session.connected = True
     assert session.pull("src", "dst")
 
-def test_adb_session_22(mocker):
+def test_adb_session_24(mocker):
     """test ADBSession.clear_log()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -613,7 +647,7 @@ def fake_adb_call(cmd, timeout=None):
     session.connected = True
     assert session.clear_logs()
 
-def test_adb_session_23(mocker):
+def test_adb_session_25(mocker):
     """test ADBSession.listdir()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -633,7 +667,7 @@ def fake_adb_call(cmd, timeout=None):
     assert len(dir_list) == 1
     assert "test" in session.listdir("fake-dir")
 
-def test_adb_session_24(mocker):
+def test_adb_session_26(mocker):
     """test ADBSession.process_exists()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -651,7 +685,7 @@ def fake_adb_call(cmd, timeout=None):
     session.connected = True
     assert session.process_exists(9990)
 
-def test_adb_session_25(mocker, tmp_path):
+def test_adb_session_27(mocker, tmp_path):
     """test ADBSession._aapt_check()"""
     # use system aapt
     mocker.patch("os.path.expanduser", return_value=b"/missing/aapt")
@@ -669,7 +703,7 @@ def test_adb_session_25(mocker, tmp_path):
     with pytest.raises(EnvironmentError, match=r"Please install AAPT"):
         assert ADBSession._aapt_check()
 
-def test_adb_session_26(mocker, tmp_path):
+def test_adb_session_28(mocker, tmp_path):
     """test ADBSession._adb_check()"""
     mocker.patch("time.sleep")  # skip delay after warning message
     # use system adb
@@ -688,7 +722,7 @@ def test_adb_session_26(mocker, tmp_path):
     with pytest.raises(EnvironmentError, match=r"Please install ADB"):
         assert ADBSession._adb_check()
 
-def test_adb_session_27(mocker):
+def test_adb_session_29(mocker):
     """test ADBSession.get_package_name()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._aapt_check", return_value="/fake/aapt")
     mocker.patch("subprocess.check_output", return_value=b"")
@@ -728,7 +762,7 @@ def test_adb_session_27(mocker):
     mocker.patch("subprocess.check_output", return_value=b"\n".join(output))
     assert ADBSession.get_package_name("/fake/path") == "org.mozilla.fennec_aurora"
 
-def test_adb_session_28(mocker):
+def test_adb_session_30(mocker):
     """test ADBSession.get_enforce()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     mocker.patch("grizzly.target.adb_device.ADBSession.call", return_value=(0, "Enforcing"))
@@ -738,7 +772,7 @@ def test_adb_session_28(mocker):
     session = ADBSession("127.0.0.1")
     assert not session.get_enforce()
 
-def test_adb_session_29(mocker):
+def test_adb_session_31(mocker):
     """test ADBSession.set_enforce()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     # disable when enabled
@@ -766,7 +800,7 @@ def test_adb_session_29(mocker):
     session.set_enforce(1)
     assert fake_call.call_count == 0
 
-def test_adb_session_30(mocker):
+def test_adb_session_32(mocker):
     """test ADBSession.realpath()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -783,7 +817,7 @@ def fake_adb_call(cmd, timeout=None):
         session.realpath("missing/path")
     assert session.realpath("existing/path") == "existing/path"
 
-def test_adb_session_31(mocker):
+def test_adb_session_33(mocker):
     """test ADBSession.reverse()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -804,7 +838,7 @@ def fake_adb_call(cmd, timeout=None):
     with pytest.raises(AssertionError):
         session.reverse(1234, 65536)
 
-def test_adb_session_32(mocker):
+def test_adb_session_34(mocker):
     """test ADBSession.reverse_remove()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -828,7 +862,7 @@ def fake_adb_call(cmd, timeout=None):
     with pytest.raises(AssertionError):
         session.reverse_remove(remote=1023)
 
-def test_adb_session_33(mocker):
+def test_adb_session_35(mocker):
     """test ADBSession.set_airplane_mode()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
@@ -857,8 +891,10 @@ def test_device_process_01():
     """test DeviceProcess"""
     # nothing to parse
     assert DeviceProcess.from_ps_line("") is None
-    # invalid info
-    assert DeviceProcess.from_ps_line("a a a a a a a a a") is None
+    # invalid number of entries
+    assert DeviceProcess.from_ps_line(" ".join("a" * 20)) is None
+    # invalid data (valid number of entries)
+    assert DeviceProcess.from_ps_line(" ".join("a" * 9)) is None
     # valid info
     proc = DeviceProcess.from_ps_line("a 1 2 a 3 a a a name")
     assert proc is not None

From d0fbc71bb47150dbe1f67711c6a63457e347302f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Aug 2019 12:55:00 -0700
Subject: [PATCH 465/531] Update ADBProcess._split_logcat() and add test
 coverage

---
 grizzly/target/adb_device/adb_process.py      |  4 +-
 grizzly/target/adb_device/test_adb_process.py | 46 +++++++++++++++++--
 2 files changed, 46 insertions(+), 4 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index 7a866223..065a1e3b 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -1,6 +1,7 @@
 import logging
 import os
 import random
+import re
 import shutil
 import tempfile
 import time
@@ -243,7 +244,8 @@ def _split_logcat(log_path):
             for line in lc_fp:
                 if b"Gecko" not in line and b"MOZ_" not in line:
                     continue
-                line = line[33:].decode("ascii", "ignore")
+                # strip logger info ... "07-27 12:10:15.442  9990  4234 E "
+                line = re.sub(r".+?\s[ADEIWV]\s+", "", line.decode("ascii", "ignore"))
                 if line.startswith("GeckoDump"):
                     o_fp.write(line.split(": ", 1)[-1])
                 elif line.startswith("Gecko") or line.startswith("MOZ_"):
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 94b0288c..c6508d9b 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -183,6 +183,46 @@ def test_adb_process_09(mocker):
     finally:
         proc.cleanup()
 
-
-# TODO:
-# _process_logs
+def test_adb_process_10(mocker, tmp_path):
+    """test ADBProcess._split_logcat()"""
+    log_path = tmp_path / "logs"
+    log_path.mkdir()
+    # missing log_logcat.txt
+    ADBProcess._split_logcat(str(log_path))
+    assert not os.listdir(str(log_path))
+    # with log_logcat.txt
+    logstderr = tmp_path / "logs" / "log_stderr.txt"
+    logstderr.touch()
+    logstdout = tmp_path / "logs" / "log_stdout.txt"
+    logstdout.touch()
+    logcat = tmp_path / "logs" / "log_logcat.txt"
+    with logcat.open("wb") as log_fp:
+        log_fp.write(b"07-27 12:10:15.414  90  90 W art     : Unexpected CPU variant for X86 using defaults: x86\n")
+        log_fp.write(b"07-27 12:10:15.430  90  90 I GeckoApplication: zerdatime 3349725 - application start\n")
+        log_fp.write(b"07-27 12:10:15.442  90  44 I GeckoThread: preparing to run Gecko\n")
+        log_fp.write(b"07-27 12:10:15.442  90  44 E GeckoLibLoad: Load sqlite start\n")
+        log_fp.write(b"07-27 12:10:15.496  90  90 I GRALLOC-DRM: foo\n")
+        log_fp.write(b"07-27 12:10:15.505  90  43 I GeckoDump: test, line1\n")
+        log_fp.write(b"07-27 12:10:15.505  90  43 E GeckoApp: test, line2\n")
+        log_fp.write(b"07-27 12:10:15.520  90  49 I EGL-DRI2: found extension DRI_Core version 1\n")
+        log_fp.write(b"07-27 12:10:15.521  90  49 I OpenGLRenderer: Initialized EGL, version 1.4\n")
+        log_fp.write(b"07-27 12:10:15.528  90  44 E GeckoLibLoad: Load sqlite done\n")
+        log_fp.write(b"07-27 12:10:15.529  90  47 W art     : Suspending all threads took: 8.966ms\n")
+        log_fp.write(b"07-27 12:10:15.533  90  44 E GeckoLibLoad: Load nss done\n")
+        log_fp.write(b"07-27 12:39:27.188  39  39 W Fake  : asdf\n")
+        log_fp.write(b"07-27 12:39:27.239  17  14 I InputReader: Reconfiguring input devices.  changes=0x00000010\n")
+        log_fp.write(b"07-27 12:39:27.440  78  78 E android.os.Debug: failed to load memtrack module: -2\n")
+        log_fp.write(b"07-27 12:39:27.441  78  78 I Radio-JNI: register_android_hardware_Radio DONE\n")
+    ADBProcess._split_logcat(str(log_path))
+    log_files = os.listdir(str(log_path))
+    assert log_files
+    assert "log_stderr.txt" in log_files
+    with logstdout.open("rb") as log_fp:
+        assert log_fp.read() == b"test, line1\n"
+    assert "log_stdout.txt" in log_files
+    with logstderr.open("rb") as log_fp:
+        stderr_lines = log_fp.read().splitlines()
+        print(stderr_lines)
+    assert len(stderr_lines) == 6
+    assert b"test, line2" in stderr_lines
+    assert b"test, line1" not in stderr_lines

From 4e6f8aaca664c3e0215f1f2867c7ccfb9735397c Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Aug 2019 14:23:16 -0700
Subject: [PATCH 466/531] Remove extra profile upload code

---
 grizzly/target/adb_device/adb_process.py | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index 065a1e3b..22384fff 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -144,15 +144,10 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
                     "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'"}
                 append_prefs(local_profile, prefs)
                 self.profile = "/".join([self._working_path, os.path.basename(local_profile)])
-                if os.listdir(local_profile):
-                    if not self._session.push(local_profile, self.profile):
-                        raise ADBLaunchError("Could not upload %r" % local_profile)
-                else:
-                    log.debug("creating empty profile on device: %s", self.profile)
-                    self._session.call(["shell", "mkdir", "-p", self.profile])
+                if not self._session.push(local_profile, self.profile):
+                    raise ADBLaunchError("Could not upload profile %r" % local_profile)
             finally:
-                if os.path.exists(local_profile):
-                    shutil.rmtree(local_profile) # TODO: temporary
+                shutil.rmtree(local_profile, True)
             if not self._session.reverse(bootstrapper.port, bootstrapper.port):
                 raise ADBLaunchError("Could not reverse port: %d" % bootstrapper.port)
             cmd = [

From 5c236e7876a8d5419b9f1c4cc30946ba1bfd0265 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Aug 2019 14:47:47 -0700
Subject: [PATCH 467/531] Rename DeviceProcess to DeviceProcessInfo

---
 grizzly/target/adb_device/adb_session.py      |  8 +++----
 grizzly/target/adb_device/test_adb_session.py | 24 +++++++++----------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index cc299fec..1f22e271 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -12,7 +12,7 @@
 __credits__ = ["Tyson Smith"]
 
 
-class DeviceProcess(object):
+class DeviceProcessInfo(object):
     def __init__(self, memory, name, pid, ppid):
         self.memory = memory
         self.name = name
@@ -381,9 +381,9 @@ def _get_procs(self, pid=None, pid_children=None):
             cmd += ["--ppid", str(pid_children)]
         procs = list()
         for line in self.call(cmd)[1].splitlines()[1:]:
-            proc = DeviceProcess.from_ps_line(line)
-            if proc is not None:
-                procs.append(proc)
+            pinfo = DeviceProcessInfo.from_ps_line(line)
+            if pinfo is not None:
+                procs.append(pinfo)
         return procs
 
     def is_installed(self, package_name):
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 5d65903b..7dec981e 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -5,7 +5,7 @@
 
 import pytest
 
-from .adb_session import ADBCommandError, ADBNoDevice, ADBSession, ADBSessionError, DeviceProcess
+from .adb_session import ADBCommandError, ADBNoDevice, ADBSession, ADBSessionError, DeviceProcessInfo
 
 def test_adb_session_01(mocker):
     """test ADBSession._call_adb()"""
@@ -350,7 +350,7 @@ def fake_adb_call(cmd, timeout=None):
             assert cmd[2] == "-r"
             if "test.apk" in cmd[3]:
                 return 0, "Success"
-            return 1, "Success"
+            return 1, ""
         if cmd[1] == "shell":
             assert cmd[2] == "pm"
             assert cmd[3] == "grant"
@@ -888,17 +888,17 @@ def fake_adb_call(cmd, timeout=None):
     session.set_airplane_mode(mode=False)
 
 def test_device_process_01():
-    """test DeviceProcess"""
+    """test DeviceProcessInfo"""
     # nothing to parse
-    assert DeviceProcess.from_ps_line("") is None
+    assert DeviceProcessInfo.from_ps_line("") is None
     # invalid number of entries
-    assert DeviceProcess.from_ps_line(" ".join("a" * 20)) is None
+    assert DeviceProcessInfo.from_ps_line(" ".join("a" * 20)) is None
     # invalid data (valid number of entries)
-    assert DeviceProcess.from_ps_line(" ".join("a" * 9)) is None
+    assert DeviceProcessInfo.from_ps_line(" ".join("a" * 9)) is None
     # valid info
-    proc = DeviceProcess.from_ps_line("a 1 2 a 3 a a a name")
-    assert proc is not None
-    assert proc.memory == 3
-    assert proc.name == "name"
-    assert proc.pid == 1
-    assert proc.ppid == 2
+    pinfo = DeviceProcessInfo.from_ps_line("a 1 2 a 3 a a a name")
+    assert pinfo is not None
+    assert pinfo.memory == 3
+    assert pinfo.name == "name"
+    assert pinfo.pid == 1
+    assert pinfo.ppid == 2

From 1d4cf16bde8d69fc1d220970477ab7bec589236a Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Aug 2019 14:48:17 -0700
Subject: [PATCH 468/531] Remove fake_adb.py

---
 grizzly/target/adb_device/fake_adb.py | 341 --------------------------
 1 file changed, 341 deletions(-)
 delete mode 100755 grizzly/target/adb_device/fake_adb.py

diff --git a/grizzly/target/adb_device/fake_adb.py b/grizzly/target/adb_device/fake_adb.py
deleted file mode 100755
index 47af259d..00000000
--- a/grizzly/target/adb_device/fake_adb.py
+++ /dev/null
@@ -1,341 +0,0 @@
-#!/usr/bin/env python
-
-import argparse
-import json
-import multiprocessing
-import os
-import socket
-
-
-def parse_args(argv=None):
-    parser = argparse.ArgumentParser(
-        description="Android Debug Bridge version ... Well really it's Fake ADB")
-    parser.add_argument(
-        "cmd",
-        help="ADB command to execute")
-    parser.add_argument(
-        "extra", action="append", default=list(), nargs=argparse.REMAINDER,
-        help="Extra args")
-    return parser.parse_args(argv)
-
-
-class FakeADBState(object):
-    STATE_FILE = os.path.join(os.path.dirname(__file__), "fake-adb-state.json")
-
-    def __init__(self):
-        self.connected = False
-        self.devices = True  # devices command will return devices
-        self.root_allowed = True
-        self.root_enabled = False
-        self.unavailable = False
-
-    @classmethod
-    def load(cls):
-        state = cls()
-        if not os.path.isfile(cls.STATE_FILE):
-            if "DEBUG" in os.environ:
-                print("=== FakeADB State FILE NOT FOUND: %r ===" % cls.STATE_FILE)
-            return state
-        with open(cls.STATE_FILE, "r") as jfp:
-            loaded = json.load(jfp)
-        if "connected" in loaded:
-            state.connected = loaded["connected"]
-        if "root_allowed" in loaded:
-            state.root_allowed = loaded["root_allowed"]
-        if "root_enabled" in loaded:
-            state.root_enabled = loaded["root_enabled"]
-        if "unavailable" in loaded:
-            state.unavailable = loaded["unavailable"]
-        if "DEBUG_FAKEADB" in os.environ:
-            print("=== FakeADB State Loaded START===")
-            print("> connected: %r" % state.connected)
-            print("> root_allowed: %r" % state.root_allowed)
-            print("> root_enabled: %r" % state.root_enabled)
-            print("> unavailable: %r" % state.unavailable)
-            print("=== FakeADB State Loaded END===")
-        return state
-
-    def save(self):
-        with open(self.STATE_FILE, "w") as jfp:
-            json.dump({
-                "connected":self.connected,
-                "root_allowed":self.root_allowed,
-                "root_enabled":self.root_enabled,
-                "unavailable":self.unavailable}, jfp, indent=2)
-
-
-def main(argv=None):  # pylint: disable=missing-docstring
-    args = parse_args(argv)
-    state = FakeADBState.load()
-
-    #print(args)
-    if args.cmd == "connect":
-        # sanity check
-        if len(args.extra[0]) != 1:
-            print("invalid arg count for %r" % args.cmd)
-            print("unable to connect")  # adb response
-            return 1
-        ip_addr, port = args.extra[0][0].split(":")
-        if ip_addr != "localhost" and len(ip_addr.split(".")) != 4:
-            print("invalid ip")
-            print("unable to connect")  # adb response
-            return 1
-        if int(port) > 65535 or int(port) < 1024:
-            print("invalid port")
-            print("unable to connect")  # adb response
-            return 1
-        if state.connected:
-            # TODO: get full message
-            print("already connected")
-        elif state.unavailable:
-            # TODO: get full message
-            print("unable to connect")
-            return 1
-        state.connected = True
-        state.save()
-        return 0
-
-    elif args.cmd == "devices":
-        if args.extra[0]:
-            print("invalid arg count for %r" % args.cmd)
-            return 1
-        print("List of devices attached")
-        print("* daemon not running; starting now at tcp:5037")
-        print("* daemon started successfully")
-        if state.devices:
-            print("emulator-5554   device")
-        return 0
-
-    elif args.cmd == "disconnect":
-        if len(args.extra[0]) != 1:
-            print("invalid arg count for %r" % args.cmd)
-            print("No such device")  # adb response
-            return 1
-        state.connected = False
-        state.save()
-        return 0
-
-    elif args.cmd == "install":
-        if len(args.extra[0]) != 2:
-            print("invalid arg count for %r" % args.cmd)
-            print("unable to connect")  # adb response
-            return 1
-        if args.extra[0][0] != "-r":
-            return 1
-        if len(args.extra[0][1]) < 1:
-            return 1
-        print("Success")
-        return 0
-
-    elif args.cmd == "logcat":
-        if len(args.extra[0]) == 1 and args.extra[0][0] == "--clear":
-            return 0
-        if len(args.extra[0]) == 2 or len(args.extra[0]) == 3 and args.extra[0][2] == "--pid=9990":
-            print("07-27 12:10:15.414  9990  9990 W art     : Unexpected CPU variant for X86 using defaults: x86")
-            print("07-27 12:10:15.430  9990  9990 I GeckoApplication: zerdatime 3349725 - application start")
-            print("07-27 12:10:15.442  9990  4714 I GeckoThread: preparing to run Gecko")
-            print("07-27 12:10:15.442  9990  4714 E GeckoLibLoad: Load sqlite start")
-            print("07-27 12:10:15.496  9990  9990 I GRALLOC-DRM: create pipe for driver vmwgfx")
-            print("07-27 12:10:15.505  9990  4713 E GeckoApp: An error occurred during restore, switching to backup file")
-            print("07-27 12:10:15.520  9990  4719 I EGL-DRI2: found extension DRI_Core version 1")
-            print("07-27 12:10:15.521  9990  4719 I OpenGLRenderer: Initialized EGL, version 1.4")
-            print("07-27 12:10:15.528  9990  4714 E GeckoLibLoad: Load sqlite done")
-            print("07-27 12:10:15.529  9990  4707 W art     : Suspending all threads took: 8.966ms")
-            print("07-27 12:10:15.533  9990  4714 E GeckoLibLoad: Load nss done")
-        if len(args.extra[0]) == 2: # all
-            print("07-27 12:39:27.188  3049  3049 W Finsky  : [1] com.google.android.finsky.wear.dx.run(8): Dropping command=auto_uninstall due to Gms not connected")
-            print("07-27 12:39:27.239  1887  1994 I InputReader: Reconfiguring input devices.  changes=0x00000010")
-            print("07-27 12:39:27.286  2767  7142 I Icing   : Usage reports ok 0, Failed Usage reports 0, indexed 0, re")
-            print("07-27 12:39:27.440  7128  7128 E android.os.Debug: failed to load memtrack module: -2")
-            print("07-27 12:39:27.441  7128  7128 I Radio-JNI: register_android_hardware_Radio DONE")
-        return 0
-
-    elif args.cmd == "pull":
-        if len(args.extra[0]) != 2:
-            print("invalid arg count for %r" % args.cmd)
-            print("unable to connect")  # adb response
-            return 1
-        print(" pulled. ")
-        return 0
-
-    elif args.cmd == "push":
-        if len(args.extra[0]) != 2:
-            print("invalid arg count for %r" % args.cmd)
-            print("unable to connect")  # adb response
-            return 1
-        print(" pushed. ")
-        return 0
-
-    elif args.cmd == "reverse":
-        if len(args.extra[0]) < 2:
-            print("invalid arg count for %r" % args.cmd)
-            return 1
-        return 0
-
-    elif args.cmd == "root":
-        if args.extra[0]:
-            print("invalid arg count for %r" % args.cmd)
-            return 1
-        if state.root_allowed:
-            if not state.root_enabled:
-                print("restarting adbd as root")
-                state.connected = False
-                state.root_enabled = True
-                state.save()
-                return 0
-        return 0
-
-    elif args.cmd == "shell" and args.extra[0][0] == "am" and args.extra[0][1] == "start":
-        if len(args.extra[0]) < 5:
-            print("invalid arg count for %r" % args.cmd)
-            return 1
-        # only "successfully" launch org.mozilla.fennec_aurora
-        if args.extra[0][4].startswith("org.mozilla.fennec_aurora"):
-            print("Status: ok")
-            host, port = args.extra[0][8].split("//")[-1].split(":")
-            def handle_bootstrap(host, port):
-                soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                try:
-                    soc.connect((host, port))
-                    soc.settimeout(5)  # just in case
-                    soc.sendall(b"welp")
-                    while soc.recv():
-                        pass
-                finally:
-                    soc.close()
-            # launch fake browser
-            proc = multiprocessing.Process(target=handle_bootstrap, args=(host, int(port)))
-            proc.start()
-            return 0
-        return 1
-
-    elif args.cmd == "shell" and args.extra[0][0] == "am" and args.extra[0][1] == "force-stop":
-        if args.extra[0][2] != "org.mozilla.fennec_aurora":
-            return 1
-        return 0
-
-    elif args.cmd == "shell" and args.extra[0][0] == "setenforce":
-        return 0
-
-    elif args.cmd == "shell" and args.extra[0][0] == "ls" and args.extra[0][1] == "-A":
-        if args.extra[0][2] == "missing-dir":
-            return 1
-        #print(".")
-        #print("..")
-        print("test")
-        return 0
-
-    elif args.cmd == "shell" and args.extra[0][0] == "lsof":
-        print("COMMAND     PID       USER   FD      TYPE             DEVICE  SIZE/OFF       NODE NAME")
-        if len(args.extra[0]) == 1:
-            print("init          1       root  cwd   unknown                                         /proc/1/cwd (readlink: Permission denied)")
-            print("lsof      15988      shell  cwd       DIR               0,13       780       4234 /")
-            print("lsof      15988      shell  txt       REG                8,1    432284    1696174 /system/bin/toybox")
-            print("lsof      15988      shell    4r      DIR                0,4         0     120901 /proc/15988/fd")
-        if len(args.extra[0]) == 1 or (args.extra[0][1] == "-p" and "9991" in args.extra[0][2].split(",")):
-            print("a.fennec_  9991     u0_a80   98r      REG                8,1    306672    1696611 /system/fonts/blah.ttf")
-        if len(args.extra[0]) == 1 or (args.extra[0][1] == "-p" and "9990" in args.extra[0][2].split(",")):
-            print("a.fennec_  9990     u0_a80  cwd       DIR               0,13       780       4234 /")
-            print("a.fennec_  9990     u0_a80  txt       REG                8,1     17948    1695879 /system/bin/app_process32")
-            print("a.fennec_  9990     u0_a80  mem   unknown                                         /dev/ashmem/dalvik-main space (deleted)")
-            print("a.fennec_  9990     u0_a80  mem       CHR              10,58                 4485 /dev/binder")
-            print("a.fennec_  9990     u0_a80  mem   unknown                                         /dev/ashmem/dalvik-allocspace zygote / non moving space live-bitmap 0 (deleted)")
-            print("a.fennec_  9990     u0_a80  mem       REG                8,1    152888    1704079 /system/lib/libexpat.so")
-            print("a.fennec_  9990     u0_a80   54u      REG                8,1    329632    1769879 /data/data/org.mozilla.fennec_aurora/files/mozilla/0kjujtli.default/browser.db-wal")
-            print("a.fennec_  9990     u0_a80   55u     IPv6                          0t0      44549 TCP []:49232->[]:443 (ESTABLISHED)")
-            print("a.fennec_  9990     u0_a80   75w     FIFO                0,9       0t0      44634 pipe:[44634]")
-            print("a.fennec_  9990     u0_a80   76u     sock                          0t0      44659 socket:[44659]")
-            print("a.fennec_  9990     u0_a80   95u      REG                8,1     98304    1769930 /data/data/org.mozilla.fennec_aurora/files/mozilla/0kjujtli.default/permissions.sqlite")
-            print("a.fennec_  9990     u0_a80   98r      REG                8,1    306672    1696611 /system/fonts/Roboto-Regular.ttf")
-            print("a.fennec_  9990     u0_a80  122u      CHR              10,59       0t0       4498 /dev/ashmem")
-            print("a.fennec_  9990     u0_a80  123u     IPv4                          0t0      44706 UDP :1900->:0")
-            print("a.fennec_  9990     u0_a80  125u     0000               0,10       0t0       3655 anon_inode:[eventpoll]")
-            print("a.fennec_  9990     u0_a80  126u     IPv4                          0t0      44773 TCP :58190->:443 (ESTABLISHED)")
-            print("a.fennec_  9990     u0_a80  128u     unix                          0t0      44747 socket")
-            print("a.fennec_  9990     u0_a80  130u     IPv4                          0t0      44840 TCP :35274->:443 (SYN_SENT)")
-        print("")
-        return 0
-
-    elif args.cmd == "shell" and args.extra[0][0] == "mkdir":
-        print("")
-        return 0
-
-    elif args.cmd == "shell" and args.extra[0][0] == "pm" and args.extra[0][1] == "grant":
-        if len(args.extra[0]) != 4:
-            return 1
-        print("")
-        return 0
-
-
-    elif (args.cmd == "shell" and args.extra[0][0] == "pm" and
-          args.extra[0][1] == "list" and args.extra[0][2] == "packages"):
-        print("package:org.mozilla.fennec_aurora")
-        print("package:org.test.preinstalled")
-        print("package:com.android.phone")
-        print("package:com.android.shell")
-        return 0
-
-    elif args.cmd == "shell" and args.extra[0][0] == "ps":
-        # TODO: add root and non-root output
-        print("USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME")
-        if len(args.extra[0]) == 1:
-            print("root      1     0     8896   2208  SyS_epoll_ 00000000 S /init")
-            print("root      1242  2     0      0         kswapd 00000000 S kswapd0")
-            print("test      1337  1772  1024   1024 SyS_epoll_ 00000000 S org.test.preinstalled")
-            print("test      1338  1337  1024   1024 SyS_epoll_ 00000000 S org.test.child")
-            print("root      1772  1     1620804 122196 poll_sched 00000000 S zygote")
-            print("media_rw  2158  1758  0      0              0 00000000 Z sdcard")
-            print("audioserver 1773  1     34000  9624  binder_thr 00000000 S /system/bin/audioserver")
-            print("root      5847  1     315992 2348  poll_sched 00000000 S /sbin/adbd")
-            print("u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora")
-            print("root      5944  5847  6280   2360           0 00000000 R ps")
-        if len(args.extra[0]) == 3 and args.extra[0][1] == "--ppid" and args.extra[0][2] == "9990":
-            print("u0_a80    9991  9990  3332   3331 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora")
-        elif len(args.extra[0]) == 2 and args.extra[0][1] == "9990":
-            print("u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora")
-        print("")
-        return 0
-
-    elif args.cmd == "shell" and args.extra[0][0] == "realpath":
-        print(args.extra[0][1])
-        return 0
-
-    elif args.cmd == "shell" and args.extra[0][0] == "rm":
-        print("")
-        return 0
-
-    elif args.cmd == "shell" and args.extra[0][0] == "whoami":
-        if state.root_enabled:
-            print("root")
-        else:
-            print("shell")
-        return 0
-
-    elif args.cmd == "uninstall":
-        if len(args.extra[0]) != 1:
-            print("invalid arg count for %r" % args.cmd)
-            print("unable to connect")
-            return 1
-        if args.extra[0][0] == "org.test.preinstalled":
-            print("Success")
-        return 0
-
-    elif args.cmd == "unroot":
-        if args.extra[0]:
-            print("invalid arg count for %r" % args.cmd)
-            return 1
-        if state.root_enabled:
-            print("restarting adbd as non root")
-            state.connected = False
-            state.root_enabled = False
-            state.save()
-        return 0
-
-
-    print("Android Debug Bridge version 1.0.XX")
-    print("Fake ADB: UNKNOWN COMMAND %r" % args.extra)
-    return 1
-
-
-if __name__ == "__main__":
-    exit(main())

From ac0b160e412a2cf881c178e012a8e38673b98914 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 1 Aug 2019 15:13:08 -0700
Subject: [PATCH 469/531] [tests] Fix test_adb_process_10 on Windows

---
 grizzly/target/adb_device/test_adb_process.py | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index c6508d9b..0acd4733 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -183,7 +183,7 @@ def test_adb_process_09(mocker):
     finally:
         proc.cleanup()
 
-def test_adb_process_10(mocker, tmp_path):
+def test_adb_process_10(tmp_path):
     """test ADBProcess._split_logcat()"""
     log_path = tmp_path / "logs"
     log_path.mkdir()
@@ -216,13 +216,10 @@ def test_adb_process_10(mocker, tmp_path):
     ADBProcess._split_logcat(str(log_path))
     log_files = os.listdir(str(log_path))
     assert log_files
-    assert "log_stderr.txt" in log_files
     with logstdout.open("rb") as log_fp:
-        assert log_fp.read() == b"test, line1\n"
-    assert "log_stdout.txt" in log_files
+        assert log_fp.read().rstrip() == b"test, line1"
     with logstderr.open("rb") as log_fp:
         stderr_lines = log_fp.read().splitlines()
-        print(stderr_lines)
-    assert len(stderr_lines) == 6
     assert b"test, line2" in stderr_lines
     assert b"test, line1" not in stderr_lines
+    assert len(stderr_lines) == 6

From 148db6c1293f9da1ae8b31da3aa019c4b948c39f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 2 Aug 2019 10:02:03 -0700
Subject: [PATCH 470/531] Make logcat parsing more robust

---
 grizzly/target/adb_device/adb_process.py      | 2 +-
 grizzly/target/adb_device/test_adb_process.py | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index 22384fff..b9e687c0 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -240,7 +240,7 @@ def _split_logcat(log_path):
                 if b"Gecko" not in line and b"MOZ_" not in line:
                     continue
                 # strip logger info ... "07-27 12:10:15.442  9990  4234 E "
-                line = re.sub(r".+?\s[ADEIWV]\s+", "", line.decode("ascii", "ignore"))
+                line = re.sub(r".+?\s[A-Z]\s+", "", line.decode("ascii", "ignore"))
                 if line.startswith("GeckoDump"):
                     o_fp.write(line.split(": ", 1)[-1])
                 elif line.startswith("Gecko") or line.startswith("MOZ_"):
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 0acd4733..a9b0cfa9 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -213,6 +213,7 @@ def test_adb_process_10(tmp_path):
         log_fp.write(b"07-27 12:39:27.239  17  14 I InputReader: Reconfiguring input devices.  changes=0x00000010\n")
         log_fp.write(b"07-27 12:39:27.440  78  78 E android.os.Debug: failed to load memtrack module: -2\n")
         log_fp.write(b"07-27 12:39:27.441  78  78 I Radio-JNI: register_android_hardware_Radio DONE\n")
+        log_fp.write(b"07-27 12:39:27.442 18461 18481 F MOZ_CRASH: Hit MOZ_CRASH(test) at gpp.rs:17\n")
     ADBProcess._split_logcat(str(log_path))
     log_files = os.listdir(str(log_path))
     assert log_files
@@ -222,4 +223,4 @@ def test_adb_process_10(tmp_path):
         stderr_lines = log_fp.read().splitlines()
     assert b"test, line2" in stderr_lines
     assert b"test, line1" not in stderr_lines
-    assert len(stderr_lines) == 6
+    assert len(stderr_lines) == 7

From 44e40f86753dcc08d50e2dc0e510ced63d298b2e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 2 Aug 2019 16:34:06 -0700
Subject: [PATCH 471/531] Make ADBSession.connect() more robust

---
 grizzly/target/adb_device/adb_session.py      | 102 ++++++++++----
 grizzly/target/adb_device/device.py           |   1 -
 grizzly/target/adb_device/test_adb_session.py | 130 ++++++++++++++++--
 3 files changed, 194 insertions(+), 39 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 1f22e271..d7cbe8fd 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -48,7 +48,9 @@ def __init__(self, ip_addr=None, port=5555):
         self.connected = False
         self.symbols = dict()
         self._adb_bin = self._adb_check()
+        self._cpu_arch = None  # Android CPU architecture string
         self._ip_addr = None  # target device IP address
+        self._os_version = None  # Android version string
         self._port = None  # ADB listening port
         self._root = False
 
@@ -71,9 +73,10 @@ def _aapt_check(cls):
             log.debug("using recommended aapt from %r", aapt_bin)
             return aapt_bin
         try:
-            aapt_bin = subprocess.check_output(["which", "aapt"]).strip().decode("utf-8", errors="ignore")
+            aapt_bin = subprocess.check_output(["which", "aapt"])
         except subprocess.CalledProcessError:
             raise EnvironmentError("Please install AAPT")
+        aapt_bin = aapt_bin.strip().decode("utf-8", errors="ignore")
         # TODO: update this to check aapt version
         log.warning("Using aapt_bin from %r", aapt_bin)
         return aapt_bin
@@ -85,9 +88,10 @@ def _adb_check(cls):
             log.debug("using recommended adb from %r", adb_bin)
             return adb_bin
         try:
-            adb_bin = subprocess.check_output(["which", "adb"]).strip().decode("utf-8", errors="ignore")
+            adb_bin = subprocess.check_output(["which", "adb"])
         except subprocess.CalledProcessError:
             raise EnvironmentError("Please install ADB")
+        adb_bin = adb_bin.strip().decode("utf-8", errors="ignore")
         # TODO: update this to check adb version
         log.warning("Using adb from %r", adb_bin)
         log.warning("You are not using the recommended ADB install!")
@@ -145,10 +149,15 @@ def clear_logs(self):
         log.debug("clear_logs()")
         return self.call(["logcat", "--clear"], timeout=10)[0] == 0
 
-    def connect(self, as_root=True, max_attempts=10):
-        max_attempts = max(1, max_attempts)
+    def connect(self, as_root=True, boot_timeout=300, max_attempts=10, retry_delay=1):
+        assert isinstance(boot_timeout, int) and boot_timeout > 0
+        assert isinstance(max_attempts, int) and max_attempts > 0
+        assert isinstance(retry_delay, (int, float)) and retry_delay > 0
+        self._cpu_arch = None
+        self._os_version = None
         attempt = 0
         root_called = False
+        set_enforce_called = False
         while attempt < max_attempts:
             attempt += 1
             if not self.connected:
@@ -157,47 +166,65 @@ def connect(self, as_root=True, max_attempts=10):
                     log.debug("connecting to %s", addr)
                     if self.call(["connect", addr])[0] != 0:
                         log.warning("connection attempt #%d failed", attempt)
-                        time.sleep(0.25)
+                        time.sleep(retry_delay)
                         continue
                 elif not self._devices_available(self.call(["devices"])[1]):
                     log.warning("No device detected (attempt %d/%d)", attempt, max_attempts)
-                    time.sleep(1)
+                    time.sleep(retry_delay)
                     continue
                 self.connected = True
 
             # verify we are connected
+            if not self.wait_for_boot(timeout=boot_timeout):
+                raise ADBSessionError("Timeout (%ds) waiting for device boot to complete" % boot_timeout)
             ret_code, user = self.call(["shell", "whoami"], require_device=False)
             if ret_code != 0 or not user:
                 self.connected = False
                 if attempt == max_attempts:
                     raise ADBSessionError("Device in a bad state, try disconnect & reboot")
-                time.sleep(0.25)
                 continue
+            self._root = user.splitlines()[-1] == "root"
+
+            # collect CPU and OS info
+            if self._os_version is None:
+                self._os_version = self.call(["shell", "getprop", "ro.build.version.release"])[1]
+            if self._cpu_arch is None:
+                self._cpu_arch = self.call(["shell", "getprop", "ro.product.cpu.abi"])[1]
+
+            # check SELinux mode
+            if self._root:
+                if self.get_enforce():
+                    if set_enforce_called:
+                        raise ADBSessionError("set_enforce(0) failed!")
+                    # set SELinux to run in permissive mode
+                    self.set_enforce(0)
+                    self.call(["shell", "stop"])
+                    self.call(["shell", "start"])
+                    # put the device in a known state
+                    self.call(["reconnect"])
+                    set_enforce_called = True
+                    self.connected = False
+                    continue
 
-            user = user.splitlines()[-1]
-            if user == "root":
-                self._root = True
             if not as_root or self._root:
-                break  # connected
+                log.debug("connected device running Android %s (%s)", self._os_version, self._cpu_arch)
+                break
+
             # enable root
             assert as_root, "Should not be here if root is not requested"
             if self.call(["root"])[0] == 0:
                 self.connected = False
+                # only skip attempt to call root once
                 if not root_called:
                     root_called = True
-                    attempt -= 1  # remove attempt used to call root
+                    attempt -= 1
                     continue
-
-            time.sleep(0.25)  # wait for adbd to restart on device
+            else:
+                log.warning("Failed root login attempt")
 
         if self.connected and as_root and not self._root:
             raise ADBSessionError("Could not enable root")
 
-        if self.connected and self._root:
-            self.set_enforce(0)
-            if self.get_enforce():
-                raise ADBSessionError("set_enforce(0) failed!")
-
         return self.connected
 
     def collect_logs(self, pid=None):
@@ -408,10 +435,35 @@ def set_airplane_mode(self, mode=True):
 
     def set_enforce(self, value):
         assert value in (0, 1)
-        is_set = self.get_enforce()
-        if (is_set and value == 0) or (not is_set and value == 1):
-            if not self._root:
-                log.warning("set_enforce requires root")
-            self.call(["shell", "setenforce", str(value)])
+        if not self._root:
+            log.warning("set_enforce requires root")
+        self.call(["shell", "setenforce", str(value)])
+
+    def wait_for_boot(self, timeout=None):
+        if timeout is not None:
+            assert isinstance(timeout, (int, float)) and timeout > 0
+            deadline = time.time() + timeout
         else:
-            log.debug("set_enforce(%d) no action required", value)
+            deadline = None
+        attempts = 0
+        booted = False
+        # first wait for the boot to complete then wait for the boot animation to complete
+        # this will help ensure the device is in a ready state
+        while True:
+            if not booted:
+                booted = self.call(["shell", "getprop", "sys.boot_completed"], require_device=False)[1] == "1"
+                attempts += 1
+            # we need to verify that boot is complete before checking the animation is stopped because
+            # the animation can be in the stopped state early in the boot process
+            if booted and self.call(["shell", "getprop", "init.svc.bootanim"])[1] == "stopped":
+                if attempts > 1:
+                    # the device was booting so give it additional time
+                    log.debug("device was boot was detected")
+                    time.sleep(5)
+                return True
+            if deadline and time.time() >= deadline:
+                log.debug("wait_for_boot() timeout %r exceeded", timeout)
+                break
+            log.debug("waiting for device to boot")
+            time.sleep(0.5)
+        return False
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index 235785a1..9e306abf 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -55,7 +55,6 @@ def main(argv=None):  # pylint: disable=missing-docstring
     try:
         if args.prep is not None:
             log.info("Preparing device...")
-            session.set_enforce(0)
             args.airplane_mode = 1
             args.install = args.prep
         if args.airplane_mode is not None:
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 7dec981e..d265b583 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -88,8 +88,10 @@ def test_adb_session_04(mocker):
     session = ADBSession(test_ip, test_port)
     assert not session.connected
     assert not session._root
+    assert session._cpu_arch is None
     assert session._ip_addr == test_ip
     assert session._port == test_port
+    assert session._os_version is None
 
 def test_adb_session_05():
     """test ADBSession._devices_available()"""
@@ -105,8 +107,10 @@ def test_adb_session_05():
 def test_adb_session_06(mocker):
     """test simple ADBSession.create()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    test_arch = "x86_64"
     test_ip = "localhost"
     test_port = 5555
+    test_version = "9"
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
@@ -115,6 +119,15 @@ def fake_adb_call(obj, cmd, timeout=None):
         # already Permissive
         if cmd[1] == "shell" and cmd[2] == "getenforce":
             return 0, "Permissive"
+        if cmd[1] == "shell" and cmd[2] == "getprop":
+            if cmd[3] == "init.svc.bootanim":
+                return 0, "stopped"
+            if cmd[3] == "ro.build.version.release":
+                return 0, test_version
+            if cmd[3] == "ro.product.cpu.abi":
+                return 0, test_arch
+            if cmd[3] == "sys.boot_completed":
+                return 0, "1"
         # already root
         if cmd[1] == "shell" and cmd[2] == "whoami":
             return 0, "root"
@@ -125,14 +138,18 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert session is not None
     assert session.connected
     assert session._root
+    assert session._cpu_arch == test_arch
     assert session._ip_addr == test_ip
+    assert session._os_version == test_version
     assert session._port == test_port
 
 def test_adb_session_07(mocker):
     """test full ADBSession.create()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    test_arch = "x86_64"
     test_ip = "localhost"
     test_port = 5555
+    test_version = "9"
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
@@ -147,12 +164,30 @@ def fake_adb_call(obj, cmd, timeout=None):
             assert cmd[2] == ":".join([test_ip, str(test_port)])
             obj.connected = False
             return 0, ""
+        if cmd[1] == "reconnect":
+            return 0, ""
         if cmd[1] == "root":
             obj._root = True
             obj.connected = False
             return 0, "restarting adbd as root"
         if cmd[1] == "shell" and cmd[2] == "getenforce":
+            if getattr(obj, "enforcing", True):
+                return 0, "Enforcing"
             return 0, "Permissive"
+        if cmd[1] == "shell" and cmd[2] == "getprop":
+            if cmd[3] == "init.svc.bootanim":
+                return 0, "stopped"
+            if cmd[3] == "ro.build.version.release":
+                return 0, test_version
+            if cmd[3] == "ro.product.cpu.abi":
+                return 0, test_arch
+            if cmd[3] == "sys.boot_completed":
+                return 0, "1"
+        if cmd[1] == "shell" and cmd[2] == "setenforce":
+            setattr(obj, "enforcing", False)
+            return 0, ""
+        if cmd[1] == "shell" and cmd[2] in ("start", "stop"):
+            return 0, ""
         if cmd[1] == "shell" and cmd[2] == "whoami":
             if obj._root:
                 return 0, "root"
@@ -168,7 +203,9 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert session is not None
     assert session.connected
     assert session._root
+    assert session._cpu_arch == test_arch
     assert session._ip_addr == test_ip
+    assert session._os_version == test_version
     assert session._port == test_port
     session.disconnect()
     assert not session.connected
@@ -177,6 +214,8 @@ def fake_adb_call(obj, cmd, timeout=None):
 def test_adb_session_08(mocker):
     """test ADBSession.create() without IP"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    test_arch = "x86"
+    test_version = "7.1.2"
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
@@ -192,6 +231,15 @@ def fake_adb_call(obj, cmd, timeout=None):
                                  "emulator-5554   device"))
         if cmd[1] == "shell" and cmd[2] == "getenforce":
             return 0, "Permissive"
+        if cmd[1] == "shell" and cmd[2] == "getprop":
+            if cmd[3] == "init.svc.bootanim":
+                return 0, "stopped"
+            if cmd[3] == "ro.build.version.release":
+                return 0, test_version
+            if cmd[3] == "ro.product.cpu.abi":
+                return 0, test_arch
+            if cmd[3] == "sys.boot_completed":
+                return 0, "1"
         if cmd[1] == "shell" and cmd[2] == "whoami":
             return 0, "shell"
         raise RuntimeError("unexpected command %r" % (cmd,))
@@ -203,6 +251,8 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert session._port is None
     assert session.connected
     assert not session._root
+    assert session._cpu_arch == test_arch
+    assert session._os_version == test_version
     session.disconnect()
     assert not session.connected
 
@@ -233,6 +283,11 @@ def fake_adb_call(cmd, timeout=None):
             return 0, ""
         if cmd[1] == "devices":
             return 0, "\n"
+        if cmd[1] == "shell" and cmd[2] == "getprop":
+            if cmd[3] == "init.svc.bootanim":
+                return 0, "stopped"
+            if cmd[3] == "sys.boot_completed":
+                return 0, "1"
         if cmd[1] == "shell" and cmd[2] == "whoami":
             return 1, ""
         raise RuntimeError("unexpected command %r" % (cmd,))
@@ -266,6 +321,15 @@ def fake_adb_call(obj, cmd, timeout=None):
             return 0, "restarting adbd as root"
         if cmd[1] == "shell" and cmd[2] == "getenforce":
             return 0, "Permissive"
+        if cmd[1] == "shell" and cmd[2] == "getprop":
+            if cmd[3] == "init.svc.bootanim":
+                return 0, "stopped"
+            if cmd[3] == "ro.build.version.release":
+                return 0, "9"
+            if cmd[3] == "ro.product.cpu.abi":
+                return 0, "x86_64"
+            if cmd[3] == "sys.boot_completed":
+                return 0, "1"
         if cmd[1] == "shell" and cmd[2] == "whoami":
             if obj._root:
                 return 0, "root"
@@ -321,7 +385,7 @@ def fake_adb_call(cmd, timeout=None):
     assert not session._root
     session.disconnect()
     # connect and enable root
-    assert not session.connect(max_attempts=1)
+    assert not session.connect(max_attempts=1, retry_delay=0.01)
     assert not session.connected
     assert not session._root
 
@@ -782,23 +846,11 @@ def test_adb_session_31(mocker):
     session.set_enforce(0)
     assert fake_call.call_count == 1
     fake_call.reset_mock()
-    # disable when disabled
-    mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=False)
-    session = ADBSession("127.0.0.1")
-    session.set_enforce(0)
-    assert fake_call.call_count == 0
-    fake_call.reset_mock()
     # enable when disabled
     mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=False)
     session = ADBSession("127.0.0.1")
     session.set_enforce(1)
     assert fake_call.call_count == 1
-    fake_call.reset_mock()
-    # enable when enabled
-    mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=True)
-    session = ADBSession("127.0.0.1")
-    session.set_enforce(1)
-    assert fake_call.call_count == 0
 
 def test_adb_session_32(mocker):
     """test ADBSession.realpath()"""
@@ -887,6 +939,58 @@ def fake_adb_call(cmd, timeout=None):
     session.set_airplane_mode()
     session.set_airplane_mode(mode=False)
 
+def test_adb_session_36(mocker):
+    """test ADBSession.wait_for_boot()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    fake_sleep = mocker.patch("time.sleep")
+    # test timeout
+    def fake_adb_01(_, cmd, timeout=None):
+        if cmd[1] == "shell" and cmd[2] == "getprop":
+            if cmd[3] == "init.svc.bootanim":
+                return 0, ""
+            if cmd[3] == "sys.boot_completed":
+                return 0, "0"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    ADBSession._call_adb = fake_adb_01
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    assert not session.wait_for_boot(timeout=0.01)
+    fake_sleep.reset_mock()
+    # test already booted
+    def fake_adb_02(_, cmd, timeout=None):
+        if cmd[1] == "shell" and cmd[2] == "getprop":
+            if cmd[3] == "init.svc.bootanim":
+                return 0, "stopped"
+            if cmd[3] == "sys.boot_completed":
+                return 0, "1"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    ADBSession._call_adb = fake_adb_02
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    assert session.wait_for_boot()
+    assert fake_sleep.call_count == 0
+    fake_sleep.reset_mock()
+    # test boot in progress
+    def fake_adb_03(obj, cmd, timeout=None):
+        if cmd[1] == "shell" and cmd[2] == "getprop":
+            if cmd[3] == "init.svc.bootanim":
+                if not getattr(obj, "anim_done", False):
+                    setattr(obj, "anim_done", True)
+                    return 0, ""
+                return 0, "stopped"
+            if cmd[3] == "sys.boot_completed":
+                if not getattr(obj, "boot_done", False):
+                    setattr(obj, "boot_done", True)
+                    return 0, "0"
+                return 0, "1"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    ADBSession._call_adb = fake_adb_03
+    session = ADBSession("127.0.0.1")
+    session.connected = True
+    assert session.wait_for_boot()
+    assert fake_sleep.call_count == 3
+
 def test_device_process_01():
     """test DeviceProcessInfo"""
     # nothing to parse

From 741e347d13ebb387d50b22132fa410d560bf9461 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 13 Aug 2019 17:36:49 -0700
Subject: [PATCH 472/531] Make device detection more robust

---
 grizzly/target/adb_device/adb_session.py      | 29 ++++++++---
 grizzly/target/adb_device/test_adb_session.py | 52 +++++++++++++++----
 2 files changed, 63 insertions(+), 18 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index d7cbe8fd..f072738b 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -149,7 +149,7 @@ def clear_logs(self):
         log.debug("clear_logs()")
         return self.call(["logcat", "--clear"], timeout=10)[0] == 0
 
-    def connect(self, as_root=True, boot_timeout=300, max_attempts=10, retry_delay=1):
+    def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1):
         assert isinstance(boot_timeout, int) and boot_timeout > 0
         assert isinstance(max_attempts, int) and max_attempts > 0
         assert isinstance(retry_delay, (int, float)) and retry_delay > 0
@@ -168,7 +168,7 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=10, retry_delay=1
                         log.warning("connection attempt #%d failed", attempt)
                         time.sleep(retry_delay)
                         continue
-                elif not self._devices_available(self.call(["devices"])[1]):
+                elif not self.devices():
                     log.warning("No device detected (attempt %d/%d)", attempt, max_attempts)
                     time.sleep(retry_delay)
                     continue
@@ -237,12 +237,25 @@ def collect_logs(self, pid=None):
             cmd += ["--pid=%d" % pid]
         return self.call(cmd, timeout=10)[1].encode("utf-8", "ignore")
 
-    @staticmethod
-    def _devices_available(adb_output):
-        entries = adb_output.strip().splitlines()
-        if len(entries) < 2:
-            return False
-        return entries[-1].endswith("device")
+    def devices(self, all_devices=False, any_state=True):
+        ret_code, entries = self.call(["devices"])
+        devices = {}
+        if ret_code != 0:
+            return devices
+        target_device = os.getenv("ANDROID_SERIAL", None) if not all_devices else None
+        for entry in entries.strip().splitlines()[1:]:
+            try:
+                name, state = entry.split()
+            except ValueError:
+                continue
+            if target_device is not None and name != target_device:
+                continue
+            if not any_state and state != "device":
+                continue
+            devices[name] = state
+        if target_device is None and not all_devices and len(devices) > 1:
+            raise ADBSessionError("Multiple devices available and ANDROID_SERIAL not set")
+        return devices
 
     def disconnect(self, unroot=True):
         if not self.connected:
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index d265b583..0f46d54b 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -93,16 +93,48 @@ def test_adb_session_04(mocker):
     assert session._port == test_port
     assert session._os_version is None
 
-def test_adb_session_05():
-    """test ADBSession._devices_available()"""
-    adb_output = (
-        "List of devices attached",
-        "* daemon not running; starting now at tcp:5037",
-        "* daemon started successfully",
-        "emulator-5554   device")
-    assert not ADBSession._devices_available("\n".join(adb_output[:-1]))
-    assert not ADBSession._devices_available("")
-    assert ADBSession._devices_available("\n".join(adb_output))
+def test_adb_session_05(mocker):
+    """test ADBSession.devices()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    def fake_adb_01(cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "devices":
+            return 1, ""
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_01)
+    assert not ADBSession().devices()
+    def fake_adb_02(cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "devices":
+            return 0, "List of devices attached\n" \
+                      "emulator-5554   device\n" \
+                      "emulator-5556   offline"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_02)
+    devices = ADBSession().devices(all_devices=True, any_state=False)
+    assert len(devices) == 1
+    assert "emulator-5554" in devices
+    def fake_adb_03(cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "devices":
+            return 0, "List of devices attached\n" \
+                      "* daemon not running; starting now at tcp:5037\n" \
+                      "* daemon started successfully\n" \
+                      "emulator-5554   device\n" \
+                      "emulator-5556   offline\n" \
+                      "emulator-5558   device\n"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_03)
+    session = ADBSession()
+    os.environ["ANDROID_SERIAL"] = "emulator-5558"
+    try:
+        devices = session.devices(all_devices=False, any_state=False)
+    finally:
+        os.environ.pop("ANDROID_SERIAL")
+    assert len(devices) == 1
+    assert "emulator-5558" in devices
+    with pytest.raises(ADBSessionError):
+        session.devices(all_devices=False, any_state=False)
 
 def test_adb_session_06(mocker):
     """test simple ADBSession.create()"""

From 7bd3a3cae42af2bef03661b7bf49484907ffabaa Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 15 Aug 2019 15:02:28 -0700
Subject: [PATCH 473/531] Add retry to bottstrap port reverse attempt

---
 grizzly/target/adb_device/adb_process.py | 36 ++++++++++++++----------
 1 file changed, 21 insertions(+), 15 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index b9e687c0..a2375ea8 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -44,7 +44,7 @@ def __init__(self, package_name, session, use_profile=None):
         self._session = session  # ADB session with device
         self._working_path = "/sdcard/ADBProc_%08X" % random.getrandbits(32)
         self.logs = None
-        self.profile = None
+        self.profile = None  # profile path on device
         self.reason = self.RC_CLOSED
 
     def cleanup(self):
@@ -130,32 +130,38 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
         self._session.clear_logs()
         self._remove_logs()
         self.reason = None
-        local_profile = create_profile(
-            extension=extension,
-            prefs_js=prefs_js,
-            template=self._profile_template)
-
-        bootstrapper = Bootstrapper(poll_wait=0.5)
+        # setup bootstrapper and reverse port
+        # reverse does fail occasionally so use a retry loop
+        for _ in range(10):
+            bootstrapper = Bootstrapper(poll_wait=0.5)
+            if not self._session.reverse(bootstrapper.port, bootstrapper.port):
+                bootstrapper.close()
+                log.debug("failed to reverse port, retrying...")
+                time.sleep(0.25)
+                continue
+            break
+        else:
+            bootstrapper.close()
+            raise ADBLaunchError("Could not reverse port")
         try:
+            profile = create_profile(extension=extension, prefs_js=prefs_js, template=self._profile_template)
             try:
                 prefs = {
                     "capability.policy.policynames": "'localfilelinks'",
                     "capability.policy.localfilelinks.sites": "'%s'" % bootstrapper.location,
                     "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'"}
-                append_prefs(local_profile, prefs)
-                self.profile = "/".join([self._working_path, os.path.basename(local_profile)])
-                if not self._session.push(local_profile, self.profile):
-                    raise ADBLaunchError("Could not upload profile %r" % local_profile)
+                append_prefs(profile, prefs)
+                self.profile = "/".join([self._working_path, os.path.basename(profile)])
+                if not self._session.push(profile, self.profile):
+                    raise ADBLaunchError("Could not upload profile %r" % profile)
             finally:
-                shutil.rmtree(local_profile, True)
-            if not self._session.reverse(bootstrapper.port, bootstrapper.port):
-                raise ADBLaunchError("Could not reverse port: %d" % bootstrapper.port)
+                shutil.rmtree(profile, True)
             cmd = [
                 "shell", "am", "start", "-W", "-n",
                 "/".join([self._package, "org.mozilla.gecko.BrowserApp"]),
                 "-a", "android.intent.action.VIEW", "-d", bootstrapper.location,
                 "--es", "args", "-profile\\ %s" % self.profile]
-
+            # add environment variables to launch command
             env_mod = dict(env_mod or {})
             env_mod.setdefault("MOZ_SKIA_DISABLE_ASSERTS", "1")
             for var_num, (var_name, var_val) in enumerate(env_mod.items()):

From b1ab1d5c1fe1d3993eda221451aae710b2ce6369 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 15 Aug 2019 18:02:15 -0700
Subject: [PATCH 474/531] Misc nits - Make some functions generators - Add more
 sanity checks - Update tests

---
 grizzly/target/adb_device/adb_process.py      |  3 +-
 grizzly/target/adb_device/adb_session.py      | 72 ++++++++++---------
 grizzly/target/adb_device/device.py           | 30 +++++---
 grizzly/target/adb_device/test_adb_process.py |  4 +-
 grizzly/target/adb_device/test_adb_session.py | 48 +++++++------
 5 files changed, 91 insertions(+), 66 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index a2375ea8..c495b1d8 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -141,7 +141,6 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
                 continue
             break
         else:
-            bootstrapper.close()
             raise ADBLaunchError("Could not reverse port")
         try:
             profile = create_profile(extension=extension, prefs_js=prefs_js, template=self._profile_template)
@@ -277,7 +276,7 @@ def wait_on_files(self, wait_files, poll_rate=0.5, timeout=60):
         wait_files = set(self._session.realpath(x) for x in wait_files)
 
         while wait_files:
-            open_files = set(x for _, x in self._session.get_open_files())
+            open_files = set(x for _, x in self._session.open_files())
             # check if any open files are in the wait file list
             if not wait_files.intersection(open_files):
                 break
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index f072738b..d46a7345 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -99,6 +99,16 @@ def _adb_check(cls):
         time.sleep(5)
         return adb_bin
 
+    @property
+    def airplane_mode(self):
+        return self.call(["shell", "settings", "get", "global", "airplane_mode_on"])[1].startswith("1")
+
+    @airplane_mode.setter
+    def airplane_mode(self, mode):
+        assert isinstance(mode, bool), "mode must be a bool"
+        self.call(["shell", "settings", "put", "global", "airplane_mode_on", "1" if mode else "0"])
+        self.call(["shell", "su", "root", "am", "broadcast", "-a", "android.intent.action.AIRPLANE_MODE"])
+
     @classmethod
     def create(cls, ip_addr=None, port=5555, as_root=True, max_attempts=10):
         session = cls(ip_addr, port)
@@ -202,8 +212,9 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                     self.call(["shell", "start"])
                     # put the device in a known state
                     self.call(["reconnect"])
-                    set_enforce_called = True
                     self.connected = False
+                    set_enforce_called = True
+                    attempt -= 1
                     continue
 
             if not as_root or self._root:
@@ -320,12 +331,14 @@ def install(self, apk_path):
         if self.call(["install", "-r", apk_path], timeout=120)[0] != 0:
             raise ADBSessionError("Failed to install %r" % apk_path)
         # unpack and lookup package name
-        package_name = self.get_package_name(apk_path)
+        pkg_name = self.get_package_name(apk_path)
+        if pkg_name is None:
+            raise ADBSessionError("Could not find APK package name")
         # set permissions
-        self.call(["shell", "pm", "grant", package_name, "android.permission.READ_EXTERNAL_STORAGE"])
-        self.call(["shell", "pm", "grant", package_name, "android.permission.WRITE_EXTERNAL_STORAGE"])
-        log.debug("installed package %r (%r)", package_name, apk_path)
-        return package_name
+        self.call(["shell", "pm", "grant", pkg_name, "android.permission.READ_EXTERNAL_STORAGE"])
+        self.call(["shell", "pm", "grant", pkg_name, "android.permission.WRITE_EXTERNAL_STORAGE"])
+        log.debug("installed package %r (%r)", pkg_name, apk_path)
+        return pkg_name
 
     # This is no longer required and I *think* it can be removed
     #def install_file(self, src, dst, mode=None, context=None):
@@ -348,23 +361,26 @@ def get_enforce(self):
 
     @classmethod
     def get_package_name(cls, apk_path):
+        if not os.path.isfile(apk_path):
+            raise IOError("APK path must point to a file")
         aapt = cls._aapt_check()
         apk_info = subprocess.check_output([aapt, "dump", "badging", apk_path])
         for line in apk_info.splitlines():
             if line.startswith(b"package: name="):
-                package_name = line.split()[1][5:].strip(b"'").decode("utf-8", errors="ignore")
-                break
-        else:
-            raise RuntimeError("Could not find APK package name")
-        return package_name
+                return line.split()[1][5:].strip(b"'").decode("utf-8", errors="ignore")
+        return None
 
-    def get_packages(self):
+    @property
+    def packages(self):
         # TODO: should this be by pid or package?
-        cmd = ["shell", "pm", "list", "packages"]
-        return [line[8:] for line in self.call(cmd)[1].splitlines() if line.startswith("package:")]
-
-    def get_open_files(self, pid=None, children=False, files=None):
-        log.debug("get_open_files(pid=%r, children=%r, files=%r", pid, children, files)
+        ret_code, output = self.call(["shell", "pm", "list", "packages"])
+        if ret_code == 0:
+            for line in output.splitlines():
+                if line.startswith("package:"):
+                    yield line[8:]
+
+    def open_files(self, pid=None, children=False, files=None):
+        log.debug("open_files(pid=%r, children=%r, files=%r", pid, children, files)
         pids = list()
         if pid is not None:
             pids.append(str(pid))
@@ -377,7 +393,6 @@ def get_open_files(self, pid=None, children=False, files=None):
             cmd += ["-p", ",".join(pids)]
         if files:
             cmd.extend(list(files))
-        open_files = list()
         for line in self.call(cmd)[1].splitlines():
             if line.endswith("Permission denied)"):
                 continue
@@ -389,17 +404,14 @@ def get_open_files(self, pid=None, children=False, files=None):
                 file_name = file_info[-1]
                 if pid is not None and file_info[1] not in pids:
                     continue
-                # add tuple containing pid and filename
-                open_files.append((int(file_info[1]), file_name))
+                # yield tuple containing pid and filename
+                yield (int(file_info[1]), file_name)
             except ValueError:
                 pass
 
-        return open_files
-
     def get_pid(self, package_name):
         # NOTE: pidof is not supported pre-Android 6
-        procs = self._get_procs()
-        pids = [proc.pid for proc in procs if proc.name == package_name]
+        pids = [proc.pid for proc in self._get_procs() if proc.name == package_name]
         if not pids:
             return None
         count = len(pids)
@@ -407,7 +419,7 @@ def get_pid(self, package_name):
             log.debug("get_pid() %d proc(s) found", count)
             # TODO: use procs and use the ppid of the procs the determine the parent
             pids.sort()
-        return int(pids[0])
+        return pids[0]
 
     def process_exists(self, pid):
         return bool(self._get_procs(pid=pid))
@@ -419,15 +431,13 @@ def _get_procs(self, pid=None, pid_children=None):
             cmd.append(str(pid))
         if pid_children is not None:
             cmd += ["--ppid", str(pid_children)]
-        procs = list()
         for line in self.call(cmd)[1].splitlines()[1:]:
             pinfo = DeviceProcessInfo.from_ps_line(line)
             if pinfo is not None:
-                procs.append(pinfo)
-        return procs
+                yield pinfo
 
     def is_installed(self, package_name):
-        return package_name in self.get_packages()
+        return package_name in self.packages
 
     def pull(self, src, dst):
         log.debug("pull(%r, %r)", src, dst)
@@ -442,10 +452,6 @@ def push(self, src, dst):
     def symbols_path(self, package_name):
         return self.symbols.get(package_name, "")
 
-    def set_airplane_mode(self, mode=True):
-        self.call(["shell", "settings", "put", "global", "airplane_mode_on", "1" if mode else "0"])
-        self.call(["shell", "su", "root", "am", "broadcast", "-a", "android.intent.action.AIRPLANE_MODE"])
-
     def set_enforce(self, value):
         assert value in (0, 1)
         if not self._root:
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index 9e306abf..72fd056b 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -47,6 +47,12 @@ def main(argv=None):  # pylint: disable=missing-docstring
         parser.error("No options selected")
         return 1
 
+    # sanity check the APK
+    for apk in (args.install, args.launch, args.prep):
+        if apk is not None and not os.path.isfile(apk):
+            log.error("Invalid APK %r", apk)
+            return 1
+
     log.debug("opening a session")
     session = ADBSession.create(args.ip, args.port, as_root=not args.non_root)
     if session is None:
@@ -62,28 +68,34 @@ def main(argv=None):  # pylint: disable=missing-docstring
                 log.info("Enabling airplane mode...")
             else:
                 log.info("Disabling airplane mode...")
-            session.set_airplane_mode(mode=args.airplane_mode > 0)
+            session.airplane_mode = bool(args.airplane_mode)
             log.info("Done.")
         if args.install is not None:
-            if session.uninstall(ADBSession.get_package_name(args.install)):
+            pkg_name = ADBSession.get_package_name(args.install)
+            if pkg_name is None:
+                log.error("Failed to lookup package name in %r", args.install)
+                return 1
+            if session.uninstall(pkg_name):
                 log.info("Uninstalled existing version")
-            log.info("Installing %r ...", args.install)
+            log.info("Installing %s (%r)...", pkg_name, args.install)
             package = session.install(args.install)
             if not package:
-                log.error("Could not install %r", args.install)
+                log.error("Could not install %s", args.install)
                 return 1
-            log.info("Installed %r.", package)
+            log.info("Installed %s.", package)
         if args.launch:
-            package = ADBSession.get_package_name(args.launch)
-            if not package:
-                log.error("APK not installed")
+            pkg_name = ADBSession.get_package_name(args.launch)
+            if pkg_name is None:
+                log.error("Failed to lookup package name in %r", args.install)
                 return 1
-            proc = ADBProcess(package, session)
+            proc = ADBProcess(pkg_name, session)
             try:
                 proc.launch("about:blank", launch_timeout=60)
                 assert proc.is_running(), "browser not running?!"
                 log.info("Launched.")
                 proc.wait()
+            except KeyboardInterrupt:
+                pass
             finally:
                 proc.close()
                 if args.logs:
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index a9b0cfa9..f695bd49 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -101,7 +101,7 @@ def test_adb_process_06(mocker):
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = ""
-    fake_session.get_open_files.return_value = ((1, "some_file"),)
+    fake_session.open_files.return_value = ((1, "some_file"),)
     fake_session.listdir.return_value = ()
     fake_session.realpath.side_effect = str.strip
     proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
@@ -109,7 +109,7 @@ def test_adb_process_06(mocker):
         proc.wait_on_files(["not_running"])
         assert proc.launch("fake.url")
         assert proc.wait_on_files([])
-        fake_session.get_open_files.return_value = ((1, "some_file"), (1, "/existing/file.txt"))
+        fake_session.open_files.return_value = ((1, "some_file"), (1, "/existing/file.txt"))
         assert not proc.wait_on_files(["/existing/file.txt"], poll_rate=0.1, timeout=0.3)
         proc.close()
     finally:
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 0f46d54b..e507fd85 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -538,7 +538,7 @@ def fake_adb_call(cmd, timeout=None):
     assert session.is_installed("org.test.preinstalled")
 
 def test_adb_session_18(mocker):
-    """test ADBSession.get_packages()"""
+    """test ADBSession.packages()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
@@ -555,7 +555,7 @@ def fake_adb_call(cmd, timeout=None):
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
-    pkgs = session.get_packages()
+    pkgs = tuple(session.packages)
     assert len(pkgs) == 4
     assert "com.android.phone" in pkgs
     assert "com.android.shell" in pkgs
@@ -601,7 +601,7 @@ def fake_adb_call(cmd, timeout=None):
     assert not session.collect_logs(1111).splitlines()
 
 def test_adb_session_20(mocker):
-    """test ADBSession.get_open_files()"""
+    """test ADBSession.open_files()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
@@ -648,13 +648,13 @@ def fake_adb_call(cmd, timeout=None):
     session = ADBSession("127.0.0.1")
     session.connected = True
     # list all open files
-    assert len(session.get_open_files()) == 7
+    assert len(tuple(session.open_files())) == 7
     # list process specific open files
-    assert len(session.get_open_files(pid=9990)) == 5
+    assert len(tuple(session.open_files(pid=9990))) == 5
     # list process and children specific open files
-    assert len(session.get_open_files(pid=9990, children=True)) == 6
+    assert len(tuple(session.open_files(pid=9990, children=True))) == 6
     with pytest.raises(AssertionError):
-        session.get_open_files(pid=None, children=True)
+        tuple(session.open_files(pid=None, children=True))
 
 def test_adb_session_21(mocker):
     """test ADBSession._get_procs()"""
@@ -690,8 +690,8 @@ def fake_adb_call(cmd, timeout=None):
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
-    assert len(session._get_procs()) == 10
-    dev_procs = session._get_procs(pid_children=9990)
+    assert len(tuple(session._get_procs())) == 10
+    dev_procs = tuple(session._get_procs(pid_children=9990))
     assert len(dev_procs) == 1
     assert dev_procs[0].pid == 9991
 
@@ -818,12 +818,15 @@ def test_adb_session_28(mocker, tmp_path):
     with pytest.raises(EnvironmentError, match=r"Please install ADB"):
         assert ADBSession._adb_check()
 
-def test_adb_session_29(mocker):
+def test_adb_session_29(mocker, tmp_path):
     """test ADBSession.get_package_name()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._aapt_check", return_value="/fake/aapt")
     mocker.patch("subprocess.check_output", return_value=b"")
-    with pytest.raises(RuntimeError, match=r"Could not find APK package name"):
+    with pytest.raises(IOError):
         ADBSession.get_package_name("/fake/path")
+    fake_apk = tmp_path / "fake.apk"
+    fake_apk.touch()
+    assert ADBSession.get_package_name(str(fake_apk)) is None
     output = (
         b"package: name='org.mozilla.fennec_aurora' versionCode='2015624653' versionName='68.0a1' platformBuildVersionName=''",
         b"install-location:'internalOnly'",
@@ -856,7 +859,7 @@ def test_adb_session_29(mocker):
         b"densities: '120' '160' '240' '320' '480' '640' '65534' '65535'",
         b"native-code: 'x86'")
     mocker.patch("subprocess.check_output", return_value=b"\n".join(output))
-    assert ADBSession.get_package_name("/fake/path") == "org.mozilla.fennec_aurora"
+    assert ADBSession.get_package_name(str(fake_apk)) == "org.mozilla.fennec_aurora"
 
 def test_adb_session_30(mocker):
     """test ADBSession.get_enforce()"""
@@ -947,16 +950,20 @@ def fake_adb_call(cmd, timeout=None):
         session.reverse_remove(remote=1023)
 
 def test_adb_session_35(mocker):
-    """test ADBSession.set_airplane_mode()"""
+    """test ADBSession.airplane_mode()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "settings":
-            assert cmd[3] == "put"
-            assert cmd[4] == "global"
-            assert cmd[5] == "airplane_mode_on"
-            assert cmd[6] in "01"
-            return 0, ""
+            if cmd[3] == "get":
+                assert cmd[4] == "global"
+                assert cmd[5] == "airplane_mode_on"
+                return 0, "1"
+            if cmd[3] == "put":
+                assert cmd[4] == "global"
+                assert cmd[5] == "airplane_mode_on"
+                assert cmd[6] in "01"
+                return 0, ""
         if cmd[1] == "shell" and cmd[2] == "su":
             assert cmd[3] == "root"
             assert cmd[4] == "am"
@@ -968,8 +975,9 @@ def fake_adb_call(cmd, timeout=None):
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
-    session.set_airplane_mode()
-    session.set_airplane_mode(mode=False)
+    session.airplane_mode = False
+    session.airplane_mode = True
+    assert session.airplane_mode
 
 def test_adb_session_36(mocker):
     """test ADBSession.wait_for_boot()"""

From a35d22d1ae186a5be2af478ae4df8b4751837a4d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 15 Aug 2019 18:33:08 -0700
Subject: [PATCH 475/531] Add reboot_device() and remount()

---
 grizzly/target/adb_device/adb_session.py      | 18 ++++++++
 grizzly/target/adb_device/test_adb_session.py | 44 +++++++++++++++++++
 2 files changed, 62 insertions(+)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index d46a7345..d6121dcd 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -300,6 +300,24 @@ def realpath(self, path):
             raise IOError("%r does not exist" % path)
         return output.strip()
 
+    def reboot_device(self, boot_timeout=300, max_attempts=60, retry_delay=1):
+        was_root = self._root
+        log.debug("calling reboot...")
+        self.call(["reboot"])
+        self.connected = False
+        self.connect(
+            as_root=was_root,
+            boot_timeout=boot_timeout,
+            max_attempts=max_attempts,
+            retry_delay=retry_delay)
+        assert self.connected, "Device did not connect after reboot"
+
+    def remount(self):
+        assert self._root
+        code, result = self.call(["remount"])
+        if code != 0 or "Permission denied" in result:
+            raise ADBSessionError("Remount failed, is '-writable-system' set?")
+
     def reverse(self, remote, local):
         # remote->device, local->desktop
         assert isinstance(local, int) and 1024 < local < 0x10000
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index e507fd85..a62176b6 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -1031,6 +1031,50 @@ def fake_adb_03(obj, cmd, timeout=None):
     assert session.wait_for_boot()
     assert fake_sleep.call_count == 3
 
+def test_adb_session_37(mocker):
+    """test ADBSession.reboot_device()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    def fake_adb_call(cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "reboot":
+            return 0, ""
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+    mocker.patch("grizzly.target.adb_device.ADBSession.connect", spec=True)
+    session = ADBSession()
+    session.connected = True
+    with pytest.raises(AssertionError):
+        session.reboot_device()
+
+def test_adb_session_38(mocker):
+    """test ADBSession.remount()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    def fake_adb_01(cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "remount":
+            return 0, "Permission denied"
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_01)
+    session = ADBSession()
+    session.connected = True
+    session._root = True
+    with pytest.raises(ADBSessionError):
+        session.remount()
+    def fake_adb_02(cmd, timeout=None):
+        assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "remount":
+            return 0, ""
+        raise RuntimeError("unexpected command %r" % (cmd,))
+    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_02)
+    session = ADBSession()
+    session.connected = True
+    # test as non-root
+    with pytest.raises(AssertionError):
+        session.remount()
+    session._root = True
+    # test as root
+    session.remount()
+
 def test_device_process_01():
     """test DeviceProcessInfo"""
     # nothing to parse

From 6e08ec0a93a92edbf0b4094f3eb04dc0def4a586 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 15 Aug 2019 19:45:08 -0700
Subject: [PATCH 476/531] Use any() instead of bool() on output of a generator

---
 grizzly/target/adb_device/adb_session.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index d6121dcd..595259ad 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -440,7 +440,7 @@ def get_pid(self, package_name):
         return pids[0]
 
     def process_exists(self, pid):
-        return bool(self._get_procs(pid=pid))
+        return any(self._get_procs(pid=pid))
 
     def _get_procs(self, pid=None, pid_children=None):
         # default list all procs

From 14e28b5910585ba8d98b281f060415e82cd3c43e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 21 Aug 2019 10:07:00 -0700
Subject: [PATCH 477/531] Add ASan support At this time
 ASAN_OPTIONS=log_file='...' does not seem to work correctly See
 https://github.com/google/sanitizers/issues/1135

- detect ASan logs in logcat output
- add ability to install ASan
---
 grizzly/target/adb_device/adb_process.py      |  42 +++++-
 grizzly/target/adb_device/adb_session.py      | 122 ++++++++++++++++--
 grizzly/target/adb_device/device.py           |   9 +-
 grizzly/target/adb_device/test_adb_process.py |   8 +-
 grizzly/target/adb_device/test_adb_session.py |   5 +-
 5 files changed, 160 insertions(+), 26 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index c495b1d8..b6e3ac8c 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -84,6 +84,10 @@ def close(self):
                 self.wait()
                 self._process_logs(crash_reports)
                 self._session.call(["shell", "rm", "-rf", self._working_path])
+                # TODO: this should be temporary until ASAN_OPTIONS=log_file is working
+                if "log_asan.txt" in os.listdir(self.logs):
+                    self.reason = self.RC_ALERT
+
         except ADBSessionError:
             log.warning("No device detected while closing process")
         self._pid = None
@@ -93,7 +97,7 @@ def close(self):
 
     def find_crashreports(self):
         reports = list()
-        # TODO: Add ASan support
+        # TODO: scan for ASan logs once ASAN_OPTIONS=log_path is working
         if self.profile:
             # check for minidumps
             md_path = os.path.join(self.profile, "minidumps")
@@ -129,6 +133,10 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
 
         self._session.clear_logs()
         self._remove_logs()
+        sanitizer_logs = os.path.dirname(self._session.SANITIZER_LOG_PREFIX)
+        self._session.call(["shell", "rm", "-r", sanitizer_logs])
+        self._session.call(["shell", "mkdir", "-p", sanitizer_logs])
+        self._session.call(["shell", "chmod", "666", sanitizer_logs])
         self.reason = None
         # setup bootstrapper and reverse port
         # reverse does fail occasionally so use a retry loop
@@ -203,7 +211,7 @@ def _process_logs(self, crash_reports):
             # TODO: should this filter by pid or not?
             log_fp.write(self._session.collect_logs())
             #log_fp.write(self._session.collect_logs(pid=self._pid))
-
+        self._split_logcat(self.logs, self._package)
         if not crash_reports:
             return
 
@@ -226,7 +234,7 @@ def _remove_logs(self):
             self.logs = None
 
     @staticmethod
-    def _split_logcat(log_path):
+    def _split_logcat(log_path, package_name):
         # Roughly split out stderr and stdout from logcat
         # This is to support FuzzManager. The original logcat output is also
         # included in the report so nothing is lost.
@@ -240,16 +248,39 @@ def _split_logcat(log_path):
         out_log = os.path.join(log_path, "log_stdout.txt")
         if os.path.isfile(out_log):
             log.warning("log_stdout.txt already exist! Overwriting...")
+        assert package_name
+        if not isinstance(package_name, bytes):
+            package_name = package_name.encode("utf-8")
+        asan_found = False
         with open(logcat, "rb") as lc_fp, open(err_log, "w") as e_fp, open(out_log, "w") as o_fp:
             for line in lc_fp:
-                if b"Gecko" not in line and b"MOZ_" not in line:
+                if b"Gecko" not in line and b"MOZ_" not in line and package_name not in line:
                     continue
                 # strip logger info ... "07-27 12:10:15.442  9990  4234 E "
                 line = re.sub(r".+?\s[A-Z]\s+", "", line.decode("ascii", "ignore"))
                 if line.startswith("GeckoDump"):
                     o_fp.write(line.split(": ", 1)[-1])
-                elif line.startswith("Gecko") or line.startswith("MOZ_"):
+                elif line.startswith("Gecko") or line.startswith("MOZ_") or line.startswith(package_name):
                     e_fp.write(line.split(": ", 1)[-1])
+                if not asan_found:
+                    asan_found = "AddressSanitizer" in line
+        # Break out ASan logs (to be removed when ASAN_OPTIONS=log_path works)
+        # This could be merged into the above block but it is kept septate
+        # so it can be remove easily in the future.
+        if asan_found:
+            asan_log = os.path.join(log_path, "log_asan.txt")
+            if os.path.isfile(asan_log):
+                log.warning("log_asan.txt already exist! Overwriting...")
+            found_log = False
+            with open(err_log, "rb") as e_fp, open(asan_log, "wb") as o_fp:
+                for line in e_fp:
+                    if not found_log:
+                        found_log = b"AddressSanitizer" in line
+                    if found_log:
+                        o_fp.write(line)
+                        if b"==ABORTING" in line:
+                            break
+
 
     def save_logs(self, log_path, meta=False):
         assert self.logs is not None
@@ -266,7 +297,6 @@ def save_logs(self, log_path, meta=False):
             if not os.path.isfile(full_name):
                 continue
             shutil.copy(full_name, log_path)
-        self._split_logcat(log_path)
 
     def wait_on_files(self, wait_files, poll_rate=0.5, timeout=60):
         assert poll_rate >= 0, "Invalid poll_rate %d, must be greater than or equal to 0" % poll_rate
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 595259ad..50b92c5a 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -1,5 +1,7 @@
+import glob
 import logging
 import os
+import shutil
 import socket
 import subprocess
 import tempfile
@@ -44,11 +46,14 @@ class ADBNoDevice(ADBSessionError):
 
 
 class ADBSession(object):
+    SANITIZER_LOG_PREFIX = "/sdcard/sanitizer_logs/report.log"
+
     def __init__(self, ip_addr=None, port=5555):
         self.connected = False
         self.symbols = dict()
         self._adb_bin = self._adb_check()
         self._cpu_arch = None  # Android CPU architecture string
+        self._debug_adb = int(os.getenv("SHOW_ADB_DEBUG", "0")) != 0  # include adb output in debug logs
         self._ip_addr = None  # target device IP address
         self._os_version = None  # Android version string
         self._port = None  # ADB listening port
@@ -142,7 +147,8 @@ def call(self, cmd, require_device=True, timeout=None):
         if not self.connected and cmd[1] not in ("connect", "devices", "disconnect"):
             raise ADBSessionError("ADB session is not connected!")
         ret_code, output = self._call_adb(cmd, timeout=timeout)
-        log.debug("=== adb start ===\n%s\n=== adb end, returned %d ===", output, ret_code)
+        if self._debug_adb:
+            log.debug("=== adb start ===\n%s\n=== adb end, returned %d ===", output, ret_code)
         if ret_code != 0:
             if output.startswith("Android Debug Bridge version"):
                 raise ADBCommandError("Invalid ADB command '%s'" % " ".join(cmd[1:]))
@@ -315,7 +321,7 @@ def reboot_device(self, boot_timeout=300, max_attempts=60, retry_delay=1):
     def remount(self):
         assert self._root
         code, result = self.call(["remount"])
-        if code != 0 or "Permission denied" in result:
+        if code != 0 or "Permission denied" in result or "remount failed" in result:
             raise ADBSessionError("Remount failed, is '-writable-system' set?")
 
     def reverse(self, remote, local):
@@ -345,8 +351,7 @@ def install(self, apk_path):
         log.debug("installing %r", apk_path)
         if not os.path.isfile(apk_path):
             raise IOError("APK does not exist %r" % apk_path)
-        # check if package is installed
-        if self.call(["install", "-r", apk_path], timeout=120)[0] != 0:
+        if self.call(["install", "-g", "-r", apk_path], timeout=120)[0] != 0:
             raise ADBSessionError("Failed to install %r" % apk_path)
         # unpack and lookup package name
         pkg_name = self.get_package_name(apk_path)
@@ -358,16 +363,105 @@ def install(self, apk_path):
         log.debug("installed package %r (%r)", pkg_name, apk_path)
         return pkg_name
 
-    # This is no longer required and I *think* it can be removed
-    #def install_file(self, src, dst, mode=None, context=None):
-    #    basename = os.path.basename(src)
-    #    full_dst = os.path.join(dst, basename)
-    #    self.push(src, full_dst)
-    #    self.call(["shell", "chown", "root.shell", full_dst])
-    #    if mode is not None:
-    #        self.call(["shell", "chmod", mode, full_dst])
-    #    if context is not None:
-    #        self.call(["shell", "chcon", context, full_dst])
+    def install_asan(self, ndk_base, asan_options=None):
+        if not os.path.isdir(ndk_base):
+            raise IOError("NDK does not exist %r" % ndk_base)
+
+        clang_path = os.path.join(
+            ndk_base, "toolchains", "llvm", "prebuilt", "linux-x86_64", "lib64",
+            "clang", "*", "lib", "linux")
+        for cpath in glob.glob(clang_path):
+            asan_rt = os.path.join(cpath, "libclang_rt.asan-i686-android.so")
+            asan_rt64 = os.path.join(cpath, "libclang_rt.asan-x86_64-android.so")
+            if os.path.isfile(asan_rt) and os.path.isfile(asan_rt64):
+                break
+        else:
+            raise IOError("Cannot find libclang_rt.asan-*-android.so")
+
+        self.remount()
+        ctx = "u:object_r:zygote_exec:s0"
+        if self.call(["shell", "ls", "/system/bin/app_process32.real"]) != 0:
+            self.call(["shell", "mv", "/system/bin/app_process32", "/system/bin/app_process32.real"])
+            self.call(["shell", "chcon", ctx, "/system/bin/app_process32.real"])
+        if self.call(["shell", "ls", "/system/bin/app_process64.real"]) != 0:
+            self.call(["shell", "mv", "/system/bin/app_process64", "/system/bin/app_process64.real"])
+            self.call(["shell", "chcon", ctx, "/system/bin/app_process64.real"])
+
+        # TODO: should we force overwrite here?
+        self.install_file(asan_rt, "/system/lib", "644")
+        self.install_file(asan_rt64, "/system/lib64", "644")
+
+        sanitizer_logs = os.path.dirname(self.SANITIZER_LOG_PREFIX)
+        self.call(["shell", "mkdir", "-p", sanitizer_logs])
+        self.call(["shell", "chmod", "666", sanitizer_logs])
+        addition_options = [
+            "abort_on_error=0",
+            "allow_user_segv_handler=1",
+            "detect_leaks=0",
+            "fast_unwind_on_check=1",
+            "fast_unwind_on_fatal=1",
+            #"log_path='%s'" % (self.SANITIZER_LOG_PREFIX,),
+            "use_sigaltstack=1",
+            "symbolize=1",
+            "start_deactivated=1"]
+        if asan_options:
+            existing_opts = [opt for opt in asan_options.split(":") if opt]
+        else:
+            existing_opts = []
+        asan_options = ":".join(existing_opts + addition_options)
+
+        tmpd = tempfile.mkdtemp()
+        try:
+            fname = os.path.join(tmpd, "app_process32")
+            with open(fname, "w") as out_fp:
+                out_fp.write("#!/system/bin/sh\n")
+                out_fp.write("ASAN_OPTIONS=%s \\\n" % asan_options)
+                #out_fp.write("ASAN_ACTIVATION_OPTIONS=include_if_exists=/sdcard/asan.options \\\n")
+                out_fp.write("LD_PRELOAD=/system/lib/libclang_rt.asan-i686-android.so \\\n")
+                out_fp.write("exec /system/bin/app_process32.real \"$@\"\n")
+            self.install_file(fname, "/system/bin", "755", ctx)
+            fname = os.path.join(tmpd, "app_process64")
+            with open(fname, "w") as out_fp:
+                out_fp.write("#!/system/bin/sh\n")
+                out_fp.write("ASAN_OPTIONS=%s \\\n" % asan_options)
+                #out_fp.write("ASAN_ACTIVATION_OPTIONS=include_if_exists=/sdcard/asan.option \\\n")
+                out_fp.write("LD_PRELOAD=/system/lib64/libclang_rt.asan-x86_64-android.so \\\n")
+                out_fp.write("exec /system/bin/app_process64.real \"$@\"\n")
+            self.install_file(fname, "/system/bin", "755", ctx)
+            fname = os.path.join(tmpd, "asanwrapper32")
+            with open(fname, "w") as out_fp:
+                out_fp.write("#!/system/bin/sh\n")
+                out_fp.write("LD_PRELOAD=/system/lib/libclang_rt.asan-i686-android.so \\\n")
+                out_fp.write("exec \"$@\"\n")
+            self.install_file(fname, "/system/bin", "755")
+            fname = os.path.join(tmpd, "asanwrapper64")
+            with open(fname, "w") as out_fp:
+                out_fp.write("#!/system/bin/sh\n")
+                out_fp.write("LD_PRELOAD=/system/lib64/libclang_rt.asan-x86_64-android.so \\\n")
+                out_fp.write("exec \"$@\"\n")
+            self.install_file(fname, "/system/bin", "755")
+        finally:
+            shutil.rmtree(tmpd, ignore_errors=True)
+
+        llvm_symer = os.path.join(
+            ndk_base, "prebuilt", "android-x86_64", "llvm-symbolizer", "llvm-symbolizer")
+        self.install_file(llvm_symer, "/system/bin", "755", ctx)
+
+        self.call(["shell", "stop"])
+        self.call(["shell", "start"])
+        # put the device in a known state
+        self.call(["reconnect"])
+        self.wait_for_boot()
+
+    def install_file(self, src, dst, mode=None, context=None):
+        basename = os.path.basename(src)
+        full_dst = os.path.join(dst, basename)
+        self.push(src, full_dst)
+        self.call(["shell", "chown", "root.shell", full_dst])
+        if mode is not None:
+            self.call(["shell", "chmod", mode, full_dst])
+        if context is not None:
+            self.call(["shell", "chcon", context, full_dst])
 
     def get_enforce(self):
         status = self.call(["shell", "getenforce"])[1]
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index 72fd056b..6fd87d40 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -28,6 +28,8 @@ def main(argv=None):  # pylint: disable=missing-docstring
         help="Enable(1) or disable(0) airplane mode")
     parser.add_argument(
         "--install", help="Path to APK to install")
+    parser.add_argument(
+        "--install-asan", help="Path to NDK")
     parser.add_argument(
         "--launch", help="Path to APK to launch")
     parser.add_argument(
@@ -43,7 +45,7 @@ def main(argv=None):  # pylint: disable=missing-docstring
     parser.add_argument(
         "--prep", help="Prepare the device for fuzzing. Path to APK")
     args = parser.parse_args(argv)
-    if not any((args.airplane_mode is not None, args.install, args.launch, args.prep)):
+    if not any((args.airplane_mode is not None, args.install, args.install_asan, args.launch, args.prep)):
         parser.error("No options selected")
         return 1
 
@@ -70,6 +72,9 @@ def main(argv=None):  # pylint: disable=missing-docstring
                 log.info("Disabling airplane mode...")
             session.airplane_mode = bool(args.airplane_mode)
             log.info("Done.")
+        if args.install_asan is not None:
+            log.info("Installing ASan from %r ...", args.install_asan)
+            session.install_asan(args.install_asan)
         if args.install is not None:
             pkg_name = ADBSession.get_package_name(args.install)
             if pkg_name is None:
@@ -90,7 +95,7 @@ def main(argv=None):  # pylint: disable=missing-docstring
                 return 1
             proc = ADBProcess(pkg_name, session)
             try:
-                proc.launch("about:blank", launch_timeout=60)
+                proc.launch("about:blank", launch_timeout=360)
                 assert proc.is_running(), "browser not running?!"
                 log.info("Launched.")
                 proc.wait()
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index f695bd49..e1837ef8 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -34,6 +34,7 @@ def test_adb_process_02(mocker):
 def test_adb_process_03(mocker):
     """test failed ADBProcess.launch() and ADBProcess.is_running()"""
     fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (1, "")
     fake_session.collect_logs.return_value = ""
     fake_session.listdir.return_value = ()
@@ -55,6 +56,7 @@ def test_adb_process_04(mocker):
     fake_bs.return_value.location.return_value = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = ""
     fake_session.get_pid.return_value = 1337
@@ -82,6 +84,7 @@ def test_adb_process_05(mocker):
     fake_bs.return_value.location.return_value = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = ""
     fake_session.get_pid.return_value = 1337
@@ -99,6 +102,7 @@ def test_adb_process_06(mocker):
     """test ADBProcess.wait_on_files()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = ""
     fake_session.open_files.return_value = ((1, "some_file"),)
@@ -188,7 +192,7 @@ def test_adb_process_10(tmp_path):
     log_path = tmp_path / "logs"
     log_path.mkdir()
     # missing log_logcat.txt
-    ADBProcess._split_logcat(str(log_path))
+    ADBProcess._split_logcat(str(log_path), "fake.package")
     assert not os.listdir(str(log_path))
     # with log_logcat.txt
     logstderr = tmp_path / "logs" / "log_stderr.txt"
@@ -214,7 +218,7 @@ def test_adb_process_10(tmp_path):
         log_fp.write(b"07-27 12:39:27.440  78  78 E android.os.Debug: failed to load memtrack module: -2\n")
         log_fp.write(b"07-27 12:39:27.441  78  78 I Radio-JNI: register_android_hardware_Radio DONE\n")
         log_fp.write(b"07-27 12:39:27.442 18461 18481 F MOZ_CRASH: Hit MOZ_CRASH(test) at gpp.rs:17\n")
-    ADBProcess._split_logcat(str(log_path))
+    ADBProcess._split_logcat(str(log_path), "fake.package")
     log_files = os.listdir(str(log_path))
     assert log_files
     with logstdout.open("rb") as log_fp:
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index a62176b6..2ceb19a0 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -443,8 +443,9 @@ def fake_get_package_name(_):
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "install":
-            assert cmd[2] == "-r"
-            if "test.apk" in cmd[3]:
+            assert cmd[2] == "-g"
+            assert cmd[3] == "-r"
+            if "test.apk" in cmd[4]:
                 return 0, "Success"
             return 1, ""
         if cmd[1] == "shell":

From ddf90b487b41bc471da3bf39b132fe07c2c34937 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 21 Aug 2019 13:54:12 -0700
Subject: [PATCH 478/531] Make logcat scanning more robust

---
 grizzly/target/adb_device/adb_process.py      | 42 ++++++++++++++-----
 grizzly/target/adb_device/test_adb_process.py | 15 +++----
 2 files changed, 39 insertions(+), 18 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index b6e3ac8c..a234cf76 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -251,22 +251,43 @@ def _split_logcat(log_path, package_name):
         assert package_name
         if not isinstance(package_name, bytes):
             package_name = package_name.encode("utf-8")
-        asan_found = False
-        with open(logcat, "rb") as lc_fp, open(err_log, "w") as e_fp, open(out_log, "w") as o_fp:
+        # create set of filter pids
+        filter_pids = set()
+        re_pid = re.compile(br"^\d+-\d+\s+(\d+[:.]){3}\d+\s+(?P<pid>\d+)")
+        with open(logcat, "rb") as lc_fp:
             for line in lc_fp:
                 if b"Gecko" not in line and b"MOZ_" not in line and package_name not in line:
                     continue
+                m_pid = re_pid.match(line)
+                if m_pid is None:
+                    continue
+                filter_pids.add(m_pid.group("pid"))
+        log.debug("%d interesting pid(s) found in logcat output", len(filter_pids))
+        # filter logs
+        asan_found = False
+        with open(logcat, "rb") as lc_fp, open(err_log, "wb") as e_fp, open(out_log, "wb") as o_fp:
+            for line in lc_fp:
+                # quick check if pid is in the line
+                if not any(pid in line for pid in filter_pids):
+                    continue
+                # verify the line pid is in set of filter pids
+                m_pid = re_pid.match(line)
+                if m_pid is None:
+                    continue
+                line_pid = m_pid.group("pid")
+                if not any(pid == line_pid for pid in filter_pids):
+                    continue
                 # strip logger info ... "07-27 12:10:15.442  9990  4234 E "
-                line = re.sub(r".+?\s[A-Z]\s+", "", line.decode("ascii", "ignore"))
-                if line.startswith("GeckoDump"):
-                    o_fp.write(line.split(": ", 1)[-1])
-                elif line.startswith("Gecko") or line.startswith("MOZ_") or line.startswith(package_name):
-                    e_fp.write(line.split(": ", 1)[-1])
+                line = re.sub(br".+?\s[ADEIVW]\s+", b"", line)
+                if line.startswith(b"GeckoDump"):
+                    o_fp.write(line.split(b": ", 1)[-1])
+                else:
+                    e_fp.write(line.split(b": ", 1)[-1])
                 if not asan_found:
-                    asan_found = "AddressSanitizer" in line
+                    asan_found = b"AddressSanitizer" in line
         # Break out ASan logs (to be removed when ASAN_OPTIONS=log_path works)
-        # This could be merged into the above block but it is kept septate
-        # so it can be remove easily in the future.
+        # This could be merged into the above block but it is kept separate
+        # so it can be removed easily in the future.
         if asan_found:
             asan_log = os.path.join(log_path, "log_asan.txt")
             if os.path.isfile(asan_log):
@@ -281,7 +302,6 @@ def _split_logcat(log_path, package_name):
                         if b"==ABORTING" in line:
                             break
 
-
     def save_logs(self, log_path, meta=False):
         assert self.logs is not None
         assert self.reason is not None, "Call close() first!"
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index e1837ef8..b55a1952 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -201,23 +201,24 @@ def test_adb_process_10(tmp_path):
     logstdout.touch()
     logcat = tmp_path / "logs" / "log_logcat.txt"
     with logcat.open("wb") as log_fp:
-        log_fp.write(b"07-27 12:10:15.414  90  90 W art     : Unexpected CPU variant for X86 using defaults: x86\n")
+        log_fp.write(b"07-27 12:10:15.414  80  80 W art     : Unexpected CPU variant for X86 using defaults: x86\n")
         log_fp.write(b"07-27 12:10:15.430  90  90 I GeckoApplication: zerdatime 3349725 - application start\n")
         log_fp.write(b"07-27 12:10:15.442  90  44 I GeckoThread: preparing to run Gecko\n")
         log_fp.write(b"07-27 12:10:15.442  90  44 E GeckoLibLoad: Load sqlite start\n")
-        log_fp.write(b"07-27 12:10:15.496  90  90 I GRALLOC-DRM: foo\n")
+        log_fp.write(b"07-27 12:10:15.496  81  81 I GRALLOC-DRM: foo\n")
         log_fp.write(b"07-27 12:10:15.505  90  43 I GeckoDump: test, line1\n")
         log_fp.write(b"07-27 12:10:15.505  90  43 E GeckoApp: test, line2\n")
-        log_fp.write(b"07-27 12:10:15.520  90  49 I EGL-DRI2: found extension DRI_Core version 1\n")
-        log_fp.write(b"07-27 12:10:15.521  90  49 I OpenGLRenderer: Initialized EGL, version 1.4\n")
+        log_fp.write(b"07-27 12:10:15.520  82  49 I EGL-DRI2: found extension DRI_Core version 1\n")
+        log_fp.write(b"07-27 12:10:15.521  82  49 I OpenGLRenderer: Initialized EGL, version 1.4\n")
         log_fp.write(b"07-27 12:10:15.528  90  44 E GeckoLibLoad: Load sqlite done\n")
-        log_fp.write(b"07-27 12:10:15.529  90  47 W art     : Suspending all threads took: 8.966ms\n")
+        log_fp.write(b"07-27 12:10:15.529  80  80 W art     : Suspending all threads took: 8.966ms\n")
         log_fp.write(b"07-27 12:10:15.533  90  44 E GeckoLibLoad: Load nss done\n")
         log_fp.write(b"07-27 12:39:27.188  39  39 W Fake  : asdf\n")
         log_fp.write(b"07-27 12:39:27.239  17  14 I InputReader: Reconfiguring input devices.  changes=0x00000010\n")
-        log_fp.write(b"07-27 12:39:27.440  78  78 E android.os.Debug: failed to load memtrack module: -2\n")
+        log_fp.write(b"07-27 12:39:27.440  78  78 E android.os.Debug: failed to load memtrack module: 90\n")
         log_fp.write(b"07-27 12:39:27.441  78  78 I Radio-JNI: register_android_hardware_Radio DONE\n")
         log_fp.write(b"07-27 12:39:27.442 18461 18481 F MOZ_CRASH: Hit MOZ_CRASH(test) at gpp.rs:17\n")
+        log_fp.write(b"07-27 12:39:27.443  90  90 I eckoThrea: potentially missed\n")
     ADBProcess._split_logcat(str(log_path), "fake.package")
     log_files = os.listdir(str(log_path))
     assert log_files
@@ -227,4 +228,4 @@ def test_adb_process_10(tmp_path):
         stderr_lines = log_fp.read().splitlines()
     assert b"test, line2" in stderr_lines
     assert b"test, line1" not in stderr_lines
-    assert len(stderr_lines) == 7
+    assert len(stderr_lines) == 8

From 8b7ceed0dd7833dbad8c3edf4f888f4656733b93 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 21 Aug 2019 15:12:39 -0700
Subject: [PATCH 479/531] Better filtering of ASan output

---
 grizzly/target/adb_device/adb_process.py | 47 +++++++++++++++---------
 1 file changed, 29 insertions(+), 18 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index a234cf76..b4cb8826 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -252,29 +252,32 @@ def _split_logcat(log_path, package_name):
         if not isinstance(package_name, bytes):
             package_name = package_name.encode("utf-8")
         # create set of filter pids
+        # this will include any line that mentions "Gecko", "MOZ_" or the package name
+        asan_tid = None
         filter_pids = set()
-        re_pid = re.compile(br"^\d+-\d+\s+(\d+[:.]){3}\d+\s+(?P<pid>\d+)")
+        re_id = re.compile(br"^\d+-\d+\s+(\d+[:.]){3}\d+\s+(?P<pid>\d+)\s+(?P<tid>\d+)")
         with open(logcat, "rb") as lc_fp:
             for line in lc_fp:
                 if b"Gecko" not in line and b"MOZ_" not in line and package_name not in line:
                     continue
-                m_pid = re_pid.match(line)
-                if m_pid is None:
+                m_id = re_id.match(line)
+                if m_id is None:
                     continue
-                filter_pids.add(m_pid.group("pid"))
+                filter_pids.add(m_id.group("pid"))
+                if asan_tid is None and b": AddressSanitizer:" in line:
+                    asan_tid = m_id.group("tid")
         log.debug("%d interesting pid(s) found in logcat output", len(filter_pids))
         # filter logs
-        asan_found = False
         with open(logcat, "rb") as lc_fp, open(err_log, "wb") as e_fp, open(out_log, "wb") as o_fp:
             for line in lc_fp:
                 # quick check if pid is in the line
                 if not any(pid in line for pid in filter_pids):
                     continue
                 # verify the line pid is in set of filter pids
-                m_pid = re_pid.match(line)
-                if m_pid is None:
+                m_id = re_id.match(line)
+                if m_id is None:
                     continue
-                line_pid = m_pid.group("pid")
+                line_pid = m_id.group("pid")
                 if not any(pid == line_pid for pid in filter_pids):
                     continue
                 # strip logger info ... "07-27 12:10:15.442  9990  4234 E "
@@ -283,24 +286,32 @@ def _split_logcat(log_path, package_name):
                     o_fp.write(line.split(b": ", 1)[-1])
                 else:
                     e_fp.write(line.split(b": ", 1)[-1])
-                if not asan_found:
-                    asan_found = b"AddressSanitizer" in line
         # Break out ASan logs (to be removed when ASAN_OPTIONS=log_path works)
         # This could be merged into the above block but it is kept separate
         # so it can be removed easily in the future.
-        if asan_found:
+        if asan_tid is not None:
             asan_log = os.path.join(log_path, "log_asan.txt")
             if os.path.isfile(asan_log):
                 log.warning("log_asan.txt already exist! Overwriting...")
             found_log = False
-            with open(err_log, "rb") as e_fp, open(asan_log, "wb") as o_fp:
-                for line in e_fp:
+            with open(logcat, "rb") as lc_fp, open(asan_log, "wb") as o_fp:
+                for line in lc_fp:
+                    # quick check if thread id is in the line
+                    if not asan_tid in line:
+                        continue
+                    # verify the line tid matches ASan thread id
+                    m_id = re_id.match(line)
+                    if m_id is None or m_id.group("tid") != asan_tid:
+                        continue
+                    # filter noise before the crash
                     if not found_log:
-                        found_log = b"AddressSanitizer" in line
-                    if found_log:
-                        o_fp.write(line)
-                        if b"==ABORTING" in line:
-                            break
+                        if b": AddressSanitizer:" in line:
+                            found_log = True
+                        else:
+                            continue
+                    # strip logger info ... "07-27 12:10:15.442  9990  4234 E "
+                    line = re.sub(br".+?\s[ADEIVW]\s+", b"", line)
+                    o_fp.write(line.split(b": ", 1)[-1])
 
     def save_logs(self, log_path, meta=False):
         assert self.logs is not None

From bd093c612415b2b4722d05109beb8a956f6dd88e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 21 Aug 2019 15:13:11 -0700
Subject: [PATCH 480/531] Add more ASAN_OPTIONS

---
 grizzly/target/adb_device/adb_session.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 50b92c5a..1a28e823 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -396,13 +396,15 @@ def install_asan(self, ndk_base, asan_options=None):
         self.call(["shell", "chmod", "666", sanitizer_logs])
         addition_options = [
             "abort_on_error=0",
-            "allow_user_segv_handler=1",
-            "detect_leaks=0",
+            "alloc_dealloc_mismatch=0",  # here until ASAN_OPTIONS set in mozglue are set properly
+            "allocator_may_return_null=1",  # here until ASAN_OPTIONS set in mozglue are set properly
+            "allow_user_segv_handler=1",  # here until ASAN_OPTIONS set in mozglue are set properly
+            "detect_leaks=0",  # here until ASAN_OPTIONS set in mozglue are set properly
             "fast_unwind_on_check=1",
             "fast_unwind_on_fatal=1",
+            "handle_sigill=1",  # here until ASAN_OPTIONS set in mozglue are set properly
             #"log_path='%s'" % (self.SANITIZER_LOG_PREFIX,),
             "use_sigaltstack=1",
-            "symbolize=1",
             "start_deactivated=1"]
         if asan_options:
             existing_opts = [opt for opt in asan_options.split(":") if opt]

From 91ee9f0188ff04ced9b46a3b77599182518c8252 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 21 Aug 2019 15:54:20 -0700
Subject: [PATCH 481/531] Fix a couple nits

---
 grizzly/target/adb_device/adb_process.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index b4cb8826..d9e87640 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -297,7 +297,7 @@ def _split_logcat(log_path, package_name):
             with open(logcat, "rb") as lc_fp, open(asan_log, "wb") as o_fp:
                 for line in lc_fp:
                     # quick check if thread id is in the line
-                    if not asan_tid in line:
+                    if asan_tid not in line:
                         continue
                     # verify the line tid matches ASan thread id
                     m_id = re_id.match(line)
@@ -305,10 +305,9 @@ def _split_logcat(log_path, package_name):
                         continue
                     # filter noise before the crash
                     if not found_log:
-                        if b": AddressSanitizer:" in line:
-                            found_log = True
-                        else:
+                        if b": AddressSanitizer:" not in line:
                             continue
+                        found_log = True
                     # strip logger info ... "07-27 12:10:15.442  9990  4234 E "
                     line = re.sub(br".+?\s[ADEIVW]\s+", b"", line)
                     o_fp.write(line.split(b": ", 1)[-1])

From c2f25cc2418c021b997b18e0a2aec55e7d2f4995 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 3 Sep 2019 16:03:03 -0700
Subject: [PATCH 482/531] Reorganize ADBSession

* Add documentation
* Fix nits
---
 grizzly/target/adb_device/adb_session.py      | 706 +++++++++++++-----
 grizzly/target/adb_device/test_adb_session.py |  84 ++-
 2 files changed, 555 insertions(+), 235 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 1a28e823..935a79c5 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -1,3 +1,7 @@
+# coding=utf-8
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
 import glob
 import logging
 import os
@@ -7,14 +11,16 @@
 import tempfile
 import time
 
-
 log = logging.getLogger("adb_session")  # pylint: disable=invalid-name
 
+__all__ = ("ADBCommandError", "ADBCommunicationError", "ADBSession", "ADBSessionError")
 __author__ = "Tyson Smith"
-__credits__ = ["Tyson Smith"]
+__credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
 
 class DeviceProcessInfo(object):
+    __slots__ = ("memory", "name", "pid", "ppid")
+
     def __init__(self, memory, name, pid, ppid):
         self.memory = memory
         self.name = name
@@ -23,6 +29,14 @@ def __init__(self, memory, name, pid, ppid):
 
     @classmethod
     def from_ps_line(cls, line):
+        """Create a DeviceProcessInfo from the string output of ps.
+
+        Args:
+            line (str): Line of output from ps.
+
+        Returns:
+            DeviceProcessInfo: new instance.
+        """
         try:
             _, pid, ppid, _, memory, _, _, _, name = line.split()
         except ValueError:
@@ -32,40 +46,40 @@ def from_ps_line(cls, line):
             return cls(int(memory), name, int(pid), int(ppid))
         except ValueError:
             log.debug("invalid ps line values")
-            return None
+        return None
 
 
 class ADBCommandError(Exception):
-    pass
+    """Raised when an ADB command is invalid or unrecognized"""
 
-class ADBSessionError(Exception):
-    pass
+class ADBCommunicationError(Exception):
+    """Raised when ADB fails to communicate with the device"""
 
-class ADBNoDevice(ADBSessionError):
-    pass
+class ADBSessionError(Exception):
+    """Raised when an operation fails unexpectedly or session state is invalid"""
 
 
 class ADBSession(object):
     SANITIZER_LOG_PREFIX = "/sdcard/sanitizer_logs/report.log"
 
     def __init__(self, ip_addr=None, port=5555):
-        self.connected = False
-        self.symbols = dict()
         self._adb_bin = self._adb_check()
         self._cpu_arch = None  # Android CPU architecture string
-        self._debug_adb = int(os.getenv("SHOW_ADB_DEBUG", "0")) != 0  # include adb output in debug logs
+        self._debug_adb = int(os.getenv("SHOW_ADB_DEBUG", "0")) != 0  # include ADB output in debug logs
         self._ip_addr = None  # target device IP address
         self._os_version = None  # Android version string
         self._port = None  # ADB listening port
         self._root = False
+        self.connected = False
+        self.symbols = dict()
 
-        log.debug("creating IP based session: %r", ip_addr is not None)
         if ip_addr is not None:
+            log.debug("creating IP based session")
             try:
                 if ip_addr != "localhost":
                     socket.inet_aton(ip_addr)
             except (socket.error, TypeError):
-                raise ValueError("IP Address is invalid")
+                raise ValueError("Invalid IP Address")
             self._ip_addr = ip_addr
             if not isinstance(port, int) or not 0x10000 > port > 1024:
                 raise ValueError("Port must be valid integer between 1025 and 65535")
@@ -73,12 +87,21 @@ def __init__(self, ip_addr=None, port=5555):
 
     @classmethod
     def _aapt_check(cls):
+        """Lookup the path for Android Asset Packaging Tool (AAPT).
+        An EnvironmentError is raised if the AAPT executable is not found.
+
+        Args:
+            None
+
+        Returns:
+            str: Path to AAPT binary.
+        """
         aapt_bin = os.path.expanduser("~/.android/sdk/android-9/aapt")
         if os.path.isfile(aapt_bin):
             log.debug("using recommended aapt from %r", aapt_bin)
             return aapt_bin
         try:
-            aapt_bin = subprocess.check_output(["which", "aapt"])
+            aapt_bin = subprocess.check_output(("which", "aapt"))
         except subprocess.CalledProcessError:
             raise EnvironmentError("Please install AAPT")
         aapt_bin = aapt_bin.strip().decode("utf-8", errors="ignore")
@@ -88,12 +111,21 @@ def _aapt_check(cls):
 
     @classmethod
     def _adb_check(cls):
+        """Lookup the path for Android Debug Bridge (ADB).
+        An EnvironmentError is raised if the ADB executable is not found.
+
+        Args:
+            None
+
+        Returns:
+            str: Path to ADB binary.
+        """
         adb_bin = os.path.expanduser("~/.android/sdk/platform-tools/adb")
         if os.path.isfile(adb_bin):
             log.debug("using recommended adb from %r", adb_bin)
             return adb_bin
         try:
-            adb_bin = subprocess.check_output(["which", "adb"])
+            adb_bin = subprocess.check_output(("which", "adb"))
         except subprocess.CalledProcessError:
             raise EnvironmentError("Please install ADB")
         adb_bin = adb_bin.strip().decode("utf-8", errors="ignore")
@@ -104,25 +136,19 @@ def _adb_check(cls):
         time.sleep(5)
         return adb_bin
 
-    @property
-    def airplane_mode(self):
-        return self.call(["shell", "settings", "get", "global", "airplane_mode_on"])[1].startswith("1")
-
-    @airplane_mode.setter
-    def airplane_mode(self, mode):
-        assert isinstance(mode, bool), "mode must be a bool"
-        self.call(["shell", "settings", "put", "global", "airplane_mode_on", "1" if mode else "0"])
-        self.call(["shell", "su", "root", "am", "broadcast", "-a", "android.intent.action.AIRPLANE_MODE"])
-
-    @classmethod
-    def create(cls, ip_addr=None, port=5555, as_root=True, max_attempts=10):
-        session = cls(ip_addr, port)
-        if session.connect(as_root=as_root, max_attempts=max_attempts):
-            return session
-        return None
-
     @staticmethod
     def _call_adb(cmd, timeout=None):
+        """Wrapper to make calls to ADB. Launches ADB in a subprocess and collects output.
+        If timeout is specified and elapses the ADB subprocess is terminated.
+        This function is only meant to be called directly by ADBSession.call().
+
+        Args:
+            cmd (list): List of strings containing full ADB command.
+            timeout (float, optional): Number of seconds to wait for ADB command to complete.
+
+        Returns:
+            tuple: Exit code and stderr, stdout of ADB call.
+        """
         with tempfile.TemporaryFile() as out_fp:
             if timeout is not None:
                 assert timeout > 0
@@ -140,32 +166,130 @@ def _call_adb(cmd, timeout=None):
             out_fp.seek(0)
             return ret_code, out_fp.read().decode("utf-8", "ignore").strip()
 
-    def call(self, cmd, require_device=True, timeout=None):
+    def _get_procs(self, pid=-1, pid_children=-1):
+        """Generator function that yields a DeviceProcessInfo object for each running
+        process by default. pid and pid_children can be used to filter the results.
+
+        Args:
+            pid (int, optional): Process ID to include in lookup.
+            pid_children (int, optional): Used to lookup the children of the given PID.
+
+        Yields:
+            DeviceProcessInfo: One instance for each process found in lookup.
+        """
+        assert isinstance(pid, int)
+        assert isinstance(pid_children, int)
+        cmd = ["shell", "ps"]
+        if pid > -1:
+            cmd.append(str(pid))
+        if pid_children > -1:
+            cmd += ["--ppid", str(pid_children)]
+        for line in self.call(cmd)[1].splitlines()[1:]:
+            pinfo = DeviceProcessInfo.from_ps_line(line)
+            if pinfo is not None:
+                yield pinfo
+
+    @property
+    def airplane_mode(self):
+        """Get the current state of airplane mode.
+
+        Args:
+            None
+
+        Returns:
+            bool: True if airplane mode is enabled otherwise False.
+        """
+        return self.call(["shell", "settings", "get", "global", "airplane_mode_on"])[1].startswith("1")
+
+    @airplane_mode.setter
+    def airplane_mode(self, mode):
+        """Enable/disable airplane mode.
+
+        Args:
+            mode (bool): True will enable and False will disable airplane mode.
+
+        Returns:
+            None
+        """
+        assert isinstance(mode, bool), "mode must be a bool"
+        self.call(["shell", "settings", "put", "global", "airplane_mode_on", "1" if mode else "0"])
+        self.call(["shell", "su", "root", "am", "broadcast", "-a", "android.intent.action.AIRPLANE_MODE"])
+
+    def call(self, cmd, device_required=True, timeout=None):
+        """Call ADB with arguments provided in cmd.
+
+        Args:
+            cmd (list): List of strings to pass as arguments when calling ADB.
+            device_required (bool, optional): A device must be available for call.
+            timeout (float, optional): Amount of time in seconds to wait for ADB cal to complete.
+
+        Returns:
+            tuple: The first element is an integer containing the exit code of the
+            ADB call and the second is a string containing stderr and stdout.
+        """
         assert isinstance(cmd, list) and cmd
         cmd = [self._adb_bin] + cmd
         log.debug("calling: %s", " ".join(cmd))
         if not self.connected and cmd[1] not in ("connect", "devices", "disconnect"):
-            raise ADBSessionError("ADB session is not connected!")
+            raise ADBCommunicationError("ADB session is not connected!")
         ret_code, output = self._call_adb(cmd, timeout=timeout)
         if self._debug_adb:
             log.debug("=== adb start ===\n%s\n=== adb end, returned %d ===", output, ret_code)
         if ret_code != 0:
             if output.startswith("Android Debug Bridge version"):
-                raise ADBCommandError("Invalid ADB command '%s'" % " ".join(cmd[1:]))
+                raise ADBCommandError("Invalid ADB command '%s'" % (" ".join(cmd[1:]),))
             if output.startswith("adb: usage:"):
                 raise ADBCommandError(output.strip())
-            if require_device and (output.startswith("error: closed") or
-                                   output.startswith("error: device offline") or
-                                   output.startswith("error: no devices/emulators found")):
+            if device_required and (output.startswith("error: closed") or
+                                    output.startswith("error: device offline") or
+                                    output.startswith("error: no devices/emulators found")):
                 self.connected = False
-                raise ADBNoDevice("No device detected!")
-        return (ret_code, output)
+                raise ADBCommunicationError("No device detected!")
+        return ret_code, output
 
     def clear_logs(self):
+        """Call 'adb logcat --clear' to wipe logs
+
+        Args:
+            None
+
+        Returns:
+            None
+        """
         log.debug("clear_logs()")
         return self.call(["logcat", "--clear"], timeout=10)[0] == 0
 
+    def collect_logs(self, pid=None):
+        """Collect logs from device with logcat.
+
+        Args:
+            pid (int, optional): Process ID to collect logs from. If pid is None
+                Logs from all processes will be collected.
+
+        Returns:
+            None
+        """
+        log.debug("collect_logs()")
+        if not self.connected:
+            log.debug("device not connected cannot collect logs")
+            return ""
+        cmd = ["logcat", "-d", "*:I"]
+        if pid is not None:
+            cmd += ["--pid=%d" % (pid,)]
+        return self.call(cmd, timeout=10)[1].encode("utf-8", "ignore")
+
     def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1):
+        """Connect to a device via ADB.
+
+        Args:
+            as_root (bool, optional): Attempt to enable root. Default is True.
+            boot_timeout (int, optional): Number of seconds to wait for device boot to complete.
+            max_attempts (int, optional): Number of attempts to make to try to connect to the device.
+            retry_delay (int, optional): Number of seconds to wait between connection attempts.
+
+        Returns:
+            bool: Returns True if connection was established successfully otherwise False.
+        """
         assert isinstance(boot_timeout, int) and boot_timeout > 0
         assert isinstance(max_attempts, int) and max_attempts > 0
         assert isinstance(retry_delay, (int, float)) and retry_delay > 0
@@ -178,7 +302,7 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
             attempt += 1
             if not self.connected:
                 if self._ip_addr is not None:
-                    addr = ":".join([self._ip_addr, str(self._port)])
+                    addr = ":".join((self._ip_addr, str(self._port)))
                     log.debug("connecting to %s", addr)
                     if self.call(["connect", addr])[0] != 0:
                         log.warning("connection attempt #%d failed", attempt)
@@ -189,24 +313,21 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                     time.sleep(retry_delay)
                     continue
                 self.connected = True
-
             # verify we are connected
             if not self.wait_for_boot(timeout=boot_timeout):
-                raise ADBSessionError("Timeout (%ds) waiting for device boot to complete" % boot_timeout)
-            ret_code, user = self.call(["shell", "whoami"], require_device=False)
+                raise ADBCommunicationError("Timeout (%ds) waiting for device to boot" % (boot_timeout,))
+            ret_code, user = self.call(["shell", "whoami"], device_required=False)
             if ret_code != 0 or not user:
                 self.connected = False
                 if attempt == max_attempts:
                     raise ADBSessionError("Device in a bad state, try disconnect & reboot")
                 continue
             self._root = user.splitlines()[-1] == "root"
-
             # collect CPU and OS info
             if self._os_version is None:
                 self._os_version = self.call(["shell", "getprop", "ro.build.version.release"])[1]
             if self._cpu_arch is None:
                 self._cpu_arch = self.call(["shell", "getprop", "ro.product.cpu.abi"])[1]
-
             # check SELinux mode
             if self._root:
                 if self.get_enforce():
@@ -222,11 +343,9 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                     set_enforce_called = True
                     attempt -= 1
                     continue
-
             if not as_root or self._root:
                 log.debug("connected device running Android %s (%s)", self._os_version, self._cpu_arch)
                 break
-
             # enable root
             assert as_root, "Should not be here if root is not requested"
             if self.call(["root"])[0] == 0:
@@ -238,29 +357,45 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                     continue
             else:
                 log.warning("Failed root login attempt")
-
         if self.connected and as_root and not self._root:
             raise ADBSessionError("Could not enable root")
-
         return self.connected
 
-    def collect_logs(self, pid=None):
-        log.debug("collect_logs()")
-        if not self.connected:
-            log.debug("device not connected cannot collect logs")
-            return ""
-        cmd = ["logcat", "-d", "*:I"]
-        if pid is not None:
-            cmd += ["--pid=%d" % pid]
-        return self.call(cmd, timeout=10)[1].encode("utf-8", "ignore")
+    @classmethod
+    def create(cls, ip_addr=None, port=5555, as_root=True, max_attempts=10):
+        """Create a ADBSession and connect to a device via ADB.
+
+        Args:
+            ip_addr (str, optional): IP address of device to connect to if using TCP/IP. Defaults to None.
+            port (int, optional): Port to use (TCP/IP only). Defaults to 5555.
+            as_root (bool, optional): Attempt to enable root. Default is True.
+            max_attempt (int, optional): Number of attempts to make to try to connect to the device.
+
+        Returns:
+            ADBSession: A connected ADBSession object otherwise None
+        """
+        session = cls(ip_addr, port)
+        if session.connect(as_root=as_root, max_attempts=max_attempts):
+            return session
+        return None
 
     def devices(self, all_devices=False, any_state=True):
+        """Devices visible to ADB.
+
+        Args:
+            all_devices (bool, optional): Don't filter devices using ANDROID_SERIAL environment variable.
+            any_state (bool, optional): Include devices in a state other than "device".
+
+        Returns:
+            dict: A dictionary keyed on device name containing the state.
+        """
         ret_code, entries = self.call(["devices"])
         devices = {}
         if ret_code != 0:
             return devices
         target_device = os.getenv("ANDROID_SERIAL", None) if not all_devices else None
-        for entry in entries.strip().splitlines()[1:]:
+        # skip header on the first line
+        for entry in entries.splitlines()[1:]:
             try:
                 name, state = entry.split()
             except ValueError:
@@ -275,100 +410,127 @@ def devices(self, all_devices=False, any_state=True):
         return devices
 
     def disconnect(self, unroot=True):
+        """Disconnect.
+
+        Args:
+            unroot (bool, optional): Attempt to unroot device.
+
+        Returns:
+            None
+        """
         if not self.connected:
             log.debug("already disconnected")
-            return True
+            return
         if self._root and unroot:
             try:
                 if self.call(["unroot"])[0] == 0:
                     self.connected = False
                     self._root = False
-                    return True
+                    return
                 log.warning("'unroot' failed")
             except ADBCommandError:
                 log.warning("'unroot' not support by ADB")
         elif self._ip_addr is not None:
-            self.call(["disconnect", ":".join([self._ip_addr, str(self._port)])])
+            self.call(["disconnect", ":".join((self._ip_addr, str(self._port)))])
         self.connected = False
-        return True
 
-    def listdir(self, path):
-        log.debug("listdir(%r)", path)
-        ret_val, output = self.call(["shell", "ls", "-A", path])
-        if ret_val != 0:
-            raise IOError("%r does not exist" % path)
-        return output.splitlines()
+    def get_enforce(self):
+        """Get SELinux state.
 
-    def realpath(self, path):
-        log.debug("realpath(%r)", path)
-        ret_val, output = self.call(["shell", "realpath", path])
-        if ret_val != 0:
-            raise IOError("%r does not exist" % path)
-        return output.strip()
+        Args:
+            None
 
-    def reboot_device(self, boot_timeout=300, max_attempts=60, retry_delay=1):
-        was_root = self._root
-        log.debug("calling reboot...")
-        self.call(["reboot"])
-        self.connected = False
-        self.connect(
-            as_root=was_root,
-            boot_timeout=boot_timeout,
-            max_attempts=max_attempts,
-            retry_delay=retry_delay)
-        assert self.connected, "Device did not connect after reboot"
+        Returns:
+            bool: Returns True if "Enforcing" otherwise False.
+        """
+        status = self.call(["shell", "getenforce"])[1]
+        if status == "Enforcing":
+            return True
+        if status != "Permissive":
+            log.warning("Unexpected SELinux state '%r'", status)
+        return False
 
-    def remount(self):
-        assert self._root
-        code, result = self.call(["remount"])
-        if code != 0 or "Permission denied" in result or "remount failed" in result:
-            raise ADBSessionError("Remount failed, is '-writable-system' set?")
+    @classmethod
+    def get_package_name(cls, apk_path):
+        """Retrieve the package name from an APK.
 
-    def reverse(self, remote, local):
-        # remote->device, local->desktop
-        assert isinstance(local, int) and 1024 < local < 0x10000
-        assert isinstance(remote, int) and 1024 < remote < 0x10000
-        return self.call(["reverse", "tcp:%d" % remote, "tcp:%d" % local])[0] == 0
+        Args:
+            apk_name (str): APK to retrieve the package name from.
 
-    def reverse_remove(self, remote=None):
-        # remote->device
-        cmd = ["reverse"]
-        if remote is not None:
-            assert isinstance(remote, int) and 1024 < remote < 0x10000
-            cmd.append("--remove")
-            cmd.append("tcp:%d" % remote)
-        else:
-            cmd.append("--remove-all")
-        return self.call(cmd)[0] == 0
+        Returns:
+            str: String containing the package name otherwise None.
+        """
+        if not os.path.isfile(apk_path):
+            raise IOError("APK path must point to a file")
+        aapt = cls._aapt_check()
+        apk_info = subprocess.check_output((aapt, "dump", "badging", apk_path))
+        for line in apk_info.splitlines():
+            if line.startswith(b"package: name="):
+                return line.split()[1][5:].strip(b"'").decode("utf-8", errors="ignore")
+        return None
 
-    def uninstall(self, package):
-        if not self.connected:
-            log.debug("already disconnected")
-            return False
-        return self.call(["uninstall", package], timeout=60)[0] == 0
+    def get_pid(self, package_name):
+        """Retrieve process ID for the process with the specified package name.
+
+        Args:
+            apk_name (str): APK to to retrieve the package name from.
+
+        Returns:
+            int: PID of the process with the specified package name if it exists otherwise None.
+        """
+        # TODO: _get_procs() is slow, move to pidof ASAP
+        # pidof is not supported pre-Android 6... do we care about <6? if so we could just fall back
+        pids = [proc.pid for proc in self._get_procs() if proc.name == package_name]
+        if not pids:
+            return None
+        count = len(pids)
+        if count > 1:
+            log.debug("get_pid() %d proc(s) found", count)
+            # TODO: get procs and use the ppid of the procs the determine the parent
+            # for now we are using the lowest pid...
+            pids.sort()
+        return pids[0]
 
     def install(self, apk_path):
+        """Install APK on the connected device, grant R/W permissions to /sdcard and lookup
+        the name of the installed APK.
+
+        Args:
+            apk_name (str): APK to install.
+
+        Returns:
+            str: Package name of APK that has been installed.
+        """
         log.debug("installing %r", apk_path)
         if not os.path.isfile(apk_path):
-            raise IOError("APK does not exist %r" % apk_path)
-        if self.call(["install", "-g", "-r", apk_path], timeout=120)[0] != 0:
-            raise ADBSessionError("Failed to install %r" % apk_path)
-        # unpack and lookup package name
+            raise IOError("APK does not exist %r" % (apk_path,))
+        # lookup package name
         pkg_name = self.get_package_name(apk_path)
         if pkg_name is None:
             raise ADBSessionError("Could not find APK package name")
+        if self.call(["install", "-g", "-r", apk_path], timeout=120)[0] != 0:
+            raise ADBSessionError("Failed to install %r" % (apk_path,))
         # set permissions
         self.call(["shell", "pm", "grant", pkg_name, "android.permission.READ_EXTERNAL_STORAGE"])
         self.call(["shell", "pm", "grant", pkg_name, "android.permission.WRITE_EXTERNAL_STORAGE"])
         log.debug("installed package %r (%r)", pkg_name, apk_path)
         return pkg_name
 
-    def install_asan(self, ndk_base, asan_options=None):
-        if not os.path.isdir(ndk_base):
-            raise IOError("NDK does not exist %r" % ndk_base)
+    def install_asan(self, ndk_path, extra_options=None):
+        """Install Address Sanitizer libraries, llvm-sanitizer and create scripts to wrap app_process.
+        NOTE: SELinux must be set to permissive for this to work.
+
+        Args:
+            ndk_path (str): Path to the NDK that contains ASan libraries.
+            extra_options (dict, optional): Extra options to add to ASAN_OPTIONS
 
+        Returns:
+            None
+        """
+        if not os.path.isdir(ndk_path):
+            raise IOError("NDK does not exist %r" % (ndk_path,))
         clang_path = os.path.join(
-            ndk_base, "toolchains", "llvm", "prebuilt", "linux-x86_64", "lib64",
+            ndk_path, "toolchains", "llvm", "prebuilt", "linux-x86_64", "lib64",
             "clang", "*", "lib", "linux")
         for cpath in glob.glob(clang_path):
             asan_rt = os.path.join(cpath, "libclang_rt.asan-i686-android.so")
@@ -377,7 +539,6 @@ def install_asan(self, ndk_base, asan_options=None):
                 break
         else:
             raise IOError("Cannot find libclang_rt.asan-*-android.so")
-
         self.remount()
         ctx = "u:object_r:zygote_exec:s0"
         if self.call(["shell", "ls", "/system/bin/app_process32.real"]) != 0:
@@ -386,16 +547,16 @@ def install_asan(self, ndk_base, asan_options=None):
         if self.call(["shell", "ls", "/system/bin/app_process64.real"]) != 0:
             self.call(["shell", "mv", "/system/bin/app_process64", "/system/bin/app_process64.real"])
             self.call(["shell", "chcon", ctx, "/system/bin/app_process64.real"])
-
         # TODO: should we force overwrite here?
         self.install_file(asan_rt, "/system/lib", "644")
         self.install_file(asan_rt64, "/system/lib64", "644")
-
+        # create sanitizer logging directory
         sanitizer_logs = os.path.dirname(self.SANITIZER_LOG_PREFIX)
         self.call(["shell", "mkdir", "-p", sanitizer_logs])
         self.call(["shell", "chmod", "666", sanitizer_logs])
-        addition_options = [
-            "abort_on_error=0",
+        # set default ASAN_OPTIONS
+        options = [
+            "abort_on_error=0",  # avoid tombstones
             "alloc_dealloc_mismatch=0",  # here until ASAN_OPTIONS set in mozglue are set properly
             "allocator_may_return_null=1",  # here until ASAN_OPTIONS set in mozglue are set properly
             "allow_user_segv_handler=1",  # here until ASAN_OPTIONS set in mozglue are set properly
@@ -406,18 +567,15 @@ def install_asan(self, ndk_base, asan_options=None):
             #"log_path='%s'" % (self.SANITIZER_LOG_PREFIX,),
             "use_sigaltstack=1",
             "start_deactivated=1"]
-        if asan_options:
-            existing_opts = [opt for opt in asan_options.split(":") if opt]
-        else:
-            existing_opts = []
-        asan_options = ":".join(existing_opts + addition_options)
-
+        if extra_options:
+            options += [opt for opt in extra_options.split(":") if opt]
+        # create and install app_process wrappers
         tmpd = tempfile.mkdtemp()
         try:
             fname = os.path.join(tmpd, "app_process32")
             with open(fname, "w") as out_fp:
                 out_fp.write("#!/system/bin/sh\n")
-                out_fp.write("ASAN_OPTIONS=%s \\\n" % asan_options)
+                out_fp.write("ASAN_OPTIONS=%s \\\n" % (":".join(options),))
                 #out_fp.write("ASAN_ACTIVATION_OPTIONS=include_if_exists=/sdcard/asan.options \\\n")
                 out_fp.write("LD_PRELOAD=/system/lib/libclang_rt.asan-i686-android.so \\\n")
                 out_fp.write("exec /system/bin/app_process32.real \"$@\"\n")
@@ -425,7 +583,7 @@ def install_asan(self, ndk_base, asan_options=None):
             fname = os.path.join(tmpd, "app_process64")
             with open(fname, "w") as out_fp:
                 out_fp.write("#!/system/bin/sh\n")
-                out_fp.write("ASAN_OPTIONS=%s \\\n" % asan_options)
+                out_fp.write("ASAN_OPTIONS=%s \\\n" % (":".join(options),))
                 #out_fp.write("ASAN_ACTIVATION_OPTIONS=include_if_exists=/sdcard/asan.option \\\n")
                 out_fp.write("LD_PRELOAD=/system/lib64/libclang_rt.asan-x86_64-android.so \\\n")
                 out_fp.write("exec /system/bin/app_process64.real \"$@\"\n")
@@ -444,11 +602,11 @@ def install_asan(self, ndk_base, asan_options=None):
             self.install_file(fname, "/system/bin", "755")
         finally:
             shutil.rmtree(tmpd, ignore_errors=True)
-
+        # install llvm-symbolizer
         llvm_symer = os.path.join(
-            ndk_base, "prebuilt", "android-x86_64", "llvm-symbolizer", "llvm-symbolizer")
+            ndk_path, "prebuilt", "android-x86_64", "llvm-symbolizer", "llvm-symbolizer")
         self.install_file(llvm_symer, "/system/bin", "755", ctx)
-
+        # restart zygote process
         self.call(["shell", "stop"])
         self.call(["shell", "start"])
         # put the device in a known state
@@ -456,8 +614,18 @@ def install_asan(self, ndk_base, asan_options=None):
         self.wait_for_boot()
 
     def install_file(self, src, dst, mode=None, context=None):
-        basename = os.path.basename(src)
-        full_dst = os.path.join(dst, basename)
+        """Install file on the device filesystem and set permissions.
+
+        Args:
+            src (str): Path to file to install on the device.
+            dst (str): Path to location on device to install file.
+            mode (int, optional): chmod mode to use.
+            context (int, optional): chcon context to use.
+
+        Returns:
+            None
+        """
+        full_dst = os.path.join(dst, os.path.basename(src))
         self.push(src, full_dst)
         self.call(["shell", "chown", "root.shell", full_dst])
         if mode is not None:
@@ -465,35 +633,45 @@ def install_file(self, src, dst, mode=None, context=None):
         if context is not None:
             self.call(["shell", "chcon", context, full_dst])
 
-    def get_enforce(self):
-        status = self.call(["shell", "getenforce"])[1]
-        if status == "Enforcing":
-            return True
-        if status != "Permissive":
-            log.warning("Unexpected SELinux state '%r'", status)
-        return False
+    def is_installed(self, package_name):
+        """Check if a package is installed on the connected device.
 
-    @classmethod
-    def get_package_name(cls, apk_path):
-        if not os.path.isfile(apk_path):
-            raise IOError("APK path must point to a file")
-        aapt = cls._aapt_check()
-        apk_info = subprocess.check_output([aapt, "dump", "badging", apk_path])
-        for line in apk_info.splitlines():
-            if line.startswith(b"package: name="):
-                return line.split()[1][5:].strip(b"'").decode("utf-8", errors="ignore")
-        return None
+        Args:
+            package_name (str): Package name to look up on the device.
 
-    @property
-    def packages(self):
-        # TODO: should this be by pid or package?
-        ret_code, output = self.call(["shell", "pm", "list", "packages"])
-        if ret_code == 0:
-            for line in output.splitlines():
-                if line.startswith("package:"):
-                    yield line[8:]
+        Returns:
+            bool: Returns True if the package is installed on the device otherwise False.
+        """
+        return package_name in self.packages
+
+    def listdir(self, path):
+        """List the contents of a directory.
+
+        Args:
+            path (str): Directory to list the contents of.
+
+        Returns:
+            list: list of strings containing names of all items in a directory.
+        """
+        log.debug("listdir(%r)", path)
+        ret_val, output = self.call(["shell", "ls", "-A", path])
+        if ret_val != 0:
+            raise IOError("%r does not exist" % (path,))
+        return output.splitlines()
 
     def open_files(self, pid=None, children=False, files=None):
+        """Look up open file on the device.
+
+        Args:
+            pid (int, optional): Only include files where the process with the matching PID
+                has an open file handle.
+            children (bool, optional): Include file opened by processes with a parent PID matching pid.
+                pid is required when children is set to True
+            files (iterable, optional): Limit results to these specific files.
+
+        Yields:
+            tuple: The first element is the PID and the second is the path of the open file.
+        """
         log.debug("open_files(pid=%r, children=%r, files=%r", pid, children, files)
         pids = list()
         if pid is not None:
@@ -523,72 +701,210 @@ def open_files(self, pid=None, children=False, files=None):
             except ValueError:
                 pass
 
-    def get_pid(self, package_name):
-        # NOTE: pidof is not supported pre-Android 6
-        pids = [proc.pid for proc in self._get_procs() if proc.name == package_name]
-        if not pids:
-            return None
-        count = len(pids)
-        if count > 1:
-            log.debug("get_pid() %d proc(s) found", count)
-            # TODO: use procs and use the ppid of the procs the determine the parent
-            pids.sort()
-        return pids[0]
+    @property
+    def packages(self):
+        """Look up packages installed on the connected device.
+
+        Args:
+            None
+
+        Yields:
+            str: Names of the installed packages
+        """
+        ret_code, output = self.call(["shell", "pm", "list", "packages"])
+        if ret_code == 0:
+            for line in output.splitlines():
+                if line.startswith("package:"):
+                    yield line[8:]
 
     def process_exists(self, pid):
-        return any(self._get_procs(pid=pid))
+        """Check if a process with a PID matching pid exists on the connected device.
 
-    def _get_procs(self, pid=None, pid_children=None):
-        # default list all procs
-        cmd = ["shell", "ps"]
-        if pid is not None:
-            cmd.append(str(pid))
-        if pid_children is not None:
-            cmd += ["--ppid", str(pid_children)]
-        for line in self.call(cmd)[1].splitlines()[1:]:
-            pinfo = DeviceProcessInfo.from_ps_line(line)
-            if pinfo is not None:
-                yield pinfo
+        Args:
+            pid (int): Process ID to lookup
 
-    def is_installed(self, package_name):
-        return package_name in self.packages
+        Returns:
+            bool: True if the process exists otherwise False
+        """
+        return any(self._get_procs(pid=pid))
 
     def pull(self, src, dst):
+        """Copy file from connected device.
+
+        Args:
+            src (str): Path to file on the device to copy.
+            dst (str): Location on the local machine to copy the file to.
+
+        Returns:
+            bool: True if successful otherwise False
+        """
         log.debug("pull(%r, %r)", src, dst)
         return self.call(["pull", src, dst])[0] == 0
 
     def push(self, src, dst):
+        """Copy file to connected device.
+
+        Args:
+            src (str): Path to file on the local machine to copy.
+            dst (str): Location on the connected device to copy the file to.
+
+        Returns:
+            bool: True if successful otherwise False
+        """
         log.debug("push(%r, %r)", src, dst)
         if not os.path.exists(src):
-            raise IOError("%r does not exist" % src)
+            raise IOError("%r does not exist" % (src,))
         return self.call(["push", src, dst])[0] == 0
 
-    def symbols_path(self, package_name):
-        return self.symbols.get(package_name, "")
+    def realpath(self, path):
+        """Get canonical path of the specified path.
+
+        Args:
+            path (str): Path to file on the connected device.
+
+        Returns:
+            str: canonical path of the specified path.
+        """
+        log.debug("realpath(%r)", path)
+        ret_val, output = self.call(["shell", "realpath", path])
+        if ret_val != 0:
+            raise IOError("%r does not exist" % (path,))
+        return output.strip()
+
+    def reboot_device(self, boot_timeout=300, max_attempts=60, retry_delay=1):
+        """Reboot the connected device and reconnect.
+
+        Args:
+            boot_timeout (int, optional): Number of seconds to wait for device boot to complete.
+            max_attempts (int, optional): Number of attempts to make to try to connect to the device.
+            retry_delay (int, optional): Number of seconds to wait between connection attempts.
+
+        Returns:
+            None
+        """
+        was_root = self._root
+        log.debug("calling reboot...")
+        self.call(["reboot"])
+        self.connected = False
+        self.connect(
+            as_root=was_root,
+            boot_timeout=boot_timeout,
+            max_attempts=max_attempts,
+            retry_delay=retry_delay)
+        assert self.connected, "Device did not connect after reboot"
+
+    def remount(self):
+        """Remount system partition as writable.
+
+        Args:
+            None
+
+        Returns:
+            None
+        """
+        assert self._root
+        code, result = self.call(["remount"])
+        if code != 0 or "Permission denied" in result or "remount failed" in result:
+            raise ADBSessionError("Remount failed, is '-writable-system' set?")
+
+    def reverse(self, remote, local):
+        """
+
+        Args:
+            remote (int): Port to bind to on remote device
+            local (int): Port to bind to on local machine
+
+        Returns:
+            bool: True if successful otherwise False
+        """
+        assert isinstance(local, int) and 1024 < local < 0x10000
+        assert isinstance(remote, int) and 1024 < remote < 0x10000
+        return self.call(["reverse", "tcp:%d" % (remote,), "tcp:%d" % (local,)])[0] == 0
+
+    def reverse_remove(self, remote=None):
+        """
+
+        Args:
+            remote (int): Port to unbind from on remote device
+
+        Returns:
+            bool: True if successful otherwise False
+        """
+        cmd = ["reverse"]
+        if remote is not None:
+            assert isinstance(remote, int) and 1024 < remote < 0x10000
+            cmd.append("--remove")
+            cmd.append("tcp:%d" % (remote,))
+        else:
+            cmd.append("--remove-all")
+        return self.call(cmd)[0] == 0
 
     def set_enforce(self, value):
+        """Set SELinux mode.
+
+        Args:
+            value (int): 1 to set 'Enforced' or 0 to set 'Permissive'
+
+        Returns:
+            None
+        """
         assert value in (0, 1)
         if not self._root:
             log.warning("set_enforce requires root")
         self.call(["shell", "setenforce", str(value)])
 
+    def symbols_path(self, package_name):
+        """Lookup path containing symbols for a specified package.
+
+        Args:
+            package_name (str): Name of package.
+
+        Returns:
+            str: Path containing symbols on the local machine.
+        """
+        return self.symbols.get(package_name, "")
+
+    def uninstall(self, package):
+        """Uninstall package from the connected device.
+
+        Args:
+            package (str): Name of package.
+
+        Returns:
+            bool: True if successful otherwise False
+        """
+        if not self.connected:
+            log.debug("already disconnected")
+            return False
+        return self.call(["uninstall", package], timeout=60)[0] == 0
+
     def wait_for_boot(self, timeout=None):
+        """Uninstall package from the connected device.
+
+        Args:
+            timeout (float or int, optional): Number of seconds to wait for device to boot.
+
+        Returns:
+            bool: True if device booted successfully otherwise False.
+        """
         if timeout is not None:
             assert isinstance(timeout, (int, float)) and timeout > 0
             deadline = time.time() + timeout
         else:
             deadline = None
-        attempts = 0
-        booted = False
         # first wait for the boot to complete then wait for the boot animation to complete
         # this will help ensure the device is in a ready state
+        anim_chk = ["shell", "getprop", "init.svc.bootanim"]
+        boot_chk = ["shell", "getprop", "sys.boot_completed"]
+        attempts = 0
+        booted = False
         while True:
             if not booted:
-                booted = self.call(["shell", "getprop", "sys.boot_completed"], require_device=False)[1] == "1"
+                booted = self.call(boot_chk, device_required=False)[1] == "1"
                 attempts += 1
             # we need to verify that boot is complete before checking the animation is stopped because
             # the animation can be in the stopped state early in the boot process
-            if booted and self.call(["shell", "getprop", "init.svc.bootanim"])[1] == "stopped":
+            if booted and self.call(anim_chk)[1] == "stopped":
                 if attempts > 1:
                     # the device was booting so give it additional time
                     log.debug("device was boot was detected")
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 2ceb19a0..d418bdf5 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -5,7 +5,8 @@
 
 import pytest
 
-from .adb_session import ADBCommandError, ADBNoDevice, ADBSession, ADBSessionError, DeviceProcessInfo
+from .adb_session import ADBCommandError, ADBCommunicationError, ADBSession, ADBSessionError
+from .adb_session import DeviceProcessInfo
 
 def test_adb_session_01(mocker):
     """test ADBSession._call_adb()"""
@@ -48,7 +49,7 @@ def test_adb_session_02(mocker):
     # not connected
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="fake_adb")
     session = ADBSession()
-    with pytest.raises(ADBSessionError, match="ADB session is not connected!"):
+    with pytest.raises(ADBCommunicationError, match="ADB session is not connected!"):
         session.call(["test"])
     # successful call
     session.connected = True
@@ -66,7 +67,7 @@ def test_adb_session_02(mocker):
         session.call(["test"])
     # disconnected device
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", return_value=(1, "error: closed"))
-    with pytest.raises(ADBNoDevice, match="No device detected!"):
+    with pytest.raises(ADBCommunicationError, match="No device detected!"):
         session.call(["test"])
     assert not session.connected
 
@@ -100,7 +101,7 @@ def fake_adb_01(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "devices":
             return 1, ""
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_01)
     assert not ADBSession().devices()
     def fake_adb_02(cmd, timeout=None):
@@ -109,7 +110,7 @@ def fake_adb_02(cmd, timeout=None):
             return 0, "List of devices attached\n" \
                       "emulator-5554   device\n" \
                       "emulator-5556   offline"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_02)
     devices = ADBSession().devices(all_devices=True, any_state=False)
     assert len(devices) == 1
@@ -123,7 +124,7 @@ def fake_adb_03(cmd, timeout=None):
                       "emulator-5554   device\n" \
                       "emulator-5556   offline\n" \
                       "emulator-5558   device\n"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_03)
     session = ADBSession()
     os.environ["ANDROID_SERIAL"] = "emulator-5558"
@@ -163,7 +164,7 @@ def fake_adb_call(obj, cmd, timeout=None):
         # already root
         if cmd[1] == "shell" and cmd[2] == "whoami":
             return 0, "root"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     ADBSession._call_adb = fake_adb_call
     session = ADBSession.create(test_ip, test_port)
@@ -228,7 +229,7 @@ def fake_adb_call(obj, cmd, timeout=None):
             obj._root = False
             obj.connected = False
             return 0, "restarting adbd as non root"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
     ADBSession._call_adb = fake_adb_call
     session = ADBSession.create(test_ip, test_port)
@@ -274,7 +275,7 @@ def fake_adb_call(obj, cmd, timeout=None):
                 return 0, "1"
         if cmd[1] == "shell" and cmd[2] == "whoami":
             return 0, "shell"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
     ADBSession._call_adb = fake_adb_call
     session = ADBSession.create(as_root=False)
@@ -300,7 +301,7 @@ def fake_adb_call(cmd, timeout=None):
             return 0, "\n".join(("List of devices attached",
                                  "* daemon not running; starting now at tcp:5037",
                                  "* daemon started successfully"))
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     assert not ADBSession().connect()
     assert not ADBSession("127.0.0.1").connect()
@@ -322,7 +323,7 @@ def fake_adb_call(cmd, timeout=None):
                 return 0, "1"
         if cmd[1] == "shell" and cmd[2] == "whoami":
             return 1, ""
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     with pytest.raises(ADBSessionError, match="Device in a bad state, try disconnect & reboot"):
         ADBSession("127.0.0.1").connect()
@@ -370,7 +371,7 @@ def fake_adb_call(obj, cmd, timeout=None):
             obj._root = False
             obj.connected = False
             return 0, "restarting adbd as non root"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
     ADBSession._call_adb = fake_adb_call
     session = ADBSession("127.0.0.1")
@@ -410,7 +411,7 @@ def fake_adb_call(cmd, timeout=None):
             return 1, "unable to connect"
         if cmd[1] == "disconnect":
             return 0, ""
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     assert not session.connected
@@ -453,7 +454,7 @@ def fake_adb_call(cmd, timeout=None):
             assert cmd[3] == "grant"
             assert cmd[4] == "test-package.blah.foo"
             return 0, ""
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     mocker.patch("grizzly.target.adb_device.ADBSession.get_package_name", side_effect=fake_get_package_name)
     session = ADBSession("127.0.0.1")
@@ -462,8 +463,11 @@ def fake_adb_call(cmd, timeout=None):
     with pytest.raises(IOError):
         session.install("fake_path")
     # bad apk
-    apk_file = tmp_path / "bad.apk"
-    apk_file.touch()
+    pkg_file = tmp_path / "package-name.txt"
+    apk_file = str(tmp_path / "bad.apk")
+    pkg_file.write_bytes(b"\n")
+    with zipfile.ZipFile(apk_file, mode="w") as z_out:
+        z_out.write(str(pkg_file), "package-name.txt")
     with pytest.raises(ADBSessionError):
         session.install(str(apk_file))
     # good apk
@@ -487,7 +491,7 @@ def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "uninstall" and cmd[2] == "org.test.preinstalled":
             return 0, "Success"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     assert not session.uninstall("org.test.unknown")
@@ -508,10 +512,10 @@ def fake_adb_call(cmd, timeout=None):
                 "root      5944  5847  6280   2360           0 00000000 R ps",
                 "")
             return 0, "\n".join(output)
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
-    with pytest.raises(ADBSessionError):
+    with pytest.raises(ADBCommunicationError, match="ADB session is not connected!"):
         session.get_pid("org.test.unknown")
     session.connected = True
     assert session.get_pid("org.test.unknown") is None
@@ -531,7 +535,7 @@ def fake_adb_call(cmd, timeout=None):
                 "package:com.android.phone",
                 "package:com.android.shell")
             return 0, "\n".join(output)
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -552,7 +556,7 @@ def fake_adb_call(cmd, timeout=None):
                 "package:com.android.phone",
                 "package:com.android.shell")
             return 0, "\n".join(output)
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -593,7 +597,7 @@ def fake_adb_call(cmd, timeout=None):
                     "07-27 12:39:27.286  2767  7142 I fake log",
                     "07-27 12:39:27.441  7128  7128 I fake log"]
             return 0, "\n".join(output)
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -644,7 +648,7 @@ def fake_adb_call(cmd, timeout=None):
                 "u0_a80    9991  9990  3332   3331 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora",
                 "")
             return 0, "\n".join(output)
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -687,7 +691,7 @@ def fake_adb_call(cmd, timeout=None):
                     "u0_a80    9991  9990  3332   3331 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora"]
             output += [""]
             return 0, "\n".join(output)
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -705,7 +709,7 @@ def fake_adb_call(cmd, timeout=None):
             assert "test.txt" in cmd[2]
             assert cmd[3] == "dst"
             return 0, " pushed. "
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -724,7 +728,7 @@ def fake_adb_call(cmd, timeout=None):
             assert cmd[2] == "src"
             assert cmd[3] == "dst"
             return 0, " pulled. "
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -738,7 +742,7 @@ def fake_adb_call(cmd, timeout=None):
         if cmd[1] == "logcat":
             assert cmd[2] == "--clear"
             return 0, ""
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -754,7 +758,7 @@ def fake_adb_call(cmd, timeout=None):
             if cmd[4] == "missing-dir":
                 return 1, ""
             return 0, "test"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -776,7 +780,7 @@ def fake_adb_call(cmd, timeout=None):
                 "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora",
                 "")
             return 0, "\n".join(output)
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -897,7 +901,7 @@ def fake_adb_call(cmd, timeout=None):
             if cmd[3] == "missing/path":
                 return 1, ""
             return 0, "existing/path"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -912,7 +916,7 @@ def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "reverse":
             return 0, ""
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -937,9 +941,9 @@ def fake_adb_call(cmd, timeout=None):
             elif cmd[2] == "--remove-all":
                 pass
             else:
-                raise RuntimeError("unexpected command %r" % (cmd,))
+                raise AssertionError("unexpected command %r" % (cmd,))
             return 0, ""
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -972,7 +976,7 @@ def fake_adb_call(cmd, timeout=None):
             assert cmd[6] == "-a"
             assert cmd[7] == "android.intent.action.AIRPLANE_MODE"
             return 0, ""
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -992,7 +996,7 @@ def fake_adb_01(_, cmd, timeout=None):
                 return 0, ""
             if cmd[3] == "sys.boot_completed":
                 return 0, "0"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     ADBSession._call_adb = fake_adb_01
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -1005,7 +1009,7 @@ def fake_adb_02(_, cmd, timeout=None):
                 return 0, "stopped"
             if cmd[3] == "sys.boot_completed":
                 return 0, "1"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     ADBSession._call_adb = fake_adb_02
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -1025,7 +1029,7 @@ def fake_adb_03(obj, cmd, timeout=None):
                     setattr(obj, "boot_done", True)
                     return 0, "0"
                 return 0, "1"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     ADBSession._call_adb = fake_adb_03
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -1039,7 +1043,7 @@ def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "reboot":
             return 0, ""
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     mocker.patch("grizzly.target.adb_device.ADBSession.connect", spec=True)
     session = ADBSession()
@@ -1054,7 +1058,7 @@ def fake_adb_01(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "remount":
             return 0, "Permission denied"
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_01)
     session = ADBSession()
     session.connected = True
@@ -1065,7 +1069,7 @@ def fake_adb_02(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "remount":
             return 0, ""
-        raise RuntimeError("unexpected command %r" % (cmd,))
+        raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_02)
     session = ADBSession()
     session.connected = True

From 4ae6ad2a6db77e61585056b2c2dc8416c36fb527 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 3 Sep 2019 16:28:10 -0700
Subject: [PATCH 483/531] Make DeviceProcessInfo a namedtuple

---
 grizzly/target/adb_device/adb_session.py      | 50 ++++++++-----------
 grizzly/target/adb_device/test_adb_session.py | 13 +++--
 2 files changed, 26 insertions(+), 37 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 935a79c5..6b7c3f77 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -2,6 +2,7 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from collections import namedtuple
 import glob
 import logging
 import os
@@ -18,35 +19,7 @@
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
 
-class DeviceProcessInfo(object):
-    __slots__ = ("memory", "name", "pid", "ppid")
-
-    def __init__(self, memory, name, pid, ppid):
-        self.memory = memory
-        self.name = name
-        self.pid = pid
-        self.ppid = ppid
-
-    @classmethod
-    def from_ps_line(cls, line):
-        """Create a DeviceProcessInfo from the string output of ps.
-
-        Args:
-            line (str): Line of output from ps.
-
-        Returns:
-            DeviceProcessInfo: new instance.
-        """
-        try:
-            _, pid, ppid, _, memory, _, _, _, name = line.split()
-        except ValueError:
-            log.debug("invalid ps line %r", line)
-            return None
-        try:
-            return cls(int(memory), name, int(pid), int(ppid))
-        except ValueError:
-            log.debug("invalid ps line values")
-        return None
+DeviceProcessInfo = namedtuple("DeviceProcessInfo", "memory name pid ppid")
 
 
 class ADBCommandError(Exception):
@@ -185,10 +158,27 @@ def _get_procs(self, pid=-1, pid_children=-1):
         if pid_children > -1:
             cmd += ["--ppid", str(pid_children)]
         for line in self.call(cmd)[1].splitlines()[1:]:
-            pinfo = DeviceProcessInfo.from_ps_line(line)
+            pinfo = self._line_to_info(line)
             if pinfo is not None:
                 yield pinfo
 
+    @staticmethod
+    def _line_to_info(ps_line):
+        """Create a DeviceProcessInfo from the string output of ps.
+
+        Args:
+            ps_line (str): Line of output from ps.
+
+        Returns:
+            DeviceProcessInfo: new instance.
+        """
+        try:
+            _, pid, ppid, _, memory, _, _, _, name = ps_line.split()
+            return DeviceProcessInfo(int(memory), name, int(pid), int(ppid))
+        except ValueError:
+            log.debug("invalid ps line %r", ps_line)
+        return None
+
     @property
     def airplane_mode(self):
         """Get the current state of airplane mode.
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index d418bdf5..ad235384 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -6,7 +6,6 @@
 import pytest
 
 from .adb_session import ADBCommandError, ADBCommunicationError, ADBSession, ADBSessionError
-from .adb_session import DeviceProcessInfo
 
 def test_adb_session_01(mocker):
     """test ADBSession._call_adb()"""
@@ -1080,16 +1079,16 @@ def fake_adb_02(cmd, timeout=None):
     # test as root
     session.remount()
 
-def test_device_process_01():
-    """test DeviceProcessInfo"""
+def test_adb_session_39():
+    """test ADBSession._line_to_info()"""
     # nothing to parse
-    assert DeviceProcessInfo.from_ps_line("") is None
+    assert ADBSession._line_to_info("") is None
     # invalid number of entries
-    assert DeviceProcessInfo.from_ps_line(" ".join("a" * 20)) is None
+    assert ADBSession._line_to_info(" ".join("a" * 20)) is None
     # invalid data (valid number of entries)
-    assert DeviceProcessInfo.from_ps_line(" ".join("a" * 9)) is None
+    assert ADBSession._line_to_info(" ".join("a" * 9)) is None
     # valid info
-    pinfo = DeviceProcessInfo.from_ps_line("a 1 2 a 3 a a a name")
+    pinfo = ADBSession._line_to_info("a 1 2 a 3 a a a name")
     assert pinfo is not None
     assert pinfo.memory == 3
     assert pinfo.name == "name"

From 4fc0a40e3fcb368ba4012245a612131b0e05fa23 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 19 Sep 2019 20:33:34 -0400
Subject: [PATCH 484/531] Fix log mode for Python 3

---
 grizzly/target/adb_device/adb_process.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index d9e87640..e52f33d0 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -207,7 +207,7 @@ def _process_logs(self, crash_reports):
         unprocessed = os.path.join(self.logs, "unprocessed")
         os.mkdir(unprocessed)
 
-        with open(os.path.join(self.logs, "log_logcat.txt"), "w") as log_fp:
+        with open(os.path.join(self.logs, "log_logcat.txt"), "wb") as log_fp:
             # TODO: should this filter by pid or not?
             log_fp.write(self._session.collect_logs())
             #log_fp.write(self._session.collect_logs(pid=self._pid))

From c4e257b0d7f3b7f26f3000f5171d484748e78a29 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 19 Sep 2019 20:34:25 -0400
Subject: [PATCH 485/531] No need to set permissions: `adb install -g` grants
 them all.

---
 grizzly/target/adb_device/adb_session.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 6b7c3f77..d2771fa6 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -500,9 +500,6 @@ def install(self, apk_path):
             raise ADBSessionError("Could not find APK package name")
         if self.call(["install", "-g", "-r", apk_path], timeout=120)[0] != 0:
             raise ADBSessionError("Failed to install %r" % (apk_path,))
-        # set permissions
-        self.call(["shell", "pm", "grant", pkg_name, "android.permission.READ_EXTERNAL_STORAGE"])
-        self.call(["shell", "pm", "grant", pkg_name, "android.permission.WRITE_EXTERNAL_STORAGE"])
         log.debug("installed package %r (%r)", pkg_name, apk_path)
         return pkg_name
 

From f236209a9da2d2db1c43f72dd507fb882d6e6cc4 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 19 Sep 2019 21:05:56 -0400
Subject: [PATCH 486/531] Fix tests broken in
 536a7878f5cd5302ffbc9502f4c0f049ef4b5b2d

---
 grizzly/target/adb_device/test_adb_process.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index b55a1952..66a61ebe 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -36,7 +36,7 @@ def test_adb_process_03(mocker):
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (1, "")
-    fake_session.collect_logs.return_value = ""
+    fake_session.collect_logs.return_value = b""
     fake_session.listdir.return_value = ()
     fake_session.process_exists.return_value = False
     proc = ADBProcess("org.test.unknown", fake_session)
@@ -58,7 +58,7 @@ def test_adb_process_04(mocker):
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
-    fake_session.collect_logs.return_value = ""
+    fake_session.collect_logs.return_value = b""
     fake_session.get_pid.return_value = 1337
     fake_session.listdir.return_value = ()
     #fake_session.process_exists.return_value = False
@@ -86,7 +86,7 @@ def test_adb_process_05(mocker):
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
-    fake_session.collect_logs.return_value = ""
+    fake_session.collect_logs.return_value = b""
     fake_session.get_pid.return_value = 1337
     fake_session.listdir.return_value = ()
     env = {"test1":"1", "test2": "2"}
@@ -104,7 +104,7 @@ def test_adb_process_06(mocker):
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
-    fake_session.collect_logs.return_value = ""
+    fake_session.collect_logs.return_value = b""
     fake_session.open_files.return_value = ((1, "some_file"),)
     fake_session.listdir.return_value = ()
     fake_session.realpath.side_effect = str.strip
@@ -162,7 +162,7 @@ def test_adb_process_09(mocker):
     mocker.patch("grizzly.target.adb_device.adb_process.PuppetLogger", autospec=True)
     fake_proc_md = mocker.patch("grizzly.target.adb_device.adb_process.process_minidumps", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
-    fake_session.collect_logs.return_value = "fake logcat data"
+    fake_session.collect_logs.return_value = b"fake logcat data"
     proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
     try:
         # no extra logs

From c09ed7c4a2b27aa506069e95399752b57e087c5d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 10 Aug 2020 13:11:03 -0700
Subject: [PATCH 487/531] [android] Add PrefPicker support

---
 grizzly/target/adb_device/adb_process.py |  3 +-
 grizzly/target/adb_target.py             | 46 ++++++++++++++++++++++--
 grizzly/target/test_adb_target.py        |  6 ++--
 3 files changed, 49 insertions(+), 6 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index e52f33d0..5ef289ee 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -6,7 +6,8 @@
 import tempfile
 import time
 
-from ffpuppet.helpers import append_prefs, Bootstrapper, create_profile
+from ffpuppet.bootstrapper import Bootstrapper
+from ffpuppet.helpers import append_prefs, create_profile
 from ffpuppet.minidump_parser import process_minidumps
 from ffpuppet.puppet_logger import PuppetLogger
 
diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index 85630f12..92f7f00c 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -4,12 +4,16 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 import logging
 import os
+from tempfile import mkstemp
 
 from ffpuppet import LaunchError
+from prefpicker import PrefPicker
 
 from .adb_device import ADBProcess, ADBSession
 from .target import Target
 from .target_monitor import TargetMonitor
+from ..common.utils import grz_tmp
+
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
@@ -18,9 +22,9 @@
 
 
 class ADBTarget(Target):
-    def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, prefs, relaunch, **kwds):
+    def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, relaunch, **kwds):
         super(ADBTarget, self).__init__(binary, extension, launch_timeout, log_limit,
-                                        memory_limit, prefs, relaunch)
+                                        memory_limit, relaunch)
         self.forced_close = True  # app will not close itself on Android
         self.use_rr = False
 
@@ -38,7 +42,9 @@ def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, p
         if self._session is None:
             raise RuntimeError("Could not create ADB Session!")
         self._package = ADBSession.get_package_name(self.binary)
+        self._prefs = None
         self._proc = ADBProcess(self._package, self._session)
+        self._remove_prefs = False
         self._session.symbols[self._package] = os.path.join(os.path.dirname(self.binary), "symbols")
 
     def cleanup(self):
@@ -48,6 +54,8 @@ def cleanup(self):
             if self._session.connected:
                 self._session.reverse_remove()
             self._session.disconnect()
+        if self._remove_prefs and self._prefs and isfile(self._prefs):
+            os.remove(self._prefs)
 
     def close(self):
         with self._lock:
@@ -132,6 +140,40 @@ def log_length(_, *_a):  # pylint: disable=arguments-differ
             self._monitor = _ADBMonitor()
         return self._monitor
 
+    # TODO: prefs is identical to puppet_target.py should be cleaned up.
+    @property
+    def prefs(self):
+        if self._prefs is None:
+            # generate temporary prefs.js
+            for prefs_template in PrefPicker.templates():
+                if prefs_template.endswith("browser-fuzzing.yml"):
+                    log.debug("using prefpicker template %r", prefs_template)
+                    tmp_fd, self._prefs = mkstemp(prefix="prefs_", suffix=".js", dir=grz_tmp())
+                    os.close(tmp_fd)
+                    PrefPicker.load_template(prefs_template).create_prefsjs(self._prefs)
+                    log.debug("generated prefs.js %r", self._prefs)
+                    self._remove_prefs = True
+                    break
+            else:  # pragma: no cover
+                raise TargetError("Failed to generate prefs.js")
+        return self._prefs
+
+    @prefs.setter
+    def prefs(self, prefs_file):
+        if self._remove_prefs and self._prefs and os.path.isfile(self._prefs):
+            os.unlink(self._prefs)
+        if prefs_file is None:
+            self._prefs = None
+            self._remove_prefs = True
+        elif os.path.isfile(prefs_file):
+            self._prefs = os.path.abspath(prefs_file)
+            self._remove_prefs = False
+        else:
+            raise TargetError("Missing prefs.js file %r" % (prefs_file,))
+
+    def save_logs(self, *args, **kwargs):
+        self._puppet.save_logs(*args, **kwargs)
+
     def reverse(self, remote, local):
         # remote->device, local->desktop
         self._session.reverse(remote, local)
diff --git a/grizzly/target/test_adb_target.py b/grizzly/target/test_adb_target.py
index 42f58814..0fc2246b 100644
--- a/grizzly/target/test_adb_target.py
+++ b/grizzly/target/test_adb_target.py
@@ -24,7 +24,7 @@ def test_adb_target_01(mocker, tmp_path):
     fake_session.get_package_name.return_value = "the_name"
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()
-    target = ADBTarget(str(fake_apk), None, 300, 25, 5000, None, 25)
+    target = ADBTarget(str(fake_apk), None, 300, 25, 5000, 25)
     try:
         assert target.closed
         assert target.forced_close
@@ -50,7 +50,7 @@ def test_adb_target_02(mocker, tmp_path):
     mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()
-    target = ADBTarget(str(fake_apk), None, 300, 25, 5000, None, 25)
+    target = ADBTarget(str(fake_apk), None, 300, 25, 5000, 25)
     target.launch("fake.url")
     assert fake_process.return_value.launch.call_count == 1
     assert target.monitor.is_running()
@@ -62,7 +62,7 @@ def test_adb_target_03(mocker, tmp_path):
     mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()
-    target = ADBTarget(str(fake_apk), None, 300, 25, 5000, None, 25)
+    target = ADBTarget(str(fake_apk), None, 300, 25, 5000, 25)
     # test everything is running
     fake_process.return_value.is_healthy.return_value = True
     fake_process.return_value.is_running.return_value = True

From 498dbca66ed638f0fa83330cf929a2b35cb1eb46 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 10 Aug 2020 13:56:56 -0700
Subject: [PATCH 488/531] Fix copy/paste error

---
 grizzly/target/adb_target.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index 92f7f00c..0eb0b60f 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -54,7 +54,7 @@ def cleanup(self):
             if self._session.connected:
                 self._session.reverse_remove()
             self._session.disconnect()
-        if self._remove_prefs and self._prefs and isfile(self._prefs):
+        if self._remove_prefs and self._prefs and os.path.isfile(self._prefs):
             os.remove(self._prefs)
 
     def close(self):
@@ -171,9 +171,6 @@ def prefs(self, prefs_file):
         else:
             raise TargetError("Missing prefs.js file %r" % (prefs_file,))
 
-    def save_logs(self, *args, **kwargs):
-        self._puppet.save_logs(*args, **kwargs)
-
     def reverse(self, remote, local):
         # remote->device, local->desktop
         self._session.reverse(remote, local)

From 780e8ef2d3dfe502888238d8a189c854c89bcd86 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 10 Aug 2020 13:58:00 -0700
Subject: [PATCH 489/531] [android] Fix geckoview_example launch

---
 grizzly/target/adb_device/adb_process.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index 5ef289ee..ec27ce06 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -166,7 +166,7 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
                 shutil.rmtree(profile, True)
             cmd = [
                 "shell", "am", "start", "-W", "-n",
-                "/".join([self._package, "org.mozilla.gecko.BrowserApp"]),
+                "/".join([self._package, "org.mozilla.geckoview_example.GeckoViewActivity"]),
                 "-a", "android.intent.action.VIEW", "-d", bootstrapper.location,
                 "--es", "args", "-profile\\ %s" % self.profile]
             # add environment variables to launch command

From adb2e6cab81d076edcc6a64d110c6f38640a3cbc Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 12 Aug 2020 10:42:27 -0700
Subject: [PATCH 490/531] [adb] Check package is not running before launching

---
 grizzly/target/adb_device/adb_process.py      | 19 ++++-
 grizzly/target/adb_device/test_adb_process.py | 73 ++++++++-----------
 2 files changed, 48 insertions(+), 44 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index ec27ce06..d2ea8f5f 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -48,6 +48,12 @@ def __init__(self, package_name, session, use_profile=None):
         self.profile = None  # profile path on device
         self.reason = self.RC_CLOSED
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.cleanup()
+
     def cleanup(self):
         if self._launches < 0:
             log.debug("clean_up() call ignored")
@@ -132,6 +138,10 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
         assert self._pid is None, "Process is already running"
         assert self.reason is not None, "Process is already running"
 
+        # check app is not previously running
+        if self._session.get_pid(self._package) is not None:
+            raise ADBLaunchError("%r is already running" % self._package)
+
         self._session.clear_logs()
         self._remove_logs()
         sanitizer_logs = os.path.dirname(self._session.SANITIZER_LOG_PREFIX)
@@ -139,6 +149,7 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
         self._session.call(["shell", "mkdir", "-p", sanitizer_logs])
         self._session.call(["shell", "chmod", "666", sanitizer_logs])
         self.reason = None
+
         # setup bootstrapper and reverse port
         # reverse does fail occasionally so use a retry loop
         for _ in range(10):
@@ -157,13 +168,15 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
                 prefs = {
                     "capability.policy.policynames": "'localfilelinks'",
                     "capability.policy.localfilelinks.sites": "'%s'" % bootstrapper.location,
-                    "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'"}
+                    "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'",
+                    "network.http.speculative-parallel-limit": "0"}
                 append_prefs(profile, prefs)
                 self.profile = "/".join([self._working_path, os.path.basename(profile)])
                 if not self._session.push(profile, self.profile):
                     raise ADBLaunchError("Could not upload profile %r" % profile)
             finally:
                 shutil.rmtree(profile, True)
+            #"/".join([self._package, "org.mozilla.fenix.IntentReceiverActivity"]),
             cmd = [
                 "shell", "am", "start", "-W", "-n",
                 "/".join([self._package, "org.mozilla.geckoview_example.GeckoViewActivity"]),
@@ -314,9 +327,11 @@ def _split_logcat(log_path, package_name):
                     o_fp.write(line.split(b": ", 1)[-1])
 
     def save_logs(self, log_path, meta=False):
-        assert self.logs is not None
         assert self.reason is not None, "Call close() first!"
         assert self._launches > -1, "clean_up() has been called"
+        if self.logs is None:
+            log.warning("No logs available to save.")
+            return
         # copy logs to location specified by log_file
         if not os.path.isdir(log_path):
             os.makedirs(log_path)
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 66a61ebe..5acfd0cc 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -11,8 +11,7 @@ def test_adb_process_01(mocker):
     """test creating a simple device"""
     test_pkg = "org.test.preinstalled"
     fake_session = mocker.Mock(spec=ADBSession)
-    proc = ADBProcess(test_pkg, fake_session)
-    try:
+    with ADBProcess(test_pkg, fake_session) as proc:
         assert isinstance(proc._session, ADBSession)
         assert proc._package == test_pkg
         assert proc.logs is None
@@ -21,8 +20,6 @@ def test_adb_process_01(mocker):
         assert proc._pid is None
         proc.close()
         assert not proc.logs  # should not have logs
-    finally:
-        proc.cleanup()
 
 def test_adb_process_02(mocker):
     """test creating device with unknown package"""
@@ -32,6 +29,15 @@ def test_adb_process_02(mocker):
         ADBProcess("org.test.unknown", fake_session)
 
 def test_adb_process_03(mocker):
+    """test ADBProcess.launch() package is running (bad state)"""
+    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.get_pid.return_value = 1337
+    with ADBProcess("org.some.app", fake_session) as proc:
+        assert not proc.is_running()
+        with pytest.raises(ADBLaunchError, match="'org.some.app' is already running"):
+            proc.launch("fake.url")
+
+def test_adb_process_04(mocker):
     """test failed ADBProcess.launch() and ADBProcess.is_running()"""
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
@@ -39,18 +45,15 @@ def test_adb_process_03(mocker):
     fake_session.collect_logs.return_value = b""
     fake_session.listdir.return_value = ()
     fake_session.process_exists.return_value = False
-    proc = ADBProcess("org.test.unknown", fake_session)
-    try:
+    with ADBProcess("org.test.unknown", fake_session) as proc:
         assert not proc.is_running()
         with pytest.raises(ADBLaunchError):
             proc.launch("fake.url")
         assert not proc.is_running()
         proc.cleanup()
         assert proc.logs is None
-    finally:
-        proc.cleanup()
 
-def test_adb_process_04(mocker):
+def test_adb_process_05(mocker):
     """test ADBProcess.launch(), ADBProcess.is_running() and ADBProcess.is_healthy()"""
     fake_bs = mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_bs.return_value.location.return_value = "http://localhost"
@@ -59,11 +62,10 @@ def test_adb_process_04(mocker):
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = b""
-    fake_session.get_pid.return_value = 1337
+    fake_session.get_pid.side_effect = (None, 1337)
     fake_session.listdir.return_value = ()
     #fake_session.process_exists.return_value = False
-    proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
-    try:
+    with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
         assert not proc.is_running()
         assert proc.launches == 0
         assert proc.launch("fake.url")
@@ -73,12 +75,10 @@ def test_adb_process_04(mocker):
         proc.close()
         assert proc._pid is None
         assert proc.logs
-    finally:
-        proc.cleanup()
     assert fake_bs.return_value.wait.call_count == 1
     assert fake_bs.return_value.close.call_count == 1
 
-def test_adb_process_05(mocker):
+def test_adb_process_06(mocker):
     """test ADBProcess.launch() with environment variables"""
     fake_bs = mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_bs.return_value.location.return_value = "http://localhost"
@@ -87,44 +87,38 @@ def test_adb_process_05(mocker):
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = b""
-    fake_session.get_pid.return_value = 1337
+    fake_session.get_pid.side_effect = (None, 1337)
     fake_session.listdir.return_value = ()
     env = {"test1":"1", "test2": "2"}
-    proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
-    try:
+    with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
         assert proc.launch("fake.url", env_mod=env)
         assert proc.is_running()
         proc.close()
-    finally:
-        proc.cleanup()
 
-def test_adb_process_06(mocker):
+def test_adb_process_07(mocker):
     """test ADBProcess.wait_on_files()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = b""
+    fake_session.get_pid.side_effect = (None, 1337)
     fake_session.open_files.return_value = ((1, "some_file"),)
     fake_session.listdir.return_value = ()
     fake_session.realpath.side_effect = str.strip
-    proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
-    try:
+    with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
         proc.wait_on_files(["not_running"])
         assert proc.launch("fake.url")
         assert proc.wait_on_files([])
         fake_session.open_files.return_value = ((1, "some_file"), (1, "/existing/file.txt"))
         assert not proc.wait_on_files(["/existing/file.txt"], poll_rate=0.1, timeout=0.3)
         proc.close()
-    finally:
-        proc.cleanup()
 
-def test_adb_process_07(mocker):
+def test_adb_process_08(mocker):
     """test ADBProcess.find_crashreports()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
-    proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
-    try:
+    with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
         proc.profile = "profile_path"
         # no dump files
         fake_session.listdir.return_value = ("somefile.txt")
@@ -135,10 +129,8 @@ def test_adb_process_07(mocker):
         # contains missing path
         fake_session.listdir.side_effect = IOError("test")
         assert not proc.find_crashreports()
-    finally:
-        proc.cleanup()
 
-def test_adb_process_08(mocker, tmp_path):
+def test_adb_process_09(mocker, tmp_path):
     """test ADBProcess.save_logs()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
@@ -148,23 +140,22 @@ def test_adb_process_08(mocker, tmp_path):
     fake_log = log_path / "fake.txt"
     fake_log.touch()
     dmp_path = tmp_path / "dst"
-    proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
-    proc.logs = str(log_path)
-    try:
+    with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
+        # without proc.logs set
+        proc.save_logs(str(dmp_path))
+        # with proc.logs set
+        proc.logs = str(log_path)
         proc.save_logs(str(dmp_path))
-    finally:
-        proc.cleanup()
     assert "fake.txt" in os.listdir(str(dmp_path))
 
-def test_adb_process_09(mocker):
+def test_adb_process_10(mocker):
     """test ADBProcess._process_logs()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     mocker.patch("grizzly.target.adb_device.adb_process.PuppetLogger", autospec=True)
     fake_proc_md = mocker.patch("grizzly.target.adb_device.adb_process.process_minidumps", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.collect_logs.return_value = b"fake logcat data"
-    proc = ADBProcess("org.mozilla.fennec_aurora", fake_session)
-    try:
+    with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
         # no extra logs
         proc._process_logs([])
         assert os.path.isdir(proc.logs)
@@ -184,10 +175,8 @@ def test_adb_process_09(mocker):
             shutil.rmtree(proc.logs)
         assert fake_proc_md.call_count == 1
         assert fake_session.pull.call_count == 2
-    finally:
-        proc.cleanup()
 
-def test_adb_process_10(tmp_path):
+def test_adb_process_11(tmp_path):
     """test ADBProcess._split_logcat()"""
     log_path = tmp_path / "logs"
     log_path.mkdir()

From 7e311f94520eaa2b179642864d48645280efcb87 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 12 Aug 2020 11:00:36 -0700
Subject: [PATCH 491/531] [adb] Remove install ASan functionality

---
 grizzly/target/adb_device/adb_session.py | 97 ------------------------
 grizzly/target/adb_device/device.py      |  7 +-
 2 files changed, 1 insertion(+), 103 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index d2771fa6..6301f0cb 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -503,103 +503,6 @@ def install(self, apk_path):
         log.debug("installed package %r (%r)", pkg_name, apk_path)
         return pkg_name
 
-    def install_asan(self, ndk_path, extra_options=None):
-        """Install Address Sanitizer libraries, llvm-sanitizer and create scripts to wrap app_process.
-        NOTE: SELinux must be set to permissive for this to work.
-
-        Args:
-            ndk_path (str): Path to the NDK that contains ASan libraries.
-            extra_options (dict, optional): Extra options to add to ASAN_OPTIONS
-
-        Returns:
-            None
-        """
-        if not os.path.isdir(ndk_path):
-            raise IOError("NDK does not exist %r" % (ndk_path,))
-        clang_path = os.path.join(
-            ndk_path, "toolchains", "llvm", "prebuilt", "linux-x86_64", "lib64",
-            "clang", "*", "lib", "linux")
-        for cpath in glob.glob(clang_path):
-            asan_rt = os.path.join(cpath, "libclang_rt.asan-i686-android.so")
-            asan_rt64 = os.path.join(cpath, "libclang_rt.asan-x86_64-android.so")
-            if os.path.isfile(asan_rt) and os.path.isfile(asan_rt64):
-                break
-        else:
-            raise IOError("Cannot find libclang_rt.asan-*-android.so")
-        self.remount()
-        ctx = "u:object_r:zygote_exec:s0"
-        if self.call(["shell", "ls", "/system/bin/app_process32.real"]) != 0:
-            self.call(["shell", "mv", "/system/bin/app_process32", "/system/bin/app_process32.real"])
-            self.call(["shell", "chcon", ctx, "/system/bin/app_process32.real"])
-        if self.call(["shell", "ls", "/system/bin/app_process64.real"]) != 0:
-            self.call(["shell", "mv", "/system/bin/app_process64", "/system/bin/app_process64.real"])
-            self.call(["shell", "chcon", ctx, "/system/bin/app_process64.real"])
-        # TODO: should we force overwrite here?
-        self.install_file(asan_rt, "/system/lib", "644")
-        self.install_file(asan_rt64, "/system/lib64", "644")
-        # create sanitizer logging directory
-        sanitizer_logs = os.path.dirname(self.SANITIZER_LOG_PREFIX)
-        self.call(["shell", "mkdir", "-p", sanitizer_logs])
-        self.call(["shell", "chmod", "666", sanitizer_logs])
-        # set default ASAN_OPTIONS
-        options = [
-            "abort_on_error=0",  # avoid tombstones
-            "alloc_dealloc_mismatch=0",  # here until ASAN_OPTIONS set in mozglue are set properly
-            "allocator_may_return_null=1",  # here until ASAN_OPTIONS set in mozglue are set properly
-            "allow_user_segv_handler=1",  # here until ASAN_OPTIONS set in mozglue are set properly
-            "detect_leaks=0",  # here until ASAN_OPTIONS set in mozglue are set properly
-            "fast_unwind_on_check=1",
-            "fast_unwind_on_fatal=1",
-            "handle_sigill=1",  # here until ASAN_OPTIONS set in mozglue are set properly
-            #"log_path='%s'" % (self.SANITIZER_LOG_PREFIX,),
-            "use_sigaltstack=1",
-            "start_deactivated=1"]
-        if extra_options:
-            options += [opt for opt in extra_options.split(":") if opt]
-        # create and install app_process wrappers
-        tmpd = tempfile.mkdtemp()
-        try:
-            fname = os.path.join(tmpd, "app_process32")
-            with open(fname, "w") as out_fp:
-                out_fp.write("#!/system/bin/sh\n")
-                out_fp.write("ASAN_OPTIONS=%s \\\n" % (":".join(options),))
-                #out_fp.write("ASAN_ACTIVATION_OPTIONS=include_if_exists=/sdcard/asan.options \\\n")
-                out_fp.write("LD_PRELOAD=/system/lib/libclang_rt.asan-i686-android.so \\\n")
-                out_fp.write("exec /system/bin/app_process32.real \"$@\"\n")
-            self.install_file(fname, "/system/bin", "755", ctx)
-            fname = os.path.join(tmpd, "app_process64")
-            with open(fname, "w") as out_fp:
-                out_fp.write("#!/system/bin/sh\n")
-                out_fp.write("ASAN_OPTIONS=%s \\\n" % (":".join(options),))
-                #out_fp.write("ASAN_ACTIVATION_OPTIONS=include_if_exists=/sdcard/asan.option \\\n")
-                out_fp.write("LD_PRELOAD=/system/lib64/libclang_rt.asan-x86_64-android.so \\\n")
-                out_fp.write("exec /system/bin/app_process64.real \"$@\"\n")
-            self.install_file(fname, "/system/bin", "755", ctx)
-            fname = os.path.join(tmpd, "asanwrapper32")
-            with open(fname, "w") as out_fp:
-                out_fp.write("#!/system/bin/sh\n")
-                out_fp.write("LD_PRELOAD=/system/lib/libclang_rt.asan-i686-android.so \\\n")
-                out_fp.write("exec \"$@\"\n")
-            self.install_file(fname, "/system/bin", "755")
-            fname = os.path.join(tmpd, "asanwrapper64")
-            with open(fname, "w") as out_fp:
-                out_fp.write("#!/system/bin/sh\n")
-                out_fp.write("LD_PRELOAD=/system/lib64/libclang_rt.asan-x86_64-android.so \\\n")
-                out_fp.write("exec \"$@\"\n")
-            self.install_file(fname, "/system/bin", "755")
-        finally:
-            shutil.rmtree(tmpd, ignore_errors=True)
-        # install llvm-symbolizer
-        llvm_symer = os.path.join(
-            ndk_path, "prebuilt", "android-x86_64", "llvm-symbolizer", "llvm-symbolizer")
-        self.install_file(llvm_symer, "/system/bin", "755", ctx)
-        # restart zygote process
-        self.call(["shell", "stop"])
-        self.call(["shell", "start"])
-        # put the device in a known state
-        self.call(["reconnect"])
-        self.wait_for_boot()
-
     def install_file(self, src, dst, mode=None, context=None):
         """Install file on the device filesystem and set permissions.
 
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index 6fd87d40..1d5d4120 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -28,8 +28,6 @@ def main(argv=None):  # pylint: disable=missing-docstring
         help="Enable(1) or disable(0) airplane mode")
     parser.add_argument(
         "--install", help="Path to APK to install")
-    parser.add_argument(
-        "--install-asan", help="Path to NDK")
     parser.add_argument(
         "--launch", help="Path to APK to launch")
     parser.add_argument(
@@ -45,7 +43,7 @@ def main(argv=None):  # pylint: disable=missing-docstring
     parser.add_argument(
         "--prep", help="Prepare the device for fuzzing. Path to APK")
     args = parser.parse_args(argv)
-    if not any((args.airplane_mode is not None, args.install, args.install_asan, args.launch, args.prep)):
+    if not any((args.airplane_mode is not None, args.install, args.launch, args.prep)):
         parser.error("No options selected")
         return 1
 
@@ -72,9 +70,6 @@ def main(argv=None):  # pylint: disable=missing-docstring
                 log.info("Disabling airplane mode...")
             session.airplane_mode = bool(args.airplane_mode)
             log.info("Done.")
-        if args.install_asan is not None:
-            log.info("Installing ASan from %r ...", args.install_asan)
-            session.install_asan(args.install_asan)
         if args.install is not None:
             pkg_name = ADBSession.get_package_name(args.install)
             if pkg_name is None:

From 0b81a4e3d8bceee09df3d2c57785b3ce6d4100e8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 12 Aug 2020 12:04:48 -0700
Subject: [PATCH 492/531] [adb] Add ADBSession.sanitizer_options()

---
 grizzly/target/adb_device/adb_session.py      | 22 +++++++++++++++++++
 grizzly/target/adb_device/device.py           |  1 +
 grizzly/target/adb_device/test_adb_session.py | 10 +++++++++
 3 files changed, 33 insertions(+)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 6301f0cb..71962d95 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -729,6 +729,28 @@ def reverse_remove(self, remote=None):
             cmd.append("--remove-all")
         return self.call(cmd)[0] == 0
 
+    def sanitizer_options(self, prefix, options):
+        """Set sanitizer options.
+
+        Args:
+            prefix (str): Prefix to use when setting "<prefix>_OPTIONS".
+            options (dict): Option/values to set.
+
+        Returns:
+            None
+        """
+        prefix = prefix.lower()
+        assert prefix == "asan", "only ASan is supported atm"
+        tfd, optfile = tempfile.mkstemp(prefix="sanopts_")
+        os.close(tfd)
+        try:
+            with open(optfile, "w+") as ofp:
+                for opt, value in options.items():
+                    ofp.write("%s=%s\n" % (opt, value))
+            self.install_file(optfile, "/data/local/tmp/%s.options.gecko" % prefix, mode="666")
+        finally:
+            os.unlink(optfile)
+
     def set_enforce(self, value):
         """Set SELinux mode.
 
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index 1d5d4120..0665bc8e 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -63,6 +63,7 @@ def main(argv=None):  # pylint: disable=missing-docstring
             log.info("Preparing device...")
             args.airplane_mode = 1
             args.install = args.prep
+            session.sanitizer_options("asan", {"abort_on_error":"0"})
         if args.airplane_mode is not None:
             if args.airplane_mode > 0:
                 log.info("Enabling airplane mode...")
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index ad235384..4affde0e 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -1094,3 +1094,13 @@ def test_adb_session_39():
     assert pinfo.name == "name"
     assert pinfo.pid == 1
     assert pinfo.ppid == 2
+
+def test_adb_session_40(mocker):
+    """test ADBSession.sanitizer_options()"""
+    def fake_install_file(src, dst, **_):
+        with open(src, "r") as ofp:
+            assert ofp.read() == "test=1\n"
+        assert dst == "/data/local/tmp/asan.options.gecko"
+    mocker.patch("grizzly.target.adb_device.ADBSession.install_file", side_effect=fake_install_file)
+    session = ADBSession()
+    session.sanitizer_options("asan", {"test":"1"})

From caca20497bf9828536dc7363363043897dbce1a3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 12 Aug 2020 12:24:33 -0700
Subject: [PATCH 493/531] [adb] Fix call to install_file()

---
 grizzly/target/adb_device/adb_session.py      | 8 ++++----
 grizzly/target/adb_device/test_adb_session.py | 3 ++-
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 71962d95..32dbee2c 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -741,15 +741,15 @@ def sanitizer_options(self, prefix, options):
         """
         prefix = prefix.lower()
         assert prefix == "asan", "only ASan is supported atm"
-        tfd, optfile = tempfile.mkstemp(prefix="sanopts_")
-        os.close(tfd)
+        working_path = tempfile.mkdtemp(prefix="sanopts_")
         try:
+            optfile = os.path.join(working_path, "%s.options.gecko" % prefix)
             with open(optfile, "w+") as ofp:
                 for opt, value in options.items():
                     ofp.write("%s=%s\n" % (opt, value))
-            self.install_file(optfile, "/data/local/tmp/%s.options.gecko" % prefix, mode="666")
+            self.install_file(optfile, "/data/local/tmp/", mode="666")
         finally:
-            os.unlink(optfile)
+            shutil.rmtree(working_path, ignore_errors=True)
 
     def set_enforce(self, value):
         """Set SELinux mode.
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 4affde0e..aca9ed23 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -1098,9 +1098,10 @@ def test_adb_session_39():
 def test_adb_session_40(mocker):
     """test ADBSession.sanitizer_options()"""
     def fake_install_file(src, dst, **_):
+        assert os.path.basename(src) == "asan.options.gecko"
         with open(src, "r") as ofp:
             assert ofp.read() == "test=1\n"
-        assert dst == "/data/local/tmp/asan.options.gecko"
+        assert dst == "/data/local/tmp/"
     mocker.patch("grizzly.target.adb_device.ADBSession.install_file", side_effect=fake_install_file)
     session = ADBSession()
     session.sanitizer_options("asan", {"test":"1"})

From bb6e87f33b8913c3e3c514199f5f0b1dc01be847 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 12 Aug 2020 16:17:32 -0700
Subject: [PATCH 494/531] [adb] Update handling sanitizer logs

---
 grizzly/target/adb_device/adb_process.py      | 22 ++++++++++---------
 grizzly/target/adb_device/adb_session.py      |  6 +++--
 grizzly/target/adb_device/device.py           |  5 ++++-
 grizzly/target/adb_device/test_adb_process.py | 21 ++++++++++++------
 grizzly/target/adb_device/test_adb_session.py |  5 +++--
 5 files changed, 37 insertions(+), 22 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index d2ea8f5f..e69bb95f 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -104,13 +104,16 @@ def close(self):
 
     def find_crashreports(self):
         reports = list()
-        # TODO: scan for ASan logs once ASAN_OPTIONS=log_path is working
-        if self.profile:
+        # look for logs from sanitizers
+        san_path = os.path.dirname(self._session.SANITIZER_LOG_PREFIX)
+        for fname in self._session.listdir(san_path):
+            reports.append(os.path.join(san_path, fname))
+
+        if not reports and self.profile:
             # check for minidumps
             md_path = os.path.join(self.profile, "minidumps")
             try:
-                contents = self._session.listdir(md_path)
-                for fname in contents:
+                for fname in self._session.listdir(md_path):
                     if ".dmp" in fname or ".extra" in fname:
                         reports.append(os.path.join(md_path, fname))
             except IOError:
@@ -144,10 +147,6 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
 
         self._session.clear_logs()
         self._remove_logs()
-        sanitizer_logs = os.path.dirname(self._session.SANITIZER_LOG_PREFIX)
-        self._session.call(["shell", "rm", "-r", sanitizer_logs])
-        self._session.call(["shell", "mkdir", "-p", sanitizer_logs])
-        self._session.call(["shell", "chmod", "666", sanitizer_logs])
         self.reason = None
 
         # setup bootstrapper and reverse port
@@ -168,8 +167,7 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
                 prefs = {
                     "capability.policy.policynames": "'localfilelinks'",
                     "capability.policy.localfilelinks.sites": "'%s'" % bootstrapper.location,
-                    "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'",
-                    "network.http.speculative-parallel-limit": "0"}
+                    "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'"}
                 append_prefs(profile, prefs)
                 self.profile = "/".join([self._working_path, os.path.basename(profile)])
                 if not self._session.push(profile, self.profile):
@@ -243,6 +241,10 @@ def _process_logs(self, crash_reports):
             logger.clean_up()
 
     def _remove_logs(self):
+        sanitizer_logs = os.path.dirname(self._session.SANITIZER_LOG_PREFIX)
+        self._session.call(["shell", "rm", "-r", sanitizer_logs])
+        self._session.call(["shell", "mkdir", "-p", sanitizer_logs])
+        self._session.call(["shell", "chmod", "666", sanitizer_logs])
         if self.logs is not None and os.path.isdir(self.logs):
             shutil.rmtree(self.logs)
             self.logs = None
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 32dbee2c..4bc42cba 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -500,6 +500,9 @@ def install(self, apk_path):
             raise ADBSessionError("Could not find APK package name")
         if self.call(["install", "-g", "-r", apk_path], timeout=120)[0] != 0:
             raise ADBSessionError("Failed to install %r" % (apk_path,))
+        # set permissions
+        self.call(["shell", "pm", "grant", pkg_name, "android.permission.READ_EXTERNAL_STORAGE"])
+        self.call(["shell", "pm", "grant", pkg_name, "android.permission.WRITE_EXTERNAL_STORAGE"])
         log.debug("installed package %r (%r)", pkg_name, apk_path)
         return pkg_name
 
@@ -745,8 +748,7 @@ def sanitizer_options(self, prefix, options):
         try:
             optfile = os.path.join(working_path, "%s.options.gecko" % prefix)
             with open(optfile, "w+") as ofp:
-                for opt, value in options.items():
-                    ofp.write("%s=%s\n" % (opt, value))
+                ofp.write(":".join(["%s=%s" % opt for opt in options.items()]))
             self.install_file(optfile, "/data/local/tmp/", mode="666")
         finally:
             shutil.rmtree(working_path, ignore_errors=True)
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index 0665bc8e..83d41f86 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -63,7 +63,10 @@ def main(argv=None):  # pylint: disable=missing-docstring
             log.info("Preparing device...")
             args.airplane_mode = 1
             args.install = args.prep
-            session.sanitizer_options("asan", {"abort_on_error":"0"})
+            asan_opts = {
+                "abort_on_error": "0",
+                "log_path": "'%s'" % session.SANITIZER_LOG_PREFIX}
+            session.sanitizer_options("asan", asan_opts)
         if args.airplane_mode is not None:
             if args.airplane_mode > 0:
                 log.info("Enabling airplane mode...")
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 5acfd0cc..10713f9d 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -10,7 +10,7 @@
 def test_adb_process_01(mocker):
     """test creating a simple device"""
     test_pkg = "org.test.preinstalled"
-    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session = mocker.Mock(spec=ADBSession, SANITIZER_LOG_PREFIX="/fake/log.txt")
     with ADBProcess(test_pkg, fake_session) as proc:
         assert isinstance(proc._session, ADBSession)
         assert proc._package == test_pkg
@@ -31,6 +31,7 @@ def test_adb_process_02(mocker):
 def test_adb_process_03(mocker):
     """test ADBProcess.launch() package is running (bad state)"""
     fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.get_pid.return_value = 1337
     with ADBProcess("org.some.app", fake_session) as proc:
         assert not proc.is_running()
@@ -118,22 +119,27 @@ def test_adb_process_08(mocker):
     """test ADBProcess.find_crashreports()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
         proc.profile = "profile_path"
-        # no dump files
-        fake_session.listdir.return_value = ("somefile.txt")
+        # no log or minidump files
+        fake_session.listdir.return_value = []
         assert not proc.find_crashreports()
-        # contains dump file
-        fake_session.listdir.return_value = ("somefile.txt", "test.dmp")
-        assert proc.find_crashreports()
+        # sanitizer logs
+        fake_session.listdir.side_effect = (["asan.log"], AssertionError())
+        assert any(x.endswith("asan.log") for x in proc.find_crashreports())
+        # contains minidump file
+        fake_session.listdir.side_effect = ([], ["somefile.txt", "test.dmp"])
+        assert any(x.endswith("test.dmp") for x in proc.find_crashreports())
         # contains missing path
-        fake_session.listdir.side_effect = IOError("test")
+        fake_session.listdir.side_effect = ([], IOError("test"))
         assert not proc.find_crashreports()
 
 def test_adb_process_09(mocker, tmp_path):
     """test ADBProcess.save_logs()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     log_path = tmp_path / "src"
     log_path.mkdir()
     (log_path / "nested").mkdir()
@@ -154,6 +160,7 @@ def test_adb_process_10(mocker):
     mocker.patch("grizzly.target.adb_device.adb_process.PuppetLogger", autospec=True)
     fake_proc_md = mocker.patch("grizzly.target.adb_device.adb_process.process_minidumps", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.collect_logs.return_value = b"fake logcat data"
     with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
         # no extra logs
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index aca9ed23..b08052db 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -1097,11 +1097,12 @@ def test_adb_session_39():
 
 def test_adb_session_40(mocker):
     """test ADBSession.sanitizer_options()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_install_file(src, dst, **_):
         assert os.path.basename(src) == "asan.options.gecko"
         with open(src, "r") as ofp:
-            assert ofp.read() == "test=1\n"
+            assert ofp.read() == "a=1:b=2"
         assert dst == "/data/local/tmp/"
     mocker.patch("grizzly.target.adb_device.ADBSession.install_file", side_effect=fake_install_file)
     session = ADBSession()
-    session.sanitizer_options("asan", {"test":"1"})
+    session.sanitizer_options("asan", {"a":"1", "b":"2"})

From 8c9654bd47df0239efc7e6829a63821cdd5f1f36 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 14 Aug 2020 15:30:14 -0700
Subject: [PATCH 495/531] [adb] Add support for geckoview-config.yaml

---
 grizzly/target/adb_device/adb_process.py      | 94 +++++++++++--------
 grizzly/target/adb_device/adb_session.py      |  1 -
 grizzly/target/adb_device/device.py           |  1 +
 grizzly/target/adb_device/test_adb_process.py | 84 ++++++++++++-----
 setup.cfg                                     |  1 +
 5 files changed, 117 insertions(+), 64 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index e69bb95f..170a9d3f 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -2,15 +2,17 @@
 import os
 import random
 import re
-import shutil
-import tempfile
-import time
+from shutil import copy, rmtree
+from time import sleep, time
+from tempfile import mkdtemp
+from yaml import safe_dump
 
 from ffpuppet.bootstrapper import Bootstrapper
 from ffpuppet.helpers import append_prefs, create_profile
 from ffpuppet.minidump_parser import process_minidumps
 from ffpuppet.puppet_logger import PuppetLogger
 
+from grizzly.common.utils import grz_tmp
 from .adb_session import ADBSession, ADBSessionError
 
 log = logging.getLogger("adb_process")  # pylint: disable=invalid-name
@@ -37,13 +39,13 @@ class ADBProcess(object):
     def __init__(self, package_name, session, use_profile=None):
         assert isinstance(session, ADBSession), "Expecting ADBSession"
         if not session.is_installed(package_name):
-            raise ADBSessionError("Package %r not installed" % package_name)
+            raise ADBSessionError("Package %r is not installed" % (package_name,))
         self._launches = 0  # number of successful browser launches
         self._package = package_name  # package to use as target process
         self._pid = None  # pid of current target process
         self._profile_template = use_profile  # profile that is used as a template
         self._session = session  # ADB session with device
-        self._working_path = "/sdcard/ADBProc_%08X" % random.getrandbits(32)
+        self._working_path = "/sdcard/ADBProc_%08X" % (random.getrandbits(32),)
         self.logs = None
         self.profile = None  # profile path on device
         self.reason = self.RC_CLOSED
@@ -141,9 +143,16 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
         assert self._pid is None, "Process is already running"
         assert self.reason is not None, "Process is already running"
 
+        if ".fenix" in self._package:
+            app = "/".join([self._package, "org.mozilla.fenix.IntentReceiverActivity"])
+        elif ".geckoview_example" in self._package:
+            app = "/".join([self._package, "org.mozilla.geckoview_example.GeckoViewActivity"])
+        else:
+            raise ADBLaunchError("Unsupported package %r" % (self._package,))
+
         # check app is not previously running
         if self._session.get_pid(self._package) is not None:
-            raise ADBLaunchError("%r is already running" % self._package)
+            raise ADBLaunchError("%r is already running" % (self._package,))
 
         self._session.clear_logs()
         self._remove_logs()
@@ -156,45 +165,50 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
             if not self._session.reverse(bootstrapper.port, bootstrapper.port):
                 bootstrapper.close()
                 log.debug("failed to reverse port, retrying...")
-                time.sleep(0.25)
+                sleep(0.25)
                 continue
             break
         else:
             raise ADBLaunchError("Could not reverse port")
+        profile = None
         try:
             profile = create_profile(extension=extension, prefs_js=prefs_js, template=self._profile_template)
-            try:
-                prefs = {
-                    "capability.policy.policynames": "'localfilelinks'",
-                    "capability.policy.localfilelinks.sites": "'%s'" % bootstrapper.location,
-                    "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'"}
-                append_prefs(profile, prefs)
-                self.profile = "/".join([self._working_path, os.path.basename(profile)])
-                if not self._session.push(profile, self.profile):
-                    raise ADBLaunchError("Could not upload profile %r" % profile)
-            finally:
-                shutil.rmtree(profile, True)
-            #"/".join([self._package, "org.mozilla.fenix.IntentReceiverActivity"]),
-            cmd = [
-                "shell", "am", "start", "-W", "-n",
-                "/".join([self._package, "org.mozilla.geckoview_example.GeckoViewActivity"]),
-                "-a", "android.intent.action.VIEW", "-d", bootstrapper.location,
-                "--es", "args", "-profile\\ %s" % self.profile]
-            # add environment variables to launch command
+            self.profile = "/".join([self._working_path, os.path.basename(profile)])
+            # add environment variables
             env_mod = dict(env_mod or {})
             env_mod.setdefault("MOZ_SKIA_DISABLE_ASSERTS", "1")
-            for var_num, (var_name, var_val) in enumerate(env_mod.items()):
-                if var_val is None:
-                    continue
-                cmd.append("--es")
-                cmd.append("env%d" % var_num)
-                cmd.append("%s=%s" % (var_name, var_val))
-
+            # build *-geckoview-config.yaml (https://firefox-source-docs.mozilla.org/ ...
+            #   mobile/android/geckoview/consumer/automation.html#configuration-file-format)
+            cfg_file = "%s-geckoview-config.yaml" % (self._package,)
+            local_cfg = os.path.join(profile, cfg_file)
+            with open(local_cfg, "w") as cfp:
+                cfp.write(safe_dump({
+                    "args": [
+                        "--profile",
+                        self.profile
+                    ],
+                    "env": env_mod
+                }))
+            if not self._session.push(local_cfg, "/data/local/tmp/%s" % (cfg_file,)):
+                raise ADBLaunchError("Could not upload %r" % (cfg_file,))
+            # add additional prefs
+            prefs = {
+                "capability.policy.policynames": "'localfilelinks'",
+                "capability.policy.localfilelinks.sites": "'%s'" % (bootstrapper.location,),
+                "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'"}
+            append_prefs(profile, prefs)
+            if not self._session.push(profile, self.profile):
+                raise ADBLaunchError("Could not upload profile %r" % (profile,))
+            cmd = [
+                "shell", "am", "start", "-W", "-n", app,
+                "-a", "android.intent.action.VIEW", "-d", bootstrapper.location]
             if "Status: ok" not in self._session.call(cmd, timeout=launch_timeout)[1].splitlines():
-                raise ADBLaunchError("Could not launch %r" % self._package)
+                raise ADBLaunchError("Could not launch %r" % (self._package,))
             self._pid = self._session.get_pid(self._package)
             bootstrapper.wait(self.is_healthy, url=url)
         finally:
+            if profile is not None:
+                rmtree(profile, ignore_errors=True)
             self._session.reverse_remove(bootstrapper.port)
             bootstrapper.close()
         self._launches += 1
@@ -215,7 +229,7 @@ def launches(self):
 
     def _process_logs(self, crash_reports):
         assert self.logs is None
-        self.logs = tempfile.mkdtemp(prefix="adb_logs_")
+        self.logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
         unprocessed = os.path.join(self.logs, "unprocessed")
         os.mkdir(unprocessed)
 
@@ -246,7 +260,7 @@ def _remove_logs(self):
         self._session.call(["shell", "mkdir", "-p", sanitizer_logs])
         self._session.call(["shell", "chmod", "666", sanitizer_logs])
         if self.logs is not None and os.path.isdir(self.logs):
-            shutil.rmtree(self.logs)
+            rmtree(self.logs)
             self.logs = None
 
     @staticmethod
@@ -344,13 +358,13 @@ def save_logs(self, log_path, meta=False):
             # skip directories
             if not os.path.isfile(full_name):
                 continue
-            shutil.copy(full_name, log_path)
+            copy(full_name, log_path)
 
     def wait_on_files(self, wait_files, poll_rate=0.5, timeout=60):
         assert poll_rate >= 0, "Invalid poll_rate %d, must be greater than or equal to 0" % poll_rate
         assert timeout >= 0, "Invalid timeout %d, must be greater than or equal to 0" % timeout
         assert poll_rate <= timeout, "poll_rate must be less then or equal to timeout"
-        wait_end = time.time() + timeout
+        wait_end = time() + timeout
         wait_files = set(self._session.realpath(x) for x in wait_files)
 
         while wait_files:
@@ -358,10 +372,10 @@ def wait_on_files(self, wait_files, poll_rate=0.5, timeout=60):
             # check if any open files are in the wait file list
             if not wait_files.intersection(open_files):
                 break
-            elif wait_end <= time.time():
+            if wait_end <= time():
                 log.debug("Timeout waiting for: %s", ", ".join(x for x in open_files if x in wait_files))
                 return False
-            time.sleep(poll_rate)
+            sleep(poll_rate)
         return True
 
     def _terminate(self):
@@ -372,4 +386,4 @@ def _terminate(self):
 
     def wait(self):
         while self.is_running():
-            time.sleep(0.25)
+            sleep(0.25)
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 4bc42cba..1ace6e99 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -3,7 +3,6 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from collections import namedtuple
-import glob
 import logging
 import os
 import shutil
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index 83d41f86..b36ed2d0 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -86,6 +86,7 @@ def main(argv=None):  # pylint: disable=missing-docstring
             if not package:
                 log.error("Could not install %s", args.install)
                 return 1
+            session.call(["shell", "am", "set-debug-app", "--persistent", package])
             log.info("Installed %s.", package)
         if args.launch:
             pkg_name = ADBSession.get_package_name(args.launch)
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 10713f9d..0812c23e 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -1,6 +1,7 @@
 # pylint: disable=protected-access
 import os
 import shutil
+from yaml import safe_load
 
 import pytest
 
@@ -24,37 +25,72 @@ def test_adb_process_01(mocker):
 def test_adb_process_02(mocker):
     """test creating device with unknown package"""
     fake_session = mocker.Mock(spec=ADBSession)
-    fake_session.is_installed.side_effect = ADBSessionError("blah")
-    with pytest.raises(ADBSessionError):
+    fake_session.is_installed.return_value = False
+    with pytest.raises(ADBSessionError, match="Package 'org.test.unknown' is not installed"):
         ADBProcess("org.test.unknown", fake_session)
 
 def test_adb_process_03(mocker):
-    """test ADBProcess.launch() package is running (bad state)"""
+    """test ADBProcess.launch() unsupported app"""
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
-    fake_session.get_pid.return_value = 1337
     with ADBProcess("org.some.app", fake_session) as proc:
-        assert not proc.is_running()
-        with pytest.raises(ADBLaunchError, match="'org.some.app' is already running"):
+        with pytest.raises(ADBLaunchError, match="Unsupported package 'org.some.app'"):
             proc.launch("fake.url")
 
 def test_adb_process_04(mocker):
-    """test failed ADBProcess.launch() and ADBProcess.is_running()"""
+    """test ADBProcess.launch() failed bootstrap setup"""
+    mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
+    mocker.patch("grizzly.target.adb_device.adb_process.sleep", autospec=True)
+    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
+    fake_session.collect_logs.return_value = b""
+    fake_session.listdir.return_value = ()
+    fake_session.get_pid.return_value = None
+    fake_session.reverse.return_value = False
+    with ADBProcess("org.mozilla.fenix", fake_session) as proc:
+        with pytest.raises(ADBLaunchError, match="Could not reverse port"):
+            proc.launch("fake.url")
+
+def test_adb_process_05(mocker):
+    """test ADBProcess.launch() package is running (bad state)"""
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (1, "")
     fake_session.collect_logs.return_value = b""
     fake_session.listdir.return_value = ()
     fake_session.process_exists.return_value = False
-    with ADBProcess("org.test.unknown", fake_session) as proc:
-        assert not proc.is_running()
-        with pytest.raises(ADBLaunchError):
+    with ADBProcess("org.mozilla.fenix", fake_session) as proc:
+        with pytest.raises(ADBLaunchError, match="'org.mozilla.fenix' is already running"):
             proc.launch("fake.url")
         assert not proc.is_running()
         proc.cleanup()
         assert proc.logs is None
 
-def test_adb_process_05(mocker):
+def test_adb_process_06(mocker, tmp_path):
+    """test ADBProcess.launch() check *-geckoview-config.yaml"""
+    mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
+    mocker.patch("grizzly.target.adb_device.adb_process.ADBProcess._remove_logs", autospec=True)
+    mocker.patch("grizzly.target.adb_device.adb_process.create_profile", return_value=str(tmp_path))
+    mocker.patch("grizzly.target.adb_device.adb_process.rmtree", autospec=True)
+    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
+    fake_session.call.return_value = (0, "Status: ok")
+    fake_session.collect_logs.return_value = b""
+    fake_session.get_pid.return_value = None
+    fake_session.listdir.return_value = ()
+    with ADBProcess("org.mozilla.fenix", fake_session) as proc:
+        proc.launch("fake.url", env_mod={"TEST_ENV": "123"})
+        cfg_file = tuple(tmp_path.glob("*-geckoview-config.yaml"))[0]
+        assert cfg_file
+        assert cfg_file.name == "%s-geckoview-config.yaml" % (proc._package,)
+        cfg_data = safe_load(cfg_file.read_text())
+        assert "args" in cfg_data
+        assert cfg_data["args"][0] == "--profile"
+        assert cfg_data["args"][1] == "%s/%s" % (proc._working_path, tmp_path.name)
+        assert "env" in cfg_data
+        assert cfg_data["env"]["TEST_ENV"] == "123"
+
+def test_adb_process_07(mocker):
     """test ADBProcess.launch(), ADBProcess.is_running() and ADBProcess.is_healthy()"""
     fake_bs = mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_bs.return_value.location.return_value = "http://localhost"
@@ -66,7 +102,7 @@ def test_adb_process_05(mocker):
     fake_session.get_pid.side_effect = (None, 1337)
     fake_session.listdir.return_value = ()
     #fake_session.process_exists.return_value = False
-    with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
+    with ADBProcess("org.mozilla.geckoview_example", fake_session) as proc:
         assert not proc.is_running()
         assert proc.launches == 0
         assert proc.launch("fake.url")
@@ -79,7 +115,7 @@ def test_adb_process_05(mocker):
     assert fake_bs.return_value.wait.call_count == 1
     assert fake_bs.return_value.close.call_count == 1
 
-def test_adb_process_06(mocker):
+def test_adb_process_08(mocker):
     """test ADBProcess.launch() with environment variables"""
     fake_bs = mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_bs.return_value.location.return_value = "http://localhost"
@@ -91,12 +127,12 @@ def test_adb_process_06(mocker):
     fake_session.get_pid.side_effect = (None, 1337)
     fake_session.listdir.return_value = ()
     env = {"test1":"1", "test2": "2"}
-    with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
+    with ADBProcess("org.mozilla.geckoview_example", fake_session) as proc:
         assert proc.launch("fake.url", env_mod=env)
         assert proc.is_running()
         proc.close()
 
-def test_adb_process_07(mocker):
+def test_adb_process_09(mocker):
     """test ADBProcess.wait_on_files()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
@@ -107,20 +143,22 @@ def test_adb_process_07(mocker):
     fake_session.open_files.return_value = ((1, "some_file"),)
     fake_session.listdir.return_value = ()
     fake_session.realpath.side_effect = str.strip
-    with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
+    with ADBProcess("org.mozilla.geckoview_example", fake_session) as proc:
         proc.wait_on_files(["not_running"])
         assert proc.launch("fake.url")
         assert proc.wait_on_files([])
+        mocker.patch("grizzly.target.adb_device.adb_process.sleep", autospec=True)
+        mocker.patch("grizzly.target.adb_device.adb_process.time", side_effect=(1, 1, 2))
         fake_session.open_files.return_value = ((1, "some_file"), (1, "/existing/file.txt"))
         assert not proc.wait_on_files(["/existing/file.txt"], poll_rate=0.1, timeout=0.3)
         proc.close()
 
-def test_adb_process_08(mocker):
+def test_adb_process_10(mocker):
     """test ADBProcess.find_crashreports()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
-    with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
+    with ADBProcess("org.some.app", fake_session) as proc:
         proc.profile = "profile_path"
         # no log or minidump files
         fake_session.listdir.return_value = []
@@ -135,7 +173,7 @@ def test_adb_process_08(mocker):
         fake_session.listdir.side_effect = ([], IOError("test"))
         assert not proc.find_crashreports()
 
-def test_adb_process_09(mocker, tmp_path):
+def test_adb_process_11(mocker, tmp_path):
     """test ADBProcess.save_logs()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec=ADBSession)
@@ -146,7 +184,7 @@ def test_adb_process_09(mocker, tmp_path):
     fake_log = log_path / "fake.txt"
     fake_log.touch()
     dmp_path = tmp_path / "dst"
-    with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
+    with ADBProcess("org.some.app", fake_session) as proc:
         # without proc.logs set
         proc.save_logs(str(dmp_path))
         # with proc.logs set
@@ -154,7 +192,7 @@ def test_adb_process_09(mocker, tmp_path):
         proc.save_logs(str(dmp_path))
     assert "fake.txt" in os.listdir(str(dmp_path))
 
-def test_adb_process_10(mocker):
+def test_adb_process_12(mocker):
     """test ADBProcess._process_logs()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     mocker.patch("grizzly.target.adb_device.adb_process.PuppetLogger", autospec=True)
@@ -162,7 +200,7 @@ def test_adb_process_10(mocker):
     fake_session = mocker.Mock(spec=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.collect_logs.return_value = b"fake logcat data"
-    with ADBProcess("org.mozilla.fennec_aurora", fake_session) as proc:
+    with ADBProcess("org.some.app", fake_session) as proc:
         # no extra logs
         proc._process_logs([])
         assert os.path.isdir(proc.logs)
@@ -183,7 +221,7 @@ def test_adb_process_10(mocker):
         assert fake_proc_md.call_count == 1
         assert fake_session.pull.call_count == 2
 
-def test_adb_process_11(tmp_path):
+def test_adb_process_13(tmp_path):
     """test ADBProcess._split_logcat()"""
     log_path = tmp_path / "logs"
     log_path.mkdir()
diff --git a/setup.cfg b/setup.cfg
index b5a60c9c..3e0956b7 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -28,6 +28,7 @@ install_requires =
     lithium-reducer >= 0.5.3
     prefpicker >= 1.1.0
     psutil >= 4.4.0
+    pyyaml
 packages =
     grizzly
     grizzly.adapter

From 258142f8a9b488fb6abf7d539974c6c6f22dd492 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 14 Aug 2020 16:17:33 -0700
Subject: [PATCH 496/531] [tests] Fix and speedup ADBSession tests

---
 grizzly/target/adb_device/adb_session.py      | 52 ++++++++++---------
 grizzly/target/adb_device/test_adb_session.py | 39 ++++++++------
 2 files changed, 51 insertions(+), 40 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 1ace6e99..c853e035 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -5,11 +5,13 @@
 from collections import namedtuple
 import logging
 import os
-import shutil
+from shutil import rmtree
 import socket
-import subprocess
-import tempfile
-import time
+from subprocess import call, CalledProcessError, check_output, Popen
+from tempfile import mkdtemp, TemporaryFile
+from time import sleep, time
+
+from grizzly.common.utils import grz_tmp
 
 log = logging.getLogger("adb_session")  # pylint: disable=invalid-name
 
@@ -73,8 +75,8 @@ def _aapt_check(cls):
             log.debug("using recommended aapt from %r", aapt_bin)
             return aapt_bin
         try:
-            aapt_bin = subprocess.check_output(("which", "aapt"))
-        except subprocess.CalledProcessError:
+            aapt_bin = check_output(("which", "aapt"))
+        except CalledProcessError:
             raise EnvironmentError("Please install AAPT")
         aapt_bin = aapt_bin.strip().decode("utf-8", errors="ignore")
         # TODO: update this to check aapt version
@@ -97,15 +99,15 @@ def _adb_check(cls):
             log.debug("using recommended adb from %r", adb_bin)
             return adb_bin
         try:
-            adb_bin = subprocess.check_output(("which", "adb"))
-        except subprocess.CalledProcessError:
+            adb_bin = check_output(("which", "adb"))
+        except CalledProcessError:
             raise EnvironmentError("Please install ADB")
         adb_bin = adb_bin.strip().decode("utf-8", errors="ignore")
         # TODO: update this to check adb version
         log.warning("Using adb from %r", adb_bin)
         log.warning("You are not using the recommended ADB install!")
         log.warning("Either run the setup script or proceed with caution.")
-        time.sleep(5)
+        sleep(5)
         return adb_bin
 
     @staticmethod
@@ -121,20 +123,20 @@ def _call_adb(cmd, timeout=None):
         Returns:
             tuple: Exit code and stderr, stdout of ADB call.
         """
-        with tempfile.TemporaryFile() as out_fp:
+        with TemporaryFile() as out_fp:
             if timeout is not None:
                 assert timeout > 0
-                end_time = time.time() + timeout
-                adb_proc = subprocess.Popen(cmd, stderr=out_fp, stdout=out_fp)
+                end_time = time() + timeout
+                adb_proc = Popen(cmd, stderr=out_fp, stdout=out_fp)
                 while adb_proc.poll() is None:
-                    time.sleep(0.05)
-                    if time.time() > end_time:
+                    sleep(0.05)
+                    if time() > end_time:
                         log.warning("adb call timeout!")
                         adb_proc.terminate()
                         break
                 ret_code = adb_proc.wait()
             else:
-                ret_code = subprocess.call(cmd, stderr=out_fp, stdout=out_fp)
+                ret_code = call(cmd, stderr=out_fp, stdout=out_fp)
             out_fp.seek(0)
             return ret_code, out_fp.read().decode("utf-8", "ignore").strip()
 
@@ -261,6 +263,7 @@ def collect_logs(self, pid=None):
         log.debug("collect_logs()")
         if not self.connected:
             log.debug("device not connected cannot collect logs")
+            # TODO: return None if disconnected?
             return ""
         cmd = ["logcat", "-d", "*:I"]
         if pid is not None:
@@ -295,11 +298,11 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                     log.debug("connecting to %s", addr)
                     if self.call(["connect", addr])[0] != 0:
                         log.warning("connection attempt #%d failed", attempt)
-                        time.sleep(retry_delay)
+                        sleep(retry_delay)
                         continue
                 elif not self.devices():
                     log.warning("No device detected (attempt %d/%d)", attempt, max_attempts)
-                    time.sleep(retry_delay)
+                    sleep(retry_delay)
                     continue
                 self.connected = True
             # verify we are connected
@@ -452,7 +455,7 @@ def get_package_name(cls, apk_path):
         if not os.path.isfile(apk_path):
             raise IOError("APK path must point to a file")
         aapt = cls._aapt_check()
-        apk_info = subprocess.check_output((aapt, "dump", "badging", apk_path))
+        apk_info = check_output((aapt, "dump", "badging", apk_path))
         for line in apk_info.splitlines():
             if line.startswith(b"package: name="):
                 return line.split()[1][5:].strip(b"'").decode("utf-8", errors="ignore")
@@ -743,14 +746,15 @@ def sanitizer_options(self, prefix, options):
         """
         prefix = prefix.lower()
         assert prefix == "asan", "only ASan is supported atm"
-        working_path = tempfile.mkdtemp(prefix="sanopts_")
+        working_path = mkdtemp(prefix="sanopts_", dir=grz_tmp())
         try:
             optfile = os.path.join(working_path, "%s.options.gecko" % prefix)
             with open(optfile, "w+") as ofp:
                 ofp.write(":".join(["%s=%s" % opt for opt in options.items()]))
+            # TODO: use push() instead?
             self.install_file(optfile, "/data/local/tmp/", mode="666")
         finally:
-            shutil.rmtree(working_path, ignore_errors=True)
+            rmtree(working_path, ignore_errors=True)
 
     def set_enforce(self, value):
         """Set SELinux mode.
@@ -802,7 +806,7 @@ def wait_for_boot(self, timeout=None):
         """
         if timeout is not None:
             assert isinstance(timeout, (int, float)) and timeout > 0
-            deadline = time.time() + timeout
+            deadline = time() + timeout
         else:
             deadline = None
         # first wait for the boot to complete then wait for the boot animation to complete
@@ -821,11 +825,11 @@ def wait_for_boot(self, timeout=None):
                 if attempts > 1:
                     # the device was booting so give it additional time
                     log.debug("device was boot was detected")
-                    time.sleep(5)
+                    sleep(5)
                 return True
-            if deadline and time.time() >= deadline:
+            if deadline and time() >= deadline:
                 log.debug("wait_for_boot() timeout %r exceeded", timeout)
                 break
             log.debug("waiting for device to boot")
-            time.sleep(0.5)
+            sleep(0.5)
         return False
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index b08052db..d8d0bb66 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -1,6 +1,6 @@
 # pylint: disable=protected-access
 import os
-import subprocess
+from subprocess import CalledProcessError
 import zipfile
 
 import pytest
@@ -14,7 +14,7 @@ def fake_call(cmd, stderr=None, stdout=None):
         stderr.write(b"")
         stdout.write(b"blah_out")
         return 0
-    mocker.patch("subprocess.call", side_effect=fake_call)
+    mocker.patch("grizzly.target.adb_device.adb_session.call", side_effect=fake_call)
     ret, output = ADBSession._call_adb(["test"])
     assert ret == 0
     assert "blah_out" in output
@@ -35,7 +35,9 @@ def terminate(self):
             self.stdout.write(b"terminate\n")
         def poll(self):
             self.stdout.write(b"poll\n")
-    mocker.patch("subprocess.Popen", new=FakeProc)
+    mocker.patch("grizzly.target.adb_device.adb_session.Popen", new=FakeProc)
+    mocker.patch("grizzly.target.adb_device.adb_session.sleep")
+    mocker.patch("grizzly.target.adb_device.adb_session.time", side_effect=(1, 1, 2))
     ret, output = ADBSession._call_adb(["test"], timeout=0.5)
     assert ret == 1
     assert "init" in output
@@ -52,11 +54,13 @@ def test_adb_session_02(mocker):
         session.call(["test"])
     # successful call
     session.connected = True
+    session._debug_adb = True
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", return_value=(0, "pass"))
     ret_code, output = session.call(["test"])
     assert ret_code == 0
     assert output == "pass"
     # invalid command
+    session._debug_adb = False
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", return_value=(1, "Android Debug Bridge version"))
     with pytest.raises(ADBCommandError, match="Invalid ADB command 'test'"):
         session.call(["test"])
@@ -290,7 +294,7 @@ def fake_adb_call(obj, cmd, timeout=None):
 
 def test_adb_session_09(mocker):
     """test ADBSession.connect() no devices available"""
-    mocker.patch("time.sleep")  # skip delay after warning message
+    mocker.patch("grizzly.target.adb_device.adb_session.sleep")  # skip delay after warning message
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
@@ -307,7 +311,7 @@ def fake_adb_call(cmd, timeout=None):
 
 def test_adb_session_10(mocker):
     """test ADBSession.connect() device in a bad state"""
-    mocker.patch("time.sleep")  # skip delays
+    mocker.patch("grizzly.target.adb_device.adb_session.sleep")  # skip delays
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
@@ -599,6 +603,9 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
     session = ADBSession("127.0.0.1")
+    # test not connected
+    assert session.collect_logs() == ""
+    # test connected
     session.connected = True
     assert len(session.collect_logs().splitlines()) == 11
     assert len(session.collect_logs(9990).splitlines()) == 7
@@ -789,43 +796,43 @@ def test_adb_session_27(mocker, tmp_path):
     """test ADBSession._aapt_check()"""
     # use system aapt
     mocker.patch("os.path.expanduser", return_value=b"/missing/aapt")
-    mocker.patch("subprocess.check_output", return_value=b"/fake_system/aapt")
+    mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"/fake_system/aapt")
     assert ADBSession._aapt_check() == "/fake_system/aapt"
     fake_aapt = tmp_path / "aapt"
     fake_aapt.touch()
     # use recommended aapt
     mocker.patch("os.path.expanduser", return_value=str(fake_aapt))
-    mocker.patch("subprocess.check_output", return_value=b"/fake_system/aapt")
+    mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"/fake_system/aapt")
     assert ADBSession._aapt_check() == str(fake_aapt)
     # aapt not installed
     mocker.patch("os.path.expanduser", return_value=b"/missing/aapt")
-    mocker.patch("subprocess.check_output", side_effect=subprocess.CalledProcessError(1, "test", "test"))
+    mocker.patch("grizzly.target.adb_device.adb_session.check_output", side_effect=CalledProcessError(1, "test", "test"))
     with pytest.raises(EnvironmentError, match=r"Please install AAPT"):
         assert ADBSession._aapt_check()
 
 def test_adb_session_28(mocker, tmp_path):
     """test ADBSession._adb_check()"""
-    mocker.patch("time.sleep")  # skip delay after warning message
+    mocker.patch("grizzly.target.adb_device.adb_session.sleep")  # skip delay after warning message
     # use system adb
     mocker.patch("os.path.expanduser", return_value=b"/missing/adb")
-    mocker.patch("subprocess.check_output", return_value=b"/fake_system/adb")
+    mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"/fake_system/adb")
     assert ADBSession._adb_check() == "/fake_system/adb"
     fake_adb = tmp_path / "adb"
     fake_adb.touch()
     # use recommended adb
     mocker.patch("os.path.expanduser", return_value=str(fake_adb))
-    mocker.patch("subprocess.check_output", return_value=b"/fake_system/adb")
+    mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"/fake_system/adb")
     assert ADBSession._adb_check() == str(fake_adb)
     # adb not installed
     mocker.patch("os.path.expanduser", return_value=b"/missing/adb")
-    mocker.patch("subprocess.check_output", side_effect=subprocess.CalledProcessError(1, "test", "test"))
+    mocker.patch("grizzly.target.adb_device.adb_session.check_output", side_effect=CalledProcessError(1, "test", "test"))
     with pytest.raises(EnvironmentError, match=r"Please install ADB"):
         assert ADBSession._adb_check()
 
 def test_adb_session_29(mocker, tmp_path):
     """test ADBSession.get_package_name()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._aapt_check", return_value="/fake/aapt")
-    mocker.patch("subprocess.check_output", return_value=b"")
+    mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"")
     with pytest.raises(IOError):
         ADBSession.get_package_name("/fake/path")
     fake_apk = tmp_path / "fake.apk"
@@ -862,7 +869,7 @@ def test_adb_session_29(mocker, tmp_path):
         b"locales: '--_--' 'ca' ' 'en-GB' 'zh-HK' 'zh-CN' 'en-IN' 'pt-BR' 'es-US' 'pt-PT' 'en-AU' 'zh-TW'",
         b"densities: '120' '160' '240' '320' '480' '640' '65534' '65535'",
         b"native-code: 'x86'")
-    mocker.patch("subprocess.check_output", return_value=b"\n".join(output))
+    mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"\n".join(output))
     assert ADBSession.get_package_name(str(fake_apk)) == "org.mozilla.fennec_aurora"
 
 def test_adb_session_30(mocker):
@@ -987,7 +994,7 @@ def test_adb_session_36(mocker):
     """test ADBSession.wait_for_boot()"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    fake_sleep = mocker.patch("time.sleep")
+    fake_sleep = mocker.patch("grizzly.target.adb_device.adb_session.sleep")
     # test timeout
     def fake_adb_01(_, cmd, timeout=None):
         if cmd[1] == "shell" and cmd[2] == "getprop":
@@ -1101,7 +1108,7 @@ def test_adb_session_40(mocker):
     def fake_install_file(src, dst, **_):
         assert os.path.basename(src) == "asan.options.gecko"
         with open(src, "r") as ofp:
-            assert ofp.read() == "a=1:b=2"
+            assert ofp.read() in ("a=1:b=2", "b=2:a=1")
         assert dst == "/data/local/tmp/"
     mocker.patch("grizzly.target.adb_device.ADBSession.install_file", side_effect=fake_install_file)
     session = ADBSession()

From be20960388818463e8d89c41c6bfc27b72cdb1e1 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 14 Aug 2020 16:42:23 -0700
Subject: [PATCH 497/531] [adb] Add __slots__ to ADBProcess and ADBSession

---
 grizzly/target/adb_device/adb_process.py      |  4 ++++
 grizzly/target/adb_device/adb_session.py      |  3 +++
 grizzly/target/adb_device/test_adb_session.py | 18 ++++++++++++------
 3 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index 170a9d3f..4d67cb29 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -36,6 +36,10 @@ class ADBProcess(object):
     #  def clone_log(self, log_id, offset=0):
     #  def log_data(self, log_id, offset=0):
     #  def log_length(self, log_id):... likely not going to happen because of overhead
+
+    __slots__ = ("_launches", "_package", "_pid", "_profile_template", "_session",
+                 "_working_path", "logs", "profile", "reason")
+
     def __init__(self, package_name, session, use_profile=None):
         assert isinstance(session, ADBSession), "Expecting ADBSession"
         if not session.is_installed(package_name):
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index c853e035..bdeb41db 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -36,6 +36,9 @@ class ADBSessionError(Exception):
 class ADBSession(object):
     SANITIZER_LOG_PREFIX = "/sdcard/sanitizer_logs/report.log"
 
+    __slots__ = ("_adb_bin", "_cpu_arch", "_debug_adb", "_ip_addr", "_os_version",
+                 "_os_version", "_port", "_root", "connected", "symbols")
+
     def __init__(self, ip_addr=None, port=5555):
         self._adb_bin = self._adb_check()
         self._cpu_arch = None  # Android CPU architecture string
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index d8d0bb66..f9860777 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -186,7 +186,9 @@ def test_adb_session_07(mocker):
     test_ip = "localhost"
     test_port = 5555
     test_version = "9"
+    test_enforcing = True
     def fake_adb_call(obj, cmd, timeout=None):
+        nonlocal test_enforcing
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
             if obj.connected:
@@ -207,7 +209,7 @@ def fake_adb_call(obj, cmd, timeout=None):
             obj.connected = False
             return 0, "restarting adbd as root"
         if cmd[1] == "shell" and cmd[2] == "getenforce":
-            if getattr(obj, "enforcing", True):
+            if test_enforcing:
                 return 0, "Enforcing"
             return 0, "Permissive"
         if cmd[1] == "shell" and cmd[2] == "getprop":
@@ -220,7 +222,7 @@ def fake_adb_call(obj, cmd, timeout=None):
             if cmd[3] == "sys.boot_completed":
                 return 0, "1"
         if cmd[1] == "shell" and cmd[2] == "setenforce":
-            setattr(obj, "enforcing", False)
+            test_enforcing = False
             return 0, ""
         if cmd[1] == "shell" and cmd[2] in ("start", "stop"):
             return 0, ""
@@ -1023,16 +1025,20 @@ def fake_adb_02(_, cmd, timeout=None):
     assert fake_sleep.call_count == 0
     fake_sleep.reset_mock()
     # test boot in progress
+    anim_done = False
+    boot_done = False
     def fake_adb_03(obj, cmd, timeout=None):
+        nonlocal anim_done
+        nonlocal boot_done
         if cmd[1] == "shell" and cmd[2] == "getprop":
             if cmd[3] == "init.svc.bootanim":
-                if not getattr(obj, "anim_done", False):
-                    setattr(obj, "anim_done", True)
+                if not anim_done:
+                    anim_done = True
                     return 0, ""
                 return 0, "stopped"
             if cmd[3] == "sys.boot_completed":
-                if not getattr(obj, "boot_done", False):
-                    setattr(obj, "boot_done", True)
+                if not boot_done:
+                    boot_done = True
                     return 0, "0"
                 return 0, "1"
         raise AssertionError("unexpected command %r" % (cmd,))

From c8a6fbb1a0dd428ec66b5534a8f8cf2e99b8c1cd Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 4 Feb 2021 11:13:02 -0500
Subject: [PATCH 498/531] [android] Fix Target and Bootstrapper after rebase

---
 grizzly/target/adb_device/adb_process.py |  2 +-
 grizzly/target/adb_target.py             | 14 +++++++++-----
 grizzly/target/test_adb_target.py        |  7 +++----
 3 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index 4d67cb29..bcdf78c2 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -165,7 +165,7 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
         # setup bootstrapper and reverse port
         # reverse does fail occasionally so use a retry loop
         for _ in range(10):
-            bootstrapper = Bootstrapper(poll_wait=0.5)
+            bootstrapper = Bootstrapper()
             if not self._session.reverse(bootstrapper.port, bootstrapper.port):
                 bootstrapper.close()
                 log.debug("failed to reverse port, retrying...")
diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index 0eb0b60f..32ae3776 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -4,7 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 import logging
 import os
-from tempfile import mkstemp
+from tempfile import mkdtemp, mkstemp
 
 from ffpuppet import LaunchError
 from prefpicker import PrefPicker
@@ -12,6 +12,7 @@
 from .adb_device import ADBProcess, ADBSession
 from .target import Target
 from .target_monitor import TargetMonitor
+from ..common.reporter import Report
 from ..common.utils import grz_tmp
 
 
@@ -22,9 +23,8 @@
 
 
 class ADBTarget(Target):
-    def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, relaunch, **kwds):
-        super(ADBTarget, self).__init__(binary, extension, launch_timeout, log_limit,
-                                        memory_limit, relaunch)
+    def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, **kwds):
+        super().__init__(binary, extension, launch_timeout, log_limit, memory_limit)
         self.forced_close = True  # app will not close itself on Android
         self.use_rr = False
 
@@ -93,7 +93,6 @@ def detect_failure(self, ignored, was_timeout):
         return status
 
     def launch(self, location, env_mod=None):
-        self.rl_countdown = self.rl_reset
         env_mod = dict(env_mod or [])
         # This may be used to disabled network connections during testing, e.g.
         env_mod["MOZ_IN_AUTOMATION"] = "1"
@@ -171,6 +170,11 @@ def prefs(self, prefs_file):
         else:
             raise TargetError("Missing prefs.js file %r" % (prefs_file,))
 
+    def create_report(self):
+        logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
+        self.save_logs(logs)
+        return Report(logs, self.binary)
+
     def reverse(self, remote, local):
         # remote->device, local->desktop
         self._session.reverse(remote, local)
diff --git a/grizzly/target/test_adb_target.py b/grizzly/target/test_adb_target.py
index 0fc2246b..0dbe9ffe 100644
--- a/grizzly/target/test_adb_target.py
+++ b/grizzly/target/test_adb_target.py
@@ -24,14 +24,13 @@ def test_adb_target_01(mocker, tmp_path):
     fake_session.get_package_name.return_value = "the_name"
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()
-    target = ADBTarget(str(fake_apk), None, 300, 25, 5000, 25)
+    target = ADBTarget(str(fake_apk), None, 300, 25, 5000)
     try:
         assert target.closed
         assert target.forced_close
         assert target.monitor is not None
         assert target.detect_failure([], False) == Target.RESULT_NONE
         assert not target.log_size()
-        target.check_relaunch()
     finally:
         target.cleanup()
     assert not target.monitor.is_running()
@@ -50,7 +49,7 @@ def test_adb_target_02(mocker, tmp_path):
     mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()
-    target = ADBTarget(str(fake_apk), None, 300, 25, 5000, 25)
+    target = ADBTarget(str(fake_apk), None, 300, 25, 5000)
     target.launch("fake.url")
     assert fake_process.return_value.launch.call_count == 1
     assert target.monitor.is_running()
@@ -62,7 +61,7 @@ def test_adb_target_03(mocker, tmp_path):
     mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()
-    target = ADBTarget(str(fake_apk), None, 300, 25, 5000, 25)
+    target = ADBTarget(str(fake_apk), None, 300, 25, 5000)
     # test everything is running
     fake_process.return_value.is_healthy.return_value = True
     fake_process.return_value.is_running.return_value = True

From 72e4207aa23ca0a6a465c3abdd4b4c4684290baa Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Thu, 4 Feb 2021 11:14:10 -0500
Subject: [PATCH 499/531] [android] Update AAPT/ADB search to use updated SDK
 locations.

---
 grizzly/target/adb_device/adb_session.py      | 57 ++++++++++++-------
 grizzly/target/adb_device/test_adb_session.py | 29 +++++-----
 2 files changed, 51 insertions(+), 35 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index bdeb41db..87707673 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -5,7 +5,9 @@
 from collections import namedtuple
 import logging
 import os
-from shutil import rmtree
+from pathlib import Path
+from platform import system
+from shutil import rmtree, which
 import socket
 from subprocess import call, CalledProcessError, check_output, Popen
 from tempfile import mkdtemp, TemporaryFile
@@ -23,6 +25,21 @@
 DeviceProcessInfo = namedtuple("DeviceProcessInfo", "memory name pid ppid")
 
 
+def _get_android_sdk():
+    if os.getenv("ANDROID_HOME") is not None:
+        android_home = Path(os.getenv("ANDROID_HOME"))
+        if android_home.is_dir():
+            return android_home
+    if os.getenv("ANDROID_SDK_ROOT") is not None:
+        return Path(os.getenv("ANDROID_SDK_ROOT"))
+    if system() == "Windows":
+        return Path(os.getenv("LOCALAPPDATA")) / "Android" / "sdk"
+    if system() == "Darwin":
+        return Path.home() / "Library" / "Android" / "sdk"
+    return Path.home() / "Android" / "Sdk"
+ANDROID_SDK_ROOT = _get_android_sdk()
+
+
 class ADBCommandError(Exception):
     """Raised when an ADB command is invalid or unrecognized"""
 
@@ -73,18 +90,17 @@ def _aapt_check(cls):
         Returns:
             str: Path to AAPT binary.
         """
-        aapt_bin = os.path.expanduser("~/.android/sdk/android-9/aapt")
-        if os.path.isfile(aapt_bin):
-            log.debug("using recommended aapt from %r", aapt_bin)
-            return aapt_bin
-        try:
-            aapt_bin = check_output(("which", "aapt"))
-        except CalledProcessError:
+        aapt_bin = ANDROID_SDK_ROOT / "android-9" / "aapt"
+        if aapt_bin.is_file():
+            log.debug("using recommended aapt from '%s'", aapt_bin)
+            return str(aapt_bin)
+        aapt_bin = which("aapt")
+        if aapt_bin is None:
             raise EnvironmentError("Please install AAPT")
-        aapt_bin = aapt_bin.strip().decode("utf-8", errors="ignore")
+        aapt_bin = Path(aapt_bin)
         # TODO: update this to check aapt version
-        log.warning("Using aapt_bin from %r", aapt_bin)
-        return aapt_bin
+        log.warning("Using aapt_bin from '%s'", aapt_bin)
+        return str(aapt_bin)
 
     @classmethod
     def _adb_check(cls):
@@ -97,21 +113,20 @@ def _adb_check(cls):
         Returns:
             str: Path to ADB binary.
         """
-        adb_bin = os.path.expanduser("~/.android/sdk/platform-tools/adb")
-        if os.path.isfile(adb_bin):
-            log.debug("using recommended adb from %r", adb_bin)
-            return adb_bin
-        try:
-            adb_bin = check_output(("which", "adb"))
-        except CalledProcessError:
+        adb_bin = ANDROID_SDK_ROOT / "platform-tools" / "adb"
+        if adb_bin.is_file():
+            log.debug("using recommended adb from '%s'", adb_bin)
+            return str(adb_bin)
+        adb_bin = which("adb")
+        if adb_bin is None:
             raise EnvironmentError("Please install ADB")
-        adb_bin = adb_bin.strip().decode("utf-8", errors="ignore")
+        adb_bin = Path(adb_bin)
         # TODO: update this to check adb version
-        log.warning("Using adb from %r", adb_bin)
+        log.warning("Using adb from '%s'", adb_bin)
         log.warning("You are not using the recommended ADB install!")
         log.warning("Either run the setup script or proceed with caution.")
         sleep(5)
-        return adb_bin
+        return str(adb_bin)
 
     @staticmethod
     def _call_adb(cmd, timeout=None):
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index f9860777..ed013c09 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -1,5 +1,6 @@
 # pylint: disable=protected-access
 import os
+from pathlib import Path
 from subprocess import CalledProcessError
 import zipfile
 
@@ -797,18 +798,18 @@ def fake_adb_call(cmd, timeout=None):
 def test_adb_session_27(mocker, tmp_path):
     """test ADBSession._aapt_check()"""
     # use system aapt
-    mocker.patch("os.path.expanduser", return_value=b"/missing/aapt")
-    mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"/fake_system/aapt")
+    mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing"))
+    mocker.patch("grizzly.target.adb_device.adb_session.which", return_value="/fake_system/aapt")
     assert ADBSession._aapt_check() == "/fake_system/aapt"
-    fake_aapt = tmp_path / "aapt"
+    (tmp_path / "android-9").mkdir()
+    fake_aapt = tmp_path / "android-9" / "aapt"
     fake_aapt.touch()
     # use recommended aapt
-    mocker.patch("os.path.expanduser", return_value=str(fake_aapt))
-    mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"/fake_system/aapt")
+    mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", tmp_path)
     assert ADBSession._aapt_check() == str(fake_aapt)
     # aapt not installed
-    mocker.patch("os.path.expanduser", return_value=b"/missing/aapt")
-    mocker.patch("grizzly.target.adb_device.adb_session.check_output", side_effect=CalledProcessError(1, "test", "test"))
+    mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing"))
+    mocker.patch("grizzly.target.adb_device.adb_session.which", return_value=None)
     with pytest.raises(EnvironmentError, match=r"Please install AAPT"):
         assert ADBSession._aapt_check()
 
@@ -816,18 +817,18 @@ def test_adb_session_28(mocker, tmp_path):
     """test ADBSession._adb_check()"""
     mocker.patch("grizzly.target.adb_device.adb_session.sleep")  # skip delay after warning message
     # use system adb
-    mocker.patch("os.path.expanduser", return_value=b"/missing/adb")
-    mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"/fake_system/adb")
+    mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing"))
+    mocker.patch("grizzly.target.adb_device.adb_session.which", return_value="/fake_system/adb")
     assert ADBSession._adb_check() == "/fake_system/adb"
-    fake_adb = tmp_path / "adb"
+    (tmp_path / "platform-tools").mkdir()
+    fake_adb = tmp_path / "platform-tools" / "adb"
     fake_adb.touch()
     # use recommended adb
-    mocker.patch("os.path.expanduser", return_value=str(fake_adb))
-    mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"/fake_system/adb")
+    mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", tmp_path)
     assert ADBSession._adb_check() == str(fake_adb)
     # adb not installed
-    mocker.patch("os.path.expanduser", return_value=b"/missing/adb")
-    mocker.patch("grizzly.target.adb_device.adb_session.check_output", side_effect=CalledProcessError(1, "test", "test"))
+    mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing"))
+    mocker.patch("grizzly.target.adb_device.adb_session.which", return_value=None)
     with pytest.raises(EnvironmentError, match=r"Please install ADB"):
         assert ADBSession._adb_check()
 

From 6b4965f72e1886224279931ce0bac7e8bc167439 Mon Sep 17 00:00:00 2001
From: Jesse Schwartzentruber <truber@mozilla.com>
Date: Mon, 8 Feb 2021 09:20:32 -0500
Subject: [PATCH 500/531] [android] Remove log_path from ASAN_OPTIONS

It isn't working yet, and breaks launch.
---
 grizzly/target/adb_device/device.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index b36ed2d0..4b286484 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -65,7 +65,7 @@ def main(argv=None):  # pylint: disable=missing-docstring
             args.install = args.prep
             asan_opts = {
                 "abort_on_error": "0",
-                "log_path": "'%s'" % session.SANITIZER_LOG_PREFIX}
+            }
             session.sanitizer_options("asan", asan_opts)
         if args.airplane_mode is not None:
             if args.airplane_mode > 0:

From def2c890b94d49044387d31bcc730f61e3afef17 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 17 Feb 2022 11:49:57 -0800
Subject: [PATCH 501/531] [adb] Update bit-rotted code

---
 grizzly/target/adb_device/adb_process.py      |  71 ++++++-----
 grizzly/target/adb_device/test_adb_process.py |  47 ++++---
 grizzly/target/adb_target.py                  | 119 ++++++++----------
 grizzly/target/test_adb_target.py             | 108 ++++++++--------
 4 files changed, 167 insertions(+), 178 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index bcdf78c2..ed7febd9 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -4,11 +4,10 @@
 import re
 from shutil import copy, rmtree
 from time import sleep, time
-from tempfile import mkdtemp
+from tempfile import NamedTemporaryFile, mkdtemp
 from yaml import safe_dump
 
 from ffpuppet.bootstrapper import Bootstrapper
-from ffpuppet.helpers import append_prefs, create_profile
 from ffpuppet.minidump_parser import process_minidumps
 from ffpuppet.puppet_logger import PuppetLogger
 
@@ -26,12 +25,12 @@ class ADBLaunchError(ADBSessionError):
 
 
 class ADBProcess(object):
-    # TODO: reason codes match FFPuppet
+    # TODO: Use FFPuppet Reason enum
     RC_ALERT = "ALERT"  # target crashed/aborted/triggered an assertion failure etc...
     RC_CLOSED = "CLOSED"  # target was closed by call to FFPuppet close()
     RC_EXITED = "EXITED"  # target exited
     #RC_WORKER = "WORKER"  # target was closed by worker thread
-    # TODO: 
+    # TODO:
     #  def save_logs(self, *args, **kwargs):
     #  def clone_log(self, log_id, offset=0):
     #  def log_data(self, log_id, offset=0):
@@ -96,7 +95,11 @@ def close(self):
                 self._terminate()
                 self.wait()
                 self._process_logs(crash_reports)
+                # remove remote working path
                 self._session.call(["shell", "rm", "-rf", self._working_path])
+                # remove remote config yaml
+                cfg_file = "/data/local/tmp/%s-geckoview-config.yaml" %  (self._package,)
+                self._session.call(["shell", "rm", "-rf", cfg_file])
                 # TODO: this should be temporary until ASAN_OPTIONS=log_file is working
                 if "log_asan.txt" in os.listdir(self.logs):
                     self.reason = self.RC_ALERT
@@ -174,35 +177,29 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
             break
         else:
             raise ADBLaunchError("Could not reverse port")
-        profile = None
         try:
-            profile = create_profile(extension=extension, prefs_js=prefs_js, template=self._profile_template)
-            self.profile = "/".join([self._working_path, os.path.basename(profile)])
+            # load prefs from prefs.js
+            prefs = self.prefs_to_dict(prefs_js) if prefs_js else dict()
+            # add additional prefs
+            prefs.update({
+                "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'",
+                "capability.policy.localfilelinks.sites": "'%s'" % bootstrapper.location,
+                "capability.policy.policynames": "'localfilelinks'",
+                "network.proxy.allow_bypass": "false",
+                "network.proxy.failover_direct": "false",
+                "privacy.partition.network_state": "false",
+            })
             # add environment variables
             env_mod = dict(env_mod or {})
             env_mod.setdefault("MOZ_SKIA_DISABLE_ASSERTS", "1")
             # build *-geckoview-config.yaml (https://firefox-source-docs.mozilla.org/ ...
             #   mobile/android/geckoview/consumer/automation.html#configuration-file-format)
             cfg_file = "%s-geckoview-config.yaml" % (self._package,)
-            local_cfg = os.path.join(profile, cfg_file)
-            with open(local_cfg, "w") as cfp:
-                cfp.write(safe_dump({
-                    "args": [
-                        "--profile",
-                        self.profile
-                    ],
-                    "env": env_mod
-                }))
-            if not self._session.push(local_cfg, "/data/local/tmp/%s" % (cfg_file,)):
-                raise ADBLaunchError("Could not upload %r" % (cfg_file,))
-            # add additional prefs
-            prefs = {
-                "capability.policy.policynames": "'localfilelinks'",
-                "capability.policy.localfilelinks.sites": "'%s'" % (bootstrapper.location,),
-                "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'"}
-            append_prefs(profile, prefs)
-            if not self._session.push(profile, self.profile):
-                raise ADBLaunchError("Could not upload profile %r" % (profile,))
+            with NamedTemporaryFile("w+t") as cfp:
+                cfp.write(safe_dump({"env": env_mod, "prefs": prefs}))
+                cfp.flush()
+                if not self._session.push(cfp.name, "/data/local/tmp/%s" % (cfg_file,)):
+                    raise ADBLaunchError("Could not upload %r" % (cfg_file,))
             cmd = [
                 "shell", "am", "start", "-W", "-n", app,
                 "-a", "android.intent.action.VIEW", "-d", bootstrapper.location]
@@ -211,8 +208,6 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
             self._pid = self._session.get_pid(self._package)
             bootstrapper.wait(self.is_healthy, url=url)
         finally:
-            if profile is not None:
-                rmtree(profile, ignore_errors=True)
             self._session.reverse_remove(bootstrapper.port)
             bootstrapper.close()
         self._launches += 1
@@ -231,6 +226,26 @@ def launches(self):
         assert self._launches > -1, "clean_up() has been called"
         return self._launches
 
+    @staticmethod
+    def prefs_to_dict(prefs_file):
+        pattern = re.compile(r"user_pref\(\"(?P<name>.+)\",\s*(?P<value>.+)\);")
+        out = dict()
+        with open(prefs_file, "r") as in_fp:
+            for line in in_fp:
+                pref = pattern.match(line)
+                if not pref:
+                    continue
+                value = pref.group("value")
+                if value in ("false", "true"):
+                    out[pref.group("name")] = value == "true"
+                elif value.startswith("'") and value.endswith("'"):
+                    out[pref.group("name")] = value.strip("'")
+                elif value.startswith('"') or value.startswith("'"):
+                    out[pref.group("name")] = value.strip('"')
+                else:
+                    out[pref.group("name")] = int(value)
+        return out
+
     def _process_logs(self, crash_reports):
         assert self.logs is None
         self.logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 0812c23e..60d275ab 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -1,7 +1,6 @@
 # pylint: disable=protected-access
 import os
 import shutil
-from yaml import safe_load
 
 import pytest
 
@@ -66,29 +65,10 @@ def test_adb_process_05(mocker):
         proc.cleanup()
         assert proc.logs is None
 
-def test_adb_process_06(mocker, tmp_path):
-    """test ADBProcess.launch() check *-geckoview-config.yaml"""
-    mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
-    mocker.patch("grizzly.target.adb_device.adb_process.ADBProcess._remove_logs", autospec=True)
-    mocker.patch("grizzly.target.adb_device.adb_process.create_profile", return_value=str(tmp_path))
-    mocker.patch("grizzly.target.adb_device.adb_process.rmtree", autospec=True)
-    fake_session = mocker.Mock(spec=ADBSession)
-    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
-    fake_session.call.return_value = (0, "Status: ok")
-    fake_session.collect_logs.return_value = b""
-    fake_session.get_pid.return_value = None
-    fake_session.listdir.return_value = ()
-    with ADBProcess("org.mozilla.fenix", fake_session) as proc:
-        proc.launch("fake.url", env_mod={"TEST_ENV": "123"})
-        cfg_file = tuple(tmp_path.glob("*-geckoview-config.yaml"))[0]
-        assert cfg_file
-        assert cfg_file.name == "%s-geckoview-config.yaml" % (proc._package,)
-        cfg_data = safe_load(cfg_file.read_text())
-        assert "args" in cfg_data
-        assert cfg_data["args"][0] == "--profile"
-        assert cfg_data["args"][1] == "%s/%s" % (proc._working_path, tmp_path.name)
-        assert "env" in cfg_data
-        assert cfg_data["env"]["TEST_ENV"] == "123"
+# TODO: check config yaml output
+#def test_adb_process_06(mocker, tmp_path):
+#    """test ADBProcess.launch() check *-geckoview-config.yaml"""
+
 
 def test_adb_process_07(mocker):
     """test ADBProcess.launch(), ADBProcess.is_running() and ADBProcess.is_healthy()"""
@@ -263,3 +243,22 @@ def test_adb_process_13(tmp_path):
     assert b"test, line2" in stderr_lines
     assert b"test, line1" not in stderr_lines
     assert len(stderr_lines) == 8
+
+@pytest.mark.parametrize(
+    "input_data, result",
+    [
+        ("", dict()),
+        ("junk\n#user_pref(\"a.b\", 0)\n", dict()),
+        ("user_pref(\"a.b.c\", false);\n", {"a.b.c": False}),
+        ("user_pref(\"a.b.c\", 0);", {"a.b.c": 0}),
+        ("user_pref(\"a.b.c\", 'test');", {"a.b.c": "test"}),
+        ("user_pref(\"a.b.c\", \"test\");", {"a.b.c": "test"}),
+        ("user_pref(\"a.b\", 1);\nuser_pref(\"a.c\", true);", {"a.b": 1, "a.c": True}),
+        ("user_pref(\"a.b\", 1);\n#\nuser_pref(\"a.c\", 1);", {"a.b": 1, "a.c": 1}),
+    ],
+)
+def test_adb_process_14(tmp_path, input_data, result):
+    """test ADBProcess.prefs_to_dict()"""
+    prefs_js = tmp_path / "prefs.js"
+    prefs_js.write_text(input_data)
+    assert ADBProcess.prefs_to_dict(str(prefs_js)) == result
diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index 32ae3776..4785e887 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -4,13 +4,13 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 import logging
 import os
-from tempfile import mkdtemp, mkstemp
+from tempfile import mkdtemp, TemporaryDirectory
 
 from ffpuppet import LaunchError
 from prefpicker import PrefPicker
 
 from .adb_device import ADBProcess, ADBSession
-from .target import Target
+from .target import Result, Target, TargetError
 from .target_monitor import TargetMonitor
 from ..common.reporter import Report
 from ..common.utils import grz_tmp
@@ -19,45 +19,46 @@
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
-log = logging.getLogger("adb_target")  # pylint: disable=invalid-name
+LOG = logging.getLogger("adb_target")  # pylint: disable=invalid-name
 
 
 class ADBTarget(Target):
-    def __init__(self, binary, extension, launch_timeout, log_limit, memory_limit, **kwds):
-        super().__init__(binary, extension, launch_timeout, log_limit, memory_limit)
+    SUPPORTED_ASSETS = ("prefs",)
+
+    def __init__(self, binary, launch_timeout, log_limit, memory_limit, **kwds):
+        super().__init__(binary, launch_timeout, log_limit, memory_limit)
         self.forced_close = True  # app will not close itself on Android
         self.use_rr = False
 
-        if kwds.pop("rr", False):
-            log.warning("ADBTarget ignoring 'rr': not supported")
-        if kwds.pop("valgrind", False):
-            log.warning("ADBTarget ignoring 'valgrind': not supported")
-        if kwds.pop("xvfb", False):
-            log.warning("ADBTarget ignoring 'xvfb': not supported")
+
+        for unsupported in ("pernosco", "rr", "valgrind", "xvfb"):
+            if kwds.pop(unsupported, False):
+                LOG.warning("ADBTarget ignoring %r: not supported", unsupported)
         if kwds:
-            log.warning("ADBTarget ignoring unsupported arguments: %s", ", ".join(kwds))
+            LOG.warning("ADBTarget ignoring unsupported arguments: %s", ", ".join(kwds))
 
-        log.debug("opening a session and setting up the environment")
+        LOG.debug("opening a session and setting up the environment")
         self._session = ADBSession.create(as_root=True)
         if self._session is None:
             raise RuntimeError("Could not create ADB Session!")
         self._package = ADBSession.get_package_name(self.binary)
         self._prefs = None
         self._proc = ADBProcess(self._package, self._session)
-        self._remove_prefs = False
-        self._session.symbols[self._package] = os.path.join(os.path.dirname(self.binary), "symbols")
+        self._session.symbols[self._package] = os.path.join(
+            os.path.dirname(self.binary), "symbols"
+        )
 
-    def cleanup(self):
+    def _cleanup(self):
         with self._lock:
             if self._proc is not None:
                 self._proc.cleanup()
             if self._session.connected:
                 self._session.reverse_remove()
             self._session.disconnect()
-        if self._remove_prefs and self._prefs and os.path.isfile(self._prefs):
+        if self._prefs and os.path.isfile(self._prefs):
             os.remove(self._prefs)
 
-    def close(self):
+    def close(self, _force_close=False):
         with self._lock:
             if self._proc is not None:
                 self._proc.close()
@@ -66,34 +67,27 @@ def close(self):
     def closed(self):
         return self._proc.reason is not None
 
-    def detect_failure(self, ignored, was_timeout):
-        status = self.RESULT_NONE
-        is_healthy = self._proc.is_healthy()
-        # check if there has been a crash, hang, etc...
-        if not is_healthy or was_timeout:
-            if self._proc.is_running():
-                log.info("Terminating browser...")
+    def check_result(self, _ignored):
+        status = Result.NONE
+        if not self._proc.is_healthy():
             self._proc.close()
-        # if something has happened figure out what
-        if not is_healthy:
+            # if something has happened figure out what
             if self._proc.reason == ADBProcess.RC_CLOSED:
-                log.info("target.close() was called")
+                LOG.info("target.close() was called")
             elif self._proc.reason == ADBProcess.RC_EXITED:
-                log.info("Target closed itself")
-            else:
-                log.debug("failure detected")
-                status = self.RESULT_FAILURE
-        elif was_timeout:
-            log.debug("timeout detected, potential browser hang")
-            if ignored and "timeout" in ignored:
-                status = self.RESULT_IGNORED
-                log.info("Timed out")
+                LOG.info("Target closed itself")
             else:
-                status = self.RESULT_FAILURE
+                LOG.debug("failure detected")
+                status = Result.FOUND
         return status
 
-    def launch(self, location, env_mod=None):
-        env_mod = dict(env_mod or [])
+    def handle_hang(self, ignore_idle=True):
+        # TODO: attempt to detect idle hangs?
+        self.close()
+        return False
+
+    def launch(self, location):
+        env_mod = dict(self.environ)
         # This may be used to disabled network connections during testing, e.g.
         env_mod["MOZ_IN_AUTOMATION"] = "1"
         # prevent crash reporter from touching the dmp files
@@ -106,7 +100,7 @@ def launch(self, location, env_mod=None):
             self._proc.launch(
                 env_mod=env_mod,
                 launch_timeout=self.launch_timeout,
-                prefs_js=self.prefs,
+                prefs_js=self._prefs,
                 url=location)
         except LaunchError:
             self._proc.close()
@@ -139,41 +133,26 @@ def log_length(_, *_a):  # pylint: disable=arguments-differ
             self._monitor = _ADBMonitor()
         return self._monitor
 
-    # TODO: prefs is identical to puppet_target.py should be cleaned up.
-    @property
-    def prefs(self):
+    def process_assets(self):
+        self._prefs = self.assets.get("prefs")
+        # generate temporary prefs.js with prefpicker
         if self._prefs is None:
-            # generate temporary prefs.js
-            for prefs_template in PrefPicker.templates():
-                if prefs_template.endswith("browser-fuzzing.yml"):
-                    log.debug("using prefpicker template %r", prefs_template)
-                    tmp_fd, self._prefs = mkstemp(prefix="prefs_", suffix=".js", dir=grz_tmp())
-                    os.close(tmp_fd)
-                    PrefPicker.load_template(prefs_template).create_prefsjs(self._prefs)
-                    log.debug("generated prefs.js %r", self._prefs)
-                    self._remove_prefs = True
+            for template in PrefPicker.templates():
+                if template.endswith("browser-fuzzing.yml"):
+                    LOG.debug("using prefpicker template %r", template)
+                    with TemporaryDirectory(dir=grz_tmp("target")) as tmp_path:
+                        prefs = os.path.join(tmp_path, "prefs.js")
+                        PrefPicker.load_template(template).create_prefsjs(prefs)
+                        LOG.debug("generated %r", prefs)
+                        self._prefs = self.assets.add("prefs", prefs, copy=False)
                     break
             else:  # pragma: no cover
                 raise TargetError("Failed to generate prefs.js")
-        return self._prefs
-
-    @prefs.setter
-    def prefs(self, prefs_file):
-        if self._remove_prefs and self._prefs and os.path.isfile(self._prefs):
-            os.unlink(self._prefs)
-        if prefs_file is None:
-            self._prefs = None
-            self._remove_prefs = True
-        elif os.path.isfile(prefs_file):
-            self._prefs = os.path.abspath(prefs_file)
-            self._remove_prefs = False
-        else:
-            raise TargetError("Missing prefs.js file %r" % (prefs_file,))
-
-    def create_report(self):
+
+    def create_report(self, is_hang=False):
         logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
         self.save_logs(logs)
-        return Report(logs, self.binary)
+        return Report(logs, self.binary, is_hang=is_hang)
 
     def reverse(self, remote, local):
         # remote->device, local->desktop
diff --git a/grizzly/target/test_adb_target.py b/grizzly/target/test_adb_target.py
index 0dbe9ffe..d8a0e96a 100644
--- a/grizzly/target/test_adb_target.py
+++ b/grizzly/target/test_adb_target.py
@@ -1,46 +1,43 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from pytest import mark
 
-from .adb_device import ADBSession
+from .adb_device import ADBProcess, ADBSession
 from .adb_target import ADBTarget
-from .target import Target
+from .target import Result
 
 def test_adb_target_01(mocker, tmp_path):
     """test creating a simple ADBTarget"""
     fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
-    fake_process.RC_ALERT = "ALERT"
-    fake_process.RC_CLOSED = "CLOSED"
-    fake_process.RC_EXITED = "EXITED"
+    fake_process.RC_ALERT = ADBProcess.RC_ALERT
+    fake_process.RC_CLOSED = ADBProcess.RC_CLOSED
+    fake_process.RC_EXITED = ADBProcess.RC_EXITED
     fake_process.return_value.is_healthy.return_value = False
     fake_process.return_value.is_running.return_value = False
     fake_process.return_value.launches = 0
     fake_process.return_value.reason = fake_process.RC_CLOSED
-    fake_sess_obj = mocker.Mock(spec=ADBSession)
-    fake_sess_obj.connected = True
-    fake_sess_obj.symbols = {}
+    fake_sess_obj = mocker.Mock(spec=ADBSession, connected=True, symbols={})
     fake_session = mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
     fake_session.create.return_value = fake_sess_obj
     fake_session.get_package_name.return_value = "the_name"
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()
-    target = ADBTarget(str(fake_apk), None, 300, 25, 5000)
-    try:
+    with ADBTarget(str(fake_apk), 300, 25, 5000) as target:
         assert target.closed
         assert target.forced_close
         assert target.monitor is not None
-        assert target.detect_failure([], False) == Target.RESULT_NONE
+        assert target.check_result(False) == Result.NONE
         assert not target.log_size()
-    finally:
         target.cleanup()
+        assert fake_sess_obj.reverse_remove.call_count == 1
+        assert fake_sess_obj.disconnect.call_count == 1
     assert not target.monitor.is_running()
     assert not target.monitor.is_healthy()
     assert target.monitor.launches == 0
     assert fake_session.create.call_count == 1
     assert fake_session.get_package_name.call_count == 1
     assert "the_name" in fake_sess_obj.symbols
-    assert fake_sess_obj.reverse_remove.call_count == 1
-    assert fake_sess_obj.disconnect.call_count == 1
 
 def test_adb_target_02(mocker, tmp_path):
     """test ADBTarget.launch()"""
@@ -49,50 +46,49 @@ def test_adb_target_02(mocker, tmp_path):
     mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()
-    target = ADBTarget(str(fake_apk), None, 300, 25, 5000)
-    target.launch("fake.url")
-    assert fake_process.return_value.launch.call_count == 1
-    assert target.monitor.is_running()
-    assert target.monitor.is_healthy()
+    with ADBTarget(str(fake_apk), 300, 25, 5000) as target:
+        target.launch("fake.url")
+        assert fake_process.return_value.launch.call_count == 1
+        assert target.monitor.is_running()
+        assert target.monitor.is_healthy()
 
-def test_adb_target_03(mocker, tmp_path):
-    """test ADBTarget.launch()"""
+@mark.parametrize(
+    "healthy, reason, result, closes",
+    [
+        # running as expected - no failures
+        (True, None, Result.NONE, 0),
+        # browser process closed
+        (False, ADBProcess.RC_CLOSED, Result.NONE, 1),
+        # browser process crashed
+        (False, ADBProcess.RC_ALERT, Result.FOUND, 1),
+        # browser exit with no crash logs
+        (False, ADBProcess.RC_EXITED, Result.NONE, 1),
+    ],
+)
+def test_adb_target_03(mocker, tmp_path, healthy, reason, result, closes):
+    """test ADBTarget.check_result()"""
     fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
+    fake_process.RC_ALERT = ADBProcess.RC_CLOSED
+    fake_process.RC_CLOSED = ADBProcess.RC_CLOSED
+    fake_process.RC_EXITED = ADBProcess.RC_EXITED
     mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()
-    target = ADBTarget(str(fake_apk), None, 300, 25, 5000)
-    # test everything is running
-    fake_process.return_value.is_healthy.return_value = True
-    fake_process.return_value.is_running.return_value = True
-    assert target.detect_failure([], False) == Target.RESULT_NONE
-    assert fake_process.return_value.close.call_count == 0
-    # test timeout case
-    assert target.detect_failure([], True) == Target.RESULT_FAILURE
-    assert fake_process.return_value.close.call_count == 1
-    fake_process.return_value.close.reset_mock()
-    # test ignored timeout case
-    assert target.detect_failure(["timeout"], True) == Target.RESULT_IGNORED
-    assert fake_process.return_value.close.call_count == 1
-    fake_process.return_value.close.reset_mock()
-    # test process not running
-    fake_process.return_value.is_healthy.return_value = False
-    fake_process.return_value.is_running.return_value = False
-    fake_process.return_value.reason = fake_process.RC_EXITED
-    assert target.detect_failure([], False) == Target.RESULT_NONE
-    assert fake_process.return_value.close.call_count == 1
-    fake_process.return_value.close.reset_mock()
-    # test process exited
-    fake_process.return_value.is_healthy.return_value = False
-    fake_process.return_value.is_running.return_value = False
-    fake_process.return_value.reason = fake_process.RC_CLOSED
-    assert target.detect_failure([], False) == Target.RESULT_NONE
-    assert fake_process.return_value.close.call_count == 1
-    fake_process.return_value.close.reset_mock()
-    # test process running but is_healthy() failed
-    fake_process.return_value.is_healthy.return_value = False
-    fake_process.return_value.is_running.return_value = True
-    fake_process.return_value.reason = fake_process.RC_ALERT
-    assert target.detect_failure([], False) == Target.RESULT_FAILURE
-    assert fake_process.return_value.close.call_count == 1
-    fake_process.return_value.close.reset_mock()
+    with ADBTarget(str(fake_apk), 300, 25, 5000) as target:
+        # test everything is running
+        fake_process.return_value.is_healthy.return_value = healthy
+        fake_process.return_value.reason = reason
+        assert target.check_result(None) == result
+        assert fake_process.return_value.close.call_count == closes
+
+def test_adb_target_04(mocker, tmp_path):
+    """test ADBTarget.handle_hang()"""
+    fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
+    mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
+    fake_apk = tmp_path / "test.apk"
+    fake_apk.touch()
+    with ADBTarget(str(fake_apk), 300, 25, 5000) as target:
+        fake_process.return_value.is_healthy.return_value = True
+        fake_process.return_value.is_running.return_value = True
+        assert not target.handle_hang()
+        assert fake_process.return_value.close.call_count == 1

From 2cdb689eb7c68238525ab580de954ca358b611eb Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 18 Feb 2022 15:31:02 -0800
Subject: [PATCH 502/531] [adb] Apply linter fixes and nits

---
 grizzly/target/adb_device/adb_process.py      | 134 ++-
 grizzly/target/adb_device/adb_session.py      | 317 ++++---
 grizzly/target/adb_device/device.py           |  90 +-
 grizzly/target/adb_device/test_adb_process.py | 176 ++--
 grizzly/target/adb_device/test_adb_session.py | 897 +++++++++++++-----
 grizzly/target/adb_target.py                  |  21 +-
 grizzly/target/test_adb_target.py             |   8 +-
 7 files changed, 1087 insertions(+), 556 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index ed7febd9..052c7fa8 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -1,20 +1,21 @@
-import logging
 import os
-import random
 import re
+from logging import getLogger
+from random import getrandbits
 from shutil import copy, rmtree
-from time import sleep, time
 from tempfile import NamedTemporaryFile, mkdtemp
-from yaml import safe_dump
+from time import sleep, time
 
 from ffpuppet.bootstrapper import Bootstrapper
 from ffpuppet.minidump_parser import process_minidumps
 from ffpuppet.puppet_logger import PuppetLogger
+from yaml import safe_dump
 
 from grizzly.common.utils import grz_tmp
+
 from .adb_session import ADBSession, ADBSessionError
 
-log = logging.getLogger("adb_process")  # pylint: disable=invalid-name
+LOG = getLogger("adb_process")
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
@@ -24,20 +25,29 @@ class ADBLaunchError(ADBSessionError):
     pass
 
 
-class ADBProcess(object):
+class ADBProcess:
     # TODO: Use FFPuppet Reason enum
     RC_ALERT = "ALERT"  # target crashed/aborted/triggered an assertion failure etc...
     RC_CLOSED = "CLOSED"  # target was closed by call to FFPuppet close()
     RC_EXITED = "EXITED"  # target exited
-    #RC_WORKER = "WORKER"  # target was closed by worker thread
+    # RC_WORKER = "WORKER"  # target was closed by worker thread
     # TODO:
     #  def save_logs(self, *args, **kwargs):
     #  def clone_log(self, log_id, offset=0):
     #  def log_data(self, log_id, offset=0):
     #  def log_length(self, log_id):... likely not going to happen because of overhead
 
-    __slots__ = ("_launches", "_package", "_pid", "_profile_template", "_session",
-                 "_working_path", "logs", "profile", "reason")
+    __slots__ = (
+        "_launches",
+        "_package",
+        "_pid",
+        "_profile_template",
+        "_session",
+        "_working_path",
+        "logs",
+        "profile",
+        "reason",
+    )
 
     def __init__(self, package_name, session, use_profile=None):
         assert isinstance(session, ADBSession), "Expecting ADBSession"
@@ -48,7 +58,7 @@ def __init__(self, package_name, session, use_profile=None):
         self._pid = None  # pid of current target process
         self._profile_template = use_profile  # profile that is used as a template
         self._session = session  # ADB session with device
-        self._working_path = "/sdcard/ADBProc_%08X" % (random.getrandbits(32),)
+        self._working_path = "/sdcard/ADBProc_%08X" % (getrandbits(32),)
         self.logs = None
         self.profile = None  # profile path on device
         self.reason = self.RC_CLOSED
@@ -61,7 +71,7 @@ def __exit__(self, *exc):
 
     def cleanup(self):
         if self._launches < 0:
-            log.debug("clean_up() call ignored")
+            LOG.debug("clean_up() call ignored")
             return
         if self.reason is None:
             self.close()
@@ -79,7 +89,7 @@ def clone_log(self):
     def close(self):
         assert self._launches > -1, "clean_up() has been called"
         if self.reason is not None:
-            log.debug("already closed!")
+            LOG.debug("already closed!")
             return
         try:
             if self._session is not None:
@@ -98,14 +108,14 @@ def close(self):
                 # remove remote working path
                 self._session.call(["shell", "rm", "-rf", self._working_path])
                 # remove remote config yaml
-                cfg_file = "/data/local/tmp/%s-geckoview-config.yaml" %  (self._package,)
+                cfg_file = "/data/local/tmp/%s-geckoview-config.yaml" % (self._package,)
                 self._session.call(["shell", "rm", "-rf", cfg_file])
                 # TODO: this should be temporary until ASAN_OPTIONS=log_file is working
                 if "log_asan.txt" in os.listdir(self.logs):
                     self.reason = self.RC_ALERT
 
         except ADBSessionError:
-            log.warning("No device detected while closing process")
+            LOG.warning("No device detected while closing process")
         self._pid = None
         self.profile = None
         if self.reason is None:
@@ -126,7 +136,7 @@ def find_crashreports(self):
                     if ".dmp" in fname or ".extra" in fname:
                         reports.append(os.path.join(md_path, fname))
             except IOError:
-                log.debug("%s does not exist", md_path)
+                LOG.debug("%s does not exist", md_path)
 
         return reports
 
@@ -142,8 +152,8 @@ def is_running(self):
             return False
         return self._session.process_exists(self._pid)
 
-    def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=None):
-        log.debug("launching %r", url)
+    def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
+        LOG.debug("launching %r", url)
         assert self._launches > -1, "clean_up() has been called"
         assert self._session, "Device not connected"
         assert self._package, "Package not specified"
@@ -151,9 +161,9 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
         assert self.reason is not None, "Process is already running"
 
         if ".fenix" in self._package:
-            app = "/".join([self._package, "org.mozilla.fenix.IntentReceiverActivity"])
+            app = "%s/org.mozilla.fenix.IntentReceiverActivity" % (self._package,)
         elif ".geckoview_example" in self._package:
-            app = "/".join([self._package, "org.mozilla.geckoview_example.GeckoViewActivity"])
+            app = "%s/org.mozilla.geckoview_example.GeckoViewActivity" % (self._package)
         else:
             raise ADBLaunchError("Unsupported package %r" % (self._package,))
 
@@ -171,7 +181,7 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
             bootstrapper = Bootstrapper()
             if not self._session.reverse(bootstrapper.port, bootstrapper.port):
                 bootstrapper.close()
-                log.debug("failed to reverse port, retrying...")
+                LOG.debug("failed to reverse port, retrying...")
                 sleep(0.25)
                 continue
             break
@@ -181,19 +191,25 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
             # load prefs from prefs.js
             prefs = self.prefs_to_dict(prefs_js) if prefs_js else dict()
             # add additional prefs
-            prefs.update({
-                "capability.policy.localfilelinks.checkloaduri.enabled": "'allAccess'",
-                "capability.policy.localfilelinks.sites": "'%s'" % bootstrapper.location,
-                "capability.policy.policynames": "'localfilelinks'",
-                "network.proxy.allow_bypass": "false",
-                "network.proxy.failover_direct": "false",
-                "privacy.partition.network_state": "false",
-            })
+            prefs.update(
+                {
+                    "capability.policy.localfilelinks.checkloaduri.enabled": (
+                        "'allAccess'"
+                    ),
+                    "capability.policy.localfilelinks.sites": "'%s'"
+                    % bootstrapper.location,
+                    "capability.policy.policynames": "'localfilelinks'",
+                    "network.proxy.allow_bypass": "false",
+                    "network.proxy.failover_direct": "false",
+                    "privacy.partition.network_state": "false",
+                }
+            )
             # add environment variables
             env_mod = dict(env_mod or {})
             env_mod.setdefault("MOZ_SKIA_DISABLE_ASSERTS", "1")
-            # build *-geckoview-config.yaml (https://firefox-source-docs.mozilla.org/ ...
-            #   mobile/android/geckoview/consumer/automation.html#configuration-file-format)
+            # build *-geckoview-config.yaml
+            # https://firefox-source-docs.mozilla.org/mobile/android/geckoview/...
+            # consumer/automation.html#configuration-file-format
             cfg_file = "%s-geckoview-config.yaml" % (self._package,)
             with NamedTemporaryFile("w+t") as cfp:
                 cfp.write(safe_dump({"env": env_mod, "prefs": prefs}))
@@ -201,9 +217,18 @@ def launch(self, url, env_mod=None, extension=None, launch_timeout=60, prefs_js=
                 if not self._session.push(cfp.name, "/data/local/tmp/%s" % (cfg_file,)):
                     raise ADBLaunchError("Could not upload %r" % (cfg_file,))
             cmd = [
-                "shell", "am", "start", "-W", "-n", app,
-                "-a", "android.intent.action.VIEW", "-d", bootstrapper.location]
-            if "Status: ok" not in self._session.call(cmd, timeout=launch_timeout)[1].splitlines():
+                "shell",
+                "am",
+                "start",
+                "-W",
+                "-n",
+                app,
+                "-a",
+                "android.intent.action.VIEW",
+                "-d",
+                bootstrapper.location,
+            ]
+            if "Status: ok" not in self._session.call(cmd, timeout=launch_timeout)[1]:
                 raise ADBLaunchError("Could not launch %r" % (self._package,))
             self._pid = self._session.get_pid(self._package)
             bootstrapper.wait(self.is_healthy, url=url)
@@ -255,7 +280,7 @@ def _process_logs(self, crash_reports):
         with open(os.path.join(self.logs, "log_logcat.txt"), "wb") as log_fp:
             # TODO: should this filter by pid or not?
             log_fp.write(self._session.collect_logs())
-            #log_fp.write(self._session.collect_logs(pid=self._pid))
+            # log_fp.write(self._session.collect_logs(pid=self._pid))
         self._split_logcat(self.logs, self._package)
         if not crash_reports:
             return
@@ -289,14 +314,14 @@ def _split_logcat(log_path, package_name):
         # included in the report so nothing is lost.
         logcat = os.path.join(log_path, "log_logcat.txt")
         if not os.path.isfile(logcat):
-            log.warning("log_logcat.txt does not exist!")
+            LOG.warning("log_logcat.txt does not exist!")
             return
         err_log = os.path.join(log_path, "log_stderr.txt")
         if os.path.isfile(err_log):
-            log.warning("log_stderr.txt already exist! Overwriting...")
+            LOG.warning("log_stderr.txt already exist! Overwriting...")
         out_log = os.path.join(log_path, "log_stdout.txt")
         if os.path.isfile(out_log):
-            log.warning("log_stdout.txt already exist! Overwriting...")
+            LOG.warning("log_stdout.txt already exist! Overwriting...")
         assert package_name
         if not isinstance(package_name, bytes):
             package_name = package_name.encode("utf-8")
@@ -304,10 +329,14 @@ def _split_logcat(log_path, package_name):
         # this will include any line that mentions "Gecko", "MOZ_" or the package name
         asan_tid = None
         filter_pids = set()
-        re_id = re.compile(br"^\d+-\d+\s+(\d+[:.]){3}\d+\s+(?P<pid>\d+)\s+(?P<tid>\d+)")
+        re_id = re.compile(rb"^\d+-\d+\s+(\d+[:.]){3}\d+\s+(?P<pid>\d+)\s+(?P<tid>\d+)")
         with open(logcat, "rb") as lc_fp:
             for line in lc_fp:
-                if b"Gecko" not in line and b"MOZ_" not in line and package_name not in line:
+                if (
+                    b"Gecko" not in line
+                    and b"MOZ_" not in line
+                    and package_name not in line
+                ):
                     continue
                 m_id = re_id.match(line)
                 if m_id is None:
@@ -315,9 +344,11 @@ def _split_logcat(log_path, package_name):
                 filter_pids.add(m_id.group("pid"))
                 if asan_tid is None and b": AddressSanitizer:" in line:
                     asan_tid = m_id.group("tid")
-        log.debug("%d interesting pid(s) found in logcat output", len(filter_pids))
+        LOG.debug("%d interesting pid(s) found in logcat output", len(filter_pids))
         # filter logs
-        with open(logcat, "rb") as lc_fp, open(err_log, "wb") as e_fp, open(out_log, "wb") as o_fp:
+        with open(logcat, "rb") as lc_fp, open(err_log, "wb") as e_fp, open(
+            out_log, "wb"
+        ) as o_fp:
             for line in lc_fp:
                 # quick check if pid is in the line
                 if not any(pid in line for pid in filter_pids):
@@ -330,7 +361,7 @@ def _split_logcat(log_path, package_name):
                 if not any(pid == line_pid for pid in filter_pids):
                     continue
                 # strip logger info ... "07-27 12:10:15.442  9990  4234 E "
-                line = re.sub(br".+?\s[ADEIVW]\s+", b"", line)
+                line = re.sub(rb".+?\s[ADEIVW]\s+", b"", line)
                 if line.startswith(b"GeckoDump"):
                     o_fp.write(line.split(b": ", 1)[-1])
                 else:
@@ -341,7 +372,7 @@ def _split_logcat(log_path, package_name):
         if asan_tid is not None:
             asan_log = os.path.join(log_path, "log_asan.txt")
             if os.path.isfile(asan_log):
-                log.warning("log_asan.txt already exist! Overwriting...")
+                LOG.warning("log_asan.txt already exist! Overwriting...")
             found_log = False
             with open(logcat, "rb") as lc_fp, open(asan_log, "wb") as o_fp:
                 for line in lc_fp:
@@ -358,14 +389,14 @@ def _split_logcat(log_path, package_name):
                             continue
                         found_log = True
                     # strip logger info ... "07-27 12:10:15.442  9990  4234 E "
-                    line = re.sub(br".+?\s[ADEIVW]\s+", b"", line)
+                    line = re.sub(rb".+?\s[ADEIVW]\s+", b"", line)
                     o_fp.write(line.split(b": ", 1)[-1])
 
-    def save_logs(self, log_path, meta=False):
+    def save_logs(self, log_path, meta=False):  # pylint: disable=unused-argument
         assert self.reason is not None, "Call close() first!"
         assert self._launches > -1, "clean_up() has been called"
         if self.logs is None:
-            log.warning("No logs available to save.")
+            LOG.warning("No logs available to save.")
             return
         # copy logs to location specified by log_file
         if not os.path.isdir(log_path):
@@ -380,9 +411,9 @@ def save_logs(self, log_path, meta=False):
             copy(full_name, log_path)
 
     def wait_on_files(self, wait_files, poll_rate=0.5, timeout=60):
-        assert poll_rate >= 0, "Invalid poll_rate %d, must be greater than or equal to 0" % poll_rate
-        assert timeout >= 0, "Invalid timeout %d, must be greater than or equal to 0" % timeout
-        assert poll_rate <= timeout, "poll_rate must be less then or equal to timeout"
+        assert poll_rate >= 0
+        assert timeout >= 0
+        assert poll_rate <= timeout
         wait_end = time() + timeout
         wait_files = set(self._session.realpath(x) for x in wait_files)
 
@@ -392,7 +423,10 @@ def wait_on_files(self, wait_files, poll_rate=0.5, timeout=60):
             if not wait_files.intersection(open_files):
                 break
             if wait_end <= time():
-                log.debug("Timeout waiting for: %s", ", ".join(x for x in open_files if x in wait_files))
+                LOG.debug(
+                    "Timeout waiting for: %s",
+                    ", ".join(x for x in open_files if x in wait_files),
+                )
                 return False
             sleep(poll_rate)
         return True
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 87707673..435a6c89 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -2,20 +2,20 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+import socket
 from collections import namedtuple
-import logging
-import os
+from logging import getLogger
+from os import getenv
 from pathlib import Path
 from platform import system
-from shutil import rmtree, which
-import socket
-from subprocess import call, CalledProcessError, check_output, Popen
-from tempfile import mkdtemp, TemporaryFile
+from shutil import which
+from subprocess import Popen, call, check_output
+from tempfile import TemporaryDirectory, TemporaryFile
 from time import sleep, time
 
 from grizzly.common.utils import grz_tmp
 
-log = logging.getLogger("adb_session")  # pylint: disable=invalid-name
+LOG = getLogger("adb_session")
 
 __all__ = ("ADBCommandError", "ADBCommunicationError", "ADBSession", "ADBSessionError")
 __author__ = "Tyson Smith"
@@ -26,40 +26,57 @@
 
 
 def _get_android_sdk():
-    if os.getenv("ANDROID_HOME") is not None:
-        android_home = Path(os.getenv("ANDROID_HOME"))
+    if getenv("ANDROID_HOME") is not None:
+        android_home = Path(getenv("ANDROID_HOME"))
         if android_home.is_dir():
             return android_home
-    if os.getenv("ANDROID_SDK_ROOT") is not None:
-        return Path(os.getenv("ANDROID_SDK_ROOT"))
+    if getenv("ANDROID_SDK_ROOT") is not None:
+        return Path(getenv("ANDROID_SDK_ROOT"))
     if system() == "Windows":
-        return Path(os.getenv("LOCALAPPDATA")) / "Android" / "sdk"
+        return Path(getenv("LOCALAPPDATA")) / "Android" / "sdk"
     if system() == "Darwin":
         return Path.home() / "Library" / "Android" / "sdk"
     return Path.home() / "Android" / "Sdk"
+
+
 ANDROID_SDK_ROOT = _get_android_sdk()
 
 
 class ADBCommandError(Exception):
     """Raised when an ADB command is invalid or unrecognized"""
 
+
 class ADBCommunicationError(Exception):
     """Raised when ADB fails to communicate with the device"""
 
+
 class ADBSessionError(Exception):
     """Raised when an operation fails unexpectedly or session state is invalid"""
 
 
-class ADBSession(object):
+# pylint: disable=too-many-public-methods
+class ADBSession:
     SANITIZER_LOG_PREFIX = "/sdcard/sanitizer_logs/report.log"
 
-    __slots__ = ("_adb_bin", "_cpu_arch", "_debug_adb", "_ip_addr", "_os_version",
-                 "_os_version", "_port", "_root", "connected", "symbols")
+    __slots__ = (
+        "_adb_bin",
+        "_cpu_arch",
+        "_debug_adb",
+        "_ip_addr",
+        "_os_version",
+        "_os_version",
+        "_port",
+        "_root",
+        "connected",
+        "symbols",
+    )
 
     def __init__(self, ip_addr=None, port=5555):
         self._adb_bin = self._adb_check()
         self._cpu_arch = None  # Android CPU architecture string
-        self._debug_adb = int(os.getenv("SHOW_ADB_DEBUG", "0")) != 0  # include ADB output in debug logs
+        self._debug_adb = (
+            int(getenv("SHOW_ADB_DEBUG", "0")) != 0
+        )  # include ADB output in debug logs
         self._ip_addr = None  # target device IP address
         self._os_version = None  # Android version string
         self._port = None  # ADB listening port
@@ -68,12 +85,12 @@ def __init__(self, ip_addr=None, port=5555):
         self.symbols = dict()
 
         if ip_addr is not None:
-            log.debug("creating IP based session")
+            LOG.debug("creating IP based session")
             try:
                 if ip_addr != "localhost":
                     socket.inet_aton(ip_addr)
             except (socket.error, TypeError):
-                raise ValueError("Invalid IP Address")
+                raise ValueError("Invalid IP Address") from None
             self._ip_addr = ip_addr
             if not isinstance(port, int) or not 0x10000 > port > 1024:
                 raise ValueError("Port must be valid integer between 1025 and 65535")
@@ -92,14 +109,14 @@ def _aapt_check(cls):
         """
         aapt_bin = ANDROID_SDK_ROOT / "android-9" / "aapt"
         if aapt_bin.is_file():
-            log.debug("using recommended aapt from '%s'", aapt_bin)
+            LOG.debug("using recommended aapt from '%s'", aapt_bin)
             return str(aapt_bin)
         aapt_bin = which("aapt")
         if aapt_bin is None:
             raise EnvironmentError("Please install AAPT")
         aapt_bin = Path(aapt_bin)
         # TODO: update this to check aapt version
-        log.warning("Using aapt_bin from '%s'", aapt_bin)
+        LOG.warning("Using aapt_bin from '%s'", aapt_bin)
         return str(aapt_bin)
 
     @classmethod
@@ -115,28 +132,28 @@ def _adb_check(cls):
         """
         adb_bin = ANDROID_SDK_ROOT / "platform-tools" / "adb"
         if adb_bin.is_file():
-            log.debug("using recommended adb from '%s'", adb_bin)
+            LOG.debug("using recommended adb from '%s'", adb_bin)
             return str(adb_bin)
         adb_bin = which("adb")
         if adb_bin is None:
             raise EnvironmentError("Please install ADB")
         adb_bin = Path(adb_bin)
         # TODO: update this to check adb version
-        log.warning("Using adb from '%s'", adb_bin)
-        log.warning("You are not using the recommended ADB install!")
-        log.warning("Either run the setup script or proceed with caution.")
+        LOG.warning("Using adb from '%s'", adb_bin)
+        LOG.warning("You are not using the recommended ADB install!")
+        LOG.warning("Either run the setup script or proceed with caution.")
         sleep(5)
         return str(adb_bin)
 
     @staticmethod
     def _call_adb(cmd, timeout=None):
-        """Wrapper to make calls to ADB. Launches ADB in a subprocess and collects output.
-        If timeout is specified and elapses the ADB subprocess is terminated.
+        """Wrapper to make calls to ADB. Launches ADB in a subprocess and collects
+        output. If timeout is specified and elapses the ADB subprocess is terminated.
         This function is only meant to be called directly by ADBSession.call().
 
         Args:
             cmd (list): List of strings containing full ADB command.
-            timeout (float, optional): Number of seconds to wait for ADB command to complete.
+            timeout (float, optional): Seconds to wait for ADB command to complete.
 
         Returns:
             tuple: Exit code and stderr, stdout of ADB call.
@@ -145,14 +162,14 @@ def _call_adb(cmd, timeout=None):
             if timeout is not None:
                 assert timeout > 0
                 end_time = time() + timeout
-                adb_proc = Popen(cmd, stderr=out_fp, stdout=out_fp)
-                while adb_proc.poll() is None:
-                    sleep(0.05)
-                    if time() > end_time:
-                        log.warning("adb call timeout!")
-                        adb_proc.terminate()
-                        break
-                ret_code = adb_proc.wait()
+                with Popen(cmd, stderr=out_fp, stdout=out_fp) as proc:
+                    while proc.poll() is None:
+                        sleep(0.05)
+                        if time() > end_time:
+                            LOG.warning("adb call timeout!")
+                            proc.terminate()
+                            break
+                    ret_code = proc.wait()
             else:
                 ret_code = call(cmd, stderr=out_fp, stdout=out_fp)
             out_fp.seek(0)
@@ -195,7 +212,7 @@ def _line_to_info(ps_line):
             _, pid, ppid, _, memory, _, _, _, name = ps_line.split()
             return DeviceProcessInfo(int(memory), name, int(pid), int(ppid))
         except ValueError:
-            log.debug("invalid ps line %r", ps_line)
+            LOG.debug("invalid ps line %r", ps_line)
         return None
 
     @property
@@ -208,7 +225,9 @@ def airplane_mode(self):
         Returns:
             bool: True if airplane mode is enabled otherwise False.
         """
-        return self.call(["shell", "settings", "get", "global", "airplane_mode_on"])[1].startswith("1")
+        return self.call(["shell", "settings", "get", "global", "airplane_mode_on"])[
+            1
+        ].startswith("1")
 
     @airplane_mode.setter
     def airplane_mode(self, mode):
@@ -221,8 +240,27 @@ def airplane_mode(self, mode):
             None
         """
         assert isinstance(mode, bool), "mode must be a bool"
-        self.call(["shell", "settings", "put", "global", "airplane_mode_on", "1" if mode else "0"])
-        self.call(["shell", "su", "root", "am", "broadcast", "-a", "android.intent.action.AIRPLANE_MODE"])
+        self.call(
+            [
+                "shell",
+                "settings",
+                "put",
+                "global",
+                "airplane_mode_on",
+                "1" if mode else "0",
+            ]
+        )
+        self.call(
+            [
+                "shell",
+                "su",
+                "root",
+                "am",
+                "broadcast",
+                "-a",
+                "android.intent.action.AIRPLANE_MODE",
+            ]
+        )
 
     def call(self, cmd, device_required=True, timeout=None):
         """Call ADB with arguments provided in cmd.
@@ -230,7 +268,7 @@ def call(self, cmd, device_required=True, timeout=None):
         Args:
             cmd (list): List of strings to pass as arguments when calling ADB.
             device_required (bool, optional): A device must be available for call.
-            timeout (float, optional): Amount of time in seconds to wait for ADB cal to complete.
+            timeout (float, optional): Seconds to wait for ADB call to complete.
 
         Returns:
             tuple: The first element is an integer containing the exit code of the
@@ -238,20 +276,24 @@ def call(self, cmd, device_required=True, timeout=None):
         """
         assert isinstance(cmd, list) and cmd
         cmd = [self._adb_bin] + cmd
-        log.debug("calling: %s", " ".join(cmd))
+        LOG.debug("calling: %s", " ".join(cmd))
         if not self.connected and cmd[1] not in ("connect", "devices", "disconnect"):
             raise ADBCommunicationError("ADB session is not connected!")
         ret_code, output = self._call_adb(cmd, timeout=timeout)
         if self._debug_adb:
-            log.debug("=== adb start ===\n%s\n=== adb end, returned %d ===", output, ret_code)
+            LOG.debug(
+                "=== adb start ===\n%s\n=== adb end, returned %d ===", output, ret_code
+            )
         if ret_code != 0:
             if output.startswith("Android Debug Bridge version"):
                 raise ADBCommandError("Invalid ADB command '%s'" % (" ".join(cmd[1:]),))
             if output.startswith("adb: usage:"):
                 raise ADBCommandError(output.strip())
-            if device_required and (output.startswith("error: closed") or
-                                    output.startswith("error: device offline") or
-                                    output.startswith("error: no devices/emulators found")):
+            if device_required and (
+                output.startswith("error: closed")
+                or output.startswith("error: device offline")
+                or output.startswith("error: no devices/emulators found")
+            ):
                 self.connected = False
                 raise ADBCommunicationError("No device detected!")
         return ret_code, output
@@ -265,7 +307,7 @@ def clear_logs(self):
         Returns:
             None
         """
-        log.debug("clear_logs()")
+        LOG.debug("clear_logs()")
         return self.call(["logcat", "--clear"], timeout=10)[0] == 0
 
     def collect_logs(self, pid=None):
@@ -278,9 +320,9 @@ def collect_logs(self, pid=None):
         Returns:
             None
         """
-        log.debug("collect_logs()")
+        LOG.debug("collect_logs()")
         if not self.connected:
-            log.debug("device not connected cannot collect logs")
+            LOG.debug("device not connected cannot collect logs")
             # TODO: return None if disconnected?
             return ""
         cmd = ["logcat", "-d", "*:I"]
@@ -293,12 +335,12 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
 
         Args:
             as_root (bool, optional): Attempt to enable root. Default is True.
-            boot_timeout (int, optional): Number of seconds to wait for device boot to complete.
-            max_attempts (int, optional): Number of attempts to make to try to connect to the device.
-            retry_delay (int, optional): Number of seconds to wait between connection attempts.
+            boot_timeout (int, optional): Seconds to wait for device boot to complete.
+            max_attempts (int, optional): Number of attempt to connect to the device.
+            retry_delay (int, optional): Seconds to wait between connection attempts.
 
         Returns:
-            bool: Returns True if connection was established successfully otherwise False.
+            bool: Returns True if connection was established otherwise False.
         """
         assert isinstance(boot_timeout, int) and boot_timeout > 0
         assert isinstance(max_attempts, int) and max_attempts > 0
@@ -313,31 +355,41 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
             if not self.connected:
                 if self._ip_addr is not None:
                     addr = ":".join((self._ip_addr, str(self._port)))
-                    log.debug("connecting to %s", addr)
+                    LOG.debug("connecting to %s", addr)
                     if self.call(["connect", addr])[0] != 0:
-                        log.warning("connection attempt #%d failed", attempt)
+                        LOG.warning("connection attempt #%d failed", attempt)
                         sleep(retry_delay)
                         continue
                 elif not self.devices():
-                    log.warning("No device detected (attempt %d/%d)", attempt, max_attempts)
+                    LOG.warning(
+                        "No device detected (attempt %d/%d)", attempt, max_attempts
+                    )
                     sleep(retry_delay)
                     continue
                 self.connected = True
             # verify we are connected
             if not self.wait_for_boot(timeout=boot_timeout):
-                raise ADBCommunicationError("Timeout (%ds) waiting for device to boot" % (boot_timeout,))
+                raise ADBCommunicationError(
+                    "Timeout (%ds) waiting for device to boot" % (boot_timeout,)
+                )
             ret_code, user = self.call(["shell", "whoami"], device_required=False)
             if ret_code != 0 or not user:
                 self.connected = False
                 if attempt == max_attempts:
-                    raise ADBSessionError("Device in a bad state, try disconnect & reboot")
+                    raise ADBSessionError(
+                        "Device in a bad state, try disconnect & reboot"
+                    )
                 continue
             self._root = user.splitlines()[-1] == "root"
             # collect CPU and OS info
             if self._os_version is None:
-                self._os_version = self.call(["shell", "getprop", "ro.build.version.release"])[1]
+                self._os_version = self.call(
+                    ["shell", "getprop", "ro.build.version.release"]
+                )[1]
             if self._cpu_arch is None:
-                self._cpu_arch = self.call(["shell", "getprop", "ro.product.cpu.abi"])[1]
+                self._cpu_arch = self.call(["shell", "getprop", "ro.product.cpu.abi"])[
+                    1
+                ]
             # check SELinux mode
             if self._root:
                 if self.get_enforce():
@@ -354,7 +406,11 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                     attempt -= 1
                     continue
             if not as_root or self._root:
-                log.debug("connected device running Android %s (%s)", self._os_version, self._cpu_arch)
+                LOG.debug(
+                    "connected device running Android %s (%s)",
+                    self._os_version,
+                    self._cpu_arch,
+                )
                 break
             # enable root
             assert as_root, "Should not be here if root is not requested"
@@ -366,7 +422,7 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                     attempt -= 1
                     continue
             else:
-                log.warning("Failed root login attempt")
+                LOG.warning("Failed root login attempt")
         if self.connected and as_root and not self._root:
             raise ADBSessionError("Could not enable root")
         return self.connected
@@ -376,10 +432,11 @@ def create(cls, ip_addr=None, port=5555, as_root=True, max_attempts=10):
         """Create a ADBSession and connect to a device via ADB.
 
         Args:
-            ip_addr (str, optional): IP address of device to connect to if using TCP/IP. Defaults to None.
+            ip_addr (str, optional): IP address of device to connect to if using TCP/IP.
+                                     Defaults to None.
             port (int, optional): Port to use (TCP/IP only). Defaults to 5555.
             as_root (bool, optional): Attempt to enable root. Default is True.
-            max_attempt (int, optional): Number of attempts to make to try to connect to the device.
+            max_attempt (int, optional): Number of attempts to connect to the device.
 
         Returns:
             ADBSession: A connected ADBSession object otherwise None
@@ -393,7 +450,8 @@ def devices(self, all_devices=False, any_state=True):
         """Devices visible to ADB.
 
         Args:
-            all_devices (bool, optional): Don't filter devices using ANDROID_SERIAL environment variable.
+            all_devices (bool, optional): Don't filter devices using ANDROID_SERIAL
+                                          environment variable.
             any_state (bool, optional): Include devices in a state other than "device".
 
         Returns:
@@ -403,7 +461,7 @@ def devices(self, all_devices=False, any_state=True):
         devices = {}
         if ret_code != 0:
             return devices
-        target_device = os.getenv("ANDROID_SERIAL", None) if not all_devices else None
+        target_device = getenv("ANDROID_SERIAL", None) if not all_devices else None
         # skip header on the first line
         for entry in entries.splitlines()[1:]:
             try:
@@ -416,7 +474,9 @@ def devices(self, all_devices=False, any_state=True):
                 continue
             devices[name] = state
         if target_device is None and not all_devices and len(devices) > 1:
-            raise ADBSessionError("Multiple devices available and ANDROID_SERIAL not set")
+            raise ADBSessionError(
+                "Multiple devices available and ANDROID_SERIAL not set"
+            )
         return devices
 
     def disconnect(self, unroot=True):
@@ -429,7 +489,7 @@ def disconnect(self, unroot=True):
             None
         """
         if not self.connected:
-            log.debug("already disconnected")
+            LOG.debug("already disconnected")
             return
         if self._root and unroot:
             try:
@@ -437,9 +497,9 @@ def disconnect(self, unroot=True):
                     self.connected = False
                     self._root = False
                     return
-                log.warning("'unroot' failed")
+                LOG.warning("'unroot' failed")
             except ADBCommandError:
-                log.warning("'unroot' not support by ADB")
+                LOG.warning("'unroot' not support by ADB")
         elif self._ip_addr is not None:
             self.call(["disconnect", ":".join((self._ip_addr, str(self._port)))])
         self.connected = False
@@ -457,7 +517,7 @@ def get_enforce(self):
         if status == "Enforcing":
             return True
         if status != "Permissive":
-            log.warning("Unexpected SELinux state '%r'", status)
+            LOG.warning("Unexpected SELinux state '%r'", status)
         return False
 
     @classmethod
@@ -470,7 +530,7 @@ def get_package_name(cls, apk_path):
         Returns:
             str: String containing the package name otherwise None.
         """
-        if not os.path.isfile(apk_path):
+        if not Path(apk_path).is_file():
             raise IOError("APK path must point to a file")
         aapt = cls._aapt_check()
         apk_info = check_output((aapt, "dump", "badging", apk_path))
@@ -486,24 +546,26 @@ def get_pid(self, package_name):
             apk_name (str): APK to to retrieve the package name from.
 
         Returns:
-            int: PID of the process with the specified package name if it exists otherwise None.
+            int: PID of the process with the specified package name if it exists
+                 otherwise None.
         """
         # TODO: _get_procs() is slow, move to pidof ASAP
-        # pidof is not supported pre-Android 6... do we care about <6? if so we could just fall back
+        # pidof is not supported pre-Android 6... do we care about <6? if so we could
+        # just fallback
         pids = [proc.pid for proc in self._get_procs() if proc.name == package_name]
         if not pids:
             return None
         count = len(pids)
         if count > 1:
-            log.debug("get_pid() %d proc(s) found", count)
+            LOG.debug("get_pid() %d proc(s) found", count)
             # TODO: get procs and use the ppid of the procs the determine the parent
             # for now we are using the lowest pid...
             pids.sort()
         return pids[0]
 
     def install(self, apk_path):
-        """Install APK on the connected device, grant R/W permissions to /sdcard and lookup
-        the name of the installed APK.
+        """Install APK on the connected device, grant R/W permissions to /sdcard and
+        lookup the name of the installed APK.
 
         Args:
             apk_name (str): APK to install.
@@ -511,8 +573,8 @@ def install(self, apk_path):
         Returns:
             str: Package name of APK that has been installed.
         """
-        log.debug("installing %r", apk_path)
-        if not os.path.isfile(apk_path):
+        LOG.debug("installing %r", apk_path)
+        if not Path(apk_path).is_file():
             raise IOError("APK does not exist %r" % (apk_path,))
         # lookup package name
         pkg_name = self.get_package_name(apk_path)
@@ -521,9 +583,25 @@ def install(self, apk_path):
         if self.call(["install", "-g", "-r", apk_path], timeout=120)[0] != 0:
             raise ADBSessionError("Failed to install %r" % (apk_path,))
         # set permissions
-        self.call(["shell", "pm", "grant", pkg_name, "android.permission.READ_EXTERNAL_STORAGE"])
-        self.call(["shell", "pm", "grant", pkg_name, "android.permission.WRITE_EXTERNAL_STORAGE"])
-        log.debug("installed package %r (%r)", pkg_name, apk_path)
+        self.call(
+            [
+                "shell",
+                "pm",
+                "grant",
+                pkg_name,
+                "android.permission.READ_EXTERNAL_STORAGE",
+            ]
+        )
+        self.call(
+            [
+                "shell",
+                "pm",
+                "grant",
+                pkg_name,
+                "android.permission.WRITE_EXTERNAL_STORAGE",
+            ]
+        )
+        LOG.debug("installed package %r (%r)", pkg_name, apk_path)
         return pkg_name
 
     def install_file(self, src, dst, mode=None, context=None):
@@ -538,7 +616,7 @@ def install_file(self, src, dst, mode=None, context=None):
         Returns:
             None
         """
-        full_dst = os.path.join(dst, os.path.basename(src))
+        full_dst = str(Path(dst) / Path(src).name)
         self.push(src, full_dst)
         self.call(["shell", "chown", "root.shell", full_dst])
         if mode is not None:
@@ -553,7 +631,7 @@ def is_installed(self, package_name):
             package_name (str): Package name to look up on the device.
 
         Returns:
-            bool: Returns True if the package is installed on the device otherwise False.
+            bool: True if the package is installed on the device otherwise False.
         """
         return package_name in self.packages
 
@@ -564,9 +642,9 @@ def listdir(self, path):
             path (str): Directory to list the contents of.
 
         Returns:
-            list: list of strings containing names of all items in a directory.
+            list: Strings containing names of all items in a directory.
         """
-        log.debug("listdir(%r)", path)
+        LOG.debug("listdir(%r)", path)
         ret_val, output = self.call(["shell", "ls", "-A", path])
         if ret_val != 0:
             raise IOError("%r does not exist" % (path,))
@@ -576,21 +654,24 @@ def open_files(self, pid=None, children=False, files=None):
         """Look up open file on the device.
 
         Args:
-            pid (int, optional): Only include files where the process with the matching PID
-                has an open file handle.
-            children (bool, optional): Include file opened by processes with a parent PID matching pid.
-                pid is required when children is set to True
+            pid (int, optional): Only include files where the process with the matching
+                                 PID has an open file handle.
+            children (bool, optional): Include file opened by processes with a parent
+                                       PID matching pid. pid is required when children
+                                       is set to True.
             files (iterable, optional): Limit results to these specific files.
 
         Yields:
-            tuple: The first element is the PID and the second is the path of the open file.
+            tuple: PID and path of the open file.
         """
-        log.debug("open_files(pid=%r, children=%r, files=%r", pid, children, files)
+        LOG.debug("open_files(pid=%r, children=%r, files=%r", pid, children, files)
         pids = list()
         if pid is not None:
             pids.append(str(pid))
         if children:
-            assert pid is not None, "Cannot request child open files without specifying pid"
+            assert (
+                pid is not None
+            ), "Cannot request child open files without specifying pid"
             for proc in self._get_procs(pid_children=pid):
                 pids.append(str(proc.pid))
         cmd = ["shell", "lsof"]
@@ -651,7 +732,7 @@ def pull(self, src, dst):
         Returns:
             bool: True if successful otherwise False
         """
-        log.debug("pull(%r, %r)", src, dst)
+        LOG.debug("pull(%r, %r)", src, dst)
         return self.call(["pull", src, dst])[0] == 0
 
     def push(self, src, dst):
@@ -664,8 +745,8 @@ def push(self, src, dst):
         Returns:
             bool: True if successful otherwise False
         """
-        log.debug("push(%r, %r)", src, dst)
-        if not os.path.exists(src):
+        LOG.debug("push(%r, %r)", src, dst)
+        if not Path(src).exists():
             raise IOError("%r does not exist" % (src,))
         return self.call(["push", src, dst])[0] == 0
 
@@ -678,7 +759,7 @@ def realpath(self, path):
         Returns:
             str: canonical path of the specified path.
         """
-        log.debug("realpath(%r)", path)
+        LOG.debug("realpath(%r)", path)
         ret_val, output = self.call(["shell", "realpath", path])
         if ret_val != 0:
             raise IOError("%r does not exist" % (path,))
@@ -688,22 +769,23 @@ def reboot_device(self, boot_timeout=300, max_attempts=60, retry_delay=1):
         """Reboot the connected device and reconnect.
 
         Args:
-            boot_timeout (int, optional): Number of seconds to wait for device boot to complete.
-            max_attempts (int, optional): Number of attempts to make to try to connect to the device.
-            retry_delay (int, optional): Number of seconds to wait between connection attempts.
+            boot_timeout (int, optional): Seconds to wait for device boot to complete.
+            max_attempts (int, optional): Number of attempts to connect to the device.
+            retry_delay (int, optional): Seconds to wait between connection attempts.
 
         Returns:
             None
         """
         was_root = self._root
-        log.debug("calling reboot...")
+        LOG.debug("calling reboot...")
         self.call(["reboot"])
         self.connected = False
         self.connect(
             as_root=was_root,
             boot_timeout=boot_timeout,
             max_attempts=max_attempts,
-            retry_delay=retry_delay)
+            retry_delay=retry_delay,
+        )
         assert self.connected, "Device did not connect after reboot"
 
     def remount(self):
@@ -764,15 +846,11 @@ def sanitizer_options(self, prefix, options):
         """
         prefix = prefix.lower()
         assert prefix == "asan", "only ASan is supported atm"
-        working_path = mkdtemp(prefix="sanopts_", dir=grz_tmp())
-        try:
-            optfile = os.path.join(working_path, "%s.options.gecko" % prefix)
-            with open(optfile, "w+") as ofp:
-                ofp.write(":".join(["%s=%s" % opt for opt in options.items()]))
+        with TemporaryDirectory(prefix="sanopts_", dir=grz_tmp()) as working_path:
+            optfile = Path(working_path) / ("%s.options.gecko" % (prefix,))
+            optfile.write_text(":".join("%s=%s" % x for x in options.items()))
             # TODO: use push() instead?
-            self.install_file(optfile, "/data/local/tmp/", mode="666")
-        finally:
-            rmtree(working_path, ignore_errors=True)
+            self.install_file(str(optfile), "/data/local/tmp/", mode="666")
 
     def set_enforce(self, value):
         """Set SELinux mode.
@@ -785,7 +863,7 @@ def set_enforce(self, value):
         """
         assert value in (0, 1)
         if not self._root:
-            log.warning("set_enforce requires root")
+            LOG.warning("set_enforce requires root")
         self.call(["shell", "setenforce", str(value)])
 
     def symbols_path(self, package_name):
@@ -809,7 +887,7 @@ def uninstall(self, package):
             bool: True if successful otherwise False
         """
         if not self.connected:
-            log.debug("already disconnected")
+            LOG.debug("already disconnected")
             return False
         return self.call(["uninstall", package], timeout=60)[0] == 0
 
@@ -817,7 +895,7 @@ def wait_for_boot(self, timeout=None):
         """Uninstall package from the connected device.
 
         Args:
-            timeout (float or int, optional): Number of seconds to wait for device to boot.
+            timeout (float or int, optional): Seconds to wait for device to boot.
 
         Returns:
             bool: True if device booted successfully otherwise False.
@@ -827,8 +905,8 @@ def wait_for_boot(self, timeout=None):
             deadline = time() + timeout
         else:
             deadline = None
-        # first wait for the boot to complete then wait for the boot animation to complete
-        # this will help ensure the device is in a ready state
+        # first wait for the boot to complete then wait for the boot animation to
+        # complete, this will help ensure the device is in a ready state
         anim_chk = ["shell", "getprop", "init.svc.bootanim"]
         boot_chk = ["shell", "getprop", "sys.boot_completed"]
         attempts = 0
@@ -837,17 +915,18 @@ def wait_for_boot(self, timeout=None):
             if not booted:
                 booted = self.call(boot_chk, device_required=False)[1] == "1"
                 attempts += 1
-            # we need to verify that boot is complete before checking the animation is stopped because
-            # the animation can be in the stopped state early in the boot process
+            # we need to verify that boot is complete before checking the animation is
+            # stopped because the animation can be in the stopped state early in the
+            # boot process
             if booted and self.call(anim_chk)[1] == "stopped":
                 if attempts > 1:
                     # the device was booting so give it additional time
-                    log.debug("device was boot was detected")
+                    LOG.debug("device was boot was detected")
                     sleep(5)
                 return True
             if deadline and time() >= deadline:
-                log.debug("wait_for_boot() timeout %r exceeded", timeout)
+                LOG.debug("wait_for_boot() timeout %r exceeded", timeout)
                 break
-            log.debug("waiting for device to boot")
+            LOG.debug("waiting for device to boot")
             sleep(0.5)
         return False
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index 4b286484..52af86e9 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -1,12 +1,12 @@
-import argparse
-import logging
-import os
-import sys
+from argparse import ArgumentParser
+from logging import DEBUG, INFO, basicConfig, getLogger
+from os import getenv
+from os.path import isfile
 
 from .adb_process import ADBProcess
 from .adb_session import ADBSession
 
-log = logging.getLogger("adb_device")  # pylint: disable=invalid-name
+LOG = getLogger("adb_device")
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
@@ -14,90 +14,84 @@
 
 def main(argv=None):  # pylint: disable=missing-docstring
     # set output verbosity
-    if bool(os.getenv("DEBUG")):
-        log_level = logging.DEBUG
+    if bool(getenv("DEBUG")):
+        log_level = DEBUG
         log_fmt = "%(levelname).1s %(name)s [%(asctime)s] %(message)s"
     else:
-        log_level = logging.INFO
+        log_level = INFO
         log_fmt = "[%(asctime)s] %(message)s"
-    logging.basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
+    basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
 
-    parser = argparse.ArgumentParser(description="ADB Device Wrapper")
+    parser = ArgumentParser(description="ADB Device Wrapper")
     parser.add_argument(
-        "--airplane-mode", default=None, type=int,
-        help="Enable(1) or disable(0) airplane mode")
+        "--airplane-mode",
+        default=None,
+        type=int,
+        help="Enable(1) or disable(0) airplane mode",
+    )
+    parser.add_argument("--install", help="Path to APK to install")
+    parser.add_argument("--launch", help="Path to APK to launch")
+    parser.add_argument("--logs", help="Location to save logs")
+    parser.add_argument("--ip", help="IP address of target device")
     parser.add_argument(
-        "--install", help="Path to APK to install")
+        "--non-root", action="store_true", help="Connect as non-root user"
+    )
     parser.add_argument(
-        "--launch", help="Path to APK to launch")
-    parser.add_argument(
-        "--logs", help="Location to save logs")
-    parser.add_argument(
-        "--ip", help="IP address of target device")
-    parser.add_argument(
-        "--non-root", action="store_true",
-        help="Connect as non-root user")
-    parser.add_argument(
-        "--port", default=5555, type=int,
-        help="ADB listening port on target device")
-    parser.add_argument(
-        "--prep", help="Prepare the device for fuzzing. Path to APK")
+        "--port", default=5555, type=int, help="ADB listening port on target device"
+    )
+    parser.add_argument("--prep", help="Prepare the device for fuzzing. Path to APK")
     args = parser.parse_args(argv)
     if not any((args.airplane_mode is not None, args.install, args.launch, args.prep)):
         parser.error("No options selected")
-        return 1
 
     # sanity check the APK
     for apk in (args.install, args.launch, args.prep):
-        if apk is not None and not os.path.isfile(apk):
-            log.error("Invalid APK %r", apk)
+        if apk is not None and not isfile(apk):
+            LOG.error("Invalid APK %r", apk)
             return 1
 
-    log.debug("opening a session")
+    LOG.debug("opening a session")
     session = ADBSession.create(args.ip, args.port, as_root=not args.non_root)
     if session is None:
-        log.error("Failed to connect to IP:%r port:%r", args.ip, args.port)
+        LOG.error("Failed to connect to IP:%r port:%r", args.ip, args.port)
         return 1
     try:
         if args.prep is not None:
-            log.info("Preparing device...")
+            LOG.info("Preparing device...")
             args.airplane_mode = 1
             args.install = args.prep
-            asan_opts = {
-                "abort_on_error": "0",
-            }
-            session.sanitizer_options("asan", asan_opts)
+            session.sanitizer_options("asan", {"abort_on_error": "0"})
         if args.airplane_mode is not None:
             if args.airplane_mode > 0:
-                log.info("Enabling airplane mode...")
+                LOG.info("Enabling airplane mode...")
             else:
-                log.info("Disabling airplane mode...")
+                LOG.info("Disabling airplane mode...")
             session.airplane_mode = bool(args.airplane_mode)
-            log.info("Done.")
+            LOG.info("Done.")
         if args.install is not None:
             pkg_name = ADBSession.get_package_name(args.install)
             if pkg_name is None:
-                log.error("Failed to lookup package name in %r", args.install)
+                LOG.error("Failed to lookup package name in %r", args.install)
                 return 1
             if session.uninstall(pkg_name):
-                log.info("Uninstalled existing version")
-            log.info("Installing %s (%r)...", pkg_name, args.install)
+                LOG.info("Uninstalled existing version")
+            LOG.info("Installing %s (%r)...", pkg_name, args.install)
             package = session.install(args.install)
             if not package:
-                log.error("Could not install %s", args.install)
+                LOG.error("Could not install %s", args.install)
                 return 1
             session.call(["shell", "am", "set-debug-app", "--persistent", package])
-            log.info("Installed %s.", package)
+            LOG.info("Installed %s.", package)
         if args.launch:
             pkg_name = ADBSession.get_package_name(args.launch)
             if pkg_name is None:
-                log.error("Failed to lookup package name in %r", args.install)
+                LOG.error("Failed to lookup package name in %r", args.install)
                 return 1
             proc = ADBProcess(pkg_name, session)
             try:
                 proc.launch("about:blank", launch_timeout=360)
                 assert proc.is_running(), "browser not running?!"
-                log.info("Launched.")
+                LOG.info("Launched.")
                 proc.wait()
             except KeyboardInterrupt:
                 pass
@@ -106,11 +100,11 @@ def main(argv=None):  # pylint: disable=missing-docstring
                 if args.logs:
                     proc.save_logs(args.logs)
                 proc.cleanup()
-                log.info("Closed.")
+                LOG.info("Closed.")
     finally:
         session.disconnect()
     return 0
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    raise SystemExit(main())
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 60d275ab..8850e164 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -1,16 +1,20 @@
 # pylint: disable=protected-access
-import os
-import shutil
+from os import listdir
+from os.path import isdir
+from shutil import rmtree
 
-import pytest
+from pytest import mark, raises
 
-from .adb_process import ADBProcess, ADBLaunchError
+from .adb_process import ADBLaunchError, ADBProcess
 from .adb_session import ADBSession, ADBSessionError
 
+
 def test_adb_process_01(mocker):
     """test creating a simple device"""
     test_pkg = "org.test.preinstalled"
-    fake_session = mocker.Mock(spec=ADBSession, SANITIZER_LOG_PREFIX="/fake/log.txt")
+    fake_session = mocker.Mock(
+        spec_set=ADBSession, SANITIZER_LOG_PREFIX="/fake/log.txt"
+    )
     with ADBProcess(test_pkg, fake_session) as proc:
         assert isinstance(proc._session, ADBSession)
         assert proc._package == test_pkg
@@ -21,67 +25,74 @@ def test_adb_process_01(mocker):
         proc.close()
         assert not proc.logs  # should not have logs
 
+
 def test_adb_process_02(mocker):
     """test creating device with unknown package"""
-    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.is_installed.return_value = False
-    with pytest.raises(ADBSessionError, match="Package 'org.test.unknown' is not installed"):
+    with raises(ADBSessionError, match="Package 'org.test.unknown' is not installed"):
         ADBProcess("org.test.unknown", fake_session)
 
+
 def test_adb_process_03(mocker):
     """test ADBProcess.launch() unsupported app"""
-    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     with ADBProcess("org.some.app", fake_session) as proc:
-        with pytest.raises(ADBLaunchError, match="Unsupported package 'org.some.app'"):
+        with raises(ADBLaunchError, match="Unsupported package 'org.some.app'"):
             proc.launch("fake.url")
 
+
 def test_adb_process_04(mocker):
     """test ADBProcess.launch() failed bootstrap setup"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     mocker.patch("grizzly.target.adb_device.adb_process.sleep", autospec=True)
-    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.collect_logs.return_value = b""
     fake_session.listdir.return_value = ()
     fake_session.get_pid.return_value = None
     fake_session.reverse.return_value = False
     with ADBProcess("org.mozilla.fenix", fake_session) as proc:
-        with pytest.raises(ADBLaunchError, match="Could not reverse port"):
+        with raises(ADBLaunchError, match="Could not reverse port"):
             proc.launch("fake.url")
 
+
 def test_adb_process_05(mocker):
     """test ADBProcess.launch() package is running (bad state)"""
-    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (1, "")
     fake_session.collect_logs.return_value = b""
     fake_session.listdir.return_value = ()
     fake_session.process_exists.return_value = False
     with ADBProcess("org.mozilla.fenix", fake_session) as proc:
-        with pytest.raises(ADBLaunchError, match="'org.mozilla.fenix' is already running"):
+        with raises(ADBLaunchError, match="'org.mozilla.fenix' is already running"):
             proc.launch("fake.url")
         assert not proc.is_running()
         proc.cleanup()
         assert proc.logs is None
 
+
 # TODO: check config yaml output
-#def test_adb_process_06(mocker, tmp_path):
+# def test_adb_process_06(mocker, tmp_path):
 #    """test ADBProcess.launch() check *-geckoview-config.yaml"""
 
 
 def test_adb_process_07(mocker):
     """test ADBProcess.launch(), ADBProcess.is_running() and ADBProcess.is_healthy()"""
-    fake_bs = mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
+    fake_bs = mocker.patch(
+        "grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True
+    )
     fake_bs.return_value.location.return_value = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
-    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = b""
     fake_session.get_pid.side_effect = (None, 1337)
     fake_session.listdir.return_value = ()
-    #fake_session.process_exists.return_value = False
+    # fake_session.process_exists.return_value = False
     with ADBProcess("org.mozilla.geckoview_example", fake_session) as proc:
         assert not proc.is_running()
         assert proc.launches == 0
@@ -95,27 +106,31 @@ def test_adb_process_07(mocker):
     assert fake_bs.return_value.wait.call_count == 1
     assert fake_bs.return_value.close.call_count == 1
 
+
 def test_adb_process_08(mocker):
     """test ADBProcess.launch() with environment variables"""
-    fake_bs = mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
+    fake_bs = mocker.patch(
+        "grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True
+    )
     fake_bs.return_value.location.return_value = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
-    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = b""
     fake_session.get_pid.side_effect = (None, 1337)
     fake_session.listdir.return_value = ()
-    env = {"test1":"1", "test2": "2"}
+    env = {"test1": "1", "test2": "2"}
     with ADBProcess("org.mozilla.geckoview_example", fake_session) as proc:
         assert proc.launch("fake.url", env_mod=env)
         assert proc.is_running()
         proc.close()
 
+
 def test_adb_process_09(mocker):
     """test ADBProcess.wait_on_files()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
-    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = b""
@@ -128,15 +143,23 @@ def test_adb_process_09(mocker):
         assert proc.launch("fake.url")
         assert proc.wait_on_files([])
         mocker.patch("grizzly.target.adb_device.adb_process.sleep", autospec=True)
-        mocker.patch("grizzly.target.adb_device.adb_process.time", side_effect=(1, 1, 2))
-        fake_session.open_files.return_value = ((1, "some_file"), (1, "/existing/file.txt"))
-        assert not proc.wait_on_files(["/existing/file.txt"], poll_rate=0.1, timeout=0.3)
+        mocker.patch(
+            "grizzly.target.adb_device.adb_process.time", side_effect=(1, 1, 2)
+        )
+        fake_session.open_files.return_value = (
+            (1, "some_file"),
+            (1, "/existing/file.txt"),
+        )
+        assert not proc.wait_on_files(
+            ["/existing/file.txt"], poll_rate=0.1, timeout=0.3
+        )
         proc.close()
 
+
 def test_adb_process_10(mocker):
     """test ADBProcess.find_crashreports()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
-    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     with ADBProcess("org.some.app", fake_session) as proc:
         proc.profile = "profile_path"
@@ -153,10 +176,11 @@ def test_adb_process_10(mocker):
         fake_session.listdir.side_effect = ([], IOError("test"))
         assert not proc.find_crashreports()
 
+
 def test_adb_process_11(mocker, tmp_path):
     """test ADBProcess.save_logs()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
-    fake_session = mocker.Mock(spec=ADBSession)
+    fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     log_path = tmp_path / "src"
     log_path.mkdir()
@@ -170,91 +194,93 @@ def test_adb_process_11(mocker, tmp_path):
         # with proc.logs set
         proc.logs = str(log_path)
         proc.save_logs(str(dmp_path))
-    assert "fake.txt" in os.listdir(str(dmp_path))
+    assert any(dmp_path.glob("fake.txt"))
+
 
 def test_adb_process_12(mocker):
     """test ADBProcess._process_logs()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     mocker.patch("grizzly.target.adb_device.adb_process.PuppetLogger", autospec=True)
-    fake_proc_md = mocker.patch("grizzly.target.adb_device.adb_process.process_minidumps", autospec=True)
-    fake_session = mocker.Mock(spec=ADBSession)
+    fake_proc_md = mocker.patch(
+        "grizzly.target.adb_device.adb_process.process_minidumps", autospec=True
+    )
+    fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.collect_logs.return_value = b"fake logcat data"
     with ADBProcess("org.some.app", fake_session) as proc:
         # no extra logs
         proc._process_logs([])
-        assert os.path.isdir(proc.logs)
+        assert isdir(proc.logs)
         try:
-            assert "log_logcat.txt" in os.listdir(proc.logs)
+            assert "log_logcat.txt" in listdir(proc.logs)
         finally:
-            shutil.rmtree(proc.logs)
+            rmtree(proc.logs)
         proc.logs = None
         assert fake_proc_md.call_count == 0
         assert fake_session.pull.call_count == 0
         # other logs available
         proc._process_logs(["log.dmp", "asan_log.txt"])
-        assert os.path.isdir(proc.logs)
+        assert isdir(proc.logs)
         try:
-            assert "log_logcat.txt" in os.listdir(proc.logs)
+            assert "log_logcat.txt" in listdir(proc.logs)
         finally:
-            shutil.rmtree(proc.logs)
+            rmtree(proc.logs)
         assert fake_proc_md.call_count == 1
         assert fake_session.pull.call_count == 2
 
+
 def test_adb_process_13(tmp_path):
     """test ADBProcess._split_logcat()"""
     log_path = tmp_path / "logs"
     log_path.mkdir()
     # missing log_logcat.txt
     ADBProcess._split_logcat(str(log_path), "fake.package")
-    assert not os.listdir(str(log_path))
+    assert not any(log_path.iterdir())
     # with log_logcat.txt
-    logstderr = tmp_path / "logs" / "log_stderr.txt"
-    logstderr.touch()
-    logstdout = tmp_path / "logs" / "log_stdout.txt"
-    logstdout.touch()
-    logcat = tmp_path / "logs" / "log_logcat.txt"
-    with logcat.open("wb") as log_fp:
-        log_fp.write(b"07-27 12:10:15.414  80  80 W art     : Unexpected CPU variant for X86 using defaults: x86\n")
-        log_fp.write(b"07-27 12:10:15.430  90  90 I GeckoApplication: zerdatime 3349725 - application start\n")
-        log_fp.write(b"07-27 12:10:15.442  90  44 I GeckoThread: preparing to run Gecko\n")
-        log_fp.write(b"07-27 12:10:15.442  90  44 E GeckoLibLoad: Load sqlite start\n")
-        log_fp.write(b"07-27 12:10:15.496  81  81 I GRALLOC-DRM: foo\n")
-        log_fp.write(b"07-27 12:10:15.505  90  43 I GeckoDump: test, line1\n")
-        log_fp.write(b"07-27 12:10:15.505  90  43 E GeckoApp: test, line2\n")
-        log_fp.write(b"07-27 12:10:15.520  82  49 I EGL-DRI2: found extension DRI_Core version 1\n")
-        log_fp.write(b"07-27 12:10:15.521  82  49 I OpenGLRenderer: Initialized EGL, version 1.4\n")
-        log_fp.write(b"07-27 12:10:15.528  90  44 E GeckoLibLoad: Load sqlite done\n")
-        log_fp.write(b"07-27 12:10:15.529  80  80 W art     : Suspending all threads took: 8.966ms\n")
-        log_fp.write(b"07-27 12:10:15.533  90  44 E GeckoLibLoad: Load nss done\n")
-        log_fp.write(b"07-27 12:39:27.188  39  39 W Fake  : asdf\n")
-        log_fp.write(b"07-27 12:39:27.239  17  14 I InputReader: Reconfiguring input devices.  changes=0x00000010\n")
-        log_fp.write(b"07-27 12:39:27.440  78  78 E android.os.Debug: failed to load memtrack module: 90\n")
-        log_fp.write(b"07-27 12:39:27.441  78  78 I Radio-JNI: register_android_hardware_Radio DONE\n")
-        log_fp.write(b"07-27 12:39:27.442 18461 18481 F MOZ_CRASH: Hit MOZ_CRASH(test) at gpp.rs:17\n")
-        log_fp.write(b"07-27 12:39:27.443  90  90 I eckoThrea: potentially missed\n")
+    (tmp_path / "logs" / "log_logcat.txt").write_text(
+        "07-27 12:10:15.414  80  80 W art     :"
+        " Unexpected CPU variant for X86 using defaults: x86\n"
+        "07-27 12:10:15.430  90  90 I GeckoApplication:"
+        " zerdatime 3349725 - application start\n"
+        "07-27 12:10:15.442  90  44 I GeckoThread: preparing to run Gecko\n"
+        "07-27 12:10:15.442  90  44 E GeckoLibLoad: Load sqlite start\n"
+        "07-27 12:10:15.496  81  81 I GRALLOC-DRM: foo\n"
+        "07-27 12:10:15.505  90  43 I GeckoDump: test, line1\n"
+        "07-27 12:10:15.505  90  43 E GeckoApp: test, line2\n"
+        "07-27 12:10:15.520  82  49 I EGL-DRI2: found extension DRI_Core version 1\n"
+        "07-27 12:10:15.521  82  49 I OpenGLRenderer: Initialized EGL, version 1.4\n"
+        "07-27 12:10:15.528  90  44 E GeckoLibLoad: Load sqlite done\n"
+        "07-27 12:10:15.529  80  80 W art     : Suspending all threads took: 8.966ms\n"
+        "07-27 12:10:15.533  90  44 E GeckoLibLoad: Load nss done\n"
+        "07-27 12:39:27.188  39  39 W Fake  : asdf\n"
+        "07-27 12:39:27.239  17  14 I InputReader:"
+        " Reconfiguring input devices.  changes=0x00000010\n"
+        "07-27 12:39:27.440  78  78 E android.os.Debug:"
+        " failed to load memtrack module: 90\n"
+        "07-27 12:39:27.441  78  78 I Radio-JNI: register_android_hardware_Radio DONE\n"
+        "07-27 12:39:27.442 18461 18481 F MOZ_CRASH: Hit MOZ_CRASH(test) at gpp.rs:17\n"
+        "07-27 12:39:27.443  90  90 I eckoThrea: potentially missed\n"
+    )
     ADBProcess._split_logcat(str(log_path), "fake.package")
-    log_files = os.listdir(str(log_path))
-    assert log_files
-    with logstdout.open("rb") as log_fp:
-        assert log_fp.read().rstrip() == b"test, line1"
-    with logstderr.open("rb") as log_fp:
-        stderr_lines = log_fp.read().splitlines()
-    assert b"test, line2" in stderr_lines
-    assert b"test, line1" not in stderr_lines
+    assert any(log_path.iterdir())
+    assert (tmp_path / "logs" / "log_stdout.txt").read_text().rstrip() == "test, line1"
+    stderr_lines = (tmp_path / "logs" / "log_stderr.txt").read_text().splitlines()
+    assert "test, line2" in stderr_lines
+    assert "test, line1" not in stderr_lines
     assert len(stderr_lines) == 8
 
-@pytest.mark.parametrize(
+
+@mark.parametrize(
     "input_data, result",
     [
         ("", dict()),
-        ("junk\n#user_pref(\"a.b\", 0)\n", dict()),
-        ("user_pref(\"a.b.c\", false);\n", {"a.b.c": False}),
-        ("user_pref(\"a.b.c\", 0);", {"a.b.c": 0}),
+        ('junk\n#user_pref("a.b", 0)\n', dict()),
+        ('user_pref("a.b.c", false);\n', {"a.b.c": False}),
+        ('user_pref("a.b.c", 0);', {"a.b.c": 0}),
         ("user_pref(\"a.b.c\", 'test');", {"a.b.c": "test"}),
-        ("user_pref(\"a.b.c\", \"test\");", {"a.b.c": "test"}),
-        ("user_pref(\"a.b\", 1);\nuser_pref(\"a.c\", true);", {"a.b": 1, "a.c": True}),
-        ("user_pref(\"a.b\", 1);\n#\nuser_pref(\"a.c\", 1);", {"a.b": 1, "a.c": 1}),
+        ('user_pref("a.b.c", "test");', {"a.b.c": "test"}),
+        ('user_pref("a.b", 1);\nuser_pref("a.c", true);', {"a.b": 1, "a.c": True}),
+        ('user_pref("a.b", 1);\n#\nuser_pref("a.c", 1);', {"a.b": 1, "a.c": 1}),
     ],
 )
 def test_adb_process_14(tmp_path, input_data, result):
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index ed013c09..4d2b58cb 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -1,41 +1,58 @@
 # pylint: disable=protected-access
-import os
 from pathlib import Path
-from subprocess import CalledProcessError
-import zipfile
+from zipfile import ZipFile
 
-import pytest
+from pytest import raises
+
+from .adb_session import (
+    ADBCommandError,
+    ADBCommunicationError,
+    ADBSession,
+    ADBSessionError,
+)
 
-from .adb_session import ADBCommandError, ADBCommunicationError, ADBSession, ADBSessionError
 
 def test_adb_session_01(mocker):
     """test ADBSession._call_adb()"""
+
     def fake_call(cmd, stderr=None, stdout=None):
         assert cmd[0] == "test"
         stderr.write(b"")
         stdout.write(b"blah_out")
         return 0
+
     mocker.patch("grizzly.target.adb_device.adb_session.call", side_effect=fake_call)
     ret, output = ADBSession._call_adb(["test"])
     assert ret == 0
     assert "blah_out" in output
     # test with invalid timeout
-    with pytest.raises(AssertionError):
+    with raises(AssertionError):
         ADBSession._call_adb(["test"], timeout=-1)
+
     # test with timeout
-    class FakeProc(object):
+    class FakeProc:
         def __init__(self, cmd, stderr=None, stdout=None):
             assert cmd[0] == "test"
             self.stdout = stdout
             stderr.write(b"")
             stdout.write(b"init\n")
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *_args):
+            pass
+
         def wait(self):
             self.stdout.write(b"wait\n")
             return 1
+
         def terminate(self):
             self.stdout.write(b"terminate\n")
+
         def poll(self):
             self.stdout.write(b"poll\n")
+
     mocker.patch("grizzly.target.adb_device.adb_session.Popen", new=FakeProc)
     mocker.patch("grizzly.target.adb_device.adb_session.sleep")
     mocker.patch("grizzly.target.adb_device.adb_session.time", side_effect=(1, 1, 2))
@@ -46,45 +63,61 @@ def poll(self):
     assert "terminate" in output
     assert "wait" in output
 
+
 def test_adb_session_02(mocker):
     """test ADBSession.call()"""
     # not connected
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="fake_adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="fake_adb"
+    )
     session = ADBSession()
-    with pytest.raises(ADBCommunicationError, match="ADB session is not connected!"):
+    with raises(ADBCommunicationError, match="ADB session is not connected!"):
         session.call(["test"])
     # successful call
     session.connected = True
     session._debug_adb = True
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", return_value=(0, "pass"))
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", return_value=(0, "pass")
+    )
     ret_code, output = session.call(["test"])
     assert ret_code == 0
     assert output == "pass"
     # invalid command
     session._debug_adb = False
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", return_value=(1, "Android Debug Bridge version"))
-    with pytest.raises(ADBCommandError, match="Invalid ADB command 'test'"):
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb",
+        return_value=(1, "Android Debug Bridge version"),
+    )
+    with raises(ADBCommandError, match="Invalid ADB command 'test'"):
         session.call(["test"])
     # invalid command
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", return_value=(1, "adb: usage:"))
-    with pytest.raises(ADBCommandError, match="adb: usage:"):
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb",
+        return_value=(1, "adb: usage:"),
+    )
+    with raises(ADBCommandError, match="adb: usage:"):
         session.call(["test"])
     # disconnected device
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", return_value=(1, "error: closed"))
-    with pytest.raises(ADBCommunicationError, match="No device detected!"):
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb",
+        return_value=(1, "error: closed"),
+    )
+    with raises(ADBCommunicationError, match="No device detected!"):
         session.call(["test"])
     assert not session.connected
 
+
 def test_adb_session_03(mocker):
     """test creating a session with invalid args"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check")
-    with pytest.raises(ValueError):
+    with raises(ValueError):
         ADBSession("invalid.ip")
-    with pytest.raises(ValueError):
+    with raises(ValueError):
         ADBSession("127.0.0.1", port=7)
-    with pytest.raises(ValueError):
+    with raises(ValueError):
         ADBSession("127.0.0.1", port="bad")
 
+
 def test_adb_session_04(mocker):
     """test simple ADBSession"""
     mocker.patch("grizzly.target.adb_device.ADBSession._adb_check")
@@ -98,56 +131,85 @@ def test_adb_session_04(mocker):
     assert session._port == test_port
     assert session._os_version is None
 
+
 def test_adb_session_05(mocker):
     """test ADBSession.devices()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_01(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "devices":
             return 1, ""
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_01)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_01
+    )
     assert not ADBSession().devices()
+
+    # pylint: disable=unused-argument
     def fake_adb_02(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "devices":
-            return 0, "List of devices attached\n" \
-                      "emulator-5554   device\n" \
-                      "emulator-5556   offline"
+            return (
+                0,
+                "List of devices attached\n"
+                "emulator-5554   device\n"
+                "emulator-5556   offline",
+            )
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_02)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_02
+    )
     devices = ADBSession().devices(all_devices=True, any_state=False)
     assert len(devices) == 1
     assert "emulator-5554" in devices
+
+    # pylint: disable=unused-argument
     def fake_adb_03(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "devices":
-            return 0, "List of devices attached\n" \
-                      "* daemon not running; starting now at tcp:5037\n" \
-                      "* daemon started successfully\n" \
-                      "emulator-5554   device\n" \
-                      "emulator-5556   offline\n" \
-                      "emulator-5558   device\n"
+            return (
+                0,
+                "List of devices attached\n"
+                "* daemon not running; starting now at tcp:5037\n"
+                "* daemon started successfully\n"
+                "emulator-5554   device\n"
+                "emulator-5556   offline\n"
+                "emulator-5558   device\n",
+            )
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_03)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_03
+    )
     session = ADBSession()
-    os.environ["ANDROID_SERIAL"] = "emulator-5558"
-    try:
-        devices = session.devices(all_devices=False, any_state=False)
-    finally:
-        os.environ.pop("ANDROID_SERIAL")
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.getenv", return_value="emulator-5558"
+    )
+    devices = session.devices(all_devices=False, any_state=False)
     assert len(devices) == 1
     assert "emulator-5558" in devices
-    with pytest.raises(ADBSessionError):
+    mocker.patch("grizzly.target.adb_device.adb_session.getenv", return_value=None)
+    with raises(ADBSessionError):
         session.devices(all_devices=False, any_state=False)
 
+
 def test_adb_session_06(mocker):
     """test simple ADBSession.create()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
     test_arch = "x86_64"
     test_ip = "localhost"
     test_port = 5555
     test_version = "9"
+
+    # pylint: disable=too-many-return-statements,unused-argument
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
@@ -169,7 +231,10 @@ def fake_adb_call(obj, cmd, timeout=None):
         if cmd[1] == "shell" and cmd[2] == "whoami":
             return 0, "root"
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     ADBSession._call_adb = fake_adb_call
     session = ADBSession.create(test_ip, test_port)
     assert session is not None
@@ -180,14 +245,19 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert session._os_version == test_version
     assert session._port == test_port
 
+
 def test_adb_session_07(mocker):
     """test full ADBSession.create()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
     test_arch = "x86_64"
     test_ip = "localhost"
     test_port = 5555
     test_version = "9"
     test_enforcing = True
+
+    # pylint: disable=too-many-return-statements,unused-argument
     def fake_adb_call(obj, cmd, timeout=None):
         nonlocal test_enforcing
         assert cmd and cmd[0].endswith("adb")
@@ -236,6 +306,7 @@ def fake_adb_call(obj, cmd, timeout=None):
             obj.connected = False
             return 0, "restarting adbd as non root"
         raise AssertionError("unexpected command %r" % (cmd,))
+
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
     ADBSession._call_adb = fake_adb_call
     session = ADBSession.create(test_ip, test_port)
@@ -250,11 +321,16 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert not session.connected
     assert not session._root
 
+
 def test_adb_session_08(mocker):
     """test ADBSession.create() without IP"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
     test_arch = "x86"
     test_version = "7.1.2"
+
+    # pylint: disable=too-many-return-statements,unused-argument
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
@@ -264,10 +340,13 @@ def fake_adb_call(obj, cmd, timeout=None):
             obj.connected = False
             return 0, ""
         if cmd[1] == "devices":
-            return 0, "\n".join(("List of devices attached",
-                                 "* daemon not running; starting now at tcp:5037",
-                                 "* daemon started successfully",
-                                 "emulator-5554   device"))
+            return (
+                0,
+                "List of devices attached\n"
+                "* daemon not running; starting now at tcp:5037\n"
+                "* daemon started successfully\n"
+                "emulator-5554   device",
+            )
         if cmd[1] == "shell" and cmd[2] == "getenforce":
             return 0, "Permissive"
         if cmd[1] == "shell" and cmd[2] == "getprop":
@@ -282,6 +361,7 @@ def fake_adb_call(obj, cmd, timeout=None):
         if cmd[1] == "shell" and cmd[2] == "whoami":
             return 0, "shell"
         raise AssertionError("unexpected command %r" % (cmd,))
+
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
     ADBSession._call_adb = fake_adb_call
     session = ADBSession.create(as_root=False)
@@ -295,27 +375,45 @@ def fake_adb_call(obj, cmd, timeout=None):
     session.disconnect()
     assert not session.connected
 
+
 def test_adb_session_09(mocker):
     """test ADBSession.connect() no devices available"""
-    mocker.patch("grizzly.target.adb_device.adb_session.sleep")  # skip delay after warning message
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.sleep"
+    )  # skip delay after warning message
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
             return 1, "unable to connect"
         if cmd[1] == "devices":
-            return 0, "\n".join(("List of devices attached",
-                                 "* daemon not running; starting now at tcp:5037",
-                                 "* daemon started successfully"))
+            return (
+                0,
+                "List of devices attached\n"
+                "* daemon not running; starting now at tcp:5037\n"
+                "* daemon started successfully",
+            )
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     assert not ADBSession().connect()
     assert not ADBSession("127.0.0.1").connect()
 
+
 def test_adb_session_10(mocker):
     """test ADBSession.connect() device in a bad state"""
     mocker.patch("grizzly.target.adb_device.adb_session.sleep")  # skip delays
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
@@ -330,13 +428,23 @@ def fake_adb_call(cmd, timeout=None):
         if cmd[1] == "shell" and cmd[2] == "whoami":
             return 1, ""
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
-    with pytest.raises(ADBSessionError, match="Device in a bad state, try disconnect & reboot"):
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
+    with raises(
+        ADBSessionError, match="Device in a bad state, try disconnect & reboot"
+    ):
         ADBSession("127.0.0.1").connect()
 
+
 def test_adb_session_11(mocker):
     """test ADBSession.connect() and ADBSession.disconnect()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=too-many-return-statements,unused-argument
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
@@ -345,10 +453,13 @@ def fake_adb_call(obj, cmd, timeout=None):
             obj.connected = True
             return 0, ""
         if cmd[1] == "devices":
-            return 0, "\n".join(("List of devices attached",
-                                 "* daemon not running; starting now at tcp:5037",
-                                 "* daemon started successfully",
-                                 "emulator-5554   device"))
+            return (
+                0,
+                "List of devices attached\n"
+                "* daemon not running; starting now at tcp:5037\n"
+                "* daemon started successfully\n"
+                "emulator-5554   device",
+            )
         if cmd[1] == "disconnect":
             if not obj.connected:
                 return 0, "already disconnected"
@@ -378,6 +489,7 @@ def fake_adb_call(obj, cmd, timeout=None):
             obj.connected = False
             return 0, "restarting adbd as non root"
         raise AssertionError("unexpected command %r" % (cmd,))
+
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
     ADBSession._call_adb = fake_adb_call
     session = ADBSession("127.0.0.1")
@@ -408,9 +520,14 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert not session.connected
     assert not session._root
 
+
 def test_adb_session_12(mocker):
     """test ADBSession.connect() with unavailable device"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
@@ -418,7 +535,10 @@ def fake_adb_call(cmd, timeout=None):
         if cmd[1] == "disconnect":
             return 0, ""
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     assert not session.connected
     assert not session._root
@@ -428,25 +548,35 @@ def fake_adb_call(cmd, timeout=None):
     assert not session.connected
     assert not session._root
 
+
 def test_adb_session_13(mocker):
     """test ADBSession.all() with unknown command"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
     mocker.patch(
         "grizzly.target.adb_device.ADBSession._call_adb",
-        return_value=(1, "Android Debug Bridge version 1.0.XX"))
+        return_value=(1, "Android Debug Bridge version 1.0.XX"),
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
     session._root = True
-    with pytest.raises(ADBCommandError):
+    with raises(ADBCommandError):
         session.call(["unknown-cmd"])
 
+
 def test_adb_session_14(tmp_path, mocker):
     """test ADBSession.install()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
     def fake_get_package_name(_):
-        with zipfile.ZipFile(apk_file, mode="r") as zfp:
+        with ZipFile(apk_file, mode="r") as zfp:
             with zfp.open("package-name.txt", "r") as pfp:
                 return pfp.read().strip().decode("utf-8", errors="ignore")
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "install":
@@ -461,109 +591,152 @@ def fake_adb_call(cmd, timeout=None):
             assert cmd[4] == "test-package.blah.foo"
             return 0, ""
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
-    mocker.patch("grizzly.target.adb_device.ADBSession.get_package_name", side_effect=fake_get_package_name)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession.get_package_name",
+        side_effect=fake_get_package_name,
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
     # missing apk
-    with pytest.raises(IOError):
+    with raises(IOError):
         session.install("fake_path")
     # bad apk
     pkg_file = tmp_path / "package-name.txt"
     apk_file = str(tmp_path / "bad.apk")
     pkg_file.write_bytes(b"\n")
-    with zipfile.ZipFile(apk_file, mode="w") as z_out:
+    with ZipFile(apk_file, mode="w") as z_out:
         z_out.write(str(pkg_file), "package-name.txt")
-    with pytest.raises(ADBSessionError):
+    with raises(ADBSessionError):
         session.install(str(apk_file))
     # good apk
     pkg_file = tmp_path / "package-name.txt"
     apk_file = str(tmp_path / "test.apk")
-    syms_path = str(tmp_path / "symbols")
-    os.makedirs(syms_path)
+    syms_path = tmp_path / "symbols"
+    syms_path.mkdir()
     pkg_file.write_bytes(b"test-package.blah.foo\n")
-    with zipfile.ZipFile(apk_file, mode="w") as z_out:
+    with ZipFile(apk_file, mode="w") as z_out:
         z_out.write(str(pkg_file), "package-name.txt")
     assert not session.symbols_path(apk_file)
     assert session.install(apk_file)
-    session.symbols[apk_file] = syms_path
-    assert session.symbols_path(apk_file) == syms_path
+    session.symbols[apk_file] = str(syms_path)
+    assert session.symbols_path(apk_file) == str(syms_path)
     # TODO: failed to get package name
 
+
 def test_adb_session_15(mocker):
     """test ADBSession.uninstall()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "uninstall" and cmd[2] == "org.test.preinstalled":
             return 0, "Success"
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     assert not session.uninstall("org.test.unknown")
     session.connected = True
     assert session.uninstall("org.test.preinstalled")
 
+
 def test_adb_session_16(mocker):
     """test ADBSession.get_pid()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ps":
-            output = (
-                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME",
-                "test      1337  1772  1024   1024 SyS_epoll_ 00000000 S org.test.preinstalled",
-                "root      5847  1     315992 2348  poll_sched 00000000 S /sbin/adbd",
-                "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora",
-                "root      5944  5847  6280   2360           0 00000000 R ps",
-                "")
-            return 0, "\n".join(output)
+            return (
+                0,
+                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME\n"
+                "test      1337  1772  1024   1024 SyS_epoll_ 00000000 S"
+                " org.test.preinstalled\n"
+                "root      5847  1     315992 2348  poll_sched 00000000 S"
+                " /sbin/adbd\n"
+                "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S"
+                " org.mozilla.fennec_aurora\n"
+                "root      5944  5847  6280   2360           0 00000000 R ps\n\n",
+            )
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
-    with pytest.raises(ADBCommunicationError, match="ADB session is not connected!"):
+    with raises(ADBCommunicationError, match="ADB session is not connected!"):
         session.get_pid("org.test.unknown")
     session.connected = True
     assert session.get_pid("org.test.unknown") is None
     assert session.get_pid("org.test.preinstalled") == 1337
 
+
 def test_adb_session_17(mocker):
     """test ADBSession.is_installed()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "pm":
             assert cmd[3] == "list"
             assert cmd[4] == "packages"
-            output = (
-                "package:org.mozilla.fennec_aurora",
-                "package:org.test.preinstalled",
-                "package:com.android.phone",
-                "package:com.android.shell")
-            return 0, "\n".join(output)
+            return (
+                0,
+                "package:org.mozilla.fennec_aurora\n"
+                "package:org.test.preinstalled\n"
+                "package:com.android.phone\n"
+                "package:com.android.shell",
+            )
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert not session.is_installed("org.test.unknown")
     assert session.is_installed("org.test.preinstalled")
 
+
 def test_adb_session_18(mocker):
     """test ADBSession.packages()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "pm":
             assert cmd[3] == "list"
             assert cmd[4] == "packages"
-            output = (
-                "package:org.mozilla.fennec_aurora",
-                "package:org.test.preinstalled",
-                "package:com.android.phone",
-                "package:com.android.shell")
-            return 0, "\n".join(output)
+            return (
+                0,
+                "package:org.mozilla.fennec_aurora\n"
+                "package:org.test.preinstalled\n"
+                "package:com.android.phone\n"
+                "package:com.android.shell",
+            )
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
     pkgs = tuple(session.packages)
@@ -573,9 +746,14 @@ def fake_adb_call(cmd, timeout=None):
     assert "org.mozilla.fennec_aurora" in pkgs
     assert "org.test.preinstalled" in pkgs
 
+
 def test_adb_session_19(mocker):
     """test ADBSession.collect_logs()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "logcat":
@@ -595,16 +773,21 @@ def fake_adb_call(cmd, timeout=None):
                     "07-27 12:10:15.505  9990  4713 E fake log",
                     "07-27 12:10:15.520  9990  4719 I fake log",
                     "07-27 12:10:15.529  9990  4707 W fake log",
-                    "07-27 12:10:15.533  9990  4714 E fake log"]
+                    "07-27 12:10:15.533  9990  4714 E fake log",
+                ]
             if pid == -1:
                 output += [
                     "07-27 12:39:27.188  3049  3049 W fake log",
                     "07-27 12:39:27.239  1887  1994 I fake log",
                     "07-27 12:39:27.286  2767  7142 I fake log",
-                    "07-27 12:39:27.441  7128  7128 I fake log"]
+                    "07-27 12:39:27.441  7128  7128 I fake log",
+                ]
             return 0, "\n".join(output)
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     # test not connected
     assert session.collect_logs() == ""
@@ -614,51 +797,86 @@ def fake_adb_call(cmd, timeout=None):
     assert len(session.collect_logs(9990).splitlines()) == 7
     assert not session.collect_logs(1111).splitlines()
 
+
 def test_adb_session_20(mocker):
     """test ADBSession.open_files()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "lsof":
             if len(cmd) == 5:
                 assert cmd[3].startswith("-p")
-            output = (
-                "COMMAND     PID    USER   FD      TYPE   DEVICE  SIZE/OFF       NODE NAME",
-                "init          1    root  cwd   unknown                               /proc/1/cwd (readlink: Permission denied)",
-                "lsof      15988   shell  cwd       DIR     0,13       780       4234 /",
-                "lsof      15988   shell  txt       REG      8,1    432284    1696174 /system/bin/toybox",
-                "lsof      15988   shell    4r      DIR      0,4         0     120901 /proc/15988/fd",
-                "a.fennec_  9991  u0_a80   98r      REG      8,1    306672    1696611 /system/fonts/blah.ttf",
-                "a.fennec_  9990  u0_a80  cwd       DIR     0,13       780       4234 /",
-                "a.fennec_  9990  u0_a80  txt       REG      8,1     17948    1695879 /system/bin/app_process32",
-                "a.fennec_  9990  u0_a80  mem   unknown                               /dev/ashmem/dalvik-main space (deleted)",
-                "a.fennec_  9990  u0_a80  mem       CHR    10,58                 4485 /dev/binder",
-                "a.fennec_  9990  u0_a80  mem   unknown                               /dev/ashmem/dalvik-allocspace zygote / x 0 (deleted)",
-                "a.fennec_  9990  u0_a80  mem       REG      8,1    152888    1704079 /system/lib/libexpat.so",
-                "a.fennec_  9990  u0_a80   54u      REG      8,1    329632    1769879 /data/data/org.mozilla.fennec_aurora/files/mozilla/a.default/browser.db-wal",
-                "a.fennec_  9990  u0_a80   55u     IPv6                0t0      44549 TCP []:49232->[]:443 (ESTABLISHED)",
-                "a.fennec_  9990  u0_a80   75w     FIFO      0,9       0t0      44634 pipe:[44634]",
-                "a.fennec_  9990  u0_a80   76u     sock                0t0      44659 socket:[44659]",
-                "a.fennec_  9990  u0_a80   95u      REG      8,1     98304    1769930 /data/data/org.mozilla.fennec_aurora/files/mozilla/a.default/permissions.sqlite",
-                "a.fennec_  9990  u0_a80   98r      REG      8,1    306672    1696611 /system/fonts/Roboto-Regular.ttf",
-                "a.fennec_  9990  u0_a80  122u      CHR    10,59       0t0       4498 /dev/ashmem",
-                "a.fennec_  9990  u0_a80  123u     IPv4                0t0      44706 UDP :1900->:0",
-                "a.fennec_  9990  u0_a80  125u     0000     0,10       0t0       3655 anon_inode:[eventpoll]",
-                "a.fennec_  9990  u0_a80  126u     IPv4                0t0      44773 TCP :58190->:443 (ESTABLISHED)",
-                "a.fennec_  9990  u0_a80  128u     unix                0t0      44747 socket",
-                "a.fennec_  9990  u0_a80  130u     IPv4                0t0      44840 TCP :35274->:443 (SYN_SENT)",
-                "")
-            return 0, "\n".join(output)
+            return (
+                0,
+                "COMMAND     PID    USER   FD      TYPE   DEVICE  SIZE/OFF"
+                "       NODE NAME\n"
+                "init          1    root  cwd   unknown                   "
+                "            /proc/1/cwd (readlink: Permission denied)\n"
+                "lsof      15988   shell  cwd       DIR     0,13       780"
+                "       4234 /\n"
+                "lsof      15988   shell  txt       REG      8,1    432284"
+                "    1696174 /system/bin/toybox\n"
+                "lsof      15988   shell    4r      DIR      0,4         0"
+                "     120901 /proc/15988/fd\n"
+                "a.fennec_  9991  u0_a80   98r      REG      8,1    306672"
+                "    1696611 /system/fonts/blah.ttf\n"
+                "a.fennec_  9990  u0_a80  cwd       DIR     0,13       780"
+                "       4234 /\n"
+                "a.fennec_  9990  u0_a80  txt       REG      8,1     17948"
+                "    1695879 /system/bin/app_process32\n"
+                "a.fennec_  9990  u0_a80  mem   unknown                   "
+                "            /dev/ashmem/dalvik-main space (deleted)\n"
+                "a.fennec_  9990  u0_a80  mem       CHR    10,58          "
+                "       4485 /dev/binder\n"
+                "a.fennec_  9990  u0_a80  mem   unknown                   "
+                "            /dev/ashmem/dalvik-allocspace zygote / x 0 (deleted)\n"
+                "a.fennec_  9990  u0_a80  mem       REG      8,1    152888"
+                "    1704079 /system/lib/libexpat.so\n"
+                "a.fennec_  9990  u0_a80   54u      REG      8,1    329632"
+                "    1769879 /data/data/org.mozilla.fennec_aurora/files/mozilla/a.defau"
+                "lt/browser.db-wal\n"
+                "a.fennec_  9990  u0_a80   55u     IPv6                0t0"
+                "      44549 TCP []:49232->[]:443 (ESTABLISHED)\n"
+                "a.fennec_  9990  u0_a80   75w     FIFO      0,9       0t0"
+                "      44634 pipe:[44634]\n"
+                "a.fennec_  9990  u0_a80   76u     sock                0t0"
+                "      44659 socket:[44659]\n"
+                "a.fennec_  9990  u0_a80   95u      REG      8,1     98304"
+                "    1769930 /data/data/org.mozilla.fennec_aurora/files/mozilla/a.defau"
+                "lt/permissions.sqlite\n"
+                "a.fennec_  9990  u0_a80   98r      REG      8,1    306672"
+                "    1696611 /system/fonts/Roboto-Regular.ttf\n"
+                "a.fennec_  9990  u0_a80  122u      CHR    10,59       0t0"
+                "       4498 /dev/ashmem\n"
+                "a.fennec_  9990  u0_a80  123u     IPv4                0t0"
+                "      44706 UDP :1900->:0\n"
+                "a.fennec_  9990  u0_a80  125u     0000     0,10       0t0"
+                "       3655 anon_inode:[eventpoll]\n"
+                "a.fennec_  9990  u0_a80  126u     IPv4                0t0"
+                "      44773 TCP :58190->:443 (ESTABLISHED)\n"
+                "a.fennec_  9990  u0_a80  128u     unix                0t0"
+                "      44747 socket\n"
+                "a.fennec_  9990  u0_a80  130u     IPv4                0t0"
+                "      44840 TCP :35274->:443 (SYN_SENT)\n",
+            )
         if cmd[1] == "shell" and cmd[2] == "ps":
             assert cmd[3] == "--ppid"
             assert cmd[4] == "9990"
-            output = (
-                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME",
-                "u0_a80    9991  9990  3332   3331 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora",
-                "")
-            return 0, "\n".join(output)
+            return (
+                0,
+                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME\n"
+                "u0_a80    9991  9990  3332   3331 SyS_epoll_ 00000000 S"
+                " org.mozilla.fennec_aurora\n",
+            )
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
     # list all open files
@@ -667,12 +885,17 @@ def fake_adb_call(cmd, timeout=None):
     assert len(tuple(session.open_files(pid=9990))) == 5
     # list process and children specific open files
     assert len(tuple(session.open_files(pid=9990, children=True))) == 6
-    with pytest.raises(AssertionError):
+    with raises(AssertionError):
         tuple(session.open_files(pid=None, children=True))
 
+
 def test_adb_session_21(mocker):
     """test ADBSession._get_procs()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=too-many-return-statements,unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ps":
@@ -681,27 +904,39 @@ def fake_adb_call(cmd, timeout=None):
                 ppid = int(cmd[-1])
             else:
                 ppid = None
-            output = [
-                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME"]
+            output = ["USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME\n"]
             if ppid is None:
                 output += [
-                    "root      1     0     8896   2208  SyS_epoll_ 00000000 S /init",
-                    "root      1242  2     0      0         kswapd 00000000 S kswapd0",
-                    "test      1337  1772  1024   1024 SyS_epoll_ 00000000 S org.test.preinstalled",
-                    "test      1338  1337  1024   1024 SyS_epoll_ 00000000 S org.test.child",
-                    "root      1772  1     1620804 122196 poll_sched 00000000 S zygote",
-                    "media_rw  2158  1758  0      0              0 00000000 Z sdcard",
-                    "audioserver 1773  1     34000  9624  binder_thr 00000000 S /system/bin/audioserver",
-                    "root      5847  1     315992 2348  poll_sched 00000000 S /sbin/adbd",
-                    "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora",
-                    "root      5944  5847  6280   2360           0 00000000 R ps"]
+                    "root      1     0     8896   2208  SyS_epoll_ 00000000 S /init\n",
+                    "root      1242  2     0      0         kswapd"
+                    " 00000000 S kswapd0\n",
+                    "test      1337  1772  1024   1024 SyS_epoll_"
+                    " 00000000 S org.test.preinstalled\n",
+                    "test      1338  1337  1024   1024 SyS_epoll_"
+                    " 00000000 S org.test.child\n",
+                    "root      1772  1     1620804 122196 poll_sched"
+                    " 00000000 S zygote\n",
+                    "media_rw  2158  1758  0      0              0 00000000 Z sdcard\n",
+                    "audioserver 1773  1     34000  9624  binder_thr"
+                    " 00000000 S /system/bin/audioserver\n",
+                    "root      5847  1     315992 2348  poll_sched"
+                    " 00000000 S /sbin/adbd\n",
+                    "u0_a80    9990  1772  1221212 128064 SyS_epoll_"
+                    " 00000000 S org.mozilla.fennec_aurora\n",
+                    "root      5944  5847  6280   2360           0 00000000 R ps\n",
+                ]
             elif ppid == 9990:
                 output += [
-                    "u0_a80    9991  9990  3332   3331 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora"]
-            output += [""]
-            return 0, "\n".join(output)
+                    "u0_a80    9991  9990  3332   3331 SyS_epoll_"
+                    " 00000000 S org.mozilla.fennec_aurora\n"
+                ]
+            output += ["\n"]
+            return 0, "".join(output)
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert len(tuple(session._get_procs())) == 10
@@ -709,9 +944,14 @@ def fake_adb_call(cmd, timeout=None):
     assert len(dev_procs) == 1
     assert dev_procs[0].pid == 9991
 
+
 def test_adb_session_22(tmp_path, mocker):
     """test ADBSession.push()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "push":
@@ -719,18 +959,26 @@ def fake_adb_call(cmd, timeout=None):
             assert cmd[3] == "dst"
             return 0, " pushed. "
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
-    with pytest.raises(IOError):
+    with raises(IOError):
         session.push("not_a_file", "dst")
     push_file = tmp_path / "test.txt"
     push_file.write_bytes(b"test\n")
     assert session.push(str(push_file), "dst")
 
+
 def test_adb_session_23(mocker):
     """test ADBSession.pull()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "pull":
@@ -738,28 +986,44 @@ def fake_adb_call(cmd, timeout=None):
             assert cmd[3] == "dst"
             return 0, " pulled. "
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert session.pull("src", "dst")
 
+
 def test_adb_session_24(mocker):
     """test ADBSession.clear_log()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "logcat":
             assert cmd[2] == "--clear"
             return 0, ""
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert session.clear_logs()
 
+
 def test_adb_session_25(mocker):
     """test ADBSession.listdir()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ls":
@@ -768,38 +1032,55 @@ def fake_adb_call(cmd, timeout=None):
                 return 1, ""
             return 0, "test"
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
-    with pytest.raises(IOError):
+    with raises(IOError):
         session.listdir("missing-dir")
     dir_list = session.listdir("fake-dir")
     assert len(dir_list) == 1
     assert "test" in session.listdir("fake-dir")
 
+
 def test_adb_session_26(mocker):
     """test ADBSession.process_exists()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "ps":
             assert cmd[3] == "9990"
-            output = (
-                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME",
-                "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S org.mozilla.fennec_aurora",
-                "")
-            return 0, "\n".join(output)
+            return (
+                0,
+                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME\n"
+                "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S"
+                " org.mozilla.fennec_aurora\n\n",
+            )
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert session.process_exists(9990)
 
+
 def test_adb_session_27(mocker, tmp_path):
     """test ADBSession._aapt_check()"""
     # use system aapt
-    mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing"))
-    mocker.patch("grizzly.target.adb_device.adb_session.which", return_value="/fake_system/aapt")
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing")
+    )
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.which", return_value="/fake_system/aapt"
+    )
     assert ADBSession._aapt_check() == "/fake_system/aapt"
     (tmp_path / "android-9").mkdir()
     fake_aapt = tmp_path / "android-9" / "aapt"
@@ -808,17 +1089,26 @@ def test_adb_session_27(mocker, tmp_path):
     mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", tmp_path)
     assert ADBSession._aapt_check() == str(fake_aapt)
     # aapt not installed
-    mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing"))
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing")
+    )
     mocker.patch("grizzly.target.adb_device.adb_session.which", return_value=None)
-    with pytest.raises(EnvironmentError, match=r"Please install AAPT"):
+    with raises(EnvironmentError, match=r"Please install AAPT"):
         assert ADBSession._aapt_check()
 
+
 def test_adb_session_28(mocker, tmp_path):
     """test ADBSession._adb_check()"""
-    mocker.patch("grizzly.target.adb_device.adb_session.sleep")  # skip delay after warning message
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.sleep"
+    )  # skip delay after warning message
     # use system adb
-    mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing"))
-    mocker.patch("grizzly.target.adb_device.adb_session.which", return_value="/fake_system/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing")
+    )
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.which", return_value="/fake_system/adb"
+    )
     assert ADBSession._adb_check() == "/fake_system/adb"
     (tmp_path / "platform-tools").mkdir()
     fake_adb = tmp_path / "platform-tools" / "adb"
@@ -827,67 +1117,91 @@ def test_adb_session_28(mocker, tmp_path):
     mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", tmp_path)
     assert ADBSession._adb_check() == str(fake_adb)
     # adb not installed
-    mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing"))
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing")
+    )
     mocker.patch("grizzly.target.adb_device.adb_session.which", return_value=None)
-    with pytest.raises(EnvironmentError, match=r"Please install ADB"):
+    with raises(EnvironmentError, match=r"Please install ADB"):
         assert ADBSession._adb_check()
 
+
 def test_adb_session_29(mocker, tmp_path):
     """test ADBSession.get_package_name()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._aapt_check", return_value="/fake/aapt")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._aapt_check", return_value="/fake/aapt"
+    )
     mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"")
-    with pytest.raises(IOError):
+    with raises(IOError):
         ADBSession.get_package_name("/fake/path")
     fake_apk = tmp_path / "fake.apk"
     fake_apk.touch()
     assert ADBSession.get_package_name(str(fake_apk)) is None
     output = (
-        b"package: name='org.mozilla.fennec_aurora' versionCode='2015624653' versionName='68.0a1' platformBuildVersionName=''",
-        b"install-location:'internalOnly'",
-        b"sdkVersion:'16'",
-        b"targetSdkVersion:'28'",
-        b"uses-permission: name='android.permission.READ_SYNC_SETTINGS'",
-        b"uses-permission: name='org.mozilla.fennec_aurora_fxaccount.permission.PER_ACCOUNT_TYPE'",
-        b"application-label:'Firefox Nightly'",
-        b"application-label-en-GB:'Firefox Nightly'",
-        b"application-icon-240:'res/mipmap-anydpi-v26/ic_launcher.xml'",
-        b"application-icon-65535:'res/mipmap-anydpi-v26/ic_launcher.xml'",
-        b"application: label='Firefox Nightly' icon='res/mipmap-anydpi-v26/ic_launcher.xml'",
-        b"application-debuggable",
-        b"feature-group: label=''",
-        b"  uses-gl-es: '0x20000'",
-        b"  uses-feature-not-required: name='android.hardware.audio.low_latency'",
-        b"  uses-feature: name='android.hardware.touchscreen'",
-        b"  uses-feature: name='android.hardware.location.network'",
-        b"  uses-implied-feature: name='android.hardware.location.network' reason='requested android.permission.ACCESS_COARSE_LOCATION permission'",
-        b"  uses-feature: name='android.hardware.wifi'",
-        b"  uses-implied-feature: name='android.hardware.wifi' reason='requested android.permission.ACCESS_WIFI_STATE permission, and requested android.permission.CHANGE_WIFI_STATE permission'",
-        b"provides-component:'app-widget'",
-        b"main",
-        b"other-activities",
-        b"other-receivers",
-        b"other-services",
-        b"supports-screens: 'small' 'normal' 'large' 'xlarge'",
-        b"supports-any-density: 'true'",
-        b"locales: '--_--' 'ca' ' 'en-GB' 'zh-HK' 'zh-CN' 'en-IN' 'pt-BR' 'es-US' 'pt-PT' 'en-AU' 'zh-TW'",
-        b"densities: '120' '160' '240' '320' '480' '640' '65534' '65535'",
-        b"native-code: 'x86'")
-    mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"\n".join(output))
+        b"package: name='org.mozilla.fennec_aurora' versionCode='2015624653'"
+        b" versionName='68.0a1' platformBuildVersionName=''\n"
+        b"install-location:'internalOnly'\n"
+        b"sdkVersion:'16'\n"
+        b"targetSdkVersion:'28'\n"
+        b"uses-permission: name='android.permission.READ_SYNC_SETTINGS'\n"
+        b"uses-permission:"
+        b" name='org.mozilla.fennec_aurora_fxaccount.permission.PER_ACCOUNT_TYPE'\n"
+        b"application-label:'Firefox Nightly'\n"
+        b"application-label-en-GB:'Firefox Nightly'\n"
+        b"application-icon-240:'res/mipmap-anydpi-v26/ic_launcher.xml'\n"
+        b"application-icon-65535:'res/mipmap-anydpi-v26/ic_launcher.xml'\n"
+        b"application:"
+        b" label='Firefox Nightly' icon='res/mipmap-anydpi-v26/ic_launcher.xml'\n"
+        b"application-debuggable\n"
+        b"feature-group: label=''\n"
+        b"  uses-gl-es: '0x20000'\n"
+        b"  uses-feature-not-required: name='android.hardware.audio.low_latency'\n"
+        b"  uses-feature: name='android.hardware.touchscreen'\n"
+        b"  uses-feature: name='android.hardware.location.network'\n"
+        b"  uses-implied-feature: name='android.hardware.location.network'"
+        b" reason='requested android.permission.ACCESS_COARSE_LOCATION permission'\n"
+        b"  uses-feature: name='android.hardware.wifi'\n"
+        b"  uses-implied-feature: name='android.hardware.wifi'"
+        b" reason='requested android.permission.ACCESS_WIFI_STATE permission, and"
+        b" requested android.permission.CHANGE_WIFI_STATE permission'\n"
+        b"provides-component:'app-widget'\n"
+        b"main\n"
+        b"other-activities\n"
+        b"other-receivers\n"
+        b"other-services\n"
+        b"supports-screens: 'small' 'normal' 'large' 'xlarge'\n"
+        b"supports-any-density: 'true'\n"
+        b"locales: '--_--' 'ca' ' 'en-GB' 'zh-HK' 'zh-CN' 'en-IN' 'pt-BR' 'es-US'"
+        b" 'pt-PT' 'en-AU' 'zh-TW'\n"
+        b"densities: '120' '160' '240' '320' '480' '640' '65534' '65535'\n"
+        b"native-code: 'x86'"
+    )
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.check_output",
+        return_value=output,
+    )
     assert ADBSession.get_package_name(str(fake_apk)) == "org.mozilla.fennec_aurora"
 
+
 def test_adb_session_30(mocker):
     """test ADBSession.get_enforce()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
-    mocker.patch("grizzly.target.adb_device.ADBSession.call", return_value=(0, "Enforcing"))
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession.call", return_value=(0, "Enforcing")
+    )
     session = ADBSession("127.0.0.1")
     assert session.get_enforce()
     mocker.patch("grizzly.target.adb_device.ADBSession.call", return_value=(0, "Blah"))
     session = ADBSession("127.0.0.1")
     assert not session.get_enforce()
 
+
 def test_adb_session_31(mocker):
     """test ADBSession.set_enforce()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
     # disable when enabled
     fake_call = mocker.patch("grizzly.target.adb_device.ADBSession.call")
     mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=True)
@@ -901,9 +1215,14 @@ def test_adb_session_31(mocker):
     session.set_enforce(1)
     assert fake_call.call_count == 1
 
+
 def test_adb_session_32(mocker):
     """test ADBSession.realpath()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "realpath":
@@ -911,37 +1230,53 @@ def fake_adb_call(cmd, timeout=None):
                 return 1, ""
             return 0, "existing/path"
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
-    with pytest.raises(IOError):
+    with raises(IOError):
         session.realpath("missing/path")
     assert session.realpath("existing/path") == "existing/path"
 
+
 def test_adb_session_33(mocker):
     """test ADBSession.reverse()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "reverse":
             return 0, ""
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert session.reverse(1234, 1235)
-    with pytest.raises(AssertionError):
+    with raises(AssertionError):
         session.reverse(1, 1235)
-    with pytest.raises(AssertionError):
+    with raises(AssertionError):
         session.reverse(1234, 1)
-    with pytest.raises(AssertionError):
+    with raises(AssertionError):
         session.reverse(65536, 1235)
-    with pytest.raises(AssertionError):
+    with raises(AssertionError):
         session.reverse(1234, 65536)
 
+
 def test_adb_session_34(mocker):
     """test ADBSession.reverse_remove()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "reverse":
@@ -953,19 +1288,27 @@ def fake_adb_call(cmd, timeout=None):
                 raise AssertionError("unexpected command %r" % (cmd,))
             return 0, ""
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert session.reverse_remove()
     assert session.reverse_remove(remote=1025)
-    with pytest.raises(AssertionError):
+    with raises(AssertionError):
         session.reverse_remove(remote=65536)
-    with pytest.raises(AssertionError):
+    with raises(AssertionError):
         session.reverse_remove(remote=1023)
 
+
 def test_adb_session_35(mocker):
     """test ADBSession.airplane_mode()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell" and cmd[2] == "settings":
@@ -986,19 +1329,27 @@ def fake_adb_call(cmd, timeout=None):
             assert cmd[7] == "android.intent.action.AIRPLANE_MODE"
             return 0, ""
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     session = ADBSession("127.0.0.1")
     session.connected = True
     session.airplane_mode = False
     session.airplane_mode = True
     assert session.airplane_mode
 
+
 def test_adb_session_36(mocker):
     """test ADBSession.wait_for_boot()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
     mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
     fake_sleep = mocker.patch("grizzly.target.adb_device.adb_session.sleep")
+
     # test timeout
+    # pylint: disable=unused-argument
     def fake_adb_01(_, cmd, timeout=None):
         if cmd[1] == "shell" and cmd[2] == "getprop":
             if cmd[3] == "init.svc.bootanim":
@@ -1006,12 +1357,15 @@ def fake_adb_01(_, cmd, timeout=None):
             if cmd[3] == "sys.boot_completed":
                 return 0, "0"
         raise AssertionError("unexpected command %r" % (cmd,))
+
     ADBSession._call_adb = fake_adb_01
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert not session.wait_for_boot(timeout=0.01)
     fake_sleep.reset_mock()
+
     # test already booted
+    # pylint: disable=unused-argument
     def fake_adb_02(_, cmd, timeout=None):
         if cmd[1] == "shell" and cmd[2] == "getprop":
             if cmd[3] == "init.svc.bootanim":
@@ -1019,15 +1373,19 @@ def fake_adb_02(_, cmd, timeout=None):
             if cmd[3] == "sys.boot_completed":
                 return 0, "1"
         raise AssertionError("unexpected command %r" % (cmd,))
+
     ADBSession._call_adb = fake_adb_02
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert session.wait_for_boot()
     assert fake_sleep.call_count == 0
     fake_sleep.reset_mock()
+
     # test boot in progress
     anim_done = False
     boot_done = False
+
+    # pylint: disable=unused-argument
     def fake_adb_03(obj, cmd, timeout=None):
         nonlocal anim_done
         nonlocal boot_done
@@ -1043,56 +1401,79 @@ def fake_adb_03(obj, cmd, timeout=None):
                     return 0, "0"
                 return 0, "1"
         raise AssertionError("unexpected command %r" % (cmd,))
+
     ADBSession._call_adb = fake_adb_03
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert session.wait_for_boot()
     assert fake_sleep.call_count == 3
 
+
 def test_adb_session_37(mocker):
     """test ADBSession.reboot_device()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "reboot":
             return 0, ""
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+    )
     mocker.patch("grizzly.target.adb_device.ADBSession.connect", spec=True)
     session = ADBSession()
     session.connected = True
-    with pytest.raises(AssertionError):
+    with raises(AssertionError):
         session.reboot_device()
 
+
 def test_adb_session_38(mocker):
     """test ADBSession.remount()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
+    # pylint: disable=unused-argument
     def fake_adb_01(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "remount":
             return 0, "Permission denied"
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_01)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_01
+    )
     session = ADBSession()
     session.connected = True
     session._root = True
-    with pytest.raises(ADBSessionError):
+    with raises(ADBSessionError):
         session.remount()
+
+    # pylint: disable=unused-argument
     def fake_adb_02(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "remount":
             return 0, ""
         raise AssertionError("unexpected command %r" % (cmd,))
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_02)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_02
+    )
     session = ADBSession()
     session.connected = True
     # test as non-root
-    with pytest.raises(AssertionError):
+    with raises(AssertionError):
         session.remount()
     session._root = True
     # test as root
     session.remount()
 
+
 def test_adb_session_39():
     """test ADBSession._line_to_info()"""
     # nothing to parse
@@ -1109,14 +1490,22 @@ def test_adb_session_39():
     assert pinfo.pid == 1
     assert pinfo.ppid == 2
 
+
 def test_adb_session_40(mocker):
     """test ADBSession.sanitizer_options()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb")
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+    )
+
     def fake_install_file(src, dst, **_):
-        assert os.path.basename(src) == "asan.options.gecko"
-        with open(src, "r") as ofp:
-            assert ofp.read() in ("a=1:b=2", "b=2:a=1")
+        src = Path(src)
+        assert src.name == "asan.options.gecko"
+        assert src.read_text() in ("a=1:b=2", "b=2:a=1")
         assert dst == "/data/local/tmp/"
-    mocker.patch("grizzly.target.adb_device.ADBSession.install_file", side_effect=fake_install_file)
+
+    mocker.patch(
+        "grizzly.target.adb_device.ADBSession.install_file",
+        side_effect=fake_install_file,
+    )
     session = ADBSession()
-    session.sanitizer_options("asan", {"a":"1", "b":"2"})
+    session.sanitizer_options("asan", {"a": "1", "b": "2"})
diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index 4785e887..c635679a 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -2,24 +2,23 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-import logging
 import os
-from tempfile import mkdtemp, TemporaryDirectory
+from logging import getLogger
+from tempfile import TemporaryDirectory, mkdtemp
 
 from ffpuppet import LaunchError
 from prefpicker import PrefPicker
 
+from ..common.reporter import Report
+from ..common.utils import grz_tmp
 from .adb_device import ADBProcess, ADBSession
 from .target import Result, Target, TargetError
 from .target_monitor import TargetMonitor
-from ..common.reporter import Report
-from ..common.utils import grz_tmp
-
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith", "Jesse Schwartzentruber"]
 
-LOG = logging.getLogger("adb_target")  # pylint: disable=invalid-name
+LOG = getLogger("adb_target")
 
 
 class ADBTarget(Target):
@@ -30,7 +29,6 @@ def __init__(self, binary, launch_timeout, log_limit, memory_limit, **kwds):
         self.forced_close = True  # app will not close itself on Android
         self.use_rr = False
 
-
         for unsupported in ("pernosco", "rr", "valgrind", "xvfb"):
             if kwds.pop(unsupported, False):
                 LOG.warning("ADBTarget ignoring %r: not supported", unsupported)
@@ -101,7 +99,8 @@ def launch(self, location):
                 env_mod=env_mod,
                 launch_timeout=self.launch_timeout,
                 prefs_js=self._prefs,
-                url=location)
+                url=location,
+            )
         except LaunchError:
             self._proc.close()
             raise
@@ -109,6 +108,7 @@ def launch(self, location):
     @property
     def monitor(self):
         if self._monitor is None:
+
             class _ADBMonitor(TargetMonitor):
                 # pylint: disable=no-self-argument,protected-access
                 def clone_log(_, *_a, **_k):  # pylint: disable=arguments-differ
@@ -120,16 +120,21 @@ def clone_log(_, *_a, **_k):  # pylint: disable=arguments-differ
                             return log_fp.read()
                     finally:
                         os.remove(log_file)
+
                 def is_running(_):
                     return self._proc.is_running()
+
                 def is_healthy(_):
                     return self._proc.is_healthy()
+
                 @property
                 def launches(_):
                     return self._proc.launches
+
                 def log_length(_, *_a):  # pylint: disable=arguments-differ
                     # TODO: This needs to be implemented
                     return 0
+
             self._monitor = _ADBMonitor()
         return self._monitor
 
diff --git a/grizzly/target/test_adb_target.py b/grizzly/target/test_adb_target.py
index d8a0e96a..79940cb1 100644
--- a/grizzly/target/test_adb_target.py
+++ b/grizzly/target/test_adb_target.py
@@ -7,6 +7,7 @@
 from .adb_target import ADBTarget
 from .target import Result
 
+
 def test_adb_target_01(mocker, tmp_path):
     """test creating a simple ADBTarget"""
     fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
@@ -17,7 +18,7 @@ def test_adb_target_01(mocker, tmp_path):
     fake_process.return_value.is_running.return_value = False
     fake_process.return_value.launches = 0
     fake_process.return_value.reason = fake_process.RC_CLOSED
-    fake_sess_obj = mocker.Mock(spec=ADBSession, connected=True, symbols={})
+    fake_sess_obj = mocker.Mock(spec_set=ADBSession, connected=True, symbols={})
     fake_session = mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
     fake_session.create.return_value = fake_sess_obj
     fake_session.get_package_name.return_value = "the_name"
@@ -27,7 +28,7 @@ def test_adb_target_01(mocker, tmp_path):
         assert target.closed
         assert target.forced_close
         assert target.monitor is not None
-        assert target.check_result(False) == Result.NONE
+        assert target.check_result(None) == Result.NONE
         assert not target.log_size()
         target.cleanup()
         assert fake_sess_obj.reverse_remove.call_count == 1
@@ -39,6 +40,7 @@ def test_adb_target_01(mocker, tmp_path):
     assert fake_session.get_package_name.call_count == 1
     assert "the_name" in fake_sess_obj.symbols
 
+
 def test_adb_target_02(mocker, tmp_path):
     """test ADBTarget.launch()"""
     fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
@@ -52,6 +54,7 @@ def test_adb_target_02(mocker, tmp_path):
         assert target.monitor.is_running()
         assert target.monitor.is_healthy()
 
+
 @mark.parametrize(
     "healthy, reason, result, closes",
     [
@@ -81,6 +84,7 @@ def test_adb_target_03(mocker, tmp_path, healthy, reason, result, closes):
         assert target.check_result(None) == result
         assert fake_process.return_value.close.call_count == closes
 
+
 def test_adb_target_04(mocker, tmp_path):
     """test ADBTarget.handle_hang()"""
     fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)

From e4f62523704424ee3b4cd7c80324139e0eb622ed Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 8 Mar 2022 13:34:37 -0800
Subject: [PATCH 503/531] [adb] Use new PrefPicker API

---
 grizzly/target/adb_target.py | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index c635679a..e0098c4d 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -4,6 +4,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 import os
 from logging import getLogger
+from pathlib import Path
 from tempfile import TemporaryDirectory, mkdtemp
 
 from ffpuppet import LaunchError
@@ -12,7 +13,7 @@
 from ..common.reporter import Report
 from ..common.utils import grz_tmp
 from .adb_device import ADBProcess, ADBSession
-from .target import Result, Target, TargetError
+from .target import Result, Target
 from .target_monitor import TargetMonitor
 
 __author__ = "Tyson Smith"
@@ -142,17 +143,12 @@ def process_assets(self):
         self._prefs = self.assets.get("prefs")
         # generate temporary prefs.js with prefpicker
         if self._prefs is None:
-            for template in PrefPicker.templates():
-                if template.endswith("browser-fuzzing.yml"):
-                    LOG.debug("using prefpicker template %r", template)
-                    with TemporaryDirectory(dir=grz_tmp("target")) as tmp_path:
-                        prefs = os.path.join(tmp_path, "prefs.js")
-                        PrefPicker.load_template(template).create_prefsjs(prefs)
-                        LOG.debug("generated %r", prefs)
-                        self._prefs = self.assets.add("prefs", prefs, copy=False)
-                    break
-            else:  # pragma: no cover
-                raise TargetError("Failed to generate prefs.js")
+            LOG.debug("using prefpicker to generate prefs.js")
+            with TemporaryDirectory(dir=grz_tmp("target")) as tmp_path:
+                prefs = Path(tmp_path) / "prefs.js"
+                template = PrefPicker.lookup_template("browser-fuzzing.yml")
+                PrefPicker.load_template(template).create_prefsjs(prefs)
+                self._prefs = self.assets.add("prefs", str(prefs), copy=False)
 
     def create_report(self, is_hang=False):
         logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))

From f8d92dcc5b5433d43abb30752625a2fcd027e8fc Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 11 Mar 2022 16:58:52 -0800
Subject: [PATCH 504/531] Make pref handling more robust

---
 grizzly/target/adb_device/adb_process.py      | 46 +++++++++++++------
 grizzly/target/adb_device/test_adb_process.py | 37 +++++++++++++--
 2 files changed, 64 insertions(+), 19 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index 052c7fa8..1b539937 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -194,14 +194,13 @@ def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
             prefs.update(
                 {
                     "capability.policy.localfilelinks.checkloaduri.enabled": (
-                        "'allAccess'"
+                        "allAccess"
                     ),
-                    "capability.policy.localfilelinks.sites": "'%s'"
-                    % bootstrapper.location,
-                    "capability.policy.policynames": "'localfilelinks'",
-                    "network.proxy.allow_bypass": "false",
-                    "network.proxy.failover_direct": "false",
-                    "privacy.partition.network_state": "false",
+                    "capability.policy.localfilelinks.sites": bootstrapper.location,
+                    "capability.policy.policynames": "localfilelinks",
+                    "network.proxy.allow_bypass": False,
+                    "network.proxy.failover_direct": False,
+                    "privacy.partition.network_state": False,
                 }
             )
             # add environment variables
@@ -253,22 +252,41 @@ def launches(self):
 
     @staticmethod
     def prefs_to_dict(prefs_file):
-        pattern = re.compile(r"user_pref\(\"(?P<name>.+)\",\s*(?P<value>.+)\);")
+        pattern = re.compile(r"user_pref\((?P<name>.+?),\s*(?P<value>.+)\);")
         out = dict()
         with open(prefs_file, "r") as in_fp:
             for line in in_fp:
                 pref = pattern.match(line)
                 if not pref:
                     continue
+                # parse name
+                name = pref.group("name")
+                if name[0] == "'" == name[-1]:
+                    name = name.strip("'")
+                elif name[0] == '"' == name[-1]:
+                    name = name.strip('"')
+                else:
+                    LOG.error("Pref name not quoted (%s)", name)
+                    raise ADBLaunchError("Invalid prefs.js file (%s)" % (prefs_file,))
+                if not name:
+                    LOG.error("Pref name missing")
+                    raise ADBLaunchError("Invalid prefs.js file (%s)" % (prefs_file,))
+                # parse value
                 value = pref.group("value")
                 if value in ("false", "true"):
-                    out[pref.group("name")] = value == "true"
-                elif value.startswith("'") and value.endswith("'"):
-                    out[pref.group("name")] = value.strip("'")
-                elif value.startswith('"') or value.startswith("'"):
-                    out[pref.group("name")] = value.strip('"')
+                    out[name] = value == "true"
+                elif value[0] == "'" == value[-1]:
+                    out[name] = value.strip("'")
+                elif value[0] == '"' == value[-1]:
+                    out[name] = value.strip('"')
                 else:
-                    out[pref.group("name")] = int(value)
+                    try:
+                        out[name] = int(value)
+                    except ValueError:
+                        LOG.error("Invalid value %r for entry %r", value, name)
+                        raise ADBLaunchError(
+                            "Invalid prefs.js file (%s)" % (prefs_file,)
+                        ) from None
         return out
 
     def _process_logs(self, crash_reports):
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 8850e164..ab886b93 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -84,7 +84,7 @@ def test_adb_process_07(mocker):
     fake_bs = mocker.patch(
         "grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True
     )
-    fake_bs.return_value.location.return_value = "http://localhost"
+    fake_bs.return_value.location = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
@@ -112,7 +112,7 @@ def test_adb_process_08(mocker):
     fake_bs = mocker.patch(
         "grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True
     )
-    fake_bs.return_value.location.return_value = "http://localhost"
+    fake_bs.return_value.location = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
@@ -129,7 +129,10 @@ def test_adb_process_08(mocker):
 
 def test_adb_process_09(mocker):
     """test ADBProcess.wait_on_files()"""
-    mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
+    fake_bs = mocker.patch(
+        "grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True
+    )
+    fake_bs.return_value.location = "http://localhost"
     fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
@@ -274,13 +277,14 @@ def test_adb_process_13(tmp_path):
     "input_data, result",
     [
         ("", dict()),
-        ('junk\n#user_pref("a.b", 0)\n', dict()),
+        ('junk\n#user_pref("a.b", 0);\n', dict()),
         ('user_pref("a.b.c", false);\n', {"a.b.c": False}),
-        ('user_pref("a.b.c", 0);', {"a.b.c": 0}),
+        ("user_pref('a.b.c', 0);", {"a.b.c": 0}),
         ("user_pref(\"a.b.c\", 'test');", {"a.b.c": "test"}),
         ('user_pref("a.b.c", "test");', {"a.b.c": "test"}),
         ('user_pref("a.b", 1);\nuser_pref("a.c", true);', {"a.b": 1, "a.c": True}),
         ('user_pref("a.b", 1);\n#\nuser_pref("a.c", 1);', {"a.b": 1, "a.c": 1}),
+        ("user_pref('a.b.c', '1,2,3,');", {"a.b.c": "1,2,3,"}),
     ],
 )
 def test_adb_process_14(tmp_path, input_data, result):
@@ -288,3 +292,26 @@ def test_adb_process_14(tmp_path, input_data, result):
     prefs_js = tmp_path / "prefs.js"
     prefs_js.write_text(input_data)
     assert ADBProcess.prefs_to_dict(str(prefs_js)) == result
+
+
+@mark.parametrize(
+    "input_data",
+    [
+        # invalid value
+        'user_pref("a.b.c", asd);\n',
+        # unbalanced quotes
+        'user_pref(", 0);\n',
+        # missing value
+        'user_pref("a", );\n',
+        # empty pref name
+        'user_pref("", 0);\n',
+        # unquoted pref name
+        "user_pref(test, 0);\n",
+    ],
+)
+def test_adb_process_15(tmp_path, input_data):
+    """test ADBProcess.prefs_to_dict() - invalid prefs.js"""
+    prefs_js = tmp_path / "prefs.js"
+    prefs_js.write_text(input_data)
+    with raises(ADBLaunchError, match="Invalid prefs.js file"):
+        ADBProcess.prefs_to_dict(str(prefs_js))

From 29c0f8aeeb611e6b26ff8f8bbf9b7b4e348367fb Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 14 Mar 2022 14:55:53 -0700
Subject: [PATCH 505/531] [adb] Place profile in '/data/local/tmp/'

---
 grizzly/target/adb_device/adb_process.py | 17 +++++++++++++++--
 grizzly/target/adb_target.py             |  2 +-
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index 1b539937..cd5c9c4b 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -58,7 +58,9 @@ def __init__(self, package_name, session, use_profile=None):
         self._pid = None  # pid of current target process
         self._profile_template = use_profile  # profile that is used as a template
         self._session = session  # ADB session with device
-        self._working_path = "/sdcard/ADBProc_%08X" % (getrandbits(32),)
+        # Note: geckview_example fails to read a profile from /sdcard/ atm
+        # self._working_path = "/sdcard/ADBProc_%08X" % (getrandbits(32),)
+        self._working_path = "/data/local/tmp/ADBProc_%08X" % (getrandbits(32),)
         self.logs = None
         self.profile = None  # profile path on device
         self.reason = self.RC_CLOSED
@@ -188,6 +190,9 @@ def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
         else:
             raise ADBLaunchError("Could not reverse port")
         try:
+
+            self.profile = "%s/gv_profile_%08X" % (self._working_path, getrandbits(32))
+            self._session.call(["shell", "mkdir", "-p", self.profile])
             # load prefs from prefs.js
             prefs = self.prefs_to_dict(prefs_js) if prefs_js else dict()
             # add additional prefs
@@ -211,7 +216,15 @@ def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
             # consumer/automation.html#configuration-file-format
             cfg_file = "%s-geckoview-config.yaml" % (self._package,)
             with NamedTemporaryFile("w+t") as cfp:
-                cfp.write(safe_dump({"env": env_mod, "prefs": prefs}))
+                cfp.write(
+                    safe_dump(
+                        {
+                            "args": ["--profile", self.profile],
+                            "env": env_mod,
+                            "prefs": prefs,
+                        }
+                    )
+                )
                 cfp.flush()
                 if not self._session.push(cfp.name, "/data/local/tmp/%s" % (cfg_file,)):
                     raise ADBLaunchError("Could not upload %r" % (cfg_file,))
diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index e0098c4d..27c15912 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -57,7 +57,7 @@ def _cleanup(self):
         if self._prefs and os.path.isfile(self._prefs):
             os.remove(self._prefs)
 
-    def close(self, _force_close=False):
+    def close(self, force_close=False):
         with self._lock:
             if self._proc is not None:
                 self._proc.close()

From 4b75be9c92360587dab15f772b34c80170acbcc2 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 14 Mar 2022 15:16:55 -0700
Subject: [PATCH 506/531] [adb] Make prefs_to_dict() return None instead of
 raising

---
 grizzly/target/adb_device/adb_process.py      | 27 ++++++++--------
 grizzly/target/adb_device/test_adb_process.py | 31 ++++++-------------
 2 files changed, 24 insertions(+), 34 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index cd5c9c4b..e959bd94 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -173,6 +173,11 @@ def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
         if self._session.get_pid(self._package) is not None:
             raise ADBLaunchError("%r is already running" % (self._package,))
 
+        # load prefs from prefs.js
+        prefs = self.prefs_to_dict(prefs_js) if prefs_js else dict()
+        if prefs is None:
+            raise ADBLaunchError("Invalid prefs.js file (%s)" % (prefs_js,))
+
         self._session.clear_logs()
         self._remove_logs()
         self.reason = None
@@ -190,11 +195,6 @@ def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
         else:
             raise ADBLaunchError("Could not reverse port")
         try:
-
-            self.profile = "%s/gv_profile_%08X" % (self._working_path, getrandbits(32))
-            self._session.call(["shell", "mkdir", "-p", self.profile])
-            # load prefs from prefs.js
-            prefs = self.prefs_to_dict(prefs_js) if prefs_js else dict()
             # add additional prefs
             prefs.update(
                 {
@@ -208,6 +208,9 @@ def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
                     "privacy.partition.network_state": False,
                 }
             )
+            # create empty profile
+            self.profile = "%s/gv_profile_%08X" % (self._working_path, getrandbits(32))
+            self._session.call(["shell", "mkdir", "-p", self.profile])
             # add environment variables
             env_mod = dict(env_mod or {})
             env_mod.setdefault("MOZ_SKIA_DISABLE_ASSERTS", "1")
@@ -279,11 +282,11 @@ def prefs_to_dict(prefs_file):
                 elif name[0] == '"' == name[-1]:
                     name = name.strip('"')
                 else:
-                    LOG.error("Pref name not quoted (%s)", name)
-                    raise ADBLaunchError("Invalid prefs.js file (%s)" % (prefs_file,))
+                    LOG.error("Pref name is not quoted (%s)", name)
+                    return None
                 if not name:
-                    LOG.error("Pref name missing")
-                    raise ADBLaunchError("Invalid prefs.js file (%s)" % (prefs_file,))
+                    LOG.error("Pref name is missing")
+                    return None
                 # parse value
                 value = pref.group("value")
                 if value in ("false", "true"):
@@ -296,10 +299,8 @@ def prefs_to_dict(prefs_file):
                     try:
                         out[name] = int(value)
                     except ValueError:
-                        LOG.error("Invalid value %r for entry %r", value, name)
-                        raise ADBLaunchError(
-                            "Invalid prefs.js file (%s)" % (prefs_file,)
-                        ) from None
+                        LOG.error("Pref %r has invalid value %r", name, value)
+                        return None
         return out
 
     def _process_logs(self, crash_reports):
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index ab886b93..d0d2a33f 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -285,33 +285,22 @@ def test_adb_process_13(tmp_path):
         ('user_pref("a.b", 1);\nuser_pref("a.c", true);', {"a.b": 1, "a.c": True}),
         ('user_pref("a.b", 1);\n#\nuser_pref("a.c", 1);', {"a.b": 1, "a.c": 1}),
         ("user_pref('a.b.c', '1,2,3,');", {"a.b.c": "1,2,3,"}),
-    ],
-)
-def test_adb_process_14(tmp_path, input_data, result):
-    """test ADBProcess.prefs_to_dict()"""
-    prefs_js = tmp_path / "prefs.js"
-    prefs_js.write_text(input_data)
-    assert ADBProcess.prefs_to_dict(str(prefs_js)) == result
-
-
-@mark.parametrize(
-    "input_data",
-    [
         # invalid value
-        'user_pref("a.b.c", asd);\n',
+        ('user_pref("a.b.c", asd);\n', None),
+        # unbalanced quotes
+        ('user_pref("a, "b");\n', None),
         # unbalanced quotes
-        'user_pref(", 0);\n',
+        ('user_pref("a", "b);\n', None),
         # missing value
-        'user_pref("a", );\n',
+        ('user_pref("a", );\n', None),
         # empty pref name
-        'user_pref("", 0);\n',
+        ('user_pref("", 0);\n', None),
         # unquoted pref name
-        "user_pref(test, 0);\n",
+        ("user_pref(test, 0);\n", None),
     ],
 )
-def test_adb_process_15(tmp_path, input_data):
-    """test ADBProcess.prefs_to_dict() - invalid prefs.js"""
+def test_adb_process_14(tmp_path, input_data, result):
+    """test ADBProcess.prefs_to_dict()"""
     prefs_js = tmp_path / "prefs.js"
     prefs_js.write_text(input_data)
-    with raises(ADBLaunchError, match="Invalid prefs.js file"):
-        ADBProcess.prefs_to_dict(str(prefs_js))
+    assert ADBProcess.prefs_to_dict(str(prefs_js)) == result

From 6f3cb3aa3ba2b1cdc9201c0a53b74026c841479e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 14 Mar 2022 16:10:27 -0700
Subject: [PATCH 507/531] [adb] Use Enum for Reason code

---
 grizzly/target/adb_device/__init__.py         |  4 +--
 grizzly/target/adb_device/adb_process.py      | 36 +++++++++++--------
 grizzly/target/adb_device/test_adb_process.py |  5 +--
 grizzly/target/adb_target.py                  |  6 ++--
 grizzly/target/test_adb_target.py             | 16 +++------
 5 files changed, 34 insertions(+), 33 deletions(-)

diff --git a/grizzly/target/adb_device/__init__.py b/grizzly/target/adb_device/__init__.py
index b4447e4f..d5e0dccb 100644
--- a/grizzly/target/adb_device/__init__.py
+++ b/grizzly/target/adb_device/__init__.py
@@ -1,7 +1,7 @@
-from .adb_process import ADBProcess
+from .adb_process import ADBProcess, Reason
 from .adb_session import ADBSession
 
-__all__ = ("ADBProcess", "ADBSession")
+__all__ = ("ADBProcess", "ADBSession", "Reason")
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index e959bd94..0813cf37 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -1,5 +1,6 @@
 import os
 import re
+from enum import Enum, unique
 from logging import getLogger
 from random import getrandbits
 from shutil import copy, rmtree
@@ -21,16 +22,24 @@
 __credits__ = ["Tyson Smith"]
 
 
+# Note: This was taken from FFPuppet.
+@unique
+class Reason(Enum):
+    """Indicates why the browser process was terminated"""
+
+    # target crashed, aborted, triggered an assertion failure, etc...
+    ALERT: int = 0
+    # target was closed by call to ADBProcess.close() or has not been launched
+    CLOSED: int = 1
+    # target exited
+    EXITED: int = 2
+
+
 class ADBLaunchError(ADBSessionError):
     pass
 
 
 class ADBProcess:
-    # TODO: Use FFPuppet Reason enum
-    RC_ALERT = "ALERT"  # target crashed/aborted/triggered an assertion failure etc...
-    RC_CLOSED = "CLOSED"  # target was closed by call to FFPuppet close()
-    RC_EXITED = "EXITED"  # target exited
-    # RC_WORKER = "WORKER"  # target was closed by worker thread
     # TODO:
     #  def save_logs(self, *args, **kwargs):
     #  def clone_log(self, log_id, offset=0):
@@ -63,7 +72,7 @@ def __init__(self, package_name, session, use_profile=None):
         self._working_path = "/data/local/tmp/ADBProc_%08X" % (getrandbits(32),)
         self.logs = None
         self.profile = None  # profile path on device
-        self.reason = self.RC_CLOSED
+        self.reason = Reason.CLOSED
 
     def __enter__(self):
         return self
@@ -98,12 +107,12 @@ def close(self):
                 crash_reports = self.find_crashreports()
                 # set reason code
                 if crash_reports:
-                    self.reason = self.RC_ALERT
+                    self.reason = Reason.ALERT
                     self.wait_on_files(crash_reports)
                 elif self.is_running():
-                    self.reason = self.RC_CLOSED
+                    self.reason = Reason.CLOSED
                 else:
-                    self.reason = self.RC_EXITED
+                    self.reason = Reason.EXITED
                 self._terminate()
                 self.wait()
                 self._process_logs(crash_reports)
@@ -114,14 +123,14 @@ def close(self):
                 self._session.call(["shell", "rm", "-rf", cfg_file])
                 # TODO: this should be temporary until ASAN_OPTIONS=log_file is working
                 if "log_asan.txt" in os.listdir(self.logs):
-                    self.reason = self.RC_ALERT
+                    self.reason = Reason.ALERT
 
         except ADBSessionError:
             LOG.warning("No device detected while closing process")
         self._pid = None
         self.profile = None
         if self.reason is None:
-            self.reason = self.RC_CLOSED
+            self.reason = Reason.CLOSED
 
     def find_crashreports(self):
         reports = list()
@@ -321,14 +330,11 @@ def _process_logs(self, crash_reports):
         for fname in crash_reports:
             self._session.pull(fname, unprocessed)
 
-        logger = PuppetLogger()
-        try:
+        with PuppetLogger() as logger:
             syms_path = self._session.symbols_path(self._package)
             process_minidumps(unprocessed, syms_path, logger.add_log)
             logger.close()
             logger.save_logs(self.logs)
-        finally:
-            logger.clean_up()
 
     def _remove_logs(self):
         sanitizer_logs = os.path.dirname(self._session.SANITIZER_LOG_PREFIX)
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index d0d2a33f..b256dfc6 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -5,7 +5,7 @@
 
 from pytest import mark, raises
 
-from .adb_process import ADBLaunchError, ADBProcess
+from .adb_process import ADBLaunchError, ADBProcess, Reason
 from .adb_session import ADBSession, ADBSessionError
 
 
@@ -20,7 +20,7 @@ def test_adb_process_01(mocker):
         assert proc._package == test_pkg
         assert proc.logs is None
         assert proc.profile is None
-        assert proc.reason == proc.RC_CLOSED
+        assert proc.reason == Reason.CLOSED
         assert proc._pid is None
         proc.close()
         assert not proc.logs  # should not have logs
@@ -100,6 +100,7 @@ def test_adb_process_07(mocker):
         assert proc.is_running()
         assert proc.is_healthy()
         assert proc.launches == 1
+        assert proc.reason is None
         proc.close()
         assert proc._pid is None
         assert proc.logs
diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index 27c15912..930fe75e 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -12,7 +12,7 @@
 
 from ..common.reporter import Report
 from ..common.utils import grz_tmp
-from .adb_device import ADBProcess, ADBSession
+from .adb_device import ADBProcess, ADBSession, Reason
 from .target import Result, Target
 from .target_monitor import TargetMonitor
 
@@ -71,9 +71,9 @@ def check_result(self, _ignored):
         if not self._proc.is_healthy():
             self._proc.close()
             # if something has happened figure out what
-            if self._proc.reason == ADBProcess.RC_CLOSED:
+            if self._proc.reason == Reason.CLOSED:
                 LOG.info("target.close() was called")
-            elif self._proc.reason == ADBProcess.RC_EXITED:
+            elif self._proc.reason == Reason.EXITED:
                 LOG.info("Target closed itself")
             else:
                 LOG.debug("failure detected")
diff --git a/grizzly/target/test_adb_target.py b/grizzly/target/test_adb_target.py
index 79940cb1..913b570c 100644
--- a/grizzly/target/test_adb_target.py
+++ b/grizzly/target/test_adb_target.py
@@ -3,7 +3,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from pytest import mark
 
-from .adb_device import ADBProcess, ADBSession
+from .adb_device import ADBSession, Reason
 from .adb_target import ADBTarget
 from .target import Result
 
@@ -11,13 +11,10 @@
 def test_adb_target_01(mocker, tmp_path):
     """test creating a simple ADBTarget"""
     fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
-    fake_process.RC_ALERT = ADBProcess.RC_ALERT
-    fake_process.RC_CLOSED = ADBProcess.RC_CLOSED
-    fake_process.RC_EXITED = ADBProcess.RC_EXITED
     fake_process.return_value.is_healthy.return_value = False
     fake_process.return_value.is_running.return_value = False
     fake_process.return_value.launches = 0
-    fake_process.return_value.reason = fake_process.RC_CLOSED
+    fake_process.return_value.reason = Reason.CLOSED
     fake_sess_obj = mocker.Mock(spec_set=ADBSession, connected=True, symbols={})
     fake_session = mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
     fake_session.create.return_value = fake_sess_obj
@@ -61,19 +58,16 @@ def test_adb_target_02(mocker, tmp_path):
         # running as expected - no failures
         (True, None, Result.NONE, 0),
         # browser process closed
-        (False, ADBProcess.RC_CLOSED, Result.NONE, 1),
+        (False, Reason.CLOSED, Result.NONE, 1),
         # browser process crashed
-        (False, ADBProcess.RC_ALERT, Result.FOUND, 1),
+        (False, Reason.ALERT, Result.FOUND, 1),
         # browser exit with no crash logs
-        (False, ADBProcess.RC_EXITED, Result.NONE, 1),
+        (False, Reason.EXITED, Result.NONE, 1),
     ],
 )
 def test_adb_target_03(mocker, tmp_path, healthy, reason, result, closes):
     """test ADBTarget.check_result()"""
     fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
-    fake_process.RC_ALERT = ADBProcess.RC_CLOSED
-    fake_process.RC_CLOSED = ADBProcess.RC_CLOSED
-    fake_process.RC_EXITED = ADBProcess.RC_EXITED
     mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()

From f6765253573cdc3bc0a0de6985a62f5a4e6fd48d Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 15 Mar 2022 10:49:39 -0700
Subject: [PATCH 508/531] [adb] Split main() and parse_args() into separate
 functions

---
 grizzly/target/adb_device/device.py | 55 ++++++++++++++++-------------
 1 file changed, 31 insertions(+), 24 deletions(-)

diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index 52af86e9..d6bad740 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -1,8 +1,12 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from argparse import ArgumentParser
-from logging import DEBUG, INFO, basicConfig, getLogger
-from os import getenv
+from logging import DEBUG, ERROR, INFO, WARNING, getLogger
 from os.path import isfile
 
+from grizzly.common.utils import configure_logging
+
 from .adb_process import ADBProcess
 from .adb_session import ADBSession
 
@@ -12,25 +16,24 @@
 __credits__ = ["Tyson Smith"]
 
 
-def main(argv=None):  # pylint: disable=missing-docstring
-    # set output verbosity
-    if bool(getenv("DEBUG")):
-        log_level = DEBUG
-        log_fmt = "%(levelname).1s %(name)s [%(asctime)s] %(message)s"
-    else:
-        log_level = INFO
-        log_fmt = "[%(asctime)s] %(message)s"
-    basicConfig(format=log_fmt, datefmt="%Y-%m-%d %H:%M:%S", level=log_level)
+def parse_args(argv=None):
+    log_level_map = {"ERROR": ERROR, "WARN": WARNING, "INFO": INFO, "DEBUG": DEBUG}
 
     parser = ArgumentParser(description="ADB Device Wrapper")
     parser.add_argument(
         "--airplane-mode",
-        default=None,
+        choices=(0, 1),
         type=int,
         help="Enable(1) or disable(0) airplane mode",
     )
     parser.add_argument("--install", help="Path to APK to install")
     parser.add_argument("--launch", help="Path to APK to launch")
+    parser.add_argument(
+        "--log-level",
+        choices=sorted(log_level_map),
+        default="INFO",
+        help="Configure console logging (default: %(default)s)",
+    )
     parser.add_argument("--logs", help="Location to save logs")
     parser.add_argument("--ip", help="IP address of target device")
     parser.add_argument(
@@ -40,16 +43,20 @@ def main(argv=None):  # pylint: disable=missing-docstring
         "--port", default=5555, type=int, help="ADB listening port on target device"
     )
     parser.add_argument("--prep", help="Prepare the device for fuzzing. Path to APK")
+
+    # sanity check args
     args = parser.parse_args(argv)
     if not any((args.airplane_mode is not None, args.install, args.launch, args.prep)):
         parser.error("No options selected")
-
-    # sanity check the APK
     for apk in (args.install, args.launch, args.prep):
         if apk is not None and not isfile(apk):
-            LOG.error("Invalid APK %r", apk)
-            return 1
+            parser.error("Invalid APK %r" % (apk,))
+    args.log_level = log_level_map[args.log_level]
+    return args
+
 
+def main(args):  # pylint: disable=missing-docstring
+    configure_logging(args.log_level)
     LOG.debug("opening a session")
     session = ADBSession.create(args.ip, args.port, as_root=not args.non_root)
     if session is None:
@@ -62,23 +69,23 @@ def main(argv=None):  # pylint: disable=missing-docstring
             args.install = args.prep
             session.sanitizer_options("asan", {"abort_on_error": "0"})
         if args.airplane_mode is not None:
+            LOG.debug("Setting airplane mode (%d)...", args.airplane_mode)
+            session.airplane_mode = args.airplane_mode == 1
             if args.airplane_mode > 0:
-                LOG.info("Enabling airplane mode...")
+                LOG.info("Enabled airplane mode.")
             else:
-                LOG.info("Disabling airplane mode...")
-            session.airplane_mode = bool(args.airplane_mode)
-            LOG.info("Done.")
+                LOG.info("Disabled airplane mode.")
         if args.install is not None:
             pkg_name = ADBSession.get_package_name(args.install)
             if pkg_name is None:
                 LOG.error("Failed to lookup package name in %r", args.install)
                 return 1
             if session.uninstall(pkg_name):
-                LOG.info("Uninstalled existing version")
-            LOG.info("Installing %s (%r)...", pkg_name, args.install)
+                LOG.info("Uninstalled existing %r.", pkg_name)
+            LOG.info("Installing %r from %r...", pkg_name, args.install)
             package = session.install(args.install)
             if not package:
-                LOG.error("Could not install %s", args.install)
+                LOG.error("Could not install %r", args.install)
                 return 1
             session.call(["shell", "am", "set-debug-app", "--persistent", package])
             LOG.info("Installed %s.", package)
@@ -107,4 +114,4 @@ def main(argv=None):  # pylint: disable=missing-docstring
 
 
 if __name__ == "__main__":
-    raise SystemExit(main())
+    raise SystemExit(main(parse_args()))

From f946355d19ad5269999c2561fafa78a34a1133e7 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 16 Mar 2022 13:07:29 -0700
Subject: [PATCH 509/531] [tests] Fix adb tests on Windows

---
 grizzly/target/adb_device/adb_session.py      |  2 +-
 grizzly/target/adb_device/test_adb_session.py | 27 ++++++++++++++++++-
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 435a6c89..c0102729 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -32,7 +32,7 @@ def _get_android_sdk():
             return android_home
     if getenv("ANDROID_SDK_ROOT") is not None:
         return Path(getenv("ANDROID_SDK_ROOT"))
-    if system() == "Windows":
+    if system() == "Windows" and getenv("LOCALAPPDATA") is not None:
         return Path(getenv("LOCALAPPDATA")) / "Android" / "sdk"
     if system() == "Darwin":
         return Path.home() / "Library" / "Android" / "sdk"
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 4d2b58cb..06fdd9de 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -2,13 +2,14 @@
 from pathlib import Path
 from zipfile import ZipFile
 
-from pytest import raises
+from pytest import mark, raises
 
 from .adb_session import (
     ADBCommandError,
     ADBCommunicationError,
     ADBSession,
     ADBSessionError,
+    _get_android_sdk,
 )
 
 
@@ -1509,3 +1510,27 @@ def fake_install_file(src, dst, **_):
     )
     session = ADBSession()
     session.sanitizer_options("asan", {"a": "1", "b": "2"})
+
+
+@mark.parametrize(
+    "env_var, os_name",
+    [
+        ("ANDROID_HOME", "Linux"),
+        ("ANDROID_SDK_ROOT", "Linux"),
+        ("LOCALAPPDATA", "Windows"),
+        (None, "Darwin"),
+        # default to ~/
+        (None, "Linux"),
+    ],
+)
+def test_adb_get_android_sdk_01(mocker, tmp_path, env_var, os_name):
+    """test ADBSession._get_android_sdk()"""
+
+    def _getenv(in_var):
+        if in_var == env_var:
+            return str(tmp_path)
+        return None
+
+    mocker.patch("grizzly.target.adb_device.adb_session.getenv", side_effect=_getenv)
+    mocker.patch("grizzly.target.adb_device.adb_session.system", return_value=os_name)
+    assert _get_android_sdk()

From df046a119bf4ab62135a2b011bfe7066092d3861 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 16 Mar 2022 17:05:02 -0700
Subject: [PATCH 510/531] [tests] Increase coverage of adb components

---
 grizzly/target/adb_device/device.py           |   9 +-
 grizzly/target/adb_device/test_adb_process.py |   1 +
 grizzly/target/adb_device/test_adb_session.py |  32 ++--
 grizzly/target/adb_device/test_main.py        | 146 ++++++++++++++++++
 grizzly/target/test_adb_target.py             |  42 +++--
 5 files changed, 196 insertions(+), 34 deletions(-)
 create mode 100644 grizzly/target/adb_device/test_main.py

diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index d6bad740..b9973713 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -71,10 +71,9 @@ def main(args):  # pylint: disable=missing-docstring
         if args.airplane_mode is not None:
             LOG.debug("Setting airplane mode (%d)...", args.airplane_mode)
             session.airplane_mode = args.airplane_mode == 1
-            if args.airplane_mode > 0:
-                LOG.info("Enabled airplane mode.")
-            else:
-                LOG.info("Disabled airplane mode.")
+            LOG.info(
+                "Airplane mode %s.", "enabled" if args.airplane_mode else "disabled"
+            )
         if args.install is not None:
             pkg_name = ADBSession.get_package_name(args.install)
             if pkg_name is None:
@@ -100,7 +99,7 @@ def main(args):  # pylint: disable=missing-docstring
                 assert proc.is_running(), "browser not running?!"
                 LOG.info("Launched.")
                 proc.wait()
-            except KeyboardInterrupt:
+            except KeyboardInterrupt:  # pragma: no cover
                 pass
             finally:
                 proc.close()
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index b256dfc6..e1c60c2f 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -95,6 +95,7 @@ def test_adb_process_07(mocker):
     # fake_session.process_exists.return_value = False
     with ADBProcess("org.mozilla.geckoview_example", fake_session) as proc:
         assert not proc.is_running()
+        assert not proc.is_healthy()
         assert proc.launches == 0
         assert proc.launch("fake.url")
         assert proc.is_running()
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 06fdd9de..f4815c94 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -888,6 +888,8 @@ def fake_adb_call(cmd, timeout=None):
     assert len(tuple(session.open_files(pid=9990, children=True))) == 6
     with raises(AssertionError):
         tuple(session.open_files(pid=None, children=True))
+    # list open files with "files" args for coverage
+    assert any(session.open_files(files=["test"]))
 
 
 def test_adb_session_21(mocker):
@@ -1043,7 +1045,7 @@ def fake_adb_call(cmd, timeout=None):
         session.listdir("missing-dir")
     dir_list = session.listdir("fake-dir")
     assert len(dir_list) == 1
-    assert "test" in session.listdir("fake-dir")
+    assert "test" in dir_list
 
 
 def test_adb_session_26(mocker):
@@ -1075,23 +1077,23 @@ def fake_adb_call(cmd, timeout=None):
 
 def test_adb_session_27(mocker, tmp_path):
     """test ADBSession._aapt_check()"""
+    (tmp_path / "android-9").mkdir()
+    fake_aapt = tmp_path / "android-9" / "aapt"
+    fake_aapt.touch()
     # use system aapt
     mocker.patch(
-        "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing")
+        "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", tmp_path / "missing"
     )
     mocker.patch(
-        "grizzly.target.adb_device.adb_session.which", return_value="/fake_system/aapt"
+        "grizzly.target.adb_device.adb_session.which", return_value=str(fake_aapt)
     )
-    assert ADBSession._aapt_check() == "/fake_system/aapt"
-    (tmp_path / "android-9").mkdir()
-    fake_aapt = tmp_path / "android-9" / "aapt"
-    fake_aapt.touch()
+    assert ADBSession._aapt_check() == str(fake_aapt)
     # use recommended aapt
     mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", tmp_path)
     assert ADBSession._aapt_check() == str(fake_aapt)
     # aapt not installed
     mocker.patch(
-        "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing")
+        "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", tmp_path / "missing"
     )
     mocker.patch("grizzly.target.adb_device.adb_session.which", return_value=None)
     with raises(EnvironmentError, match=r"Please install AAPT"):
@@ -1100,26 +1102,26 @@ def test_adb_session_27(mocker, tmp_path):
 
 def test_adb_session_28(mocker, tmp_path):
     """test ADBSession._adb_check()"""
+    (tmp_path / "platform-tools").mkdir()
+    fake_adb = tmp_path / "platform-tools" / "adb"
+    fake_adb.touch()
     mocker.patch(
         "grizzly.target.adb_device.adb_session.sleep"
     )  # skip delay after warning message
     # use system adb
     mocker.patch(
-        "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing")
+        "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", tmp_path / "missing"
     )
     mocker.patch(
-        "grizzly.target.adb_device.adb_session.which", return_value="/fake_system/adb"
+        "grizzly.target.adb_device.adb_session.which", return_value=str(fake_adb)
     )
-    assert ADBSession._adb_check() == "/fake_system/adb"
-    (tmp_path / "platform-tools").mkdir()
-    fake_adb = tmp_path / "platform-tools" / "adb"
-    fake_adb.touch()
+    assert ADBSession._adb_check() == str(fake_adb)
     # use recommended adb
     mocker.patch("grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", tmp_path)
     assert ADBSession._adb_check() == str(fake_adb)
     # adb not installed
     mocker.patch(
-        "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", Path("/missing")
+        "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", tmp_path / "missing"
     )
     mocker.patch("grizzly.target.adb_device.adb_session.which", return_value=None)
     with raises(EnvironmentError, match=r"Please install ADB"):
diff --git a/grizzly/target/adb_device/test_main.py b/grizzly/target/adb_device/test_main.py
new file mode 100644
index 00000000..af68b514
--- /dev/null
+++ b/grizzly/target/adb_device/test_main.py
@@ -0,0 +1,146 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from pytest import mark, raises
+
+from .device import main, parse_args
+
+
+@mark.parametrize(
+    "args, msg",
+    [
+        ([], "error: No options selected"),
+        (["--install", "missing"], "error: Invalid APK 'missing'"),
+        (["--launch", "missing"], "error: Invalid APK 'missing'"),
+        (["--prep", "missing"], "error: Invalid APK 'missing'"),
+    ],
+)
+def test_parse_01(capsys, args, msg):
+    """test parse_args()"""
+    with raises(SystemExit):
+        parse_args(argv=args)
+    assert msg in capsys.readouterr()[1]
+
+
+def test_parse_02(tmp_path):
+    """test parse_args()"""
+    apk = tmp_path / "fake.apk"
+    apk.touch()
+    assert parse_args(argv=["--prep", str(apk)])
+
+
+def test_main_01(mocker):
+    """test main() - create session failed"""
+    session_cls = mocker.patch(
+        "grizzly.target.adb_device.device.ADBSession", autospec=True
+    )
+    session_cls.create.return_value = None
+    args = mocker.Mock(ip=None, non_root=False, prep=None, port=12345)
+    assert main(args) == 1
+
+
+def test_main_02(mocker):
+    """test main() - airplane mode"""
+    session_cls = mocker.patch(
+        "grizzly.target.adb_device.device.ADBSession", autospec=True
+    )
+    args = mocker.Mock(
+        airplane_mode=1,
+        launch=None,
+        install=None,
+        ip=None,
+        non_root=False,
+        prep=None,
+        port=12345,
+    )
+    assert main(args) == 0
+    assert session_cls.create.call_count == 1
+    session_obj = session_cls.create.return_value
+    assert session_obj.airplane_mode == 1
+    assert session_obj.disconnect.call_count == 1
+
+
+@mark.parametrize(
+    "pkg, install, result",
+    [
+        # success
+        ("test", "test", 0),
+        # bad apk, failed to lookup name
+        (None, None, 1),
+        # install failed
+        ("test", None, 1),
+    ],
+)
+def test_main_03(mocker, pkg, install, result):
+    """test main() - install"""
+    session_cls = mocker.patch(
+        "grizzly.target.adb_device.device.ADBSession", autospec=True
+    )
+    session_cls.get_package_name.return_value = pkg
+    session_obj = session_cls.create.return_value
+    session_obj.install.return_value = install
+    args = mocker.Mock(
+        airplane_mode=None,
+        launch=None,
+        install="fake.apk",
+        ip=None,
+        non_root=False,
+        prep=None,
+        port=12345,
+    )
+    assert main(args) == result
+    assert session_cls.create.call_count == 1
+    assert session_obj.disconnect.call_count == 1
+
+
+@mark.parametrize(
+    "pkg, result",
+    [
+        # success
+        ("test", 0),
+        # bad apk, failed to lookup name
+        (None, 1),
+    ],
+)
+def test_main_04(mocker, pkg, result):
+    """test main() - launch"""
+    mocker.patch("grizzly.target.adb_device.device.ADBProcess", autospec=True)
+    session_cls = mocker.patch(
+        "grizzly.target.adb_device.device.ADBSession", autospec=True
+    )
+    session_cls.get_package_name.return_value = pkg
+    session_obj = session_cls.create.return_value
+    args = mocker.Mock(
+        airplane_mode=None,
+        launch="fake.apk",
+        install=None,
+        ip=None,
+        non_root=False,
+        prep=None,
+        port=12345,
+    )
+    assert main(args) == result
+    assert session_cls.create.call_count == 1
+    assert session_obj.disconnect.call_count == 1
+
+
+def test_main_05(mocker):
+    """test main() - prep"""
+    session_cls = mocker.patch(
+        "grizzly.target.adb_device.device.ADBSession", autospec=True
+    )
+    args = mocker.Mock(
+        airplane_mode=None,
+        launch=None,
+        install=None,
+        ip=None,
+        non_root=False,
+        prep="fake.apk",
+        port=12345,
+    )
+    assert main(args) == 0
+    assert session_cls.create.call_count == 1
+    session_obj = session_cls.create.return_value
+    assert session_obj.airplane_mode == 1
+    assert session_obj.install.call_count == 1
+    assert session_obj.disconnect.call_count == 1
diff --git a/grizzly/target/test_adb_target.py b/grizzly/target/test_adb_target.py
index 913b570c..88d70983 100644
--- a/grizzly/target/test_adb_target.py
+++ b/grizzly/target/test_adb_target.py
@@ -1,15 +1,27 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from pytest import mark
+from pytest import mark, raises
 
 from .adb_device import ADBSession, Reason
 from .adb_target import ADBTarget
 from .target import Result
 
 
-def test_adb_target_01(mocker, tmp_path):
+@mark.parametrize(
+    "kwargs",
+    [
+        # no extra kwargs
+        {},
+        # unsupported debuggers
+        {"pernosco": True, "rr": True},
+        # unknown kwargs
+        {"unknown_kwarg": "1"},
+    ],
+)
+def test_adb_target_01(mocker, tmp_path, kwargs):
     """test creating a simple ADBTarget"""
+    # pylint: disable=protected-access
     fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
     fake_process.return_value.is_healthy.return_value = False
     fake_process.return_value.is_running.return_value = False
@@ -21,12 +33,15 @@ def test_adb_target_01(mocker, tmp_path):
     fake_session.get_package_name.return_value = "the_name"
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()
-    with ADBTarget(str(fake_apk), 300, 25, 5000) as target:
+    with ADBTarget(str(fake_apk), 300, 25, 5000, **kwargs) as target:
         assert target.closed
         assert target.forced_close
         assert target.monitor is not None
         assert target.check_result(None) == Result.NONE
         assert not target.log_size()
+        assert target._prefs is None
+        target.process_assets()
+        assert target._prefs is not None
         target.cleanup()
         assert fake_sess_obj.reverse_remove.call_count == 1
         assert fake_sess_obj.disconnect.call_count == 1
@@ -39,17 +54,13 @@ def test_adb_target_01(mocker, tmp_path):
 
 
 def test_adb_target_02(mocker, tmp_path):
-    """test ADBTarget.launch()"""
-    fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
-    fake_process.return_value.launches = 0
-    mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
+    """test ADBTarget fail to create session"""
+    session_cls = mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
+    session_cls.create.return_value = None
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()
-    with ADBTarget(str(fake_apk), 300, 25, 5000) as target:
-        target.launch("fake.url")
-        assert fake_process.return_value.launch.call_count == 1
-        assert target.monitor.is_running()
-        assert target.monitor.is_healthy()
+    with raises(RuntimeError, match="Could not create ADB Session!"):
+        ADBTarget(str(fake_apk), 300, 25, 5000)
 
 
 @mark.parametrize(
@@ -66,13 +77,16 @@ def test_adb_target_02(mocker, tmp_path):
     ],
 )
 def test_adb_target_03(mocker, tmp_path, healthy, reason, result, closes):
-    """test ADBTarget.check_result()"""
+    """test ADBTarget launch() and check_result()"""
     fake_process = mocker.patch("grizzly.target.adb_target.ADBProcess", autospec=True)
     mocker.patch("grizzly.target.adb_target.ADBSession", autospec=True)
     fake_apk = tmp_path / "test.apk"
     fake_apk.touch()
     with ADBTarget(str(fake_apk), 300, 25, 5000) as target:
-        # test everything is running
+        target.launch("fake.url")
+        assert fake_process.return_value.launch.call_count == 1
+        assert target.monitor.is_running()
+        assert target.monitor.is_healthy()
         fake_process.return_value.is_healthy.return_value = healthy
         fake_process.return_value.reason = reason
         assert target.check_result(None) == result

From b896535313c3c1892b9b381506f4387acb78a613 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 17 Mar 2022 10:35:38 -0700
Subject: [PATCH 511/531] Use relative imports

---
 grizzly/conftest.py                      | 2 +-
 grizzly/target/adb_device/adb_session.py | 2 +-
 grizzly/target/adb_device/device.py      | 3 +--
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/grizzly/conftest.py b/grizzly/conftest.py
index 3d358155..ef7d76c1 100644
--- a/grizzly/conftest.py
+++ b/grizzly/conftest.py
@@ -7,7 +7,7 @@
 
 from pytest import fixture
 
-from grizzly.common.status import ReductionStatus, Status
+from .common.status import ReductionStatus, Status
 
 
 @fixture
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index c0102729..7ed48945 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -13,7 +13,7 @@
 from tempfile import TemporaryDirectory, TemporaryFile
 from time import sleep, time
 
-from grizzly.common.utils import grz_tmp
+from ...common.utils import grz_tmp
 
 LOG = getLogger("adb_session")
 
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/device.py
index b9973713..6f2199cb 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/device.py
@@ -5,8 +5,7 @@
 from logging import DEBUG, ERROR, INFO, WARNING, getLogger
 from os.path import isfile
 
-from grizzly.common.utils import configure_logging
-
+from ...common.utils import configure_logging
 from .adb_process import ADBProcess
 from .adb_session import ADBSession
 

From a4b04db7d5d59d0561fca6490256b990ced47b1e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 17 Mar 2022 10:36:32 -0700
Subject: [PATCH 512/531] [adb] Add missing header comments

---
 grizzly/target/adb_device/__init__.py         | 3 +++
 grizzly/target/adb_device/test_adb_process.py | 3 +++
 grizzly/target/adb_device/test_adb_session.py | 3 +++
 3 files changed, 9 insertions(+)

diff --git a/grizzly/target/adb_device/__init__.py b/grizzly/target/adb_device/__init__.py
index d5e0dccb..2211483e 100644
--- a/grizzly/target/adb_device/__init__.py
+++ b/grizzly/target/adb_device/__init__.py
@@ -1,3 +1,6 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from .adb_process import ADBProcess, Reason
 from .adb_session import ADBSession
 
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index e1c60c2f..9a878a5b 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -1,3 +1,6 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
 from os import listdir
 from os.path import isdir
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index f4815c94..ee3d827c 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -1,3 +1,6 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
 from pathlib import Path
 from zipfile import ZipFile

From ec149c4a069ca89405a272a78b28c265b2900be0 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 17 Mar 2022 10:51:56 -0700
Subject: [PATCH 513/531] [adb] Rename device.py -> main.py

---
 grizzly/target/adb_device/__main__.py            | 6 ++++++
 grizzly/target/adb_device/{device.py => main.py} | 4 ----
 2 files changed, 6 insertions(+), 4 deletions(-)
 create mode 100644 grizzly/target/adb_device/__main__.py
 rename grizzly/target/adb_device/{device.py => main.py} (98%)

diff --git a/grizzly/target/adb_device/__main__.py b/grizzly/target/adb_device/__main__.py
new file mode 100644
index 00000000..76926a51
--- /dev/null
+++ b/grizzly/target/adb_device/__main__.py
@@ -0,0 +1,6 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+from .main import main, parse_args
+
+raise SystemExit(main(parse_args()))
diff --git a/grizzly/target/adb_device/device.py b/grizzly/target/adb_device/main.py
similarity index 98%
rename from grizzly/target/adb_device/device.py
rename to grizzly/target/adb_device/main.py
index 6f2199cb..dcf6af62 100644
--- a/grizzly/target/adb_device/device.py
+++ b/grizzly/target/adb_device/main.py
@@ -109,7 +109,3 @@ def main(args):  # pylint: disable=missing-docstring
     finally:
         session.disconnect()
     return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(parse_args()))

From 139eed9882311c1c5e108cb20b526c4d7fc169ac Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 22 Mar 2022 18:01:42 -0700
Subject: [PATCH 514/531] [adb] Update support for ASan builds

---
 grizzly/target/adb_device/adb_process.py      | 24 +++++++++++++------
 grizzly/target/adb_device/adb_session.py      |  3 +--
 grizzly/target/adb_device/main.py             |  8 +++++--
 grizzly/target/adb_device/test_adb_process.py | 13 +---------
 grizzly/target/adb_device/test_adb_session.py |  1 +
 grizzly/target/adb_device/test_main.py        | 22 ++++++++++-------
 6 files changed, 39 insertions(+), 32 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index 0813cf37..74bb17d1 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -51,6 +51,7 @@ class ADBProcess:
         "_package",
         "_pid",
         "_profile_template",
+        "_sanitizer_logs",
         "_session",
         "_working_path",
         "logs",
@@ -70,6 +71,7 @@ def __init__(self, package_name, session, use_profile=None):
         # Note: geckview_example fails to read a profile from /sdcard/ atm
         # self._working_path = "/sdcard/ADBProc_%08X" % (getrandbits(32),)
         self._working_path = "/data/local/tmp/ADBProc_%08X" % (getrandbits(32),)
+        self._sanitizer_logs = "%s/sanitizer_logs" % (self._working_path,)
         self.logs = None
         self.profile = None  # profile path on device
         self.reason = Reason.CLOSED
@@ -135,9 +137,8 @@ def close(self):
     def find_crashreports(self):
         reports = list()
         # look for logs from sanitizers
-        san_path = os.path.dirname(self._session.SANITIZER_LOG_PREFIX)
-        for fname in self._session.listdir(san_path):
-            reports.append(os.path.join(san_path, fname))
+        for fname in self._session.listdir(self._sanitizer_logs):
+            reports.append(os.path.join(self._sanitizer_logs, fname))
 
         if not reports and self.profile:
             # check for minidumps
@@ -217,12 +218,25 @@ def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
                     "privacy.partition.network_state": False,
                 }
             )
+            # create location to store sanitizer logs
+            self._session.call(["shell", "mkdir", "-p", self._sanitizer_logs])
             # create empty profile
             self.profile = "%s/gv_profile_%08X" % (self._working_path, getrandbits(32))
             self._session.call(["shell", "mkdir", "-p", self.profile])
             # add environment variables
             env_mod = dict(env_mod or {})
             env_mod.setdefault("MOZ_SKIA_DISABLE_ASSERTS", "1")
+            self._session.sanitizer_options(
+                "asan",
+                {
+                    "abort_on_error": "1",
+                    "color": "0",
+                    "external_symbolizer_path": "'/data/local/tmp/llvm-symbolizer'",
+                    # "log_path": "'%s/log_san.txt'" % (self._sanitizer_logs,),
+                    "symbolize": "1",
+                },
+            )
+
             # build *-geckoview-config.yaml
             # https://firefox-source-docs.mozilla.org/mobile/android/geckoview/...
             # consumer/automation.html#configuration-file-format
@@ -337,10 +351,6 @@ def _process_logs(self, crash_reports):
             logger.save_logs(self.logs)
 
     def _remove_logs(self):
-        sanitizer_logs = os.path.dirname(self._session.SANITIZER_LOG_PREFIX)
-        self._session.call(["shell", "rm", "-r", sanitizer_logs])
-        self._session.call(["shell", "mkdir", "-p", sanitizer_logs])
-        self._session.call(["shell", "chmod", "666", sanitizer_logs])
         if self.logs is not None and os.path.isdir(self.logs):
             rmtree(self.logs)
             self.logs = None
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 7ed48945..ff691cf2 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -56,8 +56,6 @@ class ADBSessionError(Exception):
 
 # pylint: disable=too-many-public-methods
 class ADBSession:
-    SANITIZER_LOG_PREFIX = "/sdcard/sanitizer_logs/report.log"
-
     __slots__ = (
         "_adb_bin",
         "_cpu_arch",
@@ -846,6 +844,7 @@ def sanitizer_options(self, prefix, options):
         """
         prefix = prefix.lower()
         assert prefix == "asan", "only ASan is supported atm"
+        self.call(["shell", "rm", "-f", "%s.options.gecko" % (prefix,)])
         with TemporaryDirectory(prefix="sanopts_", dir=grz_tmp()) as working_path:
             optfile = Path(working_path) / ("%s.options.gecko" % (prefix,))
             optfile.write_text(":".join("%s=%s" % x for x in options.items()))
diff --git a/grizzly/target/adb_device/main.py b/grizzly/target/adb_device/main.py
index dcf6af62..000224b2 100644
--- a/grizzly/target/adb_device/main.py
+++ b/grizzly/target/adb_device/main.py
@@ -3,7 +3,8 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from argparse import ArgumentParser
 from logging import DEBUG, ERROR, INFO, WARNING, getLogger
-from os.path import isfile
+from os.path import dirname, isfile
+from os.path import join as path_join
 
 from ...common.utils import configure_logging
 from .adb_process import ADBProcess
@@ -66,7 +67,6 @@ def main(args):  # pylint: disable=missing-docstring
             LOG.info("Preparing device...")
             args.airplane_mode = 1
             args.install = args.prep
-            session.sanitizer_options("asan", {"abort_on_error": "0"})
         if args.airplane_mode is not None:
             LOG.debug("Setting airplane mode (%d)...", args.airplane_mode)
             session.airplane_mode = args.airplane_mode == 1
@@ -85,6 +85,10 @@ def main(args):  # pylint: disable=missing-docstring
             if not package:
                 LOG.error("Could not install %r", args.install)
                 return 1
+            llvm_sym = path_join(dirname(args.install), "llvm-symbolizer")
+            if isfile(llvm_sym):
+                LOG.info("Installing llvm-symbolizer...")
+                session.install_file(llvm_sym, "/data/local/tmp/", mode="777")
             session.call(["shell", "am", "set-debug-app", "--persistent", package])
             LOG.info("Installed %s.", package)
         if args.launch:
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 9a878a5b..6c18cf5c 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -15,9 +15,7 @@
 def test_adb_process_01(mocker):
     """test creating a simple device"""
     test_pkg = "org.test.preinstalled"
-    fake_session = mocker.Mock(
-        spec_set=ADBSession, SANITIZER_LOG_PREFIX="/fake/log.txt"
-    )
+    fake_session = mocker.Mock(spec_set=ADBSession)
     with ADBProcess(test_pkg, fake_session) as proc:
         assert isinstance(proc._session, ADBSession)
         assert proc._package == test_pkg
@@ -40,7 +38,6 @@ def test_adb_process_02(mocker):
 def test_adb_process_03(mocker):
     """test ADBProcess.launch() unsupported app"""
     fake_session = mocker.Mock(spec_set=ADBSession)
-    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     with ADBProcess("org.some.app", fake_session) as proc:
         with raises(ADBLaunchError, match="Unsupported package 'org.some.app'"):
             proc.launch("fake.url")
@@ -51,7 +48,6 @@ def test_adb_process_04(mocker):
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     mocker.patch("grizzly.target.adb_device.adb_process.sleep", autospec=True)
     fake_session = mocker.Mock(spec_set=ADBSession)
-    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.collect_logs.return_value = b""
     fake_session.listdir.return_value = ()
     fake_session.get_pid.return_value = None
@@ -64,7 +60,6 @@ def test_adb_process_04(mocker):
 def test_adb_process_05(mocker):
     """test ADBProcess.launch() package is running (bad state)"""
     fake_session = mocker.Mock(spec_set=ADBSession)
-    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (1, "")
     fake_session.collect_logs.return_value = b""
     fake_session.listdir.return_value = ()
@@ -90,7 +85,6 @@ def test_adb_process_07(mocker):
     fake_bs.return_value.location = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec_set=ADBSession)
-    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = b""
     fake_session.get_pid.side_effect = (None, 1337)
@@ -120,7 +114,6 @@ def test_adb_process_08(mocker):
     fake_bs.return_value.location = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec_set=ADBSession)
-    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = b""
     fake_session.get_pid.side_effect = (None, 1337)
@@ -139,7 +132,6 @@ def test_adb_process_09(mocker):
     )
     fake_bs.return_value.location = "http://localhost"
     fake_session = mocker.Mock(spec_set=ADBSession)
-    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.call.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = b""
     fake_session.get_pid.side_effect = (None, 1337)
@@ -168,7 +160,6 @@ def test_adb_process_10(mocker):
     """test ADBProcess.find_crashreports()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec_set=ADBSession)
-    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     with ADBProcess("org.some.app", fake_session) as proc:
         proc.profile = "profile_path"
         # no log or minidump files
@@ -189,7 +180,6 @@ def test_adb_process_11(mocker, tmp_path):
     """test ADBProcess.save_logs()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec_set=ADBSession)
-    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     log_path = tmp_path / "src"
     log_path.mkdir()
     (log_path / "nested").mkdir()
@@ -213,7 +203,6 @@ def test_adb_process_12(mocker):
         "grizzly.target.adb_device.adb_process.process_minidumps", autospec=True
     )
     fake_session = mocker.Mock(spec_set=ADBSession)
-    fake_session.SANITIZER_LOG_PREFIX = "/fake/log/prefix.txt"
     fake_session.collect_logs.return_value = b"fake logcat data"
     with ADBProcess("org.some.app", fake_session) as proc:
         # no extra logs
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index ee3d827c..67ceeaa2 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -1499,6 +1499,7 @@ def test_adb_session_39():
 
 def test_adb_session_40(mocker):
     """test ADBSession.sanitizer_options()"""
+    mocker.patch("grizzly.target.adb_device.ADBSession.call", autospec=True)
     mocker.patch(
         "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
     )
diff --git a/grizzly/target/adb_device/test_main.py b/grizzly/target/adb_device/test_main.py
index af68b514..4a76cb79 100644
--- a/grizzly/target/adb_device/test_main.py
+++ b/grizzly/target/adb_device/test_main.py
@@ -3,7 +3,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from pytest import mark, raises
 
-from .device import main, parse_args
+from .main import main, parse_args
 
 
 @mark.parametrize(
@@ -32,7 +32,7 @@ def test_parse_02(tmp_path):
 def test_main_01(mocker):
     """test main() - create session failed"""
     session_cls = mocker.patch(
-        "grizzly.target.adb_device.device.ADBSession", autospec=True
+        "grizzly.target.adb_device.main.ADBSession", autospec=True
     )
     session_cls.create.return_value = None
     args = mocker.Mock(ip=None, non_root=False, prep=None, port=12345)
@@ -42,7 +42,7 @@ def test_main_01(mocker):
 def test_main_02(mocker):
     """test main() - airplane mode"""
     session_cls = mocker.patch(
-        "grizzly.target.adb_device.device.ADBSession", autospec=True
+        "grizzly.target.adb_device.main.ADBSession", autospec=True
     )
     args = mocker.Mock(
         airplane_mode=1,
@@ -71,18 +71,20 @@ def test_main_02(mocker):
         ("test", None, 1),
     ],
 )
-def test_main_03(mocker, pkg, install, result):
+def test_main_03(mocker, tmp_path, pkg, install, result):
     """test main() - install"""
     session_cls = mocker.patch(
-        "grizzly.target.adb_device.device.ADBSession", autospec=True
+        "grizzly.target.adb_device.main.ADBSession", autospec=True
     )
     session_cls.get_package_name.return_value = pkg
     session_obj = session_cls.create.return_value
     session_obj.install.return_value = install
+    apk = tmp_path / "fake.apk"
+    (tmp_path / "llvm-symbolizer").touch()
     args = mocker.Mock(
         airplane_mode=None,
         launch=None,
-        install="fake.apk",
+        install=str(apk),
         ip=None,
         non_root=False,
         prep=None,
@@ -90,6 +92,8 @@ def test_main_03(mocker, pkg, install, result):
     )
     assert main(args) == result
     assert session_cls.create.call_count == 1
+    assert session_obj.install.call_count == (1 if pkg else 0)
+    assert session_obj.install_file.call_count == (0 if result else 1)
     assert session_obj.disconnect.call_count == 1
 
 
@@ -104,9 +108,9 @@ def test_main_03(mocker, pkg, install, result):
 )
 def test_main_04(mocker, pkg, result):
     """test main() - launch"""
-    mocker.patch("grizzly.target.adb_device.device.ADBProcess", autospec=True)
+    mocker.patch("grizzly.target.adb_device.main.ADBProcess", autospec=True)
     session_cls = mocker.patch(
-        "grizzly.target.adb_device.device.ADBSession", autospec=True
+        "grizzly.target.adb_device.main.ADBSession", autospec=True
     )
     session_cls.get_package_name.return_value = pkg
     session_obj = session_cls.create.return_value
@@ -127,7 +131,7 @@ def test_main_04(mocker, pkg, result):
 def test_main_05(mocker):
     """test main() - prep"""
     session_cls = mocker.patch(
-        "grizzly.target.adb_device.device.ADBSession", autospec=True
+        "grizzly.target.adb_device.main.ADBSession", autospec=True
     )
     args = mocker.Mock(
         airplane_mode=None,

From 55624c780d3cb955f15c5e6ec790c574b881e52b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Mar 2022 16:14:07 -0700
Subject: [PATCH 515/531] [adb] Scan wrap.sh output for ASan logs

---
 grizzly/target/adb_device/adb_process.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index 74bb17d1..c19a1b1d 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -384,6 +384,7 @@ def _split_logcat(log_path, package_name):
                     b"Gecko" not in line
                     and b"MOZ_" not in line
                     and package_name not in line
+                    and b"wrap.sh" not in line
                 ):
                     continue
                 m_id = re_id.match(line)

From 0d0390ee2e1f3804af742d52c16679393c086fb8 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Mar 2022 16:15:55 -0700
Subject: [PATCH 516/531] [tests] Update ADBSession tests

---
 grizzly/target/adb_device/adb_session.py      |   4 +-
 grizzly/target/adb_device/conftest.py         |  16 +
 grizzly/target/adb_device/test_adb_session.py | 376 +++++++++---------
 3 files changed, 195 insertions(+), 201 deletions(-)
 create mode 100644 grizzly/target/adb_device/conftest.py

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index ff691cf2..0bdee33b 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -72,9 +72,7 @@ class ADBSession:
     def __init__(self, ip_addr=None, port=5555):
         self._adb_bin = self._adb_check()
         self._cpu_arch = None  # Android CPU architecture string
-        self._debug_adb = (
-            int(getenv("SHOW_ADB_DEBUG", "0")) != 0
-        )  # include ADB output in debug logs
+        self._debug_adb = getenv("SHOW_ADB_DEBUG", "0") != "0"  # include ADB output
         self._ip_addr = None  # target device IP address
         self._os_version = None  # Android version string
         self._port = None  # ADB listening port
diff --git a/grizzly/target/adb_device/conftest.py b/grizzly/target/adb_device/conftest.py
new file mode 100644
index 00000000..557dd6fc
--- /dev/null
+++ b/grizzly/target/adb_device/conftest.py
@@ -0,0 +1,16 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+"""Common unit test fixtures for `adb_device`.
+"""
+
+from pytest import fixture
+
+
+@fixture
+def tmp_session_adb_check(mocker):
+    """Mock adb binary location lookup function"""
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.ADBSession._adb_check",
+        return_value="fake_adb",
+    )
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 67ceeaa2..aba33ace 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -68,52 +68,60 @@ def poll(self):
     assert "wait" in output
 
 
-def test_adb_session_02(mocker):
+@mark.parametrize(
+    "ret, msg, exc, connected",
+    [
+        # not connected
+        (None, "ADB session is not connected!", ADBCommunicationError, False),
+        # invalid command
+        (
+            (1, "Android Debug Bridge version"),
+            "Invalid ADB command 'test'",
+            ADBCommandError,
+            True,
+        ),
+        # invalid command
+        ((1, "adb: usage:"), "adb: usage:", ADBCommandError, True),
+        # disconnected device
+        ((1, "error: closed"), "No device detected!", ADBCommunicationError, True),
+        # disconnected device
+        (
+            (1, "error: device offline"),
+            "No device detected!",
+            ADBCommunicationError,
+            True,
+        ),
+        # disconnected device
+        (
+            (1, "error: no devices/emulators found"),
+            "No device detected!",
+            ADBCommunicationError,
+            True,
+        ),
+        # success
+        ((0, "pass"), None, None, True),
+    ],
+)
+@mark.usefixtures("tmp_session_adb_check")
+def test_adb_session_02(mocker, ret, msg, exc, connected):
     """test ADBSession.call()"""
-    # not connected
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="fake_adb"
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb", return_value=ret
     )
     session = ADBSession()
-    with raises(ADBCommunicationError, match="ADB session is not connected!"):
-        session.call(["test"])
-    # successful call
-    session.connected = True
-    session._debug_adb = True
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", return_value=(0, "pass")
-    )
-    ret_code, output = session.call(["test"])
-    assert ret_code == 0
-    assert output == "pass"
-    # invalid command
-    session._debug_adb = False
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb",
-        return_value=(1, "Android Debug Bridge version"),
-    )
-    with raises(ADBCommandError, match="Invalid ADB command 'test'"):
-        session.call(["test"])
-    # invalid command
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb",
-        return_value=(1, "adb: usage:"),
-    )
-    with raises(ADBCommandError, match="adb: usage:"):
-        session.call(["test"])
-    # disconnected device
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb",
-        return_value=(1, "error: closed"),
-    )
-    with raises(ADBCommunicationError, match="No device detected!"):
-        session.call(["test"])
-    assert not session.connected
-
-
-def test_adb_session_03(mocker):
+    session.connected = connected
+    if exc is None:
+        session._debug_adb = False
+        assert session.call(["test"]) == (0, "pass")
+    else:
+        session._debug_adb = True
+        with raises(exc, match=msg):
+            session.call(["test"])
+
+
+@mark.usefixtures("tmp_session_adb_check")
+def test_adb_session_03():
     """test creating a session with invalid args"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check")
     with raises(ValueError):
         ADBSession("invalid.ip")
     with raises(ValueError):
@@ -122,9 +130,9 @@ def test_adb_session_03(mocker):
         ADBSession("127.0.0.1", port="bad")
 
 
-def test_adb_session_04(mocker):
+@mark.usefixtures("tmp_session_adb_check")
+def test_adb_session_04():
     """test simple ADBSession"""
-    mocker.patch("grizzly.target.adb_device.ADBSession._adb_check")
     test_ip = "127.0.0.1"
     test_port = 5556
     session = ADBSession(test_ip, test_port)
@@ -136,11 +144,9 @@ def test_adb_session_04(mocker):
     assert session._os_version is None
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_05(mocker):
     """test ADBSession.devices()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_01(cmd, timeout=None):
@@ -150,7 +156,8 @@ def fake_adb_01(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_01
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_01,
     )
     assert not ADBSession().devices()
 
@@ -167,7 +174,8 @@ def fake_adb_02(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_02
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_02,
     )
     devices = ADBSession().devices(all_devices=True, any_state=False)
     assert len(devices) == 1
@@ -189,7 +197,8 @@ def fake_adb_03(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_03
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_03,
     )
     session = ADBSession()
     mocker.patch(
@@ -203,18 +212,16 @@ def fake_adb_03(cmd, timeout=None):
         session.devices(all_devices=False, any_state=False)
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_06(mocker):
     """test simple ADBSession.create()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
     test_arch = "x86_64"
     test_ip = "localhost"
     test_port = 5555
     test_version = "9"
 
     # pylint: disable=too-many-return-statements,unused-argument
-    def fake_adb_call(obj, cmd, timeout=None):
+    def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "connect":
             assert cmd[2] == ":".join([test_ip, str(test_port)])
@@ -237,9 +244,9 @@ def fake_adb_call(obj, cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
-    ADBSession._call_adb = fake_adb_call
     session = ADBSession.create(test_ip, test_port)
     assert session is not None
     assert session.connected
@@ -250,11 +257,9 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert session._port == test_port
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_07(mocker):
     """test full ADBSession.create()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
     test_arch = "x86_64"
     test_ip = "localhost"
     test_port = 5555
@@ -311,7 +316,7 @@ def fake_adb_call(obj, cmd, timeout=None):
             return 0, "restarting adbd as non root"
         raise AssertionError("unexpected command %r" % (cmd,))
 
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    mocker.patch("grizzly.target.adb_device.adb_session.ADBSession._call_adb")
     ADBSession._call_adb = fake_adb_call
     session = ADBSession.create(test_ip, test_port)
     assert session is not None
@@ -326,11 +331,9 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert not session._root
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_08(mocker):
     """test ADBSession.create() without IP"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
     test_arch = "x86"
     test_version = "7.1.2"
 
@@ -366,7 +369,7 @@ def fake_adb_call(obj, cmd, timeout=None):
             return 0, "shell"
         raise AssertionError("unexpected command %r" % (cmd,))
 
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    mocker.patch("grizzly.target.adb_device.adb_session.ADBSession._call_adb")
     ADBSession._call_adb = fake_adb_call
     session = ADBSession.create(as_root=False)
     assert session is not None
@@ -380,14 +383,10 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert not session.connected
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_09(mocker):
     """test ADBSession.connect() no devices available"""
-    mocker.patch(
-        "grizzly.target.adb_device.adb_session.sleep"
-    )  # skip delay after warning message
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
+    mocker.patch("grizzly.target.adb_device.adb_session.sleep")
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -404,18 +403,17 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     assert not ADBSession().connect()
     assert not ADBSession("127.0.0.1").connect()
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_10(mocker):
     """test ADBSession.connect() device in a bad state"""
-    mocker.patch("grizzly.target.adb_device.adb_session.sleep")  # skip delays
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
+    mocker.patch("grizzly.target.adb_device.adb_session.sleep")
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -434,7 +432,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     with raises(
         ADBSessionError, match="Device in a bad state, try disconnect & reboot"
@@ -442,12 +441,9 @@ def fake_adb_call(cmd, timeout=None):
         ADBSession("127.0.0.1").connect()
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_11(mocker):
     """test ADBSession.connect() and ADBSession.disconnect()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
-
     # pylint: disable=too-many-return-statements,unused-argument
     def fake_adb_call(obj, cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
@@ -494,9 +490,12 @@ def fake_adb_call(obj, cmd, timeout=None):
             return 0, "restarting adbd as non root"
         raise AssertionError("unexpected command %r" % (cmd,))
 
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
-    ADBSession._call_adb = fake_adb_call
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        autospec=True,
+    )
     session = ADBSession("127.0.0.1")
+    ADBSession._call_adb = fake_adb_call
     assert not session.connected
     assert not session._root
     session.disconnect()
@@ -525,12 +524,9 @@ def fake_adb_call(obj, cmd, timeout=None):
     assert not session._root
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_12(mocker):
     """test ADBSession.connect() with unavailable device"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
-
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
@@ -541,7 +537,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     assert not session.connected
@@ -553,13 +550,11 @@ def fake_adb_call(cmd, timeout=None):
     assert not session._root
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_13(mocker):
     """test ADBSession.all() with unknown command"""
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb",
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
         return_value=(1, "Android Debug Bridge version 1.0.XX"),
     )
     session = ADBSession("127.0.0.1")
@@ -569,11 +564,9 @@ def test_adb_session_13(mocker):
         session.call(["unknown-cmd"])
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_14(tmp_path, mocker):
     """test ADBSession.install()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     def fake_get_package_name(_):
         with ZipFile(apk_file, mode="r") as zfp:
@@ -597,10 +590,11 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession.get_package_name",
+        "grizzly.target.adb_device.adb_session.ADBSession.get_package_name",
         side_effect=fake_get_package_name,
     )
     session = ADBSession("127.0.0.1")
@@ -631,12 +625,9 @@ def fake_adb_call(cmd, timeout=None):
     # TODO: failed to get package name
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_15(mocker):
     """test ADBSession.uninstall()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
-
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
@@ -645,7 +636,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     assert not session.uninstall("org.test.unknown")
@@ -653,12 +645,9 @@ def fake_adb_call(cmd, timeout=None):
     assert session.uninstall("org.test.preinstalled")
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_16(mocker):
     """test ADBSession.get_pid()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
-
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
@@ -677,7 +666,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     with raises(ADBCommunicationError, match="ADB session is not connected!"):
@@ -687,12 +677,9 @@ def fake_adb_call(cmd, timeout=None):
     assert session.get_pid("org.test.preinstalled") == 1337
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_17(mocker):
     """test ADBSession.is_installed()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
-
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
@@ -709,7 +696,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -717,11 +705,9 @@ def fake_adb_call(cmd, timeout=None):
     assert session.is_installed("org.test.preinstalled")
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_18(mocker):
     """test ADBSession.packages()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -739,7 +725,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -751,11 +738,9 @@ def fake_adb_call(cmd, timeout=None):
     assert "org.test.preinstalled" in pkgs
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_19(mocker):
     """test ADBSession.collect_logs()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -790,7 +775,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     # test not connected
@@ -802,11 +788,9 @@ def fake_adb_call(cmd, timeout=None):
     assert not session.collect_logs(1111).splitlines()
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_20(mocker):
     """test ADBSession.open_files()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -879,7 +863,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -895,11 +880,9 @@ def fake_adb_call(cmd, timeout=None):
     assert any(session.open_files(files=["test"]))
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_21(mocker):
     """test ADBSession._get_procs()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=too-many-return-statements,unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -941,7 +924,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -951,11 +935,9 @@ def fake_adb_call(cmd, timeout=None):
     assert dev_procs[0].pid == 9991
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_22(tmp_path, mocker):
     """test ADBSession.push()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -967,7 +949,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -978,11 +961,9 @@ def fake_adb_call(cmd, timeout=None):
     assert session.push(str(push_file), "dst")
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_23(mocker):
     """test ADBSession.pull()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -994,18 +975,17 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert session.pull("src", "dst")
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_24(mocker):
     """test ADBSession.clear_log()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -1016,18 +996,17 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
     assert session.clear_logs()
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_25(mocker):
     """test ADBSession.listdir()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -1040,7 +1019,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -1051,11 +1031,9 @@ def fake_adb_call(cmd, timeout=None):
     assert "test" in dir_list
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_26(mocker):
     """test ADBSession.process_exists()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -1071,7 +1049,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -1105,12 +1084,10 @@ def test_adb_session_27(mocker, tmp_path):
 
 def test_adb_session_28(mocker, tmp_path):
     """test ADBSession._adb_check()"""
+    mocker.patch("grizzly.target.adb_device.adb_session.sleep")
     (tmp_path / "platform-tools").mkdir()
     fake_adb = tmp_path / "platform-tools" / "adb"
     fake_adb.touch()
-    mocker.patch(
-        "grizzly.target.adb_device.adb_session.sleep"
-    )  # skip delay after warning message
     # use system adb
     mocker.patch(
         "grizzly.target.adb_device.adb_session.ANDROID_SDK_ROOT", tmp_path / "missing"
@@ -1131,11 +1108,9 @@ def test_adb_session_28(mocker, tmp_path):
         assert ADBSession._adb_check()
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_29(mocker, tmp_path):
     """test ADBSession.get_package_name()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._aapt_check", return_value="/fake/aapt"
-    )
     mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"")
     with raises(IOError):
         ADBSession.get_package_name("/fake/path")
@@ -1188,45 +1163,49 @@ def test_adb_session_29(mocker, tmp_path):
     assert ADBSession.get_package_name(str(fake_apk)) == "org.mozilla.fennec_aurora"
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_30(mocker):
     """test ADBSession.get_enforce()"""
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession.call", return_value=(0, "Enforcing")
+        "grizzly.target.adb_device.adb_session.ADBSession.call",
+        return_value=(0, "Enforcing"),
     )
     session = ADBSession("127.0.0.1")
     assert session.get_enforce()
-    mocker.patch("grizzly.target.adb_device.ADBSession.call", return_value=(0, "Blah"))
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.ADBSession.call",
+        return_value=(0, "Blah"),
+    )
     session = ADBSession("127.0.0.1")
     assert not session.get_enforce()
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_31(mocker):
     """test ADBSession.set_enforce()"""
+    # disable when enabled
+    fake_call = mocker.patch("grizzly.target.adb_device.adb_session.ADBSession.call")
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
+        "grizzly.target.adb_device.adb_session.ADBSession.get_enforce",
+        return_value=True,
     )
-    # disable when enabled
-    fake_call = mocker.patch("grizzly.target.adb_device.ADBSession.call")
-    mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=True)
     session = ADBSession("127.0.0.1")
     session.set_enforce(0)
     assert fake_call.call_count == 1
     fake_call.reset_mock()
     # enable when disabled
-    mocker.patch("grizzly.target.adb_device.ADBSession.get_enforce", return_value=False)
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.ADBSession.get_enforce",
+        return_value=False,
+    )
     session = ADBSession("127.0.0.1")
     session.set_enforce(1)
     assert fake_call.call_count == 1
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_32(mocker):
     """test ADBSession.realpath()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -1238,7 +1217,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -1247,11 +1227,9 @@ def fake_adb_call(cmd, timeout=None):
     assert session.realpath("existing/path") == "existing/path"
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_33(mocker):
     """test ADBSession.reverse()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -1261,7 +1239,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -1276,11 +1255,9 @@ def fake_adb_call(cmd, timeout=None):
         session.reverse(1234, 65536)
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_34(mocker):
     """test ADBSession.reverse_remove()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -1296,7 +1273,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -1308,11 +1286,9 @@ def fake_adb_call(cmd, timeout=None):
         session.reverse_remove(remote=1023)
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_35(mocker):
     """test ADBSession.airplane_mode()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -1337,7 +1313,8 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
     session = ADBSession("127.0.0.1")
     session.connected = True
@@ -1346,12 +1323,10 @@ def fake_adb_call(cmd, timeout=None):
     assert session.airplane_mode
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_36(mocker):
     """test ADBSession.wait_for_boot()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
-    mocker.patch("grizzly.target.adb_device.ADBSession._call_adb")
+    mocker.patch("grizzly.target.adb_device.adb_session.ADBSession._call_adb")
     fake_sleep = mocker.patch("grizzly.target.adb_device.adb_session.sleep")
 
     # test timeout
@@ -1392,7 +1367,7 @@ def fake_adb_02(_, cmd, timeout=None):
     boot_done = False
 
     # pylint: disable=unused-argument
-    def fake_adb_03(obj, cmd, timeout=None):
+    def fake_adb_03(_, cmd, timeout=None):
         nonlocal anim_done
         nonlocal boot_done
         if cmd[1] == "shell" and cmd[2] == "getprop":
@@ -1415,11 +1390,9 @@ def fake_adb_03(obj, cmd, timeout=None):
     assert fake_sleep.call_count == 3
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_37(mocker):
     """test ADBSession.reboot_device()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
@@ -1429,20 +1402,19 @@ def fake_adb_call(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_call
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_call,
     )
-    mocker.patch("grizzly.target.adb_device.ADBSession.connect", spec=True)
+    mocker.patch("grizzly.target.adb_device.adb_session.ADBSession.connect", spec=True)
     session = ADBSession()
     session.connected = True
     with raises(AssertionError):
         session.reboot_device()
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_38(mocker):
     """test ADBSession.remount()"""
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
 
     # pylint: disable=unused-argument
     def fake_adb_01(cmd, timeout=None):
@@ -1452,7 +1424,8 @@ def fake_adb_01(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_01
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_01,
     )
     session = ADBSession()
     session.connected = True
@@ -1468,7 +1441,8 @@ def fake_adb_02(cmd, timeout=None):
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession._call_adb", side_effect=fake_adb_02
+        "grizzly.target.adb_device.adb_session.ADBSession._call_adb",
+        side_effect=fake_adb_02,
     )
     session = ADBSession()
     session.connected = True
@@ -1497,12 +1471,10 @@ def test_adb_session_39():
     assert pinfo.ppid == 2
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_40(mocker):
     """test ADBSession.sanitizer_options()"""
-    mocker.patch("grizzly.target.adb_device.ADBSession.call", autospec=True)
-    mocker.patch(
-        "grizzly.target.adb_device.ADBSession._adb_check", return_value="/fake/adb"
-    )
+    mocker.patch("grizzly.target.adb_device.adb_session.ADBSession.call", autospec=True)
 
     def fake_install_file(src, dst, **_):
         src = Path(src)
@@ -1511,13 +1483,21 @@ def fake_install_file(src, dst, **_):
         assert dst == "/data/local/tmp/"
 
     mocker.patch(
-        "grizzly.target.adb_device.ADBSession.install_file",
+        "grizzly.target.adb_device.adb_session.ADBSession.install_file",
         side_effect=fake_install_file,
     )
     session = ADBSession()
     session.sanitizer_options("asan", {"a": "1", "b": "2"})
 
 
+def test_adb_session_41(mocker):
+    """test ADBSession.install_file()"""
+    mocker.patch("grizzly.target.adb_device.adb_session.ADBSession.call", autospec=True)
+    mocker.patch("grizzly.target.adb_device.adb_session.ADBSession.push", autospec=True)
+    session = ADBSession()
+    session.install_file("a/b", "/sdcard/", mode="777", context="foo")
+
+
 @mark.parametrize(
     "env_var, os_name",
     [

From c6e20d3b2d3336b2b47aecf457e2b5cecdcddd67 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 23 Mar 2022 16:25:18 -0700
Subject: [PATCH 517/531] [adb] Raise TargetLaunchError and TargetLaunchTimeout
 from ADBTarget.launch()

---
 grizzly/target/adb_target.py | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index 930fe75e..2d631a87 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -7,13 +7,13 @@
 from pathlib import Path
 from tempfile import TemporaryDirectory, mkdtemp
 
-from ffpuppet import LaunchError
+from ffpuppet import BrowserTimeoutError, LaunchError
 from prefpicker import PrefPicker
 
 from ..common.reporter import Report
 from ..common.utils import grz_tmp
 from .adb_device import ADBProcess, ADBSession, Reason
-from .target import Result, Target
+from .target import Result, Target, TargetLaunchError, TargetLaunchTimeout
 from .target_monitor import TargetMonitor
 
 __author__ = "Tyson Smith"
@@ -80,6 +80,11 @@ def check_result(self, _ignored):
                 status = Result.FOUND
         return status
 
+    def create_report(self, is_hang=False):
+        logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
+        self.save_logs(logs)
+        return Report(logs, self.binary, is_hang=is_hang)
+
     def handle_hang(self, ignore_idle=True):
         # TODO: attempt to detect idle hangs?
         self.close()
@@ -87,7 +92,7 @@ def handle_hang(self, ignore_idle=True):
 
     def launch(self, location):
         env_mod = dict(self.environ)
-        # This may be used to disabled network connections during testing, e.g.
+        # disabled external network connections during testing
         env_mod["MOZ_IN_AUTOMATION"] = "1"
         # prevent crash reporter from touching the dmp files
         env_mod["MOZ_CRASHREPORTER"] = "1"
@@ -102,9 +107,12 @@ def launch(self, location):
                 prefs_js=self._prefs,
                 url=location,
             )
-        except LaunchError:
-            self._proc.close()
-            raise
+        except LaunchError as exc:
+            LOG.error("ADBProcess LaunchError: %s", exc)
+            self.close()
+            if isinstance(exc, BrowserTimeoutError):
+                raise TargetLaunchTimeout(str(exc)) from None
+            raise TargetLaunchError(str(exc), self.create_report()) from None
 
     @property
     def monitor(self):
@@ -150,11 +158,6 @@ def process_assets(self):
                 PrefPicker.load_template(template).create_prefsjs(prefs)
                 self._prefs = self.assets.add("prefs", str(prefs), copy=False)
 
-    def create_report(self, is_hang=False):
-        logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
-        self.save_logs(logs)
-        return Report(logs, self.binary, is_hang=is_hang)
-
     def reverse(self, remote, local):
         # remote->device, local->desktop
         self._session.reverse(remote, local)

From 3957ba684744bc5c0cf79b0cbf16a6192d9cfe52 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 28 Mar 2022 16:54:10 -0700
Subject: [PATCH 518/531] [adb] Handle ADBLaunchErrors in target

---
 grizzly/target/adb_device/__init__.py | 4 ++--
 grizzly/target/adb_target.py          | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/grizzly/target/adb_device/__init__.py b/grizzly/target/adb_device/__init__.py
index 2211483e..29902b50 100644
--- a/grizzly/target/adb_device/__init__.py
+++ b/grizzly/target/adb_device/__init__.py
@@ -1,10 +1,10 @@
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from .adb_process import ADBProcess, Reason
+from .adb_process import ADBLaunchError, ADBProcess, Reason
 from .adb_session import ADBSession
 
-__all__ = ("ADBProcess", "ADBSession", "Reason")
+__all__ = ("ADBLaunchError", "ADBProcess", "ADBSession", "Reason")
 
 __author__ = "Tyson Smith"
 __credits__ = ["Tyson Smith"]
diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index 2d631a87..fd2cad8c 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -12,7 +12,7 @@
 
 from ..common.reporter import Report
 from ..common.utils import grz_tmp
-from .adb_device import ADBProcess, ADBSession, Reason
+from .adb_device import ADBLaunchError, ADBProcess, ADBSession, Reason
 from .target import Result, Target, TargetLaunchError, TargetLaunchTimeout
 from .target_monitor import TargetMonitor
 
@@ -72,9 +72,9 @@ def check_result(self, _ignored):
             self._proc.close()
             # if something has happened figure out what
             if self._proc.reason == Reason.CLOSED:
-                LOG.info("target.close() was called")
+                LOG.debug("target.close() was called")
             elif self._proc.reason == Reason.EXITED:
-                LOG.info("Target closed itself")
+                LOG.debug("Target closed itself")
             else:
                 LOG.debug("failure detected")
                 status = Result.FOUND
@@ -107,7 +107,7 @@ def launch(self, location):
                 prefs_js=self._prefs,
                 url=location,
             )
-        except LaunchError as exc:
+        except (ADBLaunchError, LaunchError) as exc:
             LOG.error("ADBProcess LaunchError: %s", exc)
             self.close()
             if isinstance(exc, BrowserTimeoutError):

From 42ea47e6f1eaf2c71697bbef831e1c0c578e6b8b Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Tue, 29 Mar 2022 18:23:31 -0700
Subject: [PATCH 519/531] [adb] Add ADBSession.shell()

---
 grizzly/target/adb_device/adb_process.py      |  31 +-
 grizzly/target/adb_device/adb_session.py      |  98 ++---
 grizzly/target/adb_device/main.py             |   5 +-
 grizzly/target/adb_device/test_adb_process.py |  54 +--
 grizzly/target/adb_device/test_adb_session.py | 395 +++++++++++-------
 5 files changed, 322 insertions(+), 261 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index c19a1b1d..f7cbb69b 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -51,7 +51,7 @@ class ADBProcess:
         "_package",
         "_pid",
         "_profile_template",
-        "_sanitizer_logs",
+        # "_sanitizer_logs",
         "_session",
         "_working_path",
         "logs",
@@ -71,7 +71,7 @@ def __init__(self, package_name, session, use_profile=None):
         # Note: geckview_example fails to read a profile from /sdcard/ atm
         # self._working_path = "/sdcard/ADBProc_%08X" % (getrandbits(32),)
         self._working_path = "/data/local/tmp/ADBProc_%08X" % (getrandbits(32),)
-        self._sanitizer_logs = "%s/sanitizer_logs" % (self._working_path,)
+        # self._sanitizer_logs = "%s/sanitizer_logs" % (self._working_path,)
         self.logs = None
         self.profile = None  # profile path on device
         self.reason = Reason.CLOSED
@@ -119,10 +119,10 @@ def close(self):
                 self.wait()
                 self._process_logs(crash_reports)
                 # remove remote working path
-                self._session.call(["shell", "rm", "-rf", self._working_path])
+                self._session.shell(["rm", "-rf", self._working_path])
                 # remove remote config yaml
                 cfg_file = "/data/local/tmp/%s-geckoview-config.yaml" % (self._package,)
-                self._session.call(["shell", "rm", "-rf", cfg_file])
+                self._session.shell(["rm", "-rf", cfg_file])
                 # TODO: this should be temporary until ASAN_OPTIONS=log_file is working
                 if "log_asan.txt" in os.listdir(self.logs):
                     self.reason = Reason.ALERT
@@ -137,10 +137,10 @@ def close(self):
     def find_crashreports(self):
         reports = list()
         # look for logs from sanitizers
-        for fname in self._session.listdir(self._sanitizer_logs):
-            reports.append(os.path.join(self._sanitizer_logs, fname))
+        # for fname in self._session.listdir(self._sanitizer_logs):
+        #    reports.append(os.path.join(self._sanitizer_logs, fname))
 
-        if not reports and self.profile:
+        if self.profile:
             # check for minidumps
             md_path = os.path.join(self.profile, "minidumps")
             try:
@@ -172,6 +172,10 @@ def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
         assert self._pid is None, "Process is already running"
         assert self.reason is not None, "Process is already running"
 
+        self._session.clear_logs()
+        self._remove_logs()
+        self.reason = None
+
         if ".fenix" in self._package:
             app = "%s/org.mozilla.fenix.IntentReceiverActivity" % (self._package,)
         elif ".geckoview_example" in self._package:
@@ -188,10 +192,6 @@ def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
         if prefs is None:
             raise ADBLaunchError("Invalid prefs.js file (%s)" % (prefs_js,))
 
-        self._session.clear_logs()
-        self._remove_logs()
-        self.reason = None
-
         # setup bootstrapper and reverse port
         # reverse does fail occasionally so use a retry loop
         for _ in range(10):
@@ -219,10 +219,10 @@ def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
                 }
             )
             # create location to store sanitizer logs
-            self._session.call(["shell", "mkdir", "-p", self._sanitizer_logs])
+            # self._session.shell(["mkdir", "-p", self._sanitizer_logs])
             # create empty profile
             self.profile = "%s/gv_profile_%08X" % (self._working_path, getrandbits(32))
-            self._session.call(["shell", "mkdir", "-p", self.profile])
+            self._session.shell(["mkdir", "-p", self.profile])
             # add environment variables
             env_mod = dict(env_mod or {})
             env_mod.setdefault("MOZ_SKIA_DISABLE_ASSERTS", "1")
@@ -255,7 +255,6 @@ def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
                 if not self._session.push(cfp.name, "/data/local/tmp/%s" % (cfg_file,)):
                     raise ADBLaunchError("Could not upload %r" % (cfg_file,))
             cmd = [
-                "shell",
                 "am",
                 "start",
                 "-W",
@@ -266,7 +265,7 @@ def launch(self, url, env_mod=None, launch_timeout=60, prefs_js=None):
                 "-d",
                 bootstrapper.location,
             ]
-            if "Status: ok" not in self._session.call(cmd, timeout=launch_timeout)[1]:
+            if "Status: ok" not in self._session.shell(cmd, timeout=launch_timeout)[1]:
                 raise ADBLaunchError("Could not launch %r" % (self._package,))
             self._pid = self._session.get_pid(self._package)
             bootstrapper.wait(self.is_healthy, url=url)
@@ -484,7 +483,7 @@ def _terminate(self):
         assert self._package is not None
         assert self._session, "Device not connected"
         # TODO: is this the best way???
-        self._session.call(["shell", "am", "force-stop", self._package])
+        self._session.shell(["am", "force-stop", self._package])
 
     def wait(self):
         while self.is_running():
diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 0bdee33b..4e1a21c7 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -184,12 +184,12 @@ def _get_procs(self, pid=-1, pid_children=-1):
         """
         assert isinstance(pid, int)
         assert isinstance(pid_children, int)
-        cmd = ["shell", "ps"]
+        cmd = ["ps"]
         if pid > -1:
             cmd.append(str(pid))
         if pid_children > -1:
             cmd += ["--ppid", str(pid_children)]
-        for line in self.call(cmd)[1].splitlines()[1:]:
+        for line in self.shell(cmd)[1].splitlines()[1:]:
             pinfo = self._line_to_info(line)
             if pinfo is not None:
                 yield pinfo
@@ -221,7 +221,7 @@ def airplane_mode(self):
         Returns:
             bool: True if airplane mode is enabled otherwise False.
         """
-        return self.call(["shell", "settings", "get", "global", "airplane_mode_on"])[
+        return self.shell(["settings", "get", "global", "airplane_mode_on"])[
             1
         ].startswith("1")
 
@@ -236,19 +236,11 @@ def airplane_mode(self, mode):
             None
         """
         assert isinstance(mode, bool), "mode must be a bool"
-        self.call(
-            [
-                "shell",
-                "settings",
-                "put",
-                "global",
-                "airplane_mode_on",
-                "1" if mode else "0",
-            ]
+        self.shell(
+            ["settings", "put", "global", "airplane_mode_on", "1" if mode else "0"]
         )
-        self.call(
+        self.shell(
             [
-                "shell",
                 "su",
                 "root",
                 "am",
@@ -368,7 +360,9 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                 raise ADBCommunicationError(
                     "Timeout (%ds) waiting for device to boot" % (boot_timeout,)
                 )
-            ret_code, user = self.call(["shell", "whoami"], device_required=False)
+            ret_code, user = self.call(
+                ["shell", "-T", "-n", "whoami"], device_required=False
+            )
             if ret_code != 0 or not user:
                 self.connected = False
                 if attempt == max_attempts:
@@ -379,13 +373,11 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
             self._root = user.splitlines()[-1] == "root"
             # collect CPU and OS info
             if self._os_version is None:
-                self._os_version = self.call(
-                    ["shell", "getprop", "ro.build.version.release"]
-                )[1]
-            if self._cpu_arch is None:
-                self._cpu_arch = self.call(["shell", "getprop", "ro.product.cpu.abi"])[
+                self._os_version = self.shell(["getprop", "ro.build.version.release"])[
                     1
                 ]
+            if self._cpu_arch is None:
+                self._cpu_arch = self.shell(["getprop", "ro.product.cpu.abi"])[1]
             # check SELinux mode
             if self._root:
                 if self.get_enforce():
@@ -393,8 +385,8 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                         raise ADBSessionError("set_enforce(0) failed!")
                     # set SELinux to run in permissive mode
                     self.set_enforce(0)
-                    self.call(["shell", "stop"])
-                    self.call(["shell", "start"])
+                    self.shell(["stop"])
+                    self.shell(["start"])
                     # put the device in a known state
                     self.call(["reconnect"])
                     self.connected = False
@@ -509,7 +501,7 @@ def get_enforce(self):
         Returns:
             bool: Returns True if "Enforcing" otherwise False.
         """
-        status = self.call(["shell", "getenforce"])[1]
+        status = self.shell(["getenforce"])[1]
         if status == "Enforcing":
             return True
         if status != "Permissive":
@@ -579,23 +571,11 @@ def install(self, apk_path):
         if self.call(["install", "-g", "-r", apk_path], timeout=120)[0] != 0:
             raise ADBSessionError("Failed to install %r" % (apk_path,))
         # set permissions
-        self.call(
-            [
-                "shell",
-                "pm",
-                "grant",
-                pkg_name,
-                "android.permission.READ_EXTERNAL_STORAGE",
-            ]
+        self.shell(
+            ["pm", "grant", pkg_name, "android.permission.READ_EXTERNAL_STORAGE"]
         )
-        self.call(
-            [
-                "shell",
-                "pm",
-                "grant",
-                pkg_name,
-                "android.permission.WRITE_EXTERNAL_STORAGE",
-            ]
+        self.shell(
+            ["pm", "grant", pkg_name, "android.permission.WRITE_EXTERNAL_STORAGE"]
         )
         LOG.debug("installed package %r (%r)", pkg_name, apk_path)
         return pkg_name
@@ -614,11 +594,11 @@ def install_file(self, src, dst, mode=None, context=None):
         """
         full_dst = str(Path(dst) / Path(src).name)
         self.push(src, full_dst)
-        self.call(["shell", "chown", "root.shell", full_dst])
+        self.shell(["chown", "root.shell", full_dst])
         if mode is not None:
-            self.call(["shell", "chmod", mode, full_dst])
+            self.shell(["chmod", mode, full_dst])
         if context is not None:
-            self.call(["shell", "chcon", context, full_dst])
+            self.shell(["chcon", context, full_dst])
 
     def is_installed(self, package_name):
         """Check if a package is installed on the connected device.
@@ -641,7 +621,7 @@ def listdir(self, path):
             list: Strings containing names of all items in a directory.
         """
         LOG.debug("listdir(%r)", path)
-        ret_val, output = self.call(["shell", "ls", "-A", path])
+        ret_val, output = self.shell(["ls", "-A", path])
         if ret_val != 0:
             raise IOError("%r does not exist" % (path,))
         return output.splitlines()
@@ -670,12 +650,12 @@ def open_files(self, pid=None, children=False, files=None):
             ), "Cannot request child open files without specifying pid"
             for proc in self._get_procs(pid_children=pid):
                 pids.append(str(proc.pid))
-        cmd = ["shell", "lsof"]
+        cmd = ["lsof"]
         if pids:
             cmd += ["-p", ",".join(pids)]
         if files:
             cmd.extend(list(files))
-        for line in self.call(cmd)[1].splitlines():
+        for line in self.shell(cmd)[1].splitlines():
             if line.endswith("Permission denied)"):
                 continue
             # I believe we only care about regular files
@@ -701,7 +681,7 @@ def packages(self):
         Yields:
             str: Names of the installed packages
         """
-        ret_code, output = self.call(["shell", "pm", "list", "packages"])
+        ret_code, output = self.shell(["pm", "list", "packages"])
         if ret_code == 0:
             for line in output.splitlines():
                 if line.startswith("package:"):
@@ -756,7 +736,7 @@ def realpath(self, path):
             str: canonical path of the specified path.
         """
         LOG.debug("realpath(%r)", path)
-        ret_val, output = self.call(["shell", "realpath", path])
+        ret_val, output = self.shell(["realpath", path])
         if ret_val != 0:
             raise IOError("%r does not exist" % (path,))
         return output.strip()
@@ -842,7 +822,7 @@ def sanitizer_options(self, prefix, options):
         """
         prefix = prefix.lower()
         assert prefix == "asan", "only ASan is supported atm"
-        self.call(["shell", "rm", "-f", "%s.options.gecko" % (prefix,)])
+        self.shell(["rm", "-f", "%s.options.gecko" % (prefix,)])
         with TemporaryDirectory(prefix="sanopts_", dir=grz_tmp()) as working_path:
             optfile = Path(working_path) / ("%s.options.gecko" % (prefix,))
             optfile.write_text(":".join("%s=%s" % x for x in options.items()))
@@ -861,7 +841,21 @@ def set_enforce(self, value):
         assert value in (0, 1)
         if not self._root:
             LOG.warning("set_enforce requires root")
-        self.call(["shell", "setenforce", str(value)])
+        self.shell(["setenforce", str(value)])
+
+    def shell(self, cmd, timeout=120):
+        """Execute an ADB shell command via a non-interactive shell.
+
+        Args:
+            cmd (list(str)): List of strings to pass as arguments when calling ADB.
+            timeout (float, optional): Seconds to wait for ADB call to complete.
+
+        Returns:
+            tuple: The first element is an integer containing the exit code of the
+            ADB call and the second is a string containing stderr and stdout.
+        """
+        assert cmd
+        return self.call(["shell", "-T", "-n"] + cmd, timeout=timeout)
 
     def symbols_path(self, package_name):
         """Lookup path containing symbols for a specified package.
@@ -904,8 +898,8 @@ def wait_for_boot(self, timeout=None):
             deadline = None
         # first wait for the boot to complete then wait for the boot animation to
         # complete, this will help ensure the device is in a ready state
-        anim_chk = ["shell", "getprop", "init.svc.bootanim"]
-        boot_chk = ["shell", "getprop", "sys.boot_completed"]
+        anim_chk = ["getprop", "init.svc.bootanim"]
+        boot_chk = ["shell", "-T", "-n", "getprop", "sys.boot_completed"]
         attempts = 0
         booted = False
         while True:
@@ -915,7 +909,7 @@ def wait_for_boot(self, timeout=None):
             # we need to verify that boot is complete before checking the animation is
             # stopped because the animation can be in the stopped state early in the
             # boot process
-            if booted and self.call(anim_chk)[1] == "stopped":
+            if booted and self.shell(anim_chk)[1] == "stopped":
                 if attempts > 1:
                     # the device was booting so give it additional time
                     LOG.debug("device was boot was detected")
diff --git a/grizzly/target/adb_device/main.py b/grizzly/target/adb_device/main.py
index 000224b2..e27f543b 100644
--- a/grizzly/target/adb_device/main.py
+++ b/grizzly/target/adb_device/main.py
@@ -57,7 +57,7 @@ def parse_args(argv=None):
 
 def main(args):  # pylint: disable=missing-docstring
     configure_logging(args.log_level)
-    LOG.debug("opening a session")
+    LOG.info("Connecting to device...")
     session = ADBSession.create(args.ip, args.port, as_root=not args.non_root)
     if session is None:
         LOG.error("Failed to connect to IP:%r port:%r", args.ip, args.port)
@@ -89,7 +89,8 @@ def main(args):  # pylint: disable=missing-docstring
             if isfile(llvm_sym):
                 LOG.info("Installing llvm-symbolizer...")
                 session.install_file(llvm_sym, "/data/local/tmp/", mode="777")
-            session.call(["shell", "am", "set-debug-app", "--persistent", package])
+            # set wait for debugger
+            # session.shell(["am", "set-debug-app", "-w", "--persistent", package])
             LOG.info("Installed %s.", package)
         if args.launch:
             pkg_name = ADBSession.get_package_name(args.launch)
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 6c18cf5c..7404ca8b 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -38,6 +38,7 @@ def test_adb_process_02(mocker):
 def test_adb_process_03(mocker):
     """test ADBProcess.launch() unsupported app"""
     fake_session = mocker.Mock(spec_set=ADBSession)
+    fake_session.collect_logs.return_value = b""
     with ADBProcess("org.some.app", fake_session) as proc:
         with raises(ADBLaunchError, match="Unsupported package 'org.some.app'"):
             proc.launch("fake.url")
@@ -77,7 +78,16 @@ def test_adb_process_05(mocker):
 #    """test ADBProcess.launch() check *-geckoview-config.yaml"""
 
 
-def test_adb_process_07(mocker):
+@mark.parametrize(
+    "env",
+    [
+        # no env
+        None,
+        # with environment variables
+        {"test1": "1", "test2": "2"},
+    ],
+)
+def test_adb_process_07(mocker, env):
     """test ADBProcess.launch(), ADBProcess.is_running() and ADBProcess.is_healthy()"""
     fake_bs = mocker.patch(
         "grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True
@@ -85,7 +95,7 @@ def test_adb_process_07(mocker):
     fake_bs.return_value.location = "http://localhost"
     fake_bs.return_value.port.return_value = 1234
     fake_session = mocker.Mock(spec_set=ADBSession)
-    fake_session.call.return_value = (0, "Status: ok")
+    fake_session.shell.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = b""
     fake_session.get_pid.side_effect = (None, 1337)
     fake_session.listdir.return_value = ()
@@ -94,7 +104,7 @@ def test_adb_process_07(mocker):
         assert not proc.is_running()
         assert not proc.is_healthy()
         assert proc.launches == 0
-        assert proc.launch("fake.url")
+        assert proc.launch("fake.url", env_mod=env, prefs_js=None)
         assert proc.is_running()
         assert proc.is_healthy()
         assert proc.launches == 1
@@ -107,32 +117,13 @@ def test_adb_process_07(mocker):
 
 
 def test_adb_process_08(mocker):
-    """test ADBProcess.launch() with environment variables"""
-    fake_bs = mocker.patch(
-        "grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True
-    )
-    fake_bs.return_value.location = "http://localhost"
-    fake_bs.return_value.port.return_value = 1234
-    fake_session = mocker.Mock(spec_set=ADBSession)
-    fake_session.call.return_value = (0, "Status: ok")
-    fake_session.collect_logs.return_value = b""
-    fake_session.get_pid.side_effect = (None, 1337)
-    fake_session.listdir.return_value = ()
-    env = {"test1": "1", "test2": "2"}
-    with ADBProcess("org.mozilla.geckoview_example", fake_session) as proc:
-        assert proc.launch("fake.url", env_mod=env)
-        assert proc.is_running()
-        proc.close()
-
-
-def test_adb_process_09(mocker):
     """test ADBProcess.wait_on_files()"""
     fake_bs = mocker.patch(
         "grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True
     )
     fake_bs.return_value.location = "http://localhost"
     fake_session = mocker.Mock(spec_set=ADBSession)
-    fake_session.call.return_value = (0, "Status: ok")
+    fake_session.shell.return_value = (0, "Status: ok")
     fake_session.collect_logs.return_value = b""
     fake_session.get_pid.side_effect = (None, 1337)
     fake_session.open_files.return_value = ((1, "some_file"),)
@@ -156,7 +147,7 @@ def test_adb_process_09(mocker):
         proc.close()
 
 
-def test_adb_process_10(mocker):
+def test_adb_process_09(mocker):
     """test ADBProcess.find_crashreports()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec_set=ADBSession)
@@ -165,18 +156,15 @@ def test_adb_process_10(mocker):
         # no log or minidump files
         fake_session.listdir.return_value = []
         assert not proc.find_crashreports()
-        # sanitizer logs
-        fake_session.listdir.side_effect = (["asan.log"], AssertionError())
-        assert any(x.endswith("asan.log") for x in proc.find_crashreports())
         # contains minidump file
-        fake_session.listdir.side_effect = ([], ["somefile.txt", "test.dmp"])
+        fake_session.listdir.side_effect = (["somefile.txt", "test.dmp"],)
         assert any(x.endswith("test.dmp") for x in proc.find_crashreports())
         # contains missing path
-        fake_session.listdir.side_effect = ([], IOError("test"))
+        fake_session.listdir.side_effect = (IOError("test"),)
         assert not proc.find_crashreports()
 
 
-def test_adb_process_11(mocker, tmp_path):
+def test_adb_process_10(mocker, tmp_path):
     """test ADBProcess.save_logs()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     fake_session = mocker.Mock(spec_set=ADBSession)
@@ -195,7 +183,7 @@ def test_adb_process_11(mocker, tmp_path):
     assert any(dmp_path.glob("fake.txt"))
 
 
-def test_adb_process_12(mocker):
+def test_adb_process_11(mocker):
     """test ADBProcess._process_logs()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
     mocker.patch("grizzly.target.adb_device.adb_process.PuppetLogger", autospec=True)
@@ -226,7 +214,7 @@ def test_adb_process_12(mocker):
         assert fake_session.pull.call_count == 2
 
 
-def test_adb_process_13(tmp_path):
+def test_adb_process_12(tmp_path):
     """test ADBProcess._split_logcat()"""
     log_path = tmp_path / "logs"
     log_path.mkdir()
@@ -293,7 +281,7 @@ def test_adb_process_13(tmp_path):
         ("user_pref(test, 0);\n", None),
     ],
 )
-def test_adb_process_14(tmp_path, input_data, result):
+def test_adb_process_13(tmp_path, input_data, result):
     """test ADBProcess.prefs_to_dict()"""
     prefs_js = tmp_path / "prefs.js"
     prefs_js.write_text(input_data)
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index aba33ace..4cc98310 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -227,20 +227,24 @@ def fake_adb_call(cmd, timeout=None):
             assert cmd[2] == ":".join([test_ip, str(test_port)])
             return 0, ""
         # already Permissive
-        if cmd[1] == "shell" and cmd[2] == "getenforce":
-            return 0, "Permissive"
-        if cmd[1] == "shell" and cmd[2] == "getprop":
-            if cmd[3] == "init.svc.bootanim":
-                return 0, "stopped"
-            if cmd[3] == "ro.build.version.release":
-                return 0, test_version
-            if cmd[3] == "ro.product.cpu.abi":
-                return 0, test_arch
-            if cmd[3] == "sys.boot_completed":
-                return 0, "1"
-        # already root
-        if cmd[1] == "shell" and cmd[2] == "whoami":
-            return 0, "root"
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "getenforce":
+                return 0, "Permissive"
+            if cmd[2] == "getprop":
+                if cmd[3] == "init.svc.bootanim":
+                    return 0, "stopped"
+                if cmd[3] == "ro.build.version.release":
+                    return 0, test_version
+                if cmd[3] == "ro.product.cpu.abi":
+                    return 0, test_arch
+                if cmd[3] == "sys.boot_completed":
+                    return 0, "1"
+            # already root
+            if cmd[2] == "whoami":
+                return 0, "root"
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
@@ -288,28 +292,32 @@ def fake_adb_call(obj, cmd, timeout=None):
             obj._root = True
             obj.connected = False
             return 0, "restarting adbd as root"
-        if cmd[1] == "shell" and cmd[2] == "getenforce":
-            if test_enforcing:
-                return 0, "Enforcing"
-            return 0, "Permissive"
-        if cmd[1] == "shell" and cmd[2] == "getprop":
-            if cmd[3] == "init.svc.bootanim":
-                return 0, "stopped"
-            if cmd[3] == "ro.build.version.release":
-                return 0, test_version
-            if cmd[3] == "ro.product.cpu.abi":
-                return 0, test_arch
-            if cmd[3] == "sys.boot_completed":
-                return 0, "1"
-        if cmd[1] == "shell" and cmd[2] == "setenforce":
-            test_enforcing = False
-            return 0, ""
-        if cmd[1] == "shell" and cmd[2] in ("start", "stop"):
-            return 0, ""
-        if cmd[1] == "shell" and cmd[2] == "whoami":
-            if obj._root:
-                return 0, "root"
-            return 0, "shell"
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "getenforce":
+                if test_enforcing:
+                    return 0, "Enforcing"
+                return 0, "Permissive"
+            if cmd[2] == "getprop":
+                if cmd[3] == "init.svc.bootanim":
+                    return 0, "stopped"
+                if cmd[3] == "ro.build.version.release":
+                    return 0, test_version
+                if cmd[3] == "ro.product.cpu.abi":
+                    return 0, test_arch
+                if cmd[3] == "sys.boot_completed":
+                    return 0, "1"
+            if cmd[2] == "setenforce":
+                test_enforcing = False
+                return 0, ""
+            if cmd[2] in ("start", "stop"):
+                return 0, ""
+            if cmd[2] == "whoami":
+                if obj._root:
+                    return 0, "root"
+                return 0, "shell"
         if cmd[1] == "unroot":
             obj._root = False
             obj.connected = False
@@ -354,19 +362,23 @@ def fake_adb_call(obj, cmd, timeout=None):
                 "* daemon started successfully\n"
                 "emulator-5554   device",
             )
-        if cmd[1] == "shell" and cmd[2] == "getenforce":
-            return 0, "Permissive"
-        if cmd[1] == "shell" and cmd[2] == "getprop":
-            if cmd[3] == "init.svc.bootanim":
-                return 0, "stopped"
-            if cmd[3] == "ro.build.version.release":
-                return 0, test_version
-            if cmd[3] == "ro.product.cpu.abi":
-                return 0, test_arch
-            if cmd[3] == "sys.boot_completed":
-                return 0, "1"
-        if cmd[1] == "shell" and cmd[2] == "whoami":
-            return 0, "shell"
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "getenforce":
+                return 0, "Permissive"
+            if cmd[2] == "getprop":
+                if cmd[3] == "init.svc.bootanim":
+                    return 0, "stopped"
+                if cmd[3] == "ro.build.version.release":
+                    return 0, test_version
+                if cmd[3] == "ro.product.cpu.abi":
+                    return 0, test_arch
+                if cmd[3] == "sys.boot_completed":
+                    return 0, "1"
+            if cmd[2] == "whoami":
+                return 0, "shell"
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch("grizzly.target.adb_device.adb_session.ADBSession._call_adb")
@@ -422,13 +434,17 @@ def fake_adb_call(cmd, timeout=None):
             return 0, ""
         if cmd[1] == "devices":
             return 0, "\n"
-        if cmd[1] == "shell" and cmd[2] == "getprop":
-            if cmd[3] == "init.svc.bootanim":
-                return 0, "stopped"
-            if cmd[3] == "sys.boot_completed":
-                return 0, "1"
-        if cmd[1] == "shell" and cmd[2] == "whoami":
-            return 1, ""
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "getprop":
+                if cmd[3] == "init.svc.bootanim":
+                    return 0, "stopped"
+                if cmd[3] == "sys.boot_completed":
+                    return 0, "1"
+            if cmd[2] == "whoami":
+                return 1, ""
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
@@ -469,21 +485,25 @@ def fake_adb_call(obj, cmd, timeout=None):
             obj._root = True
             obj.connected = False
             return 0, "restarting adbd as root"
-        if cmd[1] == "shell" and cmd[2] == "getenforce":
-            return 0, "Permissive"
-        if cmd[1] == "shell" and cmd[2] == "getprop":
-            if cmd[3] == "init.svc.bootanim":
-                return 0, "stopped"
-            if cmd[3] == "ro.build.version.release":
-                return 0, "9"
-            if cmd[3] == "ro.product.cpu.abi":
-                return 0, "x86_64"
-            if cmd[3] == "sys.boot_completed":
-                return 0, "1"
-        if cmd[1] == "shell" and cmd[2] == "whoami":
-            if obj._root:
-                return 0, "root"
-            return 0, "shell"
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "getenforce":
+                return 0, "Permissive"
+            if cmd[2] == "getprop":
+                if cmd[3] == "init.svc.bootanim":
+                    return 0, "stopped"
+                if cmd[3] == "ro.build.version.release":
+                    return 0, "9"
+                if cmd[3] == "ro.product.cpu.abi":
+                    return 0, "x86_64"
+                if cmd[3] == "sys.boot_completed":
+                    return 0, "1"
+            if cmd[2] == "whoami":
+                if obj._root:
+                    return 0, "root"
+                return 0, "shell"
         if cmd[1] == "unroot":
             obj._root = False
             obj.connected = False
@@ -583,6 +603,9 @@ def fake_adb_call(cmd, timeout=None):
                 return 0, "Success"
             return 1, ""
         if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
             assert cmd[2] == "pm"
             assert cmd[3] == "grant"
             assert cmd[4] == "test-package.blah.foo"
@@ -651,18 +674,22 @@ def test_adb_session_16(mocker):
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
-        if cmd[1] == "shell" and cmd[2] == "ps":
-            return (
-                0,
-                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME\n"
-                "test      1337  1772  1024   1024 SyS_epoll_ 00000000 S"
-                " org.test.preinstalled\n"
-                "root      5847  1     315992 2348  poll_sched 00000000 S"
-                " /sbin/adbd\n"
-                "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S"
-                " org.mozilla.fennec_aurora\n"
-                "root      5944  5847  6280   2360           0 00000000 R ps\n\n",
-            )
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "ps":
+                return (
+                    0,
+                    "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME\n"
+                    "test      1337  1772  1024   1024 SyS_epoll_ 00000000 S"
+                    " org.test.preinstalled\n"
+                    "root      5847  1     315992 2348  poll_sched 00000000 S"
+                    " /sbin/adbd\n"
+                    "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S"
+                    " org.mozilla.fennec_aurora\n"
+                    "root      5944  5847  6280   2360           0 00000000 R ps\n\n",
+                )
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
@@ -683,16 +710,20 @@ def test_adb_session_17(mocker):
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
-        if cmd[1] == "shell" and cmd[2] == "pm":
-            assert cmd[3] == "list"
-            assert cmd[4] == "packages"
-            return (
-                0,
-                "package:org.mozilla.fennec_aurora\n"
-                "package:org.test.preinstalled\n"
-                "package:com.android.phone\n"
-                "package:com.android.shell",
-            )
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "pm":
+                assert cmd[3] == "list"
+                assert cmd[4] == "packages"
+                return (
+                    0,
+                    "package:org.mozilla.fennec_aurora\n"
+                    "package:org.test.preinstalled\n"
+                    "package:com.android.phone\n"
+                    "package:com.android.shell",
+                )
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
@@ -712,16 +743,20 @@ def test_adb_session_18(mocker):
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
-        if cmd[1] == "shell" and cmd[2] == "pm":
-            assert cmd[3] == "list"
-            assert cmd[4] == "packages"
-            return (
-                0,
-                "package:org.mozilla.fennec_aurora\n"
-                "package:org.test.preinstalled\n"
-                "package:com.android.phone\n"
-                "package:com.android.shell",
-            )
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "pm":
+                assert cmd[3] == "list"
+                assert cmd[4] == "packages"
+                return (
+                    0,
+                    "package:org.mozilla.fennec_aurora\n"
+                    "package:org.test.preinstalled\n"
+                    "package:com.android.phone\n"
+                    "package:com.android.shell",
+                )
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
@@ -795,6 +830,10 @@ def test_adb_session_20(mocker):
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
         if cmd[1] == "shell" and cmd[2] == "lsof":
             if len(cmd) == 5:
                 assert cmd[3].startswith("-p")
@@ -887,6 +926,10 @@ def test_adb_session_21(mocker):
     # pylint: disable=too-many-return-statements,unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
         if cmd[1] == "shell" and cmd[2] == "ps":
             if len(cmd) == 5:
                 assert cmd[3] == "--ppid"
@@ -1011,11 +1054,15 @@ def test_adb_session_25(mocker):
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
-        if cmd[1] == "shell" and cmd[2] == "ls":
-            assert cmd[3] == "-A"
-            if cmd[4] == "missing-dir":
-                return 1, ""
-            return 0, "test"
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "ls":
+                assert cmd[3] == "-A"
+                if cmd[4] == "missing-dir":
+                    return 1, ""
+                return 0, "test"
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
@@ -1038,14 +1085,18 @@ def test_adb_session_26(mocker):
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
-        if cmd[1] == "shell" and cmd[2] == "ps":
-            assert cmd[3] == "9990"
-            return (
-                0,
-                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME\n"
-                "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S"
-                " org.mozilla.fennec_aurora\n\n",
-            )
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "ps":
+                assert cmd[3] == "9990"
+                return (
+                    0,
+                    "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME\n"
+                    "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S"
+                    " org.mozilla.fennec_aurora\n\n",
+                )
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
@@ -1111,6 +1162,11 @@ def test_adb_session_28(mocker, tmp_path):
 @mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_29(mocker, tmp_path):
     """test ADBSession.get_package_name()"""
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.ADBSession._aapt_check",
+        autospec=True,
+        return_value=b"fake_aapt",
+    )
     mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"")
     with raises(IOError):
         ADBSession.get_package_name("/fake/path")
@@ -1210,10 +1266,14 @@ def test_adb_session_32(mocker):
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
-        if cmd[1] == "shell" and cmd[2] == "realpath":
-            if cmd[3] == "missing/path":
-                return 1, ""
-            return 0, "existing/path"
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "realpath":
+                if cmd[3] == "missing/path":
+                    return 1, ""
+                return 0, "existing/path"
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
@@ -1293,23 +1353,27 @@ def test_adb_session_35(mocker):
     # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
-        if cmd[1] == "shell" and cmd[2] == "settings":
-            if cmd[3] == "get":
-                assert cmd[4] == "global"
-                assert cmd[5] == "airplane_mode_on"
-                return 0, "1"
-            if cmd[3] == "put":
-                assert cmd[4] == "global"
-                assert cmd[5] == "airplane_mode_on"
-                assert cmd[6] in "01"
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "settings":
+                if cmd[3] == "get":
+                    assert cmd[4] == "global"
+                    assert cmd[5] == "airplane_mode_on"
+                    return 0, "1"
+                if cmd[3] == "put":
+                    assert cmd[4] == "global"
+                    assert cmd[5] == "airplane_mode_on"
+                    assert cmd[6] in "01"
+                    return 0, ""
+            if cmd[2] == "su":
+                assert cmd[3] == "root"
+                assert cmd[4] == "am"
+                assert cmd[5] == "broadcast"
+                assert cmd[6] == "-a"
+                assert cmd[7] == "android.intent.action.AIRPLANE_MODE"
                 return 0, ""
-        if cmd[1] == "shell" and cmd[2] == "su":
-            assert cmd[3] == "root"
-            assert cmd[4] == "am"
-            assert cmd[5] == "broadcast"
-            assert cmd[6] == "-a"
-            assert cmd[7] == "android.intent.action.AIRPLANE_MODE"
-            return 0, ""
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
@@ -1332,11 +1396,15 @@ def test_adb_session_36(mocker):
     # test timeout
     # pylint: disable=unused-argument
     def fake_adb_01(_, cmd, timeout=None):
-        if cmd[1] == "shell" and cmd[2] == "getprop":
-            if cmd[3] == "init.svc.bootanim":
-                return 0, ""
-            if cmd[3] == "sys.boot_completed":
-                return 0, "0"
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "getprop":
+                if cmd[3] == "init.svc.bootanim":
+                    return 0, ""
+                if cmd[3] == "sys.boot_completed":
+                    return 0, "0"
         raise AssertionError("unexpected command %r" % (cmd,))
 
     ADBSession._call_adb = fake_adb_01
@@ -1348,11 +1416,15 @@ def fake_adb_01(_, cmd, timeout=None):
     # test already booted
     # pylint: disable=unused-argument
     def fake_adb_02(_, cmd, timeout=None):
-        if cmd[1] == "shell" and cmd[2] == "getprop":
-            if cmd[3] == "init.svc.bootanim":
-                return 0, "stopped"
-            if cmd[3] == "sys.boot_completed":
-                return 0, "1"
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "getprop":
+                if cmd[3] == "init.svc.bootanim":
+                    return 0, "stopped"
+                if cmd[3] == "sys.boot_completed":
+                    return 0, "1"
         raise AssertionError("unexpected command %r" % (cmd,))
 
     ADBSession._call_adb = fake_adb_02
@@ -1370,17 +1442,21 @@ def fake_adb_02(_, cmd, timeout=None):
     def fake_adb_03(_, cmd, timeout=None):
         nonlocal anim_done
         nonlocal boot_done
-        if cmd[1] == "shell" and cmd[2] == "getprop":
-            if cmd[3] == "init.svc.bootanim":
-                if not anim_done:
-                    anim_done = True
-                    return 0, ""
-                return 0, "stopped"
-            if cmd[3] == "sys.boot_completed":
-                if not boot_done:
-                    boot_done = True
-                    return 0, "0"
-                return 0, "1"
+        if cmd[1] == "shell":
+            # strip shell args
+            cmd.remove("-T")
+            cmd.remove("-n")
+            if cmd[2] == "getprop":
+                if cmd[3] == "init.svc.bootanim":
+                    if not anim_done:
+                        anim_done = True
+                        return 0, ""
+                    return 0, "stopped"
+                if cmd[3] == "sys.boot_completed":
+                    if not boot_done:
+                        boot_done = True
+                        return 0, "0"
+                    return 0, "1"
         raise AssertionError("unexpected command %r" % (cmd,))
 
     ADBSession._call_adb = fake_adb_03
@@ -1490,10 +1566,13 @@ def fake_install_file(src, dst, **_):
     session.sanitizer_options("asan", {"a": "1", "b": "2"})
 
 
+@mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_41(mocker):
     """test ADBSession.install_file()"""
-    mocker.patch("grizzly.target.adb_device.adb_session.ADBSession.call", autospec=True)
     mocker.patch("grizzly.target.adb_device.adb_session.ADBSession.push", autospec=True)
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.ADBSession.shell", autospec=True
+    )
     session = ADBSession()
     session.install_file("a/b", "/sdcard/", mode="777", context="foo")
 

From ff2b07fd8b907ba9cc506afce901556731645c66 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 30 Mar 2022 13:58:21 -0700
Subject: [PATCH 520/531] [adb] Use subprocess.run() in ADBSession._call_adb()

---
 grizzly/target/adb_device/adb_session.py      | 33 ++++-----
 grizzly/target/adb_device/test_adb_session.py | 68 ++++++-------------
 2 files changed, 34 insertions(+), 67 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 4e1a21c7..8b18ae77 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -9,8 +9,8 @@
 from pathlib import Path
 from platform import system
 from shutil import which
-from subprocess import Popen, call, check_output
-from tempfile import TemporaryDirectory, TemporaryFile
+from subprocess import PIPE, STDOUT, TimeoutExpired, check_output, run
+from tempfile import TemporaryDirectory
 from time import sleep, time
 
 from ...common.utils import grz_tmp
@@ -154,22 +154,19 @@ def _call_adb(cmd, timeout=None):
         Returns:
             tuple: Exit code and stderr, stdout of ADB call.
         """
-        with TemporaryFile() as out_fp:
-            if timeout is not None:
-                assert timeout > 0
-                end_time = time() + timeout
-                with Popen(cmd, stderr=out_fp, stdout=out_fp) as proc:
-                    while proc.poll() is None:
-                        sleep(0.05)
-                        if time() > end_time:
-                            LOG.warning("adb call timeout!")
-                            proc.terminate()
-                            break
-                    ret_code = proc.wait()
-            else:
-                ret_code = call(cmd, stderr=out_fp, stdout=out_fp)
-            out_fp.seek(0)
-            return ret_code, out_fp.read().decode("utf-8", "ignore").strip()
+        try:
+            result = run(
+                cmd,
+                encoding="utf-8",
+                errors="replace",
+                stderr=STDOUT,
+                stdout=PIPE,
+                timeout=timeout,
+            )
+        except TimeoutExpired as exc:
+            LOG.warning("ADB call timed out!")
+            return 1, exc.output.strip()
+        return result.returncode, result.stdout.strip()
 
     def _get_procs(self, pid=-1, pid_children=-1):
         """Generator function that yields a DeviceProcessInfo object for each running
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 4cc98310..daba059a 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -3,6 +3,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # pylint: disable=protected-access
 from pathlib import Path
+from subprocess import CompletedProcess, TimeoutExpired
 from zipfile import ZipFile
 
 from pytest import mark, raises
@@ -16,56 +17,25 @@
 )
 
 
-def test_adb_session_01(mocker):
+@mark.parametrize(
+    "result",
+    [
+        # success
+        (CompletedProcess(["test"], stdout="test\n", returncode=0),),
+        # timeout
+        TimeoutExpired(["test"], output="test\n", timeout=1),
+    ],
+)
+def test_adb_session_01(mocker, result):
     """test ADBSession._call_adb()"""
-
-    def fake_call(cmd, stderr=None, stdout=None):
-        assert cmd[0] == "test"
-        stderr.write(b"")
-        stdout.write(b"blah_out")
-        return 0
-
-    mocker.patch("grizzly.target.adb_device.adb_session.call", side_effect=fake_call)
-    ret, output = ADBSession._call_adb(["test"])
-    assert ret == 0
-    assert "blah_out" in output
-    # test with invalid timeout
-    with raises(AssertionError):
-        ADBSession._call_adb(["test"], timeout=-1)
-
-    # test with timeout
-    class FakeProc:
-        def __init__(self, cmd, stderr=None, stdout=None):
-            assert cmd[0] == "test"
-            self.stdout = stdout
-            stderr.write(b"")
-            stdout.write(b"init\n")
-
-        def __enter__(self):
-            return self
-
-        def __exit__(self, *_args):
-            pass
-
-        def wait(self):
-            self.stdout.write(b"wait\n")
-            return 1
-
-        def terminate(self):
-            self.stdout.write(b"terminate\n")
-
-        def poll(self):
-            self.stdout.write(b"poll\n")
-
-    mocker.patch("grizzly.target.adb_device.adb_session.Popen", new=FakeProc)
-    mocker.patch("grizzly.target.adb_device.adb_session.sleep")
-    mocker.patch("grizzly.target.adb_device.adb_session.time", side_effect=(1, 1, 2))
-    ret, output = ADBSession._call_adb(["test"], timeout=0.5)
-    assert ret == 1
-    assert "init" in output
-    assert "poll" in output
-    assert "terminate" in output
-    assert "wait" in output
+    mocker.patch(
+        "grizzly.target.adb_device.adb_session.run",
+        autospec=True,
+        side_effect=result,
+    )
+    retcode, output = ADBSession._call_adb(["test"])
+    assert retcode == (1 if isinstance(result, TimeoutExpired) else 0)
+    assert output == "test"
 
 
 @mark.parametrize(

From 0698e53da834db34da4c82a2921fbde5544efafd Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 30 Mar 2022 16:46:51 -0700
Subject: [PATCH 521/531] [adb] Disable some UI animations in --prep

---
 grizzly/target/adb_device/main.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/grizzly/target/adb_device/main.py b/grizzly/target/adb_device/main.py
index e27f543b..b6e729fe 100644
--- a/grizzly/target/adb_device/main.py
+++ b/grizzly/target/adb_device/main.py
@@ -67,6 +67,14 @@ def main(args):  # pylint: disable=missing-docstring
             LOG.info("Preparing device...")
             args.airplane_mode = 1
             args.install = args.prep
+            # disable some UI animations
+            session.shell(["settings", "put", "global", "animator_duration_scale", "0"])
+            session.shell(
+                ["settings", "put", "global", "transition_animation_scale", "0"]
+            )
+            session.shell(["settings", "put", "global", "window_animation_scale", "0"])
+            # keep device awake
+            session.shell(["svc", "power", "stayon", "true"])
         if args.airplane_mode is not None:
             LOG.debug("Setting airplane mode (%d)...", args.airplane_mode)
             session.airplane_mode = args.airplane_mode == 1

From c4b9996356236653fe1a8394d26959ad9b40c570 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Wed, 30 Mar 2022 17:37:22 -0700
Subject: [PATCH 522/531] [tests] Fix test_adb_session_29

---
 grizzly/target/adb_device/test_adb_session.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index daba059a..3037d38f 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -1134,7 +1134,6 @@ def test_adb_session_29(mocker, tmp_path):
     """test ADBSession.get_package_name()"""
     mocker.patch(
         "grizzly.target.adb_device.adb_session.ADBSession._aapt_check",
-        autospec=True,
         return_value=b"fake_aapt",
     )
     mocker.patch("grizzly.target.adb_device.adb_session.check_output", return_value=b"")

From 9386ab21e624120a9d4725eca1b01af7aad063d6 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 31 Mar 2022 12:56:43 -0700
Subject: [PATCH 523/531] [adb] Don't try to return output when ADB call times
 out

---
 grizzly/target/adb_device/adb_session.py      |  4 ++--
 grizzly/target/adb_device/test_adb_session.py | 10 +++++++---
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 8b18ae77..a9f29be2 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -163,9 +163,9 @@ def _call_adb(cmd, timeout=None):
                 stdout=PIPE,
                 timeout=timeout,
             )
-        except TimeoutExpired as exc:
+        except TimeoutExpired:
             LOG.warning("ADB call timed out!")
-            return 1, exc.output.strip()
+            return 1, ""
         return result.returncode, result.stdout.strip()
 
     def _get_procs(self, pid=-1, pid_children=-1):
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 3037d38f..6d360cd2 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -23,7 +23,7 @@
         # success
         (CompletedProcess(["test"], stdout="test\n", returncode=0),),
         # timeout
-        TimeoutExpired(["test"], output="test\n", timeout=1),
+        TimeoutExpired(["test"], timeout=1),
     ],
 )
 def test_adb_session_01(mocker, result):
@@ -34,8 +34,12 @@ def test_adb_session_01(mocker, result):
         side_effect=result,
     )
     retcode, output = ADBSession._call_adb(["test"])
-    assert retcode == (1 if isinstance(result, TimeoutExpired) else 0)
-    assert output == "test"
+    if isinstance(result, TimeoutExpired):
+        assert retcode == 1
+        assert output == ""
+    else:
+        assert retcode == 0
+        assert output == "test"
 
 
 @mark.parametrize(

From 4a20e0aafe0eb404ff22590121ef01e128e376dd Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 1 Apr 2022 12:21:13 -0700
Subject: [PATCH 524/531] [adb] Add timeout to ADB calls

---
 grizzly/target/adb_device/adb_session.py | 63 ++++++++++++------------
 1 file changed, 31 insertions(+), 32 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index a9f29be2..053420f3 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -247,21 +247,21 @@ def airplane_mode(self, mode):
             ]
         )
 
-    def call(self, cmd, device_required=True, timeout=None):
+    def call(self, cmd, device_required=True, timeout=120):
         """Call ADB with arguments provided in cmd.
 
         Args:
             cmd (list): List of strings to pass as arguments when calling ADB.
-            device_required (bool, optional): A device must be available for call.
+            device_required (bool, optional): A device must be available.
             timeout (float, optional): Seconds to wait for ADB call to complete.
 
         Returns:
             tuple: The first element is an integer containing the exit code of the
             ADB call and the second is a string containing stderr and stdout.
         """
-        assert isinstance(cmd, list) and cmd
+        assert cmd
         cmd = [self._adb_bin] + cmd
-        LOG.debug("calling: %s", " ".join(cmd))
+        LOG.debug("call %r (%r)", " ".join(cmd[1:]), timeout)
         if not self.connected and cmd[1] not in ("connect", "devices", "disconnect"):
             raise ADBCommunicationError("ADB session is not connected!")
         ret_code, output = self._call_adb(cmd, timeout=timeout)
@@ -273,7 +273,7 @@ def call(self, cmd, device_required=True, timeout=None):
             if output.startswith("Android Debug Bridge version"):
                 raise ADBCommandError("Invalid ADB command '%s'" % (" ".join(cmd[1:]),))
             if output.startswith("adb: usage:"):
-                raise ADBCommandError(output.strip())
+                raise ADBCommandError(output)
             if device_required and (
                 output.startswith("error: closed")
                 or output.startswith("error: device offline")
@@ -292,7 +292,6 @@ def clear_logs(self):
         Returns:
             None
         """
-        LOG.debug("clear_logs()")
         return self.call(["logcat", "--clear"], timeout=10)[0] == 0
 
     def collect_logs(self, pid=None):
@@ -313,7 +312,7 @@ def collect_logs(self, pid=None):
         cmd = ["logcat", "-d", "*:I"]
         if pid is not None:
             cmd += ["--pid=%d" % (pid,)]
-        return self.call(cmd, timeout=10)[1].encode("utf-8", "ignore")
+        return self.call(cmd, timeout=30)[1].encode("utf-8", "ignore")
 
     def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1):
         """Connect to a device via ADB.
@@ -327,9 +326,9 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
         Returns:
             bool: Returns True if connection was established otherwise False.
         """
-        assert isinstance(boot_timeout, int) and boot_timeout > 0
-        assert isinstance(max_attempts, int) and max_attempts > 0
-        assert isinstance(retry_delay, (int, float)) and retry_delay > 0
+        assert boot_timeout > 0
+        assert max_attempts > 0
+        assert retry_delay > 0
         self._cpu_arch = None
         self._os_version = None
         attempt = 0
@@ -341,7 +340,7 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                 if self._ip_addr is not None:
                     addr = ":".join((self._ip_addr, str(self._port)))
                     LOG.debug("connecting to %s", addr)
-                    if self.call(["connect", addr])[0] != 0:
+                    if self.call(["connect", addr], timeout=30)[0] != 0:
                         LOG.warning("connection attempt #%d failed", attempt)
                         sleep(retry_delay)
                         continue
@@ -358,7 +357,7 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                     "Timeout (%ds) waiting for device to boot" % (boot_timeout,)
                 )
             ret_code, user = self.call(
-                ["shell", "-T", "-n", "whoami"], device_required=False
+                ["shell", "-T", "-n", "whoami"], device_required=False, timeout=30
             )
             if ret_code != 0 or not user:
                 self.connected = False
@@ -385,7 +384,7 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                     self.shell(["stop"])
                     self.shell(["start"])
                     # put the device in a known state
-                    self.call(["reconnect"])
+                    self.call(["reconnect"], timeout=30)
                     self.connected = False
                     set_enforce_called = True
                     attempt -= 1
@@ -399,7 +398,7 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
                 break
             # enable root
             assert as_root, "Should not be here if root is not requested"
-            if self.call(["root"])[0] == 0:
+            if self.call(["root"], timeout=30)[0] == 0:
                 self.connected = False
                 # only skip attempt to call root once
                 if not root_called:
@@ -442,7 +441,7 @@ def devices(self, all_devices=False, any_state=True):
         Returns:
             dict: A dictionary keyed on device name containing the state.
         """
-        ret_code, entries = self.call(["devices"])
+        ret_code, entries = self.call(["devices"], timeout=30)
         devices = {}
         if ret_code != 0:
             return devices
@@ -478,7 +477,7 @@ def disconnect(self, unroot=True):
             return
         if self._root and unroot:
             try:
-                if self.call(["unroot"])[0] == 0:
+                if self.call(["unroot"], timeout=30)[0] == 0:
                     self.connected = False
                     self._root = False
                     return
@@ -486,7 +485,9 @@ def disconnect(self, unroot=True):
             except ADBCommandError:
                 LOG.warning("'unroot' not support by ADB")
         elif self._ip_addr is not None:
-            self.call(["disconnect", ":".join((self._ip_addr, str(self._port)))])
+            self.call(
+                ["disconnect", ":".join((self._ip_addr, str(self._port)))], timeout=30
+            )
         self.connected = False
 
     def get_enforce(self):
@@ -565,7 +566,7 @@ def install(self, apk_path):
         pkg_name = self.get_package_name(apk_path)
         if pkg_name is None:
             raise ADBSessionError("Could not find APK package name")
-        if self.call(["install", "-g", "-r", apk_path], timeout=120)[0] != 0:
+        if self.call(["install", "-g", "-r", apk_path], timeout=180)[0] != 0:
             raise ADBSessionError("Failed to install %r" % (apk_path,))
         # set permissions
         self.shell(
@@ -617,7 +618,6 @@ def listdir(self, path):
         Returns:
             list: Strings containing names of all items in a directory.
         """
-        LOG.debug("listdir(%r)", path)
         ret_val, output = self.shell(["ls", "-A", path])
         if ret_val != 0:
             raise IOError("%r does not exist" % (path,))
@@ -706,7 +706,7 @@ def pull(self, src, dst):
             bool: True if successful otherwise False
         """
         LOG.debug("pull(%r, %r)", src, dst)
-        return self.call(["pull", src, dst])[0] == 0
+        return self.call(["pull", src, dst], timeout=180)[0] == 0
 
     def push(self, src, dst):
         """Copy file to connected device.
@@ -721,7 +721,7 @@ def push(self, src, dst):
         LOG.debug("push(%r, %r)", src, dst)
         if not Path(src).exists():
             raise IOError("%r does not exist" % (src,))
-        return self.call(["push", src, dst])[0] == 0
+        return self.call(["push", src, dst], timeout=180)[0] == 0
 
     def realpath(self, path):
         """Get canonical path of the specified path.
@@ -732,11 +732,10 @@ def realpath(self, path):
         Returns:
             str: canonical path of the specified path.
         """
-        LOG.debug("realpath(%r)", path)
         ret_val, output = self.shell(["realpath", path])
         if ret_val != 0:
             raise IOError("%r does not exist" % (path,))
-        return output.strip()
+        return output
 
     def reboot_device(self, boot_timeout=300, max_attempts=60, retry_delay=1):
         """Reboot the connected device and reconnect.
@@ -750,7 +749,6 @@ def reboot_device(self, boot_timeout=300, max_attempts=60, retry_delay=1):
             None
         """
         was_root = self._root
-        LOG.debug("calling reboot...")
         self.call(["reboot"])
         self.connected = False
         self.connect(
@@ -785,9 +783,10 @@ def reverse(self, remote, local):
         Returns:
             bool: True if successful otherwise False
         """
-        assert isinstance(local, int) and 1024 < local < 0x10000
-        assert isinstance(remote, int) and 1024 < remote < 0x10000
-        return self.call(["reverse", "tcp:%d" % (remote,), "tcp:%d" % (local,)])[0] == 0
+        assert 1024 < local < 0x10000
+        assert 1024 < remote < 0x10000
+        cmd = ["reverse", "tcp:%d" % (remote,), "tcp:%d" % (local,)]
+        return self.call(cmd, timeout=10)[0] == 0
 
     def reverse_remove(self, remote=None):
         """
@@ -800,12 +799,12 @@ def reverse_remove(self, remote=None):
         """
         cmd = ["reverse"]
         if remote is not None:
-            assert isinstance(remote, int) and 1024 < remote < 0x10000
+            assert 1024 < remote < 0x10000
             cmd.append("--remove")
             cmd.append("tcp:%d" % (remote,))
         else:
             cmd.append("--remove-all")
-        return self.call(cmd)[0] == 0
+        return self.call(cmd, timeout=10)[0] == 0
 
     def sanitizer_options(self, prefix, options):
         """Set sanitizer options.
@@ -840,7 +839,7 @@ def set_enforce(self, value):
             LOG.warning("set_enforce requires root")
         self.shell(["setenforce", str(value)])
 
-    def shell(self, cmd, timeout=120):
+    def shell(self, cmd, timeout=60):
         """Execute an ADB shell command via a non-interactive shell.
 
         Args:
@@ -889,7 +888,7 @@ def wait_for_boot(self, timeout=None):
             bool: True if device booted successfully otherwise False.
         """
         if timeout is not None:
-            assert isinstance(timeout, (int, float)) and timeout > 0
+            assert timeout > 0
             deadline = time() + timeout
         else:
             deadline = None
@@ -909,7 +908,7 @@ def wait_for_boot(self, timeout=None):
             if booted and self.shell(anim_chk)[1] == "stopped":
                 if attempts > 1:
                     # the device was booting so give it additional time
-                    LOG.debug("device was boot was detected")
+                    LOG.debug("device boot was detected")
                     sleep(5)
                 return True
             if deadline and time() >= deadline:

From d27690108cecb1e1de4d5a6591ecdd76670408e3 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 1 Apr 2022 12:24:37 -0700
Subject: [PATCH 525/531] [adb] Add retry_delay kwarg to ADBSession.create()

---
 grizzly/target/adb_device/adb_session.py | 11 ++++++++---
 grizzly/target/adb_target.py             |  2 +-
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 053420f3..3b1e8e13 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -412,7 +412,9 @@ def connect(self, as_root=True, boot_timeout=300, max_attempts=60, retry_delay=1
         return self.connected
 
     @classmethod
-    def create(cls, ip_addr=None, port=5555, as_root=True, max_attempts=10):
+    def create(
+        cls, ip_addr=None, port=5555, as_root=True, max_attempts=10, retry_delay=1
+    ):
         """Create a ADBSession and connect to a device via ADB.
 
         Args:
@@ -420,13 +422,16 @@ def create(cls, ip_addr=None, port=5555, as_root=True, max_attempts=10):
                                      Defaults to None.
             port (int, optional): Port to use (TCP/IP only). Defaults to 5555.
             as_root (bool, optional): Attempt to enable root. Default is True.
-            max_attempt (int, optional): Number of attempts to connect to the device.
+            max_attempts (int, optional): Number of attempts to connect to the device.
+            retry_delay (int, optional): Number of seconds to wait between attempts.
 
         Returns:
             ADBSession: A connected ADBSession object otherwise None
         """
         session = cls(ip_addr, port)
-        if session.connect(as_root=as_root, max_attempts=max_attempts):
+        if session.connect(
+            as_root=as_root, max_attempts=max_attempts, retry_delay=retry_delay
+        ):
             return session
         return None
 
diff --git a/grizzly/target/adb_target.py b/grizzly/target/adb_target.py
index fd2cad8c..e40b2ae7 100644
--- a/grizzly/target/adb_target.py
+++ b/grizzly/target/adb_target.py
@@ -37,7 +37,7 @@ def __init__(self, binary, launch_timeout, log_limit, memory_limit, **kwds):
             LOG.warning("ADBTarget ignoring unsupported arguments: %s", ", ".join(kwds))
 
         LOG.debug("opening a session and setting up the environment")
-        self._session = ADBSession.create(as_root=True)
+        self._session = ADBSession.create(as_root=True, max_attempts=10, retry_delay=15)
         if self._session is None:
             raise RuntimeError("Could not create ADB Session!")
         self._package = ADBSession.get_package_name(self.binary)

From 4c26008d36805b6ff80498ab2ee511997b1fb078 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Fri, 1 Apr 2022 13:06:26 -0700
Subject: [PATCH 526/531] [adb] Refactor ADBSession._get_procs()

---
 grizzly/target/adb_device/adb_session.py      | 39 +++-----
 grizzly/target/adb_device/test_adb_session.py | 90 ++++++-------------
 2 files changed, 39 insertions(+), 90 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 3b1e8e13..8fc9f36f 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -168,7 +168,7 @@ def _call_adb(cmd, timeout=None):
             return 1, ""
         return result.returncode, result.stdout.strip()
 
-    def _get_procs(self, pid=-1, pid_children=-1):
+    def _get_procs(self, pid=None, pid_children=None):
         """Generator function that yields a DeviceProcessInfo object for each running
         process by default. pid and pid_children can be used to filter the results.
 
@@ -179,34 +179,19 @@ def _get_procs(self, pid=-1, pid_children=-1):
         Yields:
             DeviceProcessInfo: One instance for each process found in lookup.
         """
-        assert isinstance(pid, int)
-        assert isinstance(pid_children, int)
-        cmd = ["ps"]
-        if pid > -1:
+        cmd = ["ps", "-A", "-o", "pid,ppid,rss,name"]
+        if pid is not None:
+            assert isinstance(pid, int)
             cmd.append(str(pid))
-        if pid_children > -1:
+        if pid_children is not None:
+            assert isinstance(pid_children, int)
             cmd += ["--ppid", str(pid_children)]
-        for line in self.shell(cmd)[1].splitlines()[1:]:
-            pinfo = self._line_to_info(line)
-            if pinfo is not None:
-                yield pinfo
-
-    @staticmethod
-    def _line_to_info(ps_line):
-        """Create a DeviceProcessInfo from the string output of ps.
-
-        Args:
-            ps_line (str): Line of output from ps.
-
-        Returns:
-            DeviceProcessInfo: new instance.
-        """
-        try:
-            _, pid, ppid, _, memory, _, _, _, name = ps_line.split()
-            return DeviceProcessInfo(int(memory), name, int(pid), int(ppid))
-        except ValueError:
-            LOG.debug("invalid ps line %r", ps_line)
-        return None
+        for line in self.shell(cmd, timeout=30)[1].splitlines()[1:]:
+            try:
+                proc_id, ppid, memory, name = line.split()
+                yield DeviceProcessInfo(int(memory), name, int(proc_id), int(ppid))
+            except ValueError:
+                LOG.debug("failed to parse ps line %r", line)
 
     @property
     def airplane_mode(self):
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index 6d360cd2..e7abebf7 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -655,14 +655,11 @@ def fake_adb_call(cmd, timeout=None):
             if cmd[2] == "ps":
                 return (
                     0,
-                    "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME\n"
-                    "test      1337  1772  1024   1024 SyS_epoll_ 00000000 S"
-                    " org.test.preinstalled\n"
-                    "root      5847  1     315992 2348  poll_sched 00000000 S"
-                    " /sbin/adbd\n"
-                    "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S"
-                    " org.mozilla.fennec_aurora\n"
-                    "root      5944  5847  6280   2360           0 00000000 R ps\n\n",
+                    "header... this should be skipped\n"
+                    "1337  1772  1024    org.test.preinstalled\n"
+                    "5847  1     315992  /sbin/adbd\n"
+                    "9990  1772  1221212 org.mozilla.fennec_aurora\n"
+                    "5944  5847  6280    ps\n\n",
                 )
         raise AssertionError("unexpected command %r" % (cmd,))
 
@@ -865,13 +862,12 @@ def fake_adb_call(cmd, timeout=None):
                 "      44840 TCP :35274->:443 (SYN_SENT)\n",
             )
         if cmd[1] == "shell" and cmd[2] == "ps":
-            assert cmd[3] == "--ppid"
-            assert cmd[4] == "9990"
+            assert "--ppid" in cmd
+            assert "9990" in cmd
             return (
                 0,
-                "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME\n"
-                "u0_a80    9991  9990  3332   3331 SyS_epoll_ 00000000 S"
-                " org.mozilla.fennec_aurora\n",
+                "PID   PPID  RSS  NAME\n"
+                "9991  9990  3331 org.mozilla.fennec_aurora\n",
             )
         raise AssertionError("unexpected command %r" % (cmd,))
 
@@ -897,7 +893,7 @@ def fake_adb_call(cmd, timeout=None):
 def test_adb_session_21(mocker):
     """test ADBSession._get_procs()"""
 
-    # pylint: disable=too-many-return-statements,unused-argument
+    # pylint: disable=unused-argument
     def fake_adb_call(cmd, timeout=None):
         assert cmd and cmd[0].endswith("adb")
         if cmd[1] == "shell":
@@ -905,38 +901,24 @@ def fake_adb_call(cmd, timeout=None):
             cmd.remove("-T")
             cmd.remove("-n")
         if cmd[1] == "shell" and cmd[2] == "ps":
-            if len(cmd) == 5:
-                assert cmd[3] == "--ppid"
-                ppid = int(cmd[-1])
-            else:
-                ppid = None
-            output = ["USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME\n"]
+            ppid = int(cmd[-1]) if "--ppid" in cmd else None
+            output = ["PID   PPID  RSS  NAME\n"]
             if ppid is None:
                 output += [
-                    "root      1     0     8896   2208  SyS_epoll_ 00000000 S /init\n",
-                    "root      1242  2     0      0         kswapd"
-                    " 00000000 S kswapd0\n",
-                    "test      1337  1772  1024   1024 SyS_epoll_"
-                    " 00000000 S org.test.preinstalled\n",
-                    "test      1338  1337  1024   1024 SyS_epoll_"
-                    " 00000000 S org.test.child\n",
-                    "root      1772  1     1620804 122196 poll_sched"
-                    " 00000000 S zygote\n",
-                    "media_rw  2158  1758  0      0              0 00000000 Z sdcard\n",
-                    "audioserver 1773  1     34000  9624  binder_thr"
-                    " 00000000 S /system/bin/audioserver\n",
-                    "root      5847  1     315992 2348  poll_sched"
-                    " 00000000 S /sbin/adbd\n",
-                    "u0_a80    9990  1772  1221212 128064 SyS_epoll_"
-                    " 00000000 S org.mozilla.fennec_aurora\n",
-                    "root      5944  5847  6280   2360           0 00000000 R ps\n",
+                    "1     0     2208   /init\n",
+                    "a     a     a      invalid.for.coverage\n",
+                    "1242  2     0      kswapd0\n",
+                    "1337  1772  1024   org.test.preinstalled\n",
+                    "1338  1337  1024   org.test.child\n",
+                    "1772  1     122196 zygote\n",
+                    "2158  1758  0      sdcard\n",
+                    "1773  1     9624   /system/bin/audioserver\n",
+                    "5847  1     2348   /sbin/adbd\n",
+                    "9990  1772  128064 org.mozilla.fennec_aurora\n",
+                    "5944  5847  6280   ps\n",
                 ]
             elif ppid == 9990:
-                output += [
-                    "u0_a80    9991  9990  3332   3331 SyS_epoll_"
-                    " 00000000 S org.mozilla.fennec_aurora\n"
-                ]
-            output += ["\n"]
+                output.append("9991  9990  3332   org.mozilla.fennec_aurora\n")
             return 0, "".join(output)
         raise AssertionError("unexpected command %r" % (cmd,))
 
@@ -1064,12 +1046,11 @@ def fake_adb_call(cmd, timeout=None):
             cmd.remove("-T")
             cmd.remove("-n")
             if cmd[2] == "ps":
-                assert cmd[3] == "9990"
+                assert cmd[-1] == "9990"
                 return (
                     0,
-                    "USER      PID   PPID  VSIZE  RSS   WCHAN            PC  NAME\n"
-                    "u0_a80    9990  1772  1221212 128064 SyS_epoll_ 00000000 S"
-                    " org.mozilla.fennec_aurora\n\n",
+                    "PID   PPID  RSS    NAME\n"
+                    "9990  1772  128064 org.mozilla.fennec_aurora\n\n",
                 )
         raise AssertionError("unexpected command %r" % (cmd,))
 
@@ -1503,23 +1484,6 @@ def fake_adb_02(cmd, timeout=None):
     session.remount()
 
 
-def test_adb_session_39():
-    """test ADBSession._line_to_info()"""
-    # nothing to parse
-    assert ADBSession._line_to_info("") is None
-    # invalid number of entries
-    assert ADBSession._line_to_info(" ".join("a" * 20)) is None
-    # invalid data (valid number of entries)
-    assert ADBSession._line_to_info(" ".join("a" * 9)) is None
-    # valid info
-    pinfo = ADBSession._line_to_info("a 1 2 a 3 a a a name")
-    assert pinfo is not None
-    assert pinfo.memory == 3
-    assert pinfo.name == "name"
-    assert pinfo.pid == 1
-    assert pinfo.ppid == 2
-
-
 @mark.usefixtures("tmp_session_adb_check")
 def test_adb_session_40(mocker):
     """test ADBSession.sanitizer_options()"""

From ac0cf13240fedf96537438d8f4bff837445fb5b1 Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Mon, 4 Apr 2022 10:12:23 -0700
Subject: [PATCH 527/531] [adb] Cleanup ADBSession.open_files()

---
 grizzly/target/adb_device/adb_session.py | 33 ++++++++++--------------
 1 file changed, 13 insertions(+), 20 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 8fc9f36f..cb51990a 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -628,33 +628,26 @@ def open_files(self, pid=None, children=False, files=None):
             tuple: PID and path of the open file.
         """
         LOG.debug("open_files(pid=%r, children=%r, files=%r", pid, children, files)
-        pids = list()
-        if pid is not None:
-            pids.append(str(pid))
-        if children:
-            assert (
-                pid is not None
-            ), "Cannot request child open files without specifying pid"
-            for proc in self._get_procs(pid_children=pid):
-                pids.append(str(proc.pid))
         cmd = ["lsof"]
-        if pids:
+        if pid is not None:
+            pids = [str(pid)]
+            if children:
+                pids.extend(str(x.pid) for x in self._get_procs(pid_children=pid))
             cmd += ["-p", ",".join(pids)]
+        else:
+            assert not children, "children requires pid"
+            pids = None
         if files:
-            cmd.extend(list(files))
+            cmd.extend(files)
         for line in self.shell(cmd)[1].splitlines():
-            if line.endswith("Permission denied)"):
-                continue
-            # I believe we only care about regular files
-            if " REG " not in line:
+            if line.endswith("Permission denied)") or " REG " not in line:
+                # only include regular files for now
                 continue
             try:
                 file_info = line.split()
-                file_name = file_info[-1]
-                if pid is not None and file_info[1] not in pids:
-                    continue
-                # yield tuple containing pid and filename
-                yield (int(file_info[1]), file_name)
+                if pids is None or file_info[1] in pids:
+                    # tuple containing pid and filename
+                    yield (int(file_info[1]), file_info[-1])
             except ValueError:
                 pass
 

From 6f00ccb5efb95cb8721f1c4b2e7fbc72bd8eaf5f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 7 Apr 2022 17:42:22 -0700
Subject: [PATCH 528/531] [adb] Only pass -A to ps when pid or --ppid is not
 provided

---
 grizzly/target/adb_device/adb_session.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index cb51990a..a9265417 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -179,13 +179,15 @@ def _get_procs(self, pid=None, pid_children=None):
         Yields:
             DeviceProcessInfo: One instance for each process found in lookup.
         """
-        cmd = ["ps", "-A", "-o", "pid,ppid,rss,name"]
+        cmd = ["ps", "-o", "pid,ppid,rss,name"]
         if pid is not None:
             assert isinstance(pid, int)
             cmd.append(str(pid))
         if pid_children is not None:
             assert isinstance(pid_children, int)
             cmd += ["--ppid", str(pid_children)]
+        if not pid and not pid_children:
+            cmd.append("-A")
         for line in self.shell(cmd, timeout=30)[1].splitlines()[1:]:
             try:
                 proc_id, ppid, memory, name = line.split()

From 2a15ca825badcee07592710e3c1f8fa7da88b60e Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 7 Apr 2022 17:45:29 -0700
Subject: [PATCH 529/531] [adb] Use pidof to lookup pid

---
 grizzly/target/adb_device/adb_session.py | 15 ++-------------
 1 file changed, 2 insertions(+), 13 deletions(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index a9265417..7b7a99e3 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -527,19 +527,8 @@ def get_pid(self, package_name):
             int: PID of the process with the specified package name if it exists
                  otherwise None.
         """
-        # TODO: _get_procs() is slow, move to pidof ASAP
-        # pidof is not supported pre-Android 6... do we care about <6? if so we could
-        # just fallback
-        pids = [proc.pid for proc in self._get_procs() if proc.name == package_name]
-        if not pids:
-            return None
-        count = len(pids)
-        if count > 1:
-            LOG.debug("get_pid() %d proc(s) found", count)
-            # TODO: get procs and use the ppid of the procs the determine the parent
-            # for now we are using the lowest pid...
-            pids.sort()
-        return pids[0]
+        ret_code, pid = self.shell(["pidof", package_name], timeout=30)
+        return int(pid) if ret_code == 0 else None
 
     def install(self, apk_path):
         """Install APK on the connected device, grant R/W permissions to /sdcard and

From 3c29ed93dce8b2d1b766f4e166e231f940e2bb4f Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 7 Apr 2022 17:50:03 -0700
Subject: [PATCH 530/531] [adb] Simplify ps called used in process_exists()

---
 grizzly/target/adb_device/adb_session.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/grizzly/target/adb_device/adb_session.py b/grizzly/target/adb_device/adb_session.py
index 7b7a99e3..78d54afa 100644
--- a/grizzly/target/adb_device/adb_session.py
+++ b/grizzly/target/adb_device/adb_session.py
@@ -667,7 +667,9 @@ def process_exists(self, pid):
         Returns:
             bool: True if the process exists otherwise False
         """
-        return any(self._get_procs(pid=pid))
+        # this is called frequently and should be as light weight as possible
+        pid = str(pid)
+        return pid in self.shell(["ps", "-p", pid, "-o", "pid"], timeout=30)[1]
 
     def pull(self, src, dst):
         """Copy file from connected device.

From c14be5651b797deca86310efef1fac7f4a8eceef Mon Sep 17 00:00:00 2001
From: Tyson Smith <tyson.w.smith@gmail.com>
Date: Thu, 14 Apr 2022 12:56:12 -0700
Subject: [PATCH 531/531] [adb] Update use of process_minidumps()

---
 grizzly/target/adb_device/adb_process.py      | 17 ++++++++-----
 grizzly/target/adb_device/test_adb_process.py | 24 +++++++++++--------
 grizzly/target/adb_device/test_adb_session.py | 21 +++++-----------
 3 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/grizzly/target/adb_device/adb_process.py b/grizzly/target/adb_device/adb_process.py
index f7cbb69b..83985885 100644
--- a/grizzly/target/adb_device/adb_process.py
+++ b/grizzly/target/adb_device/adb_process.py
@@ -2,6 +2,7 @@
 import re
 from enum import Enum, unique
 from logging import getLogger
+from pathlib import Path
 from random import getrandbits
 from shutil import copy, rmtree
 from tempfile import NamedTemporaryFile, mkdtemp
@@ -328,10 +329,10 @@ def prefs_to_dict(prefs_file):
     def _process_logs(self, crash_reports):
         assert self.logs is None
         self.logs = mkdtemp(prefix="logs_", dir=grz_tmp("logs"))
-        unprocessed = os.path.join(self.logs, "unprocessed")
-        os.mkdir(unprocessed)
+        unprocessed = Path(self.logs) / "unprocessed"
+        unprocessed.mkdir(exist_ok=True)
 
-        with open(os.path.join(self.logs, "log_logcat.txt"), "wb") as log_fp:
+        with (Path(self.logs) / "log_logcat.txt").open("wb") as log_fp:
             # TODO: should this filter by pid or not?
             log_fp.write(self._session.collect_logs())
             # log_fp.write(self._session.collect_logs(pid=self._pid))
@@ -341,11 +342,15 @@ def _process_logs(self, crash_reports):
 
         # copy crash logs from the device
         for fname in crash_reports:
-            self._session.pull(fname, unprocessed)
+            self._session.pull(fname, str(unprocessed))
 
         with PuppetLogger() as logger:
-            syms_path = self._session.symbols_path(self._package)
-            process_minidumps(unprocessed, syms_path, logger.add_log)
+            if any(unprocessed.glob("*.dmp")):
+                process_minidumps(
+                    unprocessed,
+                    Path(self._session.symbols_path(self._package)),
+                    logger.add_log,
+                )
             logger.close()
             logger.save_logs(self.logs)
 
diff --git a/grizzly/target/adb_device/test_adb_process.py b/grizzly/target/adb_device/test_adb_process.py
index 7404ca8b..30148e6e 100644
--- a/grizzly/target/adb_device/test_adb_process.py
+++ b/grizzly/target/adb_device/test_adb_process.py
@@ -183,33 +183,37 @@ def test_adb_process_10(mocker, tmp_path):
     assert any(dmp_path.glob("fake.txt"))
 
 
-def test_adb_process_11(mocker):
+def test_adb_process_11(mocker, tmp_path):
     """test ADBProcess._process_logs()"""
     mocker.patch("grizzly.target.adb_device.adb_process.Bootstrapper", autospec=True)
+    mocker.patch(
+        "grizzly.target.adb_device.adb_process.mkdtemp",
+        autospec=True,
+        return_value=str(tmp_path),
+    )
     mocker.patch("grizzly.target.adb_device.adb_process.PuppetLogger", autospec=True)
     fake_proc_md = mocker.patch(
         "grizzly.target.adb_device.adb_process.process_minidumps", autospec=True
     )
     fake_session = mocker.Mock(spec_set=ADBSession)
     fake_session.collect_logs.return_value = b"fake logcat data"
+    fake_session.symbols_path.return_value = "foo"
     with ADBProcess("org.some.app", fake_session) as proc:
         # no extra logs
         proc._process_logs([])
-        assert isdir(proc.logs)
-        try:
-            assert "log_logcat.txt" in listdir(proc.logs)
-        finally:
-            rmtree(proc.logs)
+        assert "log_logcat.txt" in listdir(proc.logs)
+        rmtree(proc.logs)
         proc.logs = None
         assert fake_proc_md.call_count == 0
         assert fake_session.pull.call_count == 0
         # other logs available
+        (tmp_path / "unprocessed").mkdir(parents=True)
+        (tmp_path / "unprocessed" / "log.dmp").touch()
+        (tmp_path / "unprocessed" / "asan_log.dmp").touch()
         proc._process_logs(["log.dmp", "asan_log.txt"])
         assert isdir(proc.logs)
-        try:
-            assert "log_logcat.txt" in listdir(proc.logs)
-        finally:
-            rmtree(proc.logs)
+        assert "log_logcat.txt" in listdir(proc.logs)
+        rmtree(proc.logs)
         assert fake_proc_md.call_count == 1
         assert fake_session.pull.call_count == 2
 
diff --git a/grizzly/target/adb_device/test_adb_session.py b/grizzly/target/adb_device/test_adb_session.py
index e7abebf7..07982998 100644
--- a/grizzly/target/adb_device/test_adb_session.py
+++ b/grizzly/target/adb_device/test_adb_session.py
@@ -652,15 +652,10 @@ def fake_adb_call(cmd, timeout=None):
             # strip shell args
             cmd.remove("-T")
             cmd.remove("-n")
-            if cmd[2] == "ps":
-                return (
-                    0,
-                    "header... this should be skipped\n"
-                    "1337  1772  1024    org.test.preinstalled\n"
-                    "5847  1     315992  /sbin/adbd\n"
-                    "9990  1772  1221212 org.mozilla.fennec_aurora\n"
-                    "5944  5847  6280    ps\n\n",
-                )
+            if cmd[2] == "pidof":
+                if cmd[3] == "org.test.preinstalled":
+                    return 0, "1337"
+                return 1, ""
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(
@@ -1046,12 +1041,8 @@ def fake_adb_call(cmd, timeout=None):
             cmd.remove("-T")
             cmd.remove("-n")
             if cmd[2] == "ps":
-                assert cmd[-1] == "9990"
-                return (
-                    0,
-                    "PID   PPID  RSS    NAME\n"
-                    "9990  1772  128064 org.mozilla.fennec_aurora\n\n",
-                )
+                assert "9990" in cmd
+                return 0, "PID\n9990\n\n"
         raise AssertionError("unexpected command %r" % (cmd,))
 
     mocker.patch(