diff --git a/DuckDuckGo.xcodeproj/project.pbxproj b/DuckDuckGo.xcodeproj/project.pbxproj
index a97d747dd3..a817ecdd4a 100644
--- a/DuckDuckGo.xcodeproj/project.pbxproj
+++ b/DuckDuckGo.xcodeproj/project.pbxproj
@@ -3320,6 +3320,7 @@
 		EE339228291BDEFD009F62C1 /* JSAlertController.swift in Sources */ = {isa = PBXBuildFile; fileRef = EE339227291BDEFD009F62C1 /* JSAlertController.swift */; };
 		EE3424602BA0853900173B1B /* VPNUninstaller.swift in Sources */ = {isa = PBXBuildFile; fileRef = EE34245D2BA0853900173B1B /* VPNUninstaller.swift */; };
 		EE3424612BA0853900173B1B /* VPNUninstaller.swift in Sources */ = {isa = PBXBuildFile; fileRef = EE34245D2BA0853900173B1B /* VPNUninstaller.swift */; };
+		EE42CBCC2BC8004700AD411C /* PermissionsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = EE42CBCB2BC8004700AD411C /* PermissionsTests.swift */; };
 		EE54F7B32BBFEA49006218DB /* BookmarksAndFavoritesTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = EE54F7B22BBFEA48006218DB /* BookmarksAndFavoritesTests.swift */; };
 		EE66418C2B9B1981005BCD17 /* NetworkProtectionTokenStore+SubscriptionTokenKeychainStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = EE66418B2B9B1981005BCD17 /* NetworkProtectionTokenStore+SubscriptionTokenKeychainStorage.swift */; };
 		EE66418D2B9B1981005BCD17 /* NetworkProtectionTokenStore+SubscriptionTokenKeychainStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = EE66418B2B9B1981005BCD17 /* NetworkProtectionTokenStore+SubscriptionTokenKeychainStorage.swift */; };
@@ -4813,6 +4814,7 @@
 		EE0429DF2BA31D2F009EB20F /* FindInPageTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = FindInPageTests.swift; sourceTree = "<group>"; };
 		EE339227291BDEFD009F62C1 /* JSAlertController.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSAlertController.swift; sourceTree = "<group>"; };
 		EE34245D2BA0853900173B1B /* VPNUninstaller.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VPNUninstaller.swift; sourceTree = "<group>"; };
+		EE42CBCB2BC8004700AD411C /* PermissionsTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = PermissionsTests.swift; sourceTree = "<group>"; };
 		EE54F7B22BBFEA48006218DB /* BookmarksAndFavoritesTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = BookmarksAndFavoritesTests.swift; sourceTree = "<group>"; };
 		EE66418B2B9B1981005BCD17 /* NetworkProtectionTokenStore+SubscriptionTokenKeychainStorage.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "NetworkProtectionTokenStore+SubscriptionTokenKeychainStorage.swift"; sourceTree = "<group>"; };
 		EE66666E2B56EDE4001D898D /* VPNLocationsHostingViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VPNLocationsHostingViewController.swift; sourceTree = "<group>"; };
@@ -6614,6 +6616,7 @@
 				EE7F74902BB5D76600CD9456 /* BookmarksBarTests.swift */,
 				EE02D41B2BB460A600DBE6B3 /* BrowsingHistoryTests.swift */,
 				EE0429DF2BA31D2F009EB20F /* FindInPageTests.swift */,
+				EE42CBCB2BC8004700AD411C /* PermissionsTests.swift */,
 				EE9D81C22BC57A3700338BE3 /* StateRestorationTests.swift */,
 				7B4CE8E626F02134009134B1 /* TabBarTests.swift */,
 			);
@@ -12363,6 +12366,7 @@
 				EEC7BE2E2BC6C09500F86835 /* AddressBarKeyboardShortcutsTests.swift in Sources */,
 				EE54F7B32BBFEA49006218DB /* BookmarksAndFavoritesTests.swift in Sources */,
 				EE02D4222BB4611A00DBE6B3 /* TestsURLExtension.swift in Sources */,
+				EE42CBCC2BC8004700AD411C /* PermissionsTests.swift in Sources */,
 				7B4CE8E726F02135009134B1 /* TabBarTests.swift in Sources */,
 				EEBCE6832BA463DD00B9DF00 /* NSImageExtensions.swift in Sources */,
 				EEBCE6822BA444FA00B9DF00 /* XCUIElementExtension.swift in Sources */,
diff --git a/DuckDuckGo/NavigationBar/View/AddressBarButtonsViewController.swift b/DuckDuckGo/NavigationBar/View/AddressBarButtonsViewController.swift
index e17e162d79..b6cf9fd9f0 100644
--- a/DuckDuckGo/NavigationBar/View/AddressBarButtonsViewController.swift
+++ b/DuckDuckGo/NavigationBar/View/AddressBarButtonsViewController.swift
@@ -49,6 +49,7 @@ final class AddressBarButtonsViewController: NSViewController {
         return permissionAuthorizationPopover ?? {
             let popover = PermissionAuthorizationPopover()
             self.permissionAuthorizationPopover = popover
+            popover.setAccessibilityIdentifier("AddressBarButtonsViewController.permissionAuthorizationPopover")
             return popover
         }()
     }
diff --git a/DuckDuckGo/NavigationBar/View/NavigationBar.storyboard b/DuckDuckGo/NavigationBar/View/NavigationBar.storyboard
index 357dbe0d25..a656539f29 100644
--- a/DuckDuckGo/NavigationBar/View/NavigationBar.storyboard
+++ b/DuckDuckGo/NavigationBar/View/NavigationBar.storyboard
@@ -724,6 +724,7 @@
                                                     <userDefinedRuntimeAttribute type="image" keyPath="disabledImage" value="Geolocation-Icon"/>
                                                     <userDefinedRuntimeAttribute type="image" keyPath="mutedImage" value="Geolocation-Icon"/>
                                                 </userDefinedRuntimeAttributes>
+                                                <accessibility identifier="NavigationBarViewController.geolocationPermissionButton"/>
                                             </button>
                                             <button verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="uao-nC-0co" userLabel="Microphone Button" customClass="PermissionButton" customModule="DuckDuckGo_Privacy_Browser" customModuleProvider="target">
                                                 <rect key="frame" x="32" y="0.0" width="32" height="32"/>
@@ -747,6 +748,7 @@
                                                     <userDefinedRuntimeAttribute type="image" keyPath="disabledImage" value="Microphone-Icon"/>
                                                     <userDefinedRuntimeAttribute type="image" keyPath="mutedImage" value="Microphone-Icon"/>
                                                 </userDefinedRuntimeAttributes>
+                                                <accessibility identifier="NavigationBarViewController.microphonePermissionButton"/>
                                             </button>
                                             <button verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="C2L-f9-L3r" userLabel="Camera Button" customClass="PermissionButton" customModule="DuckDuckGo_Privacy_Browser" customModuleProvider="target">
                                                 <rect key="frame" x="64" y="0.0" width="32" height="32"/>
@@ -770,6 +772,7 @@
                                                     <userDefinedRuntimeAttribute type="image" keyPath="disabledImage" value="Camera-Tab-Blocked"/>
                                                     <userDefinedRuntimeAttribute type="image" keyPath="mutedImage" value="Camera-Icon"/>
                                                 </userDefinedRuntimeAttributes>
+                                                <accessibility identifier="NavigationBarViewController.cameraPermissionButton"/>
                                             </button>
                                             <button verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="qqY-h9-UQ7" userLabel="Popups Button" customClass="PermissionButton" customModule="DuckDuckGo_Privacy_Browser" customModuleProvider="target">
                                                 <rect key="frame" x="96" y="0.0" width="32" height="32"/>
@@ -789,6 +792,7 @@
                                                         <color key="value" name="ButtonMouseDownColor"/>
                                                     </userDefinedRuntimeAttribute>
                                                 </userDefinedRuntimeAttributes>
+                                                <accessibility identifier="NavigationBarViewController.popupsPermissionButton"/>
                                             </button>
                                             <button verticalHuggingPriority="750" translatesAutoresizingMaskIntoConstraints="NO" id="gGA-Yv-pnz" userLabel="External Scheme Button" customClass="PermissionButton" customModule="DuckDuckGo_Privacy_Browser" customModuleProvider="target">
                                                 <rect key="frame" x="128" y="0.0" width="32" height="32"/>
diff --git a/DuckDuckGo/Permissions/View/PermissionAuthorizationViewController.swift b/DuckDuckGo/Permissions/View/PermissionAuthorizationViewController.swift
index 5d8221c0e3..aeef6142a5 100644
--- a/DuckDuckGo/Permissions/View/PermissionAuthorizationViewController.swift
+++ b/DuckDuckGo/Permissions/View/PermissionAuthorizationViewController.swift
@@ -83,6 +83,7 @@ final class PermissionAuthorizationViewController: NSViewController {
         } else {
             denyButton.title = UserText.permissionPopoverDenyButton
         }
+        denyButton.setAccessibilityIdentifier("PermissionAuthorizationViewController.denyButton")
     }
 
     private func updateText() {
@@ -116,6 +117,7 @@ final class PermissionAuthorizationViewController: NSViewController {
         buttonsBottomConstraint.isActive = !learnMoreBottomConstraint.isActive
         linkButton.title = UserText.permissionPopupLearnMoreLink
         allowButton.title = UserText.permissionPopupAllowButton
+        allowButton.setAccessibilityIdentifier("PermissionAuthorizationViewController.allowButton")
     }
 
     @IBAction func alwaysAllowLabelClick(_ sender: Any) {
diff --git a/DuckDuckGo/Permissions/View/PermissionButton.swift b/DuckDuckGo/Permissions/View/PermissionButton.swift
index 87e665adb5..dbfae82eac 100644
--- a/DuckDuckGo/Permissions/View/PermissionButton.swift
+++ b/DuckDuckGo/Permissions/View/PermissionButton.swift
@@ -40,18 +40,23 @@ final class PermissionButton: AddressBarButton {
             case .active:
                 self.image = activeImage ?? defaultImage
                 self.normalTintColor = activeTintColor
+                self.setAccessibilityValue("active")
             case .paused:
                 self.image = mutedImage ?? defaultImage
                 self.normalTintColor = mutedTintColor
+                self.setAccessibilityValue("paused")
             case .disabled, .denied, .revoking:
                 self.image = disabledImage ?? defaultImage
                 self.normalTintColor = disabledTintColor
+                self.setAccessibilityValue("disabled-denied-revoking")
             case .requested:
                 self.image = defaultImage
                 self.normalTintColor = defaultTint
+                self.setAccessibilityValue("requested")
             case .inactive:
                 self.image = inactiveImage ?? defaultImage
                 self.normalTintColor = inactiveTintColor ?? defaultTint
+                self.setAccessibilityValue("inactive")
             }
             self.isHidden = isHidden
         }
diff --git a/DuckDuckGo/Permissions/View/PermissionContextMenu.swift b/DuckDuckGo/Permissions/View/PermissionContextMenu.swift
index e207d95d01..308e5c3cc2 100644
--- a/DuckDuckGo/Permissions/View/PermissionContextMenu.swift
+++ b/DuckDuckGo/Permissions/View/PermissionContextMenu.swift
@@ -57,6 +57,7 @@ final class PermissionContextMenu: NSMenu {
         setupOtherPermissionMenuItems(for: remainingPermission)
         setupPopupsPermissionsMenuItems()
         addPersistenceItems()
+        self.setAccessibilityIdentifier("PermissionContextMenu")
     }
 
     private func setupCameraPermissionsMenuItems(_ permissions: Permissions) -> Permissions {
@@ -279,6 +280,8 @@ private extension NSMenuItem {
         if isChecked {
             item.state = .on
         }
+        item.setAccessibilityIdentifier("PermissionContextMenu.alwaysAllow")
+        item.setAccessibilityValue(item.state == .on ? "selected" : "unselected")
         return item
     }
 
@@ -299,6 +302,8 @@ private extension NSMenuItem {
         if isChecked {
             item.state = .on
         }
+        item.setAccessibilityIdentifier("PermissionContextMenu.alwaysAsk")
+        item.setAccessibilityValue(item.state == .on ? "selected" : "unselected")
         return item
     }
 
@@ -312,6 +317,8 @@ private extension NSMenuItem {
         if isChecked {
             item.state = .on
         }
+        item.setAccessibilityIdentifier("PermissionContextMenu.alwaysDeny")
+        item.setAccessibilityValue(item.state == .on ? "selected" : "unselected")
         return item
     }
 
@@ -325,7 +332,10 @@ private extension NSMenuItem {
                            permission.localizedDescription,
                            Bundle.main.displayName ?? "DuckDuckGo")
         }
-        return NSMenuItem(title: title, action: nil, keyEquivalent: "")
+        let item = NSMenuItem(title: title, action: nil, keyEquivalent: "")
+        item.setAccessibilityIdentifier("PermissionContextMenu.permissionDisabled")
+        item.setAccessibilityValue(item.state == .on ? "selected" : "unselected")
+        return item
     }
 
     static func openSystemPreferences(for permission: PermissionType, target: PermissionContextMenu) -> NSMenuItem {
diff --git a/UITests/AddressBarKeyboardShortcutsTests.swift b/UITests/AddressBarKeyboardShortcutsTests.swift
index 675b4f63b3..bf97489e5d 100644
--- a/UITests/AddressBarKeyboardShortcutsTests.swift
+++ b/UITests/AddressBarKeyboardShortcutsTests.swift
@@ -25,6 +25,7 @@ class AddressBarKeyboardShortcutsTests: XCTestCase {
 
     private var addressBarTextField: XCUIElement!
     override class func setUp() {
+        UITests.firstRun()
         UITests.setAutocompleteToggleBeforeTestcaseRuns(false) // We don't want changes in the address bar that we don't create
     }
 
diff --git a/UITests/AutocompleteTests.swift b/UITests/AutocompleteTests.swift
index cea246ca33..94bb74b822 100644
--- a/UITests/AutocompleteTests.swift
+++ b/UITests/AutocompleteTests.swift
@@ -32,6 +32,7 @@ class AutocompleteTests: XCTestCase {
     private var siteTitleForHistorySite: String!
 
     override class func setUp() {
+        UITests.firstRun()
         UITests.setAutocompleteToggleBeforeTestcaseRuns(true) // These tests require autocomplete to be on
     }
 
diff --git a/UITests/BookmarksAndFavoritesTests.swift b/UITests/BookmarksAndFavoritesTests.swift
index bf06b4aac6..7c9bb93673 100644
--- a/UITests/BookmarksAndFavoritesTests.swift
+++ b/UITests/BookmarksAndFavoritesTests.swift
@@ -54,6 +54,10 @@ class BookmarksAndFavoritesTests: XCTestCase {
     private var showBookmarksBarPopup: XCUIElement!
     private var showFavoritesPreferenceToggle: XCUIElement!
 
+    override class func setUp() {
+        UITests.firstRun()
+    }
+
     override func setUpWithError() throws {
         continueAfterFailure = false
         app = XCUIApplication()
@@ -595,7 +599,8 @@ class BookmarksAndFavoritesTests: XCTestCase {
 //        This test uses coordinates (instead of accessibility IDs) to address the elements of the right click. As the writer of this test, I see this
 //        as a fragile test hook. However, I think it is preferable to making changes to the UI element it tests for this test alone. The reason is
 //        that the bookmark item on the bookmark bar isn't yet an accessibility-enabled UI element and doesn't appear to have a natural anchor point
-//        from which we can set its accessibility values without redesigning it. However, redesigning a road-tested UI element for a single test isn't a
+//        from which we can set its accessibility values without redesigning it. However, redesigning a road-tested UI element for a single test isn't
+//        a
 //        good idea, since the road-testing is also (valuable) testing and we don't want a single test to be the driver of a possible behavioral
 //        change in existing interface.
 //
diff --git a/UITests/BookmarksBarTests.swift b/UITests/BookmarksBarTests.swift
index eacea0c9aa..2d233cdfbd 100644
--- a/UITests/BookmarksBarTests.swift
+++ b/UITests/BookmarksBarTests.swift
@@ -35,6 +35,10 @@ class BookmarksBarTests: XCTestCase {
     private var addressBarTextField: XCUIElement!
     private let titleStringLength = 12
 
+    override class func setUp() {
+        UITests.firstRun()
+    }
+
     override func setUpWithError() throws {
         continueAfterFailure = false
         app = XCUIApplication()
diff --git a/UITests/BrowsingHistoryTests.swift b/UITests/BrowsingHistoryTests.swift
index 2218bd9d32..ac26e4ca7a 100644
--- a/UITests/BrowsingHistoryTests.swift
+++ b/UITests/BrowsingHistoryTests.swift
@@ -27,6 +27,10 @@ class BrowsingHistoryTests: XCTestCase {
     private var addressBarTextField: XCUIElement!
     private let lengthForRandomPageTitle = 8
 
+    override class func setUp() {
+        UITests.firstRun()
+    }
+
     override func setUpWithError() throws {
         continueAfterFailure = false
         app = XCUIApplication()
diff --git a/UITests/Common/UITests.swift b/UITests/Common/UITests.swift
index 4bd7581e32..10ebf5046d 100644
--- a/UITests/Common/UITests.swift
+++ b/UITests/Common/UITests.swift
@@ -88,4 +88,17 @@ enum UITests {
         openVanillaBrowser.clickAfterExistenceTestSucceeds()
         app.typeKey("w", modifierFlags: [.command, .option])
     }
+
+    /// Avoid some first-run states that we aren't testing.
+    static func firstRun() {
+        let notificationCenter = XCUIApplication(bundleIdentifier: "com.apple.UserNotificationCenter")
+        if notificationCenter.exists { // If tests-server is asking for network permissions, deny them.
+            notificationCenter.typeKey(.escape, modifierFlags: [])
+        }
+        let app = XCUIApplication()
+        app.launch()
+        app.typeKey("n", modifierFlags: .command)
+        app.typeKey("w", modifierFlags: [.command, .option])
+        app.terminate()
+    }
 }
diff --git a/UITests/Common/XCUIElementExtension.swift b/UITests/Common/XCUIElementExtension.swift
index 1e0d0ba991..e799a94b37 100644
--- a/UITests/Common/XCUIElementExtension.swift
+++ b/UITests/Common/XCUIElementExtension.swift
@@ -63,6 +63,20 @@ extension XCUIElement {
         }
     }
 
+    /// Check for the existence of the address bar and type a URL into it if it passes. Although it doesn't really make sense to restrict its usage to
+    /// the address bar, it is only foreseen and recommended for use with the address bar.
+    /// - Parameters:
+    ///   - url: The URL to be typed into the address bar (or other element, for which use with this function should be seen as experimental)
+    ///   - pressingEnter: If the `enter` key should not be pressed after typing this URL in, set this optional parameter to `false`, otherwise it
+    /// will be pressed.
+    func typeURLAfterExistenceTestSucceeds(_ url: URL, pressingEnter: Bool = true) {
+        XCTAssertTrue(
+            self.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "The element \(self.debugDescription) didn't load with the expected title in a reasonable timeframe."
+        )
+        self.typeURL(url, pressingEnter: pressingEnter)
+    }
+
     func clickAfterExistenceTestSucceeds() {
         XCTAssertTrue(
             self.waitForExistence(timeout: UITests.Timeouts.elementExistence),
diff --git a/UITests/FindInPageTests.swift b/UITests/FindInPageTests.swift
index bb8f124f10..0f8de44641 100644
--- a/UITests/FindInPageTests.swift
+++ b/UITests/FindInPageTests.swift
@@ -26,6 +26,7 @@ class FindInPageTests: XCTestCase {
     private let minimumExpectedMatchingPixelsInFindHighlight = 150
 
     override class func setUp() {
+        UITests.firstRun()
         saveLocalHTML()
     }
 
@@ -99,8 +100,7 @@ class FindInPageTests: XCTestCase {
             "Local \"Lorem Ipsum\" web page didn't load with the expected title in a reasonable timeframe. If this is unexpected, it can also be due to the timeout being too short."
         )
         let optionsButton = app.windows.buttons["NavigationBarViewController.optionsButton"]
-        XCTAssertTrue(optionsButton.waitForExistence(timeout: UITests.Timeouts.elementExistence), "Couldn't find options item in a reasonable timeframe.")
-        optionsButton.click()
+        optionsButton.clickAfterExistenceTestSucceeds()
 
         let findInPageMoreOptionsMenuItem = app.menuItems["MoreOptionsMenu.findInPage"]
         XCTAssertTrue(
@@ -246,7 +246,7 @@ class FindInPageTests: XCTestCase {
         XCTAssertEqual(statusFieldTextContent, "1 of 4", "Unexpected status field text content after a \"Find in Page\" operation.")
 
         let webViewWithSelectedWordsScreenshot = loremIpsumWebView.screenshot()
-        let highlightedPixelsInScreenshot = webViewWithSelectedWordsScreenshot.image.matchingPixels(of: .findHighlightColor)
+        let highlightedPixelsInScreenshot = try XCTUnwrap(webViewWithSelectedWordsScreenshot.image.matchingPixels(of: .findHighlightColor))
         XCTAssertGreaterThan(
             highlightedPixelsInScreenshot.count,
             minimumExpectedMatchingPixelsInFindHighlight,
@@ -279,7 +279,7 @@ class FindInPageTests: XCTestCase {
         // Note: the following is not a localized test element, but it should have a localization strategy.
         XCTAssertEqual(statusFieldTextContent, "1 of 4", "Unexpected status field text content after a \"Find in Page\" operation.")
         let findInPageScreenshot = loremIpsumWebView.screenshot()
-        let highlightedPixelsInFindScreenshot = findInPageScreenshot.image.matchingPixels(of: .findHighlightColor)
+        let highlightedPixelsInFindScreenshot = try XCTUnwrap(findInPageScreenshot.image.matchingPixels(of: .findHighlightColor))
         let findHighlightPoints = Set(highlightedPixelsInFindScreenshot.map { $0.point }) // Coordinates of highlighted pixels in the find screenshot
 
         let findNextMenuBarItem = app.menuItems["MainMenu.findNext"]
@@ -296,8 +296,9 @@ class FindInPageTests: XCTestCase {
         )
         XCTAssertEqual(updatedStatusFieldTextContent, "2 of 4", "Unexpected status field text content after a \"Find Next\" operation.")
         let findNextScreenshot = loremIpsumWebView.screenshot()
-        let highlightedPixelsInFindNextScreenshot = Set(findNextScreenshot.image
-            .matchingPixels(of: .findHighlightColor)) // Coordinates of highlighted pixels in the find next screenshot
+        let highlightedPixelsInFindNextScreenshot =
+            try XCTUnwrap(Set(findNextScreenshot.image
+                    .matchingPixels(of: .findHighlightColor))) // Coordinates of highlighted pixels in the find next screenshot
         let findNextHighlightPoints = highlightedPixelsInFindNextScreenshot.map { $0.point }
         let pixelSetIntersection = findHighlightPoints
             .intersection(findNextHighlightPoints) // If the highlighted text has moved as expected, this should not have many elements
@@ -338,7 +339,7 @@ class FindInPageTests: XCTestCase {
         // Note: the following is not a localized test element, but it should have a localization strategy.
         XCTAssertEqual(statusFieldTextContent, "1 of 4", "Unexpected status field text content after a \"Find in Page\" operation.")
         let findInPageScreenshot = loremIpsumWebView.screenshot()
-        let highlightedPixelsInFindScreenshot = findInPageScreenshot.image.matchingPixels(of: .findHighlightColor)
+        let highlightedPixelsInFindScreenshot = try XCTUnwrap(findInPageScreenshot.image.matchingPixels(of: .findHighlightColor))
         let findHighlightPoints = Set(highlightedPixelsInFindScreenshot.map { $0.point }) // Coordinates of highlighted pixels in the find screenshot
         let findInPageNextButton = app.windows.buttons["FindInPageController.nextButton"]
         XCTAssertTrue(
@@ -355,7 +356,7 @@ class FindInPageTests: XCTestCase {
         )
         XCTAssertEqual(updatedStatusFieldTextContent, "2 of 4", "Unexpected status field text content after a \"Find Next\" operation.")
         let findNextScreenshot = loremIpsumWebView.screenshot()
-        let highlightedPixelsInFindNextScreenshot = findNextScreenshot.image.matchingPixels(of: .findHighlightColor)
+        let highlightedPixelsInFindNextScreenshot = try XCTUnwrap(findNextScreenshot.image.matchingPixels(of: .findHighlightColor))
         let findNextHighlightPoints = highlightedPixelsInFindNextScreenshot.map { $0.point }
         let pixelSetIntersection = findHighlightPoints
             .intersection(findNextHighlightPoints) // If the highlighted text has moved as expected, this should not have many elements
@@ -397,7 +398,7 @@ class FindInPageTests: XCTestCase {
         // Note: the following is not a localized test element, but it should have a localization strategy.
         XCTAssertEqual(statusFieldTextContent, "1 of 4", "Unexpected status field text content after a \"Find in Page\" operation.")
         let findInPageScreenshot = loremIpsumWebView.screenshot()
-        let highlightedPixelsInFindScreenshot = findInPageScreenshot.image.matchingPixels(of: .findHighlightColor)
+        let highlightedPixelsInFindScreenshot = try XCTUnwrap(findInPageScreenshot.image.matchingPixels(of: .findHighlightColor))
         let findHighlightPoints = Set(highlightedPixelsInFindScreenshot.map { $0.point }) // Coordinates of highlighted pixels in the find screenshot
         app.typeKey("g", modifierFlags: [.command])
         let updatedStatusField = app.textFields["FindInPageController.statusField"]
@@ -409,7 +410,7 @@ class FindInPageTests: XCTestCase {
 
         XCTAssertEqual(updatedStatusFieldTextContent, "2 of 4", "Unexpected status field text content after a \"Find Next\" operation.")
         let findNextScreenshot = loremIpsumWebView.screenshot()
-        let highlightedPixelsInFindNextScreenshot = findNextScreenshot.image.matchingPixels(of: .findHighlightColor)
+        let highlightedPixelsInFindNextScreenshot = try XCTUnwrap(findNextScreenshot.image.matchingPixels(of: .findHighlightColor))
         let findNextHighlightPoints = highlightedPixelsInFindNextScreenshot.map { $0.point }
         let pixelSetIntersection = findHighlightPoints
             .intersection(findNextHighlightPoints) // If the highlighted text has moved as expected, this should not have many elements
@@ -488,21 +489,19 @@ private extension NSImage {
     /// Find matching pixels in an NSImage for a specific NSColor
     /// - Parameter colorToMatch: the NSColor to match
     /// - Returns: An array of Pixel structs
-    func matchingPixels(of colorToMatch: NSColor) -> [Pixel] {
-        let cgImage = cgImage(forProposedRect: nil, context: nil, hints: nil)
-        XCTAssertNotNil(cgImage, "It wasn't possible to obtain the CGImage of the NSImage.")
-        let bitmap = NSBitmapImageRep(cgImage: cgImage!)
+    func matchingPixels(of colorToMatch: NSColor) throws -> [Pixel] {
+        let cgImage = try XCTUnwrap(
+            cgImage(forProposedRect: nil, context: nil, hints: nil),
+            "It wasn't possible to obtain the CGImage of the NSImage."
+        )
+        let bitmap = NSBitmapImageRep(cgImage: cgImage)
         let colorSpace = bitmap.colorSpace
-
-        XCTAssertNotNil(
+        let colorToMatchWithColorSpace = try XCTUnwrap(
             colorToMatch.usingColorSpace(colorSpace),
             "It wasn't possible to get the color to match in the local colorspace."
-        )
-        let colorToMatchWithColorSpace = colorToMatch
-            .usingColorSpace(colorSpace)! // Compare the color we want to look for in the image after it is in the same colorspace as the image
+        ) // Compare the color we want to look for in the image after it is in the same colorspace as the image
 
-        XCTAssertNotNil(bitmap.bitmapData, "It wasn't possible to obtain the bitmapData of the bitmap.")
-        var bitmapData: UnsafeMutablePointer<UInt8> = bitmap.bitmapData!
+        var bitmapData: UnsafeMutablePointer<UInt8> = try XCTUnwrap(bitmap.bitmapData, "It wasn't possible to obtain the bitmapData of the bitmap.")
         var redInImage, greenInImage, blueInImage, alphaInImage: UInt8
 
         let redToMatch = UInt8(colorToMatchWithColorSpace.redComponent * 255.999999) // color components in 0-255 values in this colorspace
diff --git a/UITests/PermissionsTests.swift b/UITests/PermissionsTests.swift
new file mode 100644
index 0000000000..86a82b06f5
--- /dev/null
+++ b/UITests/PermissionsTests.swift
@@ -0,0 +1,595 @@
+//
+//  PermissionsTests.swift
+//
+//  Copyright © 2024 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import XCTest
+
+/// We are apparently in the part of the `XCUIAutomation` life cycle right now in which interruption management using `addUIInterruptionMonitor`
+/// doesn't fire due to an acknowledged bug (https://forums.developer.apple.com/forums/thread/737880), so we can't test these the best way, which is
+/// to create an interruption handler and wait for TCC requests to respond to (https://eclecticlight.co/2023/02/10/privacy-what-tcc-does-and-doesnt/).
+/// Realistically, the best approach (in terms of robust test design) may never be a good fit for these tests, because it is always a possibility that
+/// one of the targeted macOS versions is manifesting this every-few-systems bug. Therefore, these tests simply wait for the relevant
+/// privacy request to click on directly, via a combination of bundle ID targeting and button targeting by number. That means that adjustments could
+/// be needed in the future, in case of significant changes in this system-level interface in future macOS versions (but Apple tries not to change
+/// that too frequently) or its backend (for instance, if the bundle ID for the user notification center changes). Here is a link to how to do this
+/// the best way, in the event that a future macOS version stops supporting this approach, but also solves the bug with `addUIInterruptionMonitor`,
+/// and you want to branch the implementations per macOS version:
+/// https://stackoverflow.com/questions/56559269/adduiinterruptionmonitor-is-not-getting-called-on-macos
+class PermissionsTests: XCTestCase {
+    private var app: XCUIApplication!
+    private var notificationCenter: XCUIApplication!
+    private var addressBarTextField: XCUIElement!
+    private var permissionsSiteURL: URL!
+    private var historyMenuBarItem: XCUIElement!
+    private var clearAllHistoryMenuItem: XCUIElement!
+    private var clearAllHistoryAlertClearButton: XCUIElement!
+    private var fakeFireButton: XCUIElement!
+    override class func setUp() {
+        UITests.firstRun()
+    }
+
+    override func setUpWithError() throws {
+        continueAfterFailure = false
+        app = XCUIApplication()
+        app.launchEnvironment["UITEST_MODE"] = "1"
+
+        permissionsSiteURL = try XCTUnwrap(URL(string: "https://permission.site"), "It wasn't possible to unwrap a URL that the tests depend on.")
+        notificationCenter = XCUIApplication(bundleIdentifier: "com.apple.UserNotificationCenter")
+        addressBarTextField = app.windows.textFields["AddressBarViewController.addressBarTextField"]
+        historyMenuBarItem = app.menuBarItems["History"]
+        clearAllHistoryMenuItem = app.menuItems["HistoryMenu.clearAllHistory"]
+        clearAllHistoryAlertClearButton = app.buttons["ClearAllHistoryAndDataAlert.clearButton"]
+        fakeFireButton = app.buttons["FireViewController.fakeFireButton"]
+
+        app.resetAuthorizationStatus(for: .camera) // These resets work much better before launch.
+        app.resetAuthorizationStatus(for: .microphone)
+
+        app.launch()
+        app.activate()
+        historyMenuBarItem.clickAfterExistenceTestSucceeds()
+        clearAllHistoryMenuItem.clickAfterExistenceTestSucceeds()
+        clearAllHistoryAlertClearButton.clickAfterExistenceTestSucceeds() // Manually remove the history
+        XCTAssertTrue( // Let any ongoing fire animation or data processes complete
+            fakeFireButton.waitForNonExistence(timeout: UITests.Timeouts.fireAnimation),
+            "Fire animation didn't finish and cease existing in a reasonable timeframe."
+        )
+
+        app.typeKey("w", modifierFlags: [.command, .option, .shift]) // Enforce a single window
+        app.typeKey("n", modifierFlags: .command)
+        XCTAssertTrue(
+            addressBarTextField.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "The address bar text field didn't become available in a reasonable timeframe before starting the test."
+        )
+    }
+
+    func test_cameraPermissions_withAcceptedTCCChallenge_showCorrectStateInBrowser() throws {
+        addressBarTextField.typeURLAfterExistenceTestSucceeds(permissionsSiteURL)
+
+        let cameraButton = app.webViews.buttons["Camera"]
+        cameraButton.clickAfterExistenceTestSucceeds()
+        XCTAssert(
+            notificationCenter.buttons.firstMatch.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "The notification center didn't appear. This can happen because the TCC setting at the start of the test wasn't correct – check the app.resetPermissions behavior."
+        )
+        let allowButtonIndex = try XCTUnwrap(notificationCenter.indexOfSystemModelDialogButtonOnElement(
+            titled: "Allow",
+            "OK"
+        )) // You can add any titles you see this permission dialog using on any tested macOS versions, because it is evaluated by a variadic
+        // function.
+        let allowButton = notificationCenter.buttons.element(boundBy: allowButtonIndex)
+        allowButton.clickAfterExistenceTestSucceeds() // Click system camera permissions dialog
+        let permissionsPopoverAllowButton = app.popovers.buttons["PermissionAuthorizationViewController.allowButton"]
+        permissionsPopoverAllowButton.clickAfterExistenceTestSucceeds()
+        var websitePermissionsColorIsGreen = false
+        for _ in 1 ... 4 { // permission.site updates this color a bit slowly and we have no control over it, so we try a few times.
+            websitePermissionsColorIsGreen = try websitePermissionsButtonIsExpectedColor(cameraButton, is: .green)
+            if websitePermissionsColorIsGreen {
+                break
+            }
+            usleep(500_000)
+        }
+        XCTAssertTrue(
+            websitePermissionsColorIsGreen,
+            "After a few attempts to wait for permissions.site to update their button animation after the TCC dialog, their button has to be green."
+        )
+
+        let navigationBarViewControllerPermissionButton = app.buttons["NavigationBarViewController.cameraPermissionButton"]
+        navigationBarViewControllerPermissionButton.clickAfterExistenceTestSucceeds()
+
+        let permissionContextMenuAlwaysAsk = app.menuItems["PermissionContextMenu.alwaysAsk"]
+        XCTAssertTrue(
+            permissionContextMenuAlwaysAsk.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "permissionContextMenuAlwaysAsk didn't exist in a reasonable timeframe."
+        )
+        let permissionContextMenuAlwaysAskValue = try XCTUnwrap(permissionContextMenuAlwaysAsk.value as? String)
+        XCTAssertEqual(
+            permissionContextMenuAlwaysAskValue,
+            "selected",
+            "The \"always ask\" menu item of the permission context menu has to be the selected item."
+        )
+    }
+
+    func test_cameraPermissions_withDeniedTCCChallenge_showCorrectStateInBrowser() throws {
+        addressBarTextField.typeURLAfterExistenceTestSucceeds(permissionsSiteURL)
+
+        let cameraButton = app.webViews.buttons["Camera"]
+        cameraButton.clickAfterExistenceTestSucceeds()
+        XCTAssert(
+            notificationCenter.buttons.firstMatch.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "The notification center didn't appear. This can happen because the TCC setting at the start of the test wasn't correct – check the app.resetPermissions behavior."
+        )
+        let denyButtonIndex = try XCTUnwrap(notificationCenter.indexOfSystemModelDialogButtonOnElement(
+            titled: "Deny", "No", "Cancel", "Don’t Allow", "Don't Allow"
+        )) // You can add any titles you see this permission dialog using on any tested macOS versions, because it is evaluated by a variadic
+        // function.
+        let denyButton = notificationCenter.buttons.element(boundBy: denyButtonIndex)
+        denyButton.clickAfterExistenceTestSucceeds() // Click system camera permissions dialog
+        let permissionsPopoverAllowButton = app.popovers.buttons["PermissionAuthorizationViewController.allowButton"]
+
+        XCTAssertTrue( // Prove that the browser's permission popover does not appear
+            permissionsPopoverAllowButton.waitForNonExistence(timeout: UITests.Timeouts.elementExistence),
+            "The permissions popover in the browser should not appear when camera permission has been denied."
+        )
+
+        var websitePermissionsColorIsRed = false
+        for _ in 1 ... 4 {
+            websitePermissionsColorIsRed = try websitePermissionsButtonIsExpectedColor(cameraButton, is: .red)
+            if websitePermissionsColorIsRed {
+                break
+            }
+            usleep(500_000)
+        }
+        XCTAssertTrue(
+            websitePermissionsColorIsRed,
+            "After a few attempts to wait for permissions.site to update their button animation after the TCC dialog, their button has to be red."
+        )
+
+        let navigationBarViewControllerPermissionButton = app.buttons["NavigationBarViewController.cameraPermissionButton"]
+        XCTAssertTrue( // Prove that the browser's permission button does not appear
+            navigationBarViewControllerPermissionButton.waitForNonExistence(timeout: UITests.Timeouts.elementExistence),
+            "The permissions button in the browser should not appear when camera permission has been denied."
+        )
+    }
+
+    func test_cameraPermissions_withAcceptedTCCChallenge_whereAlwaysDenyIsSelected_alwaysDenies() throws {
+        addressBarTextField.typeURLAfterExistenceTestSucceeds(permissionsSiteURL)
+
+        let cameraButton = app.webViews.buttons["Camera"]
+        cameraButton.clickAfterExistenceTestSucceeds()
+        XCTAssert(
+            notificationCenter.buttons.firstMatch.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "The notification center didn't appear. This can happen because the TCC setting at the start of the test wasn't correct – check the app.resetPermissions behavior."
+        )
+        let allowButtonIndex = try XCTUnwrap(notificationCenter.indexOfSystemModelDialogButtonOnElement(
+            titled: "Allow",
+            "OK"
+        )) // You can add any titles you see this permission dialog using on any tested macOS versions, because it is evaluated by a variadic
+        // function.
+        let allowButton = notificationCenter.buttons.element(boundBy: allowButtonIndex)
+        allowButton.clickAfterExistenceTestSucceeds() // Click system camera permissions dialog
+        let permissionsPopoverAllowButton = app.popovers.buttons["PermissionAuthorizationViewController.allowButton"]
+        permissionsPopoverAllowButton.clickAfterExistenceTestSucceeds()
+        var websitePermissionsColorIsGreen = false
+        for _ in 1 ... 4 { // permission.site updates this color a bit slowly and we have no control over it, so we try a few times.
+            websitePermissionsColorIsGreen = try websitePermissionsButtonIsExpectedColor(cameraButton, is: .green)
+            if websitePermissionsColorIsGreen {
+                break
+            }
+            usleep(500_000)
+        }
+        XCTAssertTrue(
+            websitePermissionsColorIsGreen,
+            "After a few attempts to wait for permissions.site to update their button animation after the TCC dialog, their button has to be green."
+        )
+
+        let navigationBarViewControllerPermissionButton = app.buttons["NavigationBarViewController.cameraPermissionButton"]
+        navigationBarViewControllerPermissionButton.clickAfterExistenceTestSucceeds()
+
+        let permissionContextMenuAlwaysAsk = app.menuItems["PermissionContextMenu.alwaysAsk"]
+
+        XCTAssertTrue(
+            permissionContextMenuAlwaysAsk.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "permissionContextMenuAlwaysAsk didn't exist in a reasonable timeframe."
+        )
+        let permissionContextMenuAlwaysAskValue = try XCTUnwrap(permissionContextMenuAlwaysAsk.value as? String)
+        XCTAssertEqual(
+            permissionContextMenuAlwaysAskValue,
+            "selected",
+            "The \"always ask\" menu item of the permission context menu has to be the selected item."
+        )
+        let permissionContextMenuAlwaysDeny = app.menuItems["PermissionContextMenu.alwaysDeny"]
+        permissionContextMenuAlwaysDeny.clickAfterExistenceTestSucceeds()
+        app.typeKey("w", modifierFlags: [.command, .option, .shift]) // Enforce a single window
+        app.typeKey("n", modifierFlags: .command)
+        addressBarTextField.typeURL(permissionsSiteURL)
+        for _ in 1 ... 4 {
+            cameraButton.clickAfterExistenceTestSucceeds()
+        }
+        XCTAssertTrue(
+            try websitePermissionsButtonIsExpectedColor(cameraButton, is: .red),
+            "Even if we click the button for the denied resource many times, when we are on a site where we have set \"always deny\" for the resource, the permission button will remain red"
+        )
+        XCTAssert(
+            notificationCenter.buttons.firstMatch.waitForNonExistence(timeout: UITests.Timeouts.elementExistence),
+            "Even if we click the button for the denied resource many times, when we are on a site where we have set \"always deny\" for the resource, the TCC dialog permission alert will not be on the screen"
+        )
+        XCTAssert(
+            permissionsPopoverAllowButton.waitForNonExistence(timeout: UITests.Timeouts.elementExistence),
+            "Even if we click the button for the denied resource many times, when we are on a site where we have set \"always deny\" for the resource, the permission popover will not be on the screen"
+        )
+    }
+
+    func test_microphonePermissions_withAcceptedTCCChallenge_showCorrectStateInBrowser() throws {
+        addressBarTextField.typeURLAfterExistenceTestSucceeds(permissionsSiteURL)
+
+        let microphoneButton = app.webViews.buttons["Microphone"]
+        microphoneButton.clickAfterExistenceTestSucceeds()
+        XCTAssert(
+            notificationCenter.buttons.firstMatch.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "The notification center didn't appear. This can happen because the TCC setting at the start of the test wasn't correct – check the app.resetPermissions behavior."
+        )
+        let allowButtonIndex = try XCTUnwrap(notificationCenter.indexOfSystemModelDialogButtonOnElement(
+            titled: "Allow",
+            "OK"
+        )) // You can add any titles you see this permission dialog using on any tested macOS versions, because it is evaluated by a variadic
+        // function.
+        let allowButton = notificationCenter.buttons.element(boundBy: allowButtonIndex)
+        allowButton.clickAfterExistenceTestSucceeds() // Click system microphone permissions dialog
+        let permissionsPopoverAllowButton = app.popovers.buttons["PermissionAuthorizationViewController.allowButton"]
+        permissionsPopoverAllowButton.clickAfterExistenceTestSucceeds()
+        var websitePermissionsColorIsGreen = false
+        for _ in 1 ... 4 { // permission.site updates this color a bit slowly and we have no control over it, so we try a few times.
+            websitePermissionsColorIsGreen = try websitePermissionsButtonIsExpectedColor(microphoneButton, is: .green)
+            if websitePermissionsColorIsGreen {
+                break
+            }
+            usleep(500_000)
+        }
+        XCTAssertTrue(
+            websitePermissionsColorIsGreen,
+            "After a few attempts to wait for permissions.site to update their button animation after the TCC dialog, their button has to be green."
+        )
+
+        let navigationBarViewControllerPermissionButton = app.buttons["NavigationBarViewController.microphonePermissionButton"]
+        navigationBarViewControllerPermissionButton.clickAfterExistenceTestSucceeds()
+
+        let permissionContextMenuAlwaysAsk = app.menuItems["PermissionContextMenu.alwaysAsk"]
+        XCTAssertTrue(
+            permissionContextMenuAlwaysAsk.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "permissionContextMenuAlwaysAsk didn't exist in a reasonable timeframe."
+        )
+        let permissionContextMenuAlwaysAskValue = try XCTUnwrap(permissionContextMenuAlwaysAsk.value as? String)
+        XCTAssertEqual(
+            permissionContextMenuAlwaysAskValue,
+            "selected",
+            "The \"always ask\" menu item of the permission context menu has to be the selected item."
+        )
+    }
+
+    func test_microphonePermissions_withDeniedTCCChallenge_showCorrectStateInBrowser() throws {
+        addressBarTextField.typeURLAfterExistenceTestSucceeds(permissionsSiteURL)
+
+        let microphoneButton = app.webViews.buttons["Microphone"]
+        microphoneButton.clickAfterExistenceTestSucceeds()
+        XCTAssert(
+            notificationCenter.buttons.firstMatch.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "The notification center didn't appear. This can happen because the TCC setting at the start of the test wasn't correct – check the app.resetPermissions behavior."
+        )
+        let denyButtonIndex = try XCTUnwrap(notificationCenter.indexOfSystemModelDialogButtonOnElement(
+            titled: "Deny", "No", "Cancel", "Don’t Allow", "Don't Allow"
+        )) // You can add any titles you see this permission dialog using on any tested macOS versions, because it is evaluated by a variadic
+        // function.
+        let denyButton = notificationCenter.buttons.element(boundBy: denyButtonIndex)
+        denyButton.clickAfterExistenceTestSucceeds() // Click system microphone permissions dialog
+        let permissionsPopoverAllowButton = app.popovers.buttons["PermissionAuthorizationViewController.allowButton"]
+
+        XCTAssertTrue( // Prove that the browser's permission popover does not appear
+            permissionsPopoverAllowButton.waitForNonExistence(timeout: UITests.Timeouts.elementExistence),
+            "The permissions popover in the browser should not appear when camera permission has been denied."
+        )
+
+        var websitePermissionsColorIsRed = false
+        for _ in 1 ... 4 {
+            websitePermissionsColorIsRed = try websitePermissionsButtonIsExpectedColor(microphoneButton, is: .red)
+            if websitePermissionsColorIsRed {
+                break
+            }
+            usleep(500_000)
+        }
+        XCTAssertTrue(
+            websitePermissionsColorIsRed,
+            "After between one and four attempts to wait for permissions.site to update their button animation after the TCC dialog, their button has to be red."
+        )
+
+        let navigationBarViewControllerPermissionButton = app.buttons["NavigationBarViewController.microphonePermissionButton"]
+        XCTAssertTrue( // Prove that the browser's permission button does not appear
+            navigationBarViewControllerPermissionButton.waitForNonExistence(timeout: UITests.Timeouts.elementExistence),
+            "The permissions button in the browser should not appear when microphone permission has been denied."
+        )
+    }
+
+    func test_microphonePermissions_withAcceptedTCCChallenge_whereAlwaysDenyIsSelected_alwaysDenies() throws {
+        addressBarTextField.typeURLAfterExistenceTestSucceeds(permissionsSiteURL)
+
+        let microphoneButton = app.webViews.buttons["Microphone"]
+        microphoneButton.clickAfterExistenceTestSucceeds()
+        XCTAssert(
+            notificationCenter.buttons.firstMatch.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "The notification center didn't appear. This can happen because the TCC setting at the start of the test wasn't correct – check the app.resetPermissions behavior."
+        )
+        let allowButtonIndex = try XCTUnwrap(notificationCenter.indexOfSystemModelDialogButtonOnElement(
+            titled: "Allow",
+            "OK"
+        )) // You can add any titles you see this permission dialog using on any tested macOS versions, because it is evaluated by a variadic
+        // function.
+        let allowButton = notificationCenter.buttons.element(boundBy: allowButtonIndex)
+        allowButton.clickAfterExistenceTestSucceeds() // Click system microphone permissions dialog
+        let permissionsPopoverAllowButton = app.popovers.buttons["PermissionAuthorizationViewController.allowButton"]
+        permissionsPopoverAllowButton.clickAfterExistenceTestSucceeds()
+        var websitePermissionsColorIsGreen = false
+        for _ in 1 ... 4 { // permission.site updates this color a bit slowly and we have no control over it, so we try a few times.
+            websitePermissionsColorIsGreen = try websitePermissionsButtonIsExpectedColor(microphoneButton, is: .green)
+            if websitePermissionsColorIsGreen {
+                break
+            }
+            usleep(500_000)
+        }
+        XCTAssertTrue(
+            websitePermissionsColorIsGreen,
+            "After a few attempts to wait for permissions.site to update their button animation after the TCC dialog, their button has to be green."
+        )
+
+        let navigationBarViewControllerPermissionButton = app.buttons["NavigationBarViewController.microphonePermissionButton"]
+        navigationBarViewControllerPermissionButton.clickAfterExistenceTestSucceeds()
+
+        let permissionContextMenuAlwaysAsk = app.menuItems["PermissionContextMenu.alwaysAsk"]
+        XCTAssertTrue(
+            permissionContextMenuAlwaysAsk.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "permissionContextMenuAlwaysAsk didn't exist in a reasonable timeframe."
+        )
+        let permissionContextMenuAlwaysAskValue = try XCTUnwrap(permissionContextMenuAlwaysAsk.value as? String)
+        XCTAssertEqual(
+            permissionContextMenuAlwaysAskValue,
+            "selected",
+            "The \"always ask\" menu item of the permission context menu has to be the selected item."
+        )
+
+        let permissionContextMenuAlwaysDeny = app.menuItems["PermissionContextMenu.alwaysDeny"]
+        permissionContextMenuAlwaysDeny.clickAfterExistenceTestSucceeds()
+        app.typeKey("w", modifierFlags: [.command, .option, .shift]) // Enforce a single window
+        app.typeKey("n", modifierFlags: .command)
+        addressBarTextField.typeURL(permissionsSiteURL)
+        for _ in 1 ... 4 {
+            microphoneButton.clickAfterExistenceTestSucceeds()
+        }
+        XCTAssertTrue(
+            try websitePermissionsButtonIsExpectedColor(microphoneButton, is: .red),
+            "Even if we click the button for the denied resource many times, when we are on a site where we have set \"always deny\" for the resource, the permission button will remain red"
+        )
+        XCTAssert(
+            notificationCenter.buttons.firstMatch.waitForNonExistence(timeout: UITests.Timeouts.elementExistence),
+            "Even if we click the button for the denied resource many times, when we are on a site where we have set \"always deny\" for the resource, the TCC dialog permission alert will not be on the screen"
+        )
+        XCTAssert(
+            permissionsPopoverAllowButton.waitForNonExistence(timeout: UITests.Timeouts.elementExistence),
+            "Even if we click the button for the denied resource many times, when we are on a site where we have set \"always deny\" for the resource, the permission popover will not be on the screen"
+        )
+    }
+
+    func test_locationPermissions_whenAccepted_showCorrectStateInBrowser() throws {
+        addressBarTextField.typeURLAfterExistenceTestSucceeds(permissionsSiteURL)
+
+        let locationButton = app.webViews.buttons["Location"]
+        locationButton.clickAfterExistenceTestSucceeds()
+        let permissionsPopoverAllowButton = app.popovers.buttons["PermissionAuthorizationViewController.allowButton"]
+        permissionsPopoverAllowButton.clickAfterExistenceTestSucceeds()
+        var websitePermissionsColorIsGreen = false
+        for _ in 1 ... 4 { // permission.site updates this color a bit slowly and we have no control over it, so we try a few times.
+            websitePermissionsColorIsGreen = try websitePermissionsButtonIsExpectedColor(locationButton, is: .green)
+            if websitePermissionsColorIsGreen {
+                break
+            }
+            usleep(500_000)
+        }
+        // We would like to be able to test here that the permission.site "Location" button turns green here, but it frequently doesn't turn green
+        // when location permissions are granted.
+
+        let navigationBarViewControllerPermissionButton = app.buttons["NavigationBarViewController.geolocationPermissionButton"]
+        navigationBarViewControllerPermissionButton.clickAfterExistenceTestSucceeds()
+
+        let permissionContextMenuAlwaysAsk = app.menuItems["PermissionContextMenu.alwaysAsk"]
+        XCTAssertTrue(
+            permissionContextMenuAlwaysAsk.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "permissionContextMenuAlwaysAsk didn't exist in a reasonable timeframe."
+        )
+        let permissionContextMenuAlwaysAskValue = try XCTUnwrap(permissionContextMenuAlwaysAsk.value as? String)
+        XCTAssertEqual(
+            permissionContextMenuAlwaysAskValue,
+            "selected",
+            "The \"always ask\" menu item of the permission context menu has to be the selected item."
+        )
+    }
+
+    func test_locationPermissions_whenAlwaysDenyIsSelected_alwaysDenies() throws {
+        addressBarTextField.typeURLAfterExistenceTestSucceeds(permissionsSiteURL)
+
+        let locationButton = app.webViews.buttons["Location"]
+        locationButton.clickAfterExistenceTestSucceeds()
+        let permissionsPopoverAllowButton = app.popovers.buttons["PermissionAuthorizationViewController.allowButton"]
+        permissionsPopoverAllowButton.clickAfterExistenceTestSucceeds()
+        var websitePermissionsColorIsGreen = false
+        for _ in 1 ... 4 { // permission.site updates this color a bit slowly and we have no control over it, so we try a few times.
+            websitePermissionsColorIsGreen = try websitePermissionsButtonIsExpectedColor(locationButton, is: .green)
+            if websitePermissionsColorIsGreen {
+                break
+            }
+            usleep(500_000)
+        }
+
+        // We would like to be able to test here that the permission.site "Location" button turns green here, but it frequently doesn't turn green
+        // when location permissions are granted.
+
+        let navigationBarViewControllerPermissionButton = app.buttons["NavigationBarViewController.geolocationPermissionButton"]
+        navigationBarViewControllerPermissionButton.clickAfterExistenceTestSucceeds()
+
+        let permissionContextMenuAlwaysAsk = app.menuItems["PermissionContextMenu.alwaysAsk"]
+        XCTAssertTrue(
+            permissionContextMenuAlwaysAsk.waitForExistence(timeout: UITests.Timeouts.elementExistence),
+            "permissionContextMenuAlwaysAsk didn't exist in a reasonable timeframe."
+        )
+        let permissionContextMenuAlwaysAskValue = try XCTUnwrap(permissionContextMenuAlwaysAsk.value as? String)
+        XCTAssertEqual(
+            permissionContextMenuAlwaysAskValue,
+            "selected",
+            "The \"always ask\" menu item of the permission context menu has to be the selected item."
+        )
+
+        let permissionContextMenuAlwaysDeny = app.menuItems["PermissionContextMenu.alwaysDeny"]
+        permissionContextMenuAlwaysDeny.clickAfterExistenceTestSucceeds()
+        app.typeKey("w", modifierFlags: [.command, .option, .shift]) // Enforce a single window
+        app.typeKey("n", modifierFlags: .command)
+        addressBarTextField.typeURL(permissionsSiteURL)
+        for _ in 1 ... 4 {
+            locationButton.clickAfterExistenceTestSucceeds()
+        }
+        XCTAssertTrue( // It does turn red when permission is denied.
+            try websitePermissionsButtonIsExpectedColor(locationButton, is: .red),
+            "Even if we click the button for the denied resource many times, when we are on a site where we have set \"always deny\" for the resource, the permission button will remain red"
+        )
+
+        XCTAssert(
+            permissionsPopoverAllowButton.waitForNonExistence(timeout: UITests.Timeouts.elementExistence),
+            "Even if we click the button for the denied resource many times, when we are on a site where we have set \"always deny\" for the resource, the permission popover will not be on the screen"
+        )
+    }
+}
+
+private extension PermissionsTests {
+    func websitePermissionsButtonIsExpectedColor(_ button: XCUIElement, is expectedColor: PredominantColor) throws -> Bool {
+        let buttonScreenshot = button.screenshot().image
+        let trimmedButton = buttonScreenshot.trim(to: CGRect(
+            x: 10,
+            y: 10,
+            width: 20,
+            height: 20
+        )) // A sample of the button that we are going to analyze for its predominant color tone.
+        let predominantColor = try XCTUnwrap(
+            trimmedButton.ciImage(with: nil).predominantColor(),
+            "It wasn't possible to unwrap the predominant color of the website button screenshot sample"
+        )
+        return predominantColor == expectedColor
+    }
+}
+
+private extension XCUIElement {
+    /// We don't have as much control over what is going to appear on a modal dialogue, and it feels fragile to use Apple's accessibility IDs since I
+    /// don't think there is any contract for that, but we can plan some flexibility in title matching for the button names, since the button names
+    /// are in the test description.
+    /// - Parameter titled: The title or titles (if they vary across macOS versions) of a button whose index on the element we'd like to know,
+    /// variadic
+    /// - Returns: An optional Int representing the button index on the element, if a button with this title was found.
+    func indexOfSystemModelDialogButtonOnElement(titled: String...) -> Int? {
+        for buttonIndex in 0 ... 4 { // It feels unlikely that a system modal dialog will have more than five buttons
+            let button = self.buttons.element(boundBy: buttonIndex)
+            if button.exists, titled.contains(button.title) {
+                return buttonIndex
+            }
+        }
+        return nil
+    }
+}
+
+/// Understand whether a webpage button is greenish or reddish when we expect one or the other, or states where we need to retry or fail
+private enum PredominantColor {
+    case red
+    case green
+    case neither
+}
+
+private extension NSImage {
+    /// Trim NSImage to sample
+    /// - Parameter rect: the sample size to trim to
+    /// - Returns: The trimmed NSImage
+    func trim(to rect: CGRect) -> NSImage {
+        let result = NSImage(size: rect.size)
+        result.lockFocus()
+
+        let destRect = CGRect(origin: .zero, size: result.size)
+        self.draw(in: destRect, from: rect, operation: .copy, fraction: 1.0)
+
+        result.unlockFocus()
+        return result
+    }
+}
+
+private extension CIImage {
+    /// Evaluate a sample of a webpage button to see what its predominant color tone is. Assumes it is being run on a button that is expected to be
+    /// either green or red (otherwise we are starting to think into `https://permission.site`'s potential implementation errors or surprise cases,
+    /// which I don't think should be part of this test case scope which tests UIs from three responsible organizations in which the tested UIs, in
+    /// order of importance, should be: this browser, macOS, permission.site)).
+    /// - Returns: .red, .green, .neither if we get a result but it isn't helpful, or nil in the event of an error (but it will always verbosely fail
+    /// the test before returning nil, so in practice, if the test is still in progress, it has returned a case.)
+    func predominantColor() throws -> PredominantColor? {
+        var redValueOfSample = 0.0
+        var greenValueOfSample = 0.0
+
+        for channel in 0 ... 1 { // We are only checking the first two channels
+            let extentVector = CIVector(
+                x: self.extent.origin.x,
+                y: self.extent.origin.y,
+                z: self.extent.size.width,
+                w: self.extent.size.height
+            )
+
+            guard let filter = CIFilter(name: "CIAreaAverage", parameters: [kCIInputImageKey: self, kCIInputExtentKey: extentVector])
+            else { XCTFail("It wasn't possible to set the CIFilter for the predominant color channel check")
+                return nil
+            }
+            guard let outputImage = filter.outputImage
+            else { XCTFail("It wasn't possible to set the output image for the predominant color channel check")
+                return nil
+            }
+
+            var outputBitmap = [UInt8](repeating: 0, count: 4)
+            let nullSingletonInstance = try XCTUnwrap(kCFNull, "Could not unwrap singleton null instance")
+            let outputRenderContext = CIContext(options: [.workingColorSpace: nullSingletonInstance])
+            outputRenderContext.render(
+                outputImage,
+                toBitmap: &outputBitmap,
+                rowBytes: 4,
+                bounds: CGRect(x: 0, y: 0, width: 1, height: 1),
+                format: .RGBA8,
+                colorSpace: nil
+            )
+            if channel == 0 {
+                redValueOfSample = Double(outputBitmap[channel]) / Double(255)
+            } else if channel == 1 {
+                greenValueOfSample = Double(outputBitmap[channel]) / Double(255)
+            }
+        }
+
+        let tooSimilar = abs(redValueOfSample - greenValueOfSample) < 0.05 // This isn't a huge difference because these are both very light colors
+        if tooSimilar {
+            print(
+                "It wasn't possible to get a predominant color of the button because the two channel values of red (\(redValueOfSample)) and green (\(greenValueOfSample)) were \(redValueOfSample == greenValueOfSample ? "the same." : "too close in value.")"
+            )
+            return .neither
+        }
+
+        return max(redValueOfSample, greenValueOfSample) == redValueOfSample ? .red : .green
+    }
+}
diff --git a/UITests/StateRestorationTests.swift b/UITests/StateRestorationTests.swift
index 32f86a0d2e..4d952c2d49 100644
--- a/UITests/StateRestorationTests.swift
+++ b/UITests/StateRestorationTests.swift
@@ -30,6 +30,10 @@ class StateRestorationTests: XCTestCase {
     private var openANewWindowPreference: XCUIElement!
     private var reopenAllWindowsFromLastSessionPreference: XCUIElement!
 
+    override class func setUp() {
+        UITests.firstRun()
+    }
+
     override func setUpWithError() throws {
         continueAfterFailure = false
         app = XCUIApplication()
diff --git a/UITests/TabBarTests.swift b/UITests/TabBarTests.swift
index 2480e2f71f..0c1cc4c3cc 100644
--- a/UITests/TabBarTests.swift
+++ b/UITests/TabBarTests.swift
@@ -28,6 +28,10 @@ class TabBarTests: XCTestCase {
         app.launch()
     }
 
+    override class func setUp() {
+        UITests.firstRun()
+    }
+
     func testWhenClickingAddTab_ThenTabsOpen() throws {
 //        let app = XCUIApplication()
 //