Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 


Quelle  test_win32k_enrollment.py   Sprache: Python

 
from contextlib import contextmanager

from marionette_harness import MarionetteTestCase


class ExperimentStatus:
    UNENROLLED = 0
    ENROLLED_CONTROL = 1
    ENROLLED_TREATMENT = 2
    DISQUALIFIED = 3


class ContentWin32kLockdownState:
    LockdownEnabled = 1
    MissingWebRender = 2
    OperatingSystemNotSupported = 3
    PrefNotSet = 4
    MissingRemoteWebGL = 5
    MissingNonNativeTheming = 6
    DisabledByEnvVar = 7
    DisabledBySafeMode = 8
    DisabledByE10S = 9
    DisabledByUserPref = 10
    EnabledByUserPref = 11
    DisabledByControlGroup = 12
    EnabledByTreatmentGroup = 13
    DisabledByDefault = 14
    EnabledByDefault = 15


class Prefs:
    ENROLLMENT_STATUS = "security.sandbox.content.win32k-experiment.enrollmentStatus"
    STARTUP_ENROLLMENT_STATUS = (
        "security.sandbox.content.win32k-experiment.startupEnrollmentStatus"
    )
    WIN32K = "security.sandbox.content.win32k-disable"
    WEBGL = "webgl.out-of-process"


ENV_DISABLE_WIN32K = "MOZ_ENABLE_WIN32K"
ENV_DISABLE_E10S = "MOZ_FORCE_DISABLE_E10S"


class TestWin32kAutostart(MarionetteTestCase):
    SANDBOX_NAME = "win32k-autostart"

    def execute_script(self, code, *args, **kwargs):
        with self.marionette.using_context(self.marionette.CONTEXT_CHROME):
            return self.marionette.execute_script(
                code, new_sandbox=False, sandbox=self.SANDBOX_NAME, *args, **kwargs
            )

    def get_win32k_status(self):
        return self.execute_script(
            r"""
          let win = Services.wm.getMostRecentWindow("navigator:browser");
          let ses = "security.sandbox.content.win32k-experiment.startupEnrollmentStatus";
          return {
            win32kSessionStatus: Services.appinfo.win32kSessionStatus,
            win32kStatus: Services.appinfo.win32kLiveStatusTestingOnly,
            win32kExperimentStatus: Services.appinfo.win32kExperimentStatus,
            win32kPref: Services.prefs.getBoolPref("security.sandbox.content.win32k-disable"),
            win32kStartupEnrollmentStatusPref: Services.prefs.getIntPref(ses),
          };
        """
        )

    def check_win32k_status(
        self, status, sessionStatus, experimentStatus, pref, enrollmentStatusPref
    ):
        # We CANNOT check win32kEnrollmentStatusPref after a restart because we only set this
        # pref on the default branch, and it goes away after a restart, so we only check
        # the startupEnrollmentStatusPref
        expected = {
            "win32kSessionStatus": sessionStatus,
            "win32kStatus": status,
            "win32kExperimentStatus": experimentStatus,
            "win32kPref": pref,
            "win32kStartupEnrollmentStatusPref": enrollmentStatusPref,
        }

        status = self.get_win32k_status()

        for prop, value in expected.items():
            self.assertEqual(
                status[prop],
                value,
                "%s should have the value `%r`, but has `%r`"
                % (prop, value, status[prop]),
            )

    def set_env(self, env, value):
        self.execute_script(
            "env.set(arguments[0], arguments[1]);", script_args=(env, value)
        )

    def get_env(self, env):
        return self.execute_script("return env.get(arguments[0]);", script_args=(env,))

    def set_enrollment_status(self, status):
        self.marionette.set_pref(Prefs.ENROLLMENT_STATUS, status, default_branch=True)

        updated_status = self.marionette.get_pref(Prefs.ENROLLMENT_STATUS)
        self.assertTrue(
            status == updated_status or updated_status == ExperimentStatus.DISQUALIFIED
        )
        startup_status = self.marionette.get_pref(Prefs.STARTUP_ENROLLMENT_STATUS)
        self.assertEqual(
            startup_status,
            updated_status,
            "Startup enrollment status (%r) should match "
            "session status (%r)" % (startup_status, updated_status),
        )

    def restart(self, prefs=None, env=None):
        if prefs:
            self.marionette.set_prefs(prefs)

        if env:
            for name, value in env.items():
                self.set_env(name, value)

        self.marionette.restart(in_app=True, clean=False)
        self.setUpSession()

        # Sanity check our environment.
        if prefs:
            for key, val in prefs.items():
                if val is not None:
                    self.assertEqual(self.marionette.get_pref(key), val)
        if env:
            for key, val in env.items():
                self.assertEqual(self.get_env(key), val or "")

    def setUpSession(self):
        self.marionette.set_context(self.marionette.CONTEXT_CHROME)

        self.execute_script(
            r"""
          // We're running in a function, in a sandbox, that inherits from an
          // X-ray wrapped window. Anything we want to be globally available
          // needs to be defined on that window.
          window.env = Services.env;
        """
        )

    @contextmanager
    def full_restart(self):
        profile = self.marionette.instance.profile
        try:
            self.marionette.quit()
            yield profile
        finally:
            self.marionette.start_session()
            self.setUpSession()

    def setUp(self):
        super(TestWin32kAutostart, self).setUp()

        # If we have configured marionette to require a particular value for
        # `win32k.autostart`, remove it as a forced pref until `tearDown`, and
        # perform a clean restart, so we run this test without the pref
        # pre-configured.
        self.win32kRequired = None
        if Prefs.WIN32K in self.marionette.instance.required_prefs:
            self.win32kRequired = self.marionette.instance.required_prefs[Prefs.WIN32K]
            del self.marionette.instance.required_prefs[Prefs.WIN32K]
            self.marionette.restart(in_app=False, clean=True)

        self.setUpSession()

        # Marionette doesn't let you set preferences on the default branch before startup
        # so we can't test the default=False and default=True scenarios in one test
        # What we can do is generate all the tests, and then only run the runs for which
        # the default is.  (And run the other ones locally to make sure they work before
        # we land it.)
        prefJS = 'return Services.prefs.getBoolPref("security.sandbox.content.win32k-disable");'
        self.default_is = self.execute_script(prefJS)

        if self.default_is is False:
            # Win32k status must start out with `disabledByDefault`
            self.check_win32k_status(
                status=ContentWin32kLockdownState.DisabledByDefault,
                sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
                experimentStatus=ExperimentStatus.UNENROLLED,
                pref=False,
                enrollmentStatusPref=ExperimentStatus.UNENROLLED,
            )
        else:
            # Win32k status must start out with `enabledByDefault`
            self.check_win32k_status(
                status=ContentWin32kLockdownState.EnabledByDefault,
                sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
                experimentStatus=ExperimentStatus.UNENROLLED,
                pref=True,
                enrollmentStatusPref=ExperimentStatus.UNENROLLED,
            )

    def tearDown(self):
        if self.win32kRequired is not None:
            self.marionette.instance.required_prefs[Prefs.WIN32K] = self.win32kRequired
        self.marionette.restart(in_app=False, clean=True)

        super(TestWin32kAutostart, self).tearDown()

    def test_1(self):
        # [D=F] Nothing [A#1] -> Enrolled Control [A S=DisabledByDefault SS=DisabledByDefa...

        if self.default_is is not False:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

    def test_2(self):
        # [D=F] Nothing [A#1] -> Enrolled Treatment [A S=DisabledByDefault SS=DisabledByDe...

        if self.default_is is not False:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )
        self.set_enrollment_status(ExperimentStatus.ENROLLED_TREATMENT)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_TREATMENT,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            sessionStatus=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            experimentStatus=ExperimentStatus.ENROLLED_TREATMENT,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_TREATMENT,
        )

    def test_3(self):
        # [D=F] Nothing [A#1] -> On [A S=EnabledByUserPref SS=DisabledByDefault ES=UNENROL...

        if self.default_is is not False:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_4(self):
        # [D=F] Nothing [A#1] -> Off [A#1] -> Restart [A#1]...

        if self.default_is is not False:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WIN32K, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_5(self):
        # [D=F] Nothing [A#1] -> On -> Bad Requirements [A S=MissingRemoteWebGL SS=Disable...

        if self.default_is is not False:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.marionette.set_pref(Prefs.WEBGL, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.MissingRemoteWebGL,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.MissingRemoteWebGL,
            sessionStatus=ContentWin32kLockdownState.MissingRemoteWebGL,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_6(self):
        # [D=F] Nothing [A#1] -> On -> E10S [A S=DisabledByE10S SS=DisabledByE10S ES=UNENR...

        if self.default_is is not False:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.restart(env={ENV_DISABLE_E10S: "1"})
        self.set_env(ENV_DISABLE_E10S, "null")

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByE10S,
            sessionStatus=ContentWin32kLockdownState.DisabledByE10S,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_7(self):
        # [D=F] Nothing [A#1] -> On -> Header-On [A S=DisabledByEnvVar SS=DisabledByEnvVar...

        if self.default_is is not False:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.restart(env={ENV_DISABLE_WIN32K: "1"})

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByEnvVar,
            sessionStatus=ContentWin32kLockdownState.DisabledByEnvVar,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.set_env(ENV_DISABLE_WIN32K, "")

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.DisabledByEnvVar,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_8(self):
        # [D=T] Nothing [A#1T] -> Enrolled Control [A S=EnabledByDefault SS=EnabledByDefau...

        if self.default_is is not True:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

    def test_9(self):
        # [D=T] Nothing [A#1T] -> Enrolled Treatment [A S=EnabledByDefault SS=EnabledByDef...

        if self.default_is is not True:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )
        self.set_enrollment_status(ExperimentStatus.ENROLLED_TREATMENT)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_TREATMENT,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            sessionStatus=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            experimentStatus=ExperimentStatus.ENROLLED_TREATMENT,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_TREATMENT,
        )

    def test_10(self):
        # [D=T] Nothing [A#1T] -> On [A S=EnabledByDefault SS=EnabledByDefault ES=UNENROLL...

        if self.default_is is not True:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_11(self):
        # [D=T] Nothing [A#1T] -> Off [A S=DisabledByUserPref SS=EnabledByDefault ES=UNENR...

        if self.default_is is not True:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WIN32K, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.DisabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_12(self):
        # [D=T] Nothing [A#1T] -> On -> Bad Requirements [A S=MissingRemoteWebGL SS=Enable...

        if self.default_is is not True:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.marionette.set_pref(Prefs.WEBGL, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.MissingRemoteWebGL,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.MissingRemoteWebGL,
            sessionStatus=ContentWin32kLockdownState.MissingRemoteWebGL,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_13(self):
        # [D=T] Nothing [A#1T] -> On -> E10S [A S=DisabledByE10S SS=DisabledByE10S ES=UNEN...

        if self.default_is is not True:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.restart(env={ENV_DISABLE_E10S: "1"})
        self.set_env(ENV_DISABLE_E10S, "null")

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByE10S,
            sessionStatus=ContentWin32kLockdownState.DisabledByE10S,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_14(self):
        # [D=T] Nothing [A#1T] -> On -> Header-On [A S=DisabledByEnvVar SS=DisabledByEnvVa...

        if self.default_is is not True:
            return

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.restart(env={ENV_DISABLE_WIN32K: "1"})

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByEnvVar,
            sessionStatus=ContentWin32kLockdownState.DisabledByEnvVar,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.set_env(ENV_DISABLE_WIN32K, "")

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByEnvVar,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_15(self):
        # [D=F] On [A#3] -> Restart [A#4] -> Enrolled Control [A S=EnabledByUserPref SS=En...

        if self.default_is is not False:
            return

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.DISQUALIFIED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.DISQUALIFIED,
        )

    def test_16(self):
        # [D=F] On [A#3] -> Restart [A#4] -> Enrolled Treatment [A S=EnabledByUserPref SS=...

        if self.default_is is not False:
            return

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )
        self.set_enrollment_status(ExperimentStatus.ENROLLED_TREATMENT)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_TREATMENT,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.DISQUALIFIED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.DISQUALIFIED,
        )

    def test_17(self):
        # [D=F] On [A#3] -> Restart [A#4] -> Off [A S=DisabledByDefault SS=EnabledByUserPr...

        if self.default_is is not False:
            return

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WIN32K, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_18(self):
        # [D=F] On [A#3] -> Restart [A#4] -> Bad Requirements [A S=MissingRemoteWebGL SS=E...

        if self.default_is is not False:
            return

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WEBGL, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.MissingRemoteWebGL,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_19(self):
        # [D=F] On [A#3] -> Restart [A#4] -> E10S [A S=DisabledByE10S SS=DisabledByE10S ES...

        if self.default_is is not False:
            return

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart(env={ENV_DISABLE_E10S: "1"})
        self.set_env(ENV_DISABLE_E10S, "null")

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByE10S,
            sessionStatus=ContentWin32kLockdownState.DisabledByE10S,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_20(self):
        # [D=F] On [A#3] -> Restart [A#4] -> Header-On [A S=DisabledByEnvVar SS=DisabledBy...

        if self.default_is is not False:
            return

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart(env={ENV_DISABLE_WIN32K: "1"})

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByEnvVar,
            sessionStatus=ContentWin32kLockdownState.DisabledByEnvVar,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.set_env(ENV_DISABLE_WIN32K, "")

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_21(self):
        # [D=T] On [A#3T] -> Restart [A#4T] -> Enrolled Control [A S=EnabledByDefault SS=E...

        if self.default_is is not True:
            return

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

    def test_22(self):
        # [D=T] On [A#3T] -> Restart [A#4T] -> Enrolled Treatment [A S=EnabledByDefault SS...

        if self.default_is is not True:
            return

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )
        self.set_enrollment_status(ExperimentStatus.ENROLLED_TREATMENT)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_TREATMENT,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            sessionStatus=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            experimentStatus=ExperimentStatus.ENROLLED_TREATMENT,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_TREATMENT,
        )

    def test_23(self):
        # [D=T] On [A#3T] -> Restart [A#4T] -> Off [A S=DisabledByUserPref SS=EnabledByDef...

        if self.default_is is not True:
            return

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WIN32K, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.DisabledByUserPref,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_24(self):
        # [D=T] On [A#3T] -> Restart [A#4T] -> Bad Requirements [A S=MissingRemoteWebGL SS...

        if self.default_is is not True:
            return

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.marionette.set_pref(Prefs.WEBGL, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.MissingRemoteWebGL,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_25(self):
        # [D=T] On [A#3T] -> Restart [A#4T] -> E10S [A S=DisabledByE10S SS=DisabledByE10S ...

        if self.default_is is not True:
            return

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart(env={ENV_DISABLE_E10S: "1"})
        self.set_env(ENV_DISABLE_E10S, "null")

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByE10S,
            sessionStatus=ContentWin32kLockdownState.DisabledByE10S,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_26(self):
        # [D=T] On [A#3T] -> Restart [A#4T] -> Header-On [A S=DisabledByEnvVar SS=Disabled...

        if self.default_is is not True:
            return

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.restart(env={ENV_DISABLE_WIN32K: "1"})

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByEnvVar,
            sessionStatus=ContentWin32kLockdownState.DisabledByEnvVar,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

        self.set_env(ENV_DISABLE_WIN32K, "")

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.UNENROLLED,
        )

    def test_27(self):
        # [D=F] Enrolled Control [A#5] -> Restart [A#6] -> Enrolled Control-C -> On [A S=E...

        if self.default_is is not False:
            return
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.DISQUALIFIED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.DISQUALIFIED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.DISQUALIFIED,
        )

    def test_28(self):
        # [D=F] Enrolled Control [A#5] -> Restart [A#6] -> Off [A#6]...

        if self.default_is is not False:
            return
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.marionette.set_pref(Prefs.WIN32K, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

    def test_29(self):
        # [D=F] Enrolled Control [A#5] -> Restart [A#6] -> Enrolled Control-C -> Bad Requi...

        if self.default_is is not False:
            return
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.marionette.set_pref(Prefs.WEBGL, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.MissingRemoteWebGL,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.MissingRemoteWebGL,
            sessionStatus=ContentWin32kLockdownState.MissingRemoteWebGL,
            experimentStatus=ExperimentStatus.DISQUALIFIED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.DISQUALIFIED,
        )

    def test_30(self):
        # [D=F] Enrolled Control [A#5] -> Restart [A#6] -> Enrolled Control-C -> E10S [A S...

        if self.default_is is not False:
            return
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.restart(env={ENV_DISABLE_E10S: "1"})
        self.set_env(ENV_DISABLE_E10S, "null")

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByE10S,
            sessionStatus=ContentWin32kLockdownState.DisabledByE10S,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

    def test_31(self):
        # [D=F] Enrolled Control [A#5] -> Restart [A#6] -> Enrolled Control-C -> Header-On...

        if self.default_is is not False:
            return
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.restart(env={ENV_DISABLE_WIN32K: "1"})

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByEnvVar,
            sessionStatus=ContentWin32kLockdownState.DisabledByEnvVar,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.set_env(ENV_DISABLE_WIN32K, "")

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

    def test_32(self):
        # [D=T] Enrolled Control [A#5T] -> Restart [A#6T] -> Enrolled Control-C -> On [A S...

        if self.default_is is not True:
            return
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

    def test_33(self):
        # [D=T] Enrolled Control [A#5T] -> Restart [A#6T] -> Off [A S=DisabledByUserPref S...

        if self.default_is is not True:
            return
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.marionette.set_pref(Prefs.WIN32K, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.DISQUALIFIED,
        )

    def test_34(self):
        # [D=T] Enrolled Control [A#5T] -> Restart [A#6T] -> Enrolled Control-C -> Bad Req...

        if self.default_is is not True:
            return
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.marionette.set_pref(Prefs.WEBGL, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.MissingRemoteWebGL,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.MissingRemoteWebGL,
            sessionStatus=ContentWin32kLockdownState.MissingRemoteWebGL,
            experimentStatus=ExperimentStatus.DISQUALIFIED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.DISQUALIFIED,
        )

    def test_35(self):
        # [D=T] Enrolled Control [A#5T] -> Restart [A#6T] -> Enrolled Control-C -> E10S [A...

        if self.default_is is not True:
            return
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.restart(env={ENV_DISABLE_E10S: "1"})
        self.set_env(ENV_DISABLE_E10S, "null")

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByE10S,
            sessionStatus=ContentWin32kLockdownState.DisabledByE10S,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

    def test_36(self):
        # [D=T] Enrolled Control [A#5T] -> Restart [A#6T] -> Enrolled Control-C -> Header-...

        if self.default_is is not True:
            return
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByDefault,
            sessionStatus=ContentWin32kLockdownState.EnabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.restart(env={ENV_DISABLE_WIN32K: "1"})

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByEnvVar,
            sessionStatus=ContentWin32kLockdownState.DisabledByEnvVar,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

        self.set_env(ENV_DISABLE_WIN32K, "")

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_CONTROL)

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByControlGroup,
            sessionStatus=ContentWin32kLockdownState.DisabledByControlGroup,
            experimentStatus=ExperimentStatus.ENROLLED_CONTROL,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_CONTROL,
        )

    def test_37(self):
        # [D=F] Enrolled Treatment [A#7] -> Restart [A#8] -> Enrolled Treatment-C -> On [A...

        if self.default_is is not False:
            return
        self.set_enrollment_status(ExperimentStatus.ENROLLED_TREATMENT)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_TREATMENT,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            sessionStatus=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            experimentStatus=ExperimentStatus.ENROLLED_TREATMENT,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_TREATMENT,
        )

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_TREATMENT)

        self.marionette.set_pref(Prefs.WIN32K, True)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            experimentStatus=ExperimentStatus.ENROLLED_TREATMENT,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.DISQUALIFIED,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByUserPref,
            sessionStatus=ContentWin32kLockdownState.EnabledByUserPref,
            experimentStatus=ExperimentStatus.DISQUALIFIED,
            pref=True,
            enrollmentStatusPref=ExperimentStatus.DISQUALIFIED,
        )

    def test_38(self):
        # [D=F] Enrolled Treatment [A#7] -> Restart [A#8] -> Enrolled Treatment-C -> Off [...

        if self.default_is is not False:
            return
        self.set_enrollment_status(ExperimentStatus.ENROLLED_TREATMENT)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.DisabledByDefault,
            sessionStatus=ContentWin32kLockdownState.DisabledByDefault,
            experimentStatus=ExperimentStatus.UNENROLLED,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_TREATMENT,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            sessionStatus=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            experimentStatus=ExperimentStatus.ENROLLED_TREATMENT,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_TREATMENT,
        )

        # Re-set enrollment pref, like Normandy would do
        self.set_enrollment_status(ExperimentStatus.ENROLLED_TREATMENT)

        self.marionette.set_pref(Prefs.WIN32K, False)

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            sessionStatus=ContentWin32kLockdownState.EnabledByTreatmentGroup,
            experimentStatus=ExperimentStatus.ENROLLED_TREATMENT,
            pref=False,
            enrollmentStatusPref=ExperimentStatus.ENROLLED_TREATMENT,
        )

        self.restart()

        self.check_win32k_status(
            status=ContentWin32kLockdownState.EnabledByTreatmentGroup,
--> --------------------

--> maximum size reached

--> --------------------

Messung V0.5
C=96 H=97 G=96

¤ Dauer der Verarbeitung: 0.9 Sekunden  (vorverarbeitet)  ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....
    

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge