diff --git a/src/helpers/__tests__/format-default.test.tsx b/src/helpers/__tests__/format-default.test.tsx
index 8f2e784b2..d7334caf1 100644
--- a/src/helpers/__tests__/format-default.test.tsx
+++ b/src/helpers/__tests__/format-default.test.tsx
@@ -1,12 +1,5 @@
-import { ReactTestRendererJSON } from 'react-test-renderer';
 import { defaultMapProps } from '../format-default';
 
-const node: ReactTestRendererJSON = {
-  type: 'View',
-  props: {},
-  children: null,
-};
-
 describe('mapPropsForQueryError', () => {
   test('preserves props that are helpful for debugging', () => {
     const props = {
@@ -32,39 +25,34 @@ describe('mapPropsForQueryError', () => {
       defaultValue: 'DEFAULT_VALUE',
     };
 
-    const result = defaultMapProps(props, node);
+    const result = defaultMapProps(props);
     expect(result).toStrictEqual(props);
   });
 
   test('does not preserve less helpful props', () => {
-    const result = defaultMapProps(
-      {
-        style: [{ flex: 1 }, { display: 'flex' }],
-        onPress: () => null,
-        key: 'foo',
-      },
-      node
-    );
+    const result = defaultMapProps({
+      style: [{ flex: 1 }, { flexDirection: 'row' }],
+      onPress: () => null,
+      key: 'foo',
+    });
 
     expect(result).toStrictEqual({});
   });
 
-  test('preserves "display: none" style but no other style', () => {
-    const result = defaultMapProps(
-      { style: [{ flex: 1 }, { display: 'none', flex: 2 }] },
-      node
-    );
+  test('preserves "display: none" and "opacity: 0" styles but no other style', () => {
+    const result = defaultMapProps({
+      style: [{ flex: 1 }, { display: 'none', flex: 2 }, { opacity: 0 }],
+    });
 
     expect(result).toStrictEqual({
-      style: { display: 'none' },
+      style: { display: 'none', opacity: 0 },
     });
   });
 
   test('removes undefined keys from accessibilityState', () => {
-    const result = defaultMapProps(
-      { accessibilityState: { checked: undefined, selected: false } },
-      node
-    );
+    const result = defaultMapProps({
+      accessibilityState: { checked: undefined, selected: false },
+    });
 
     expect(result).toStrictEqual({
       accessibilityState: { selected: false },
@@ -72,49 +60,44 @@ describe('mapPropsForQueryError', () => {
   });
 
   test('removes accessibilityState if all keys are undefined', () => {
-    const result = defaultMapProps(
-      { accessibilityState: { checked: undefined, selected: undefined } },
-      node
-    );
+    const result = defaultMapProps({
+      accessibilityState: { checked: undefined, selected: undefined },
+    });
 
     expect(result).toStrictEqual({});
   });
 
   test('does not fail if accessibilityState is a string, passes through', () => {
-    const result = defaultMapProps({ accessibilityState: 'foo' }, node);
+    const result = defaultMapProps({ accessibilityState: 'foo' });
     expect(result).toStrictEqual({ accessibilityState: 'foo' });
   });
 
   test('does not fail if accessibilityState is an array, passes through', () => {
-    const result = defaultMapProps({ accessibilityState: [1] }, node);
+    const result = defaultMapProps({ accessibilityState: [1] });
     expect(result).toStrictEqual({ accessibilityState: [1] });
   });
 
   test('does not fail if accessibilityState is null, passes through', () => {
-    const result = defaultMapProps({ accessibilityState: null }, node);
+    const result = defaultMapProps({ accessibilityState: null });
     expect(result).toStrictEqual({ accessibilityState: null });
   });
 
   test('does not fail if accessibilityState is nested object, passes through', () => {
     const accessibilityState = { 1: { 2: 3 }, 2: undefined };
-    const result = defaultMapProps({ accessibilityState }, node);
+    const result = defaultMapProps({ accessibilityState });
     expect(result).toStrictEqual({ accessibilityState: { 1: { 2: 3 } } });
   });
 
   test('removes undefined keys from accessibilityValue', () => {
-    const result = defaultMapProps(
-      { accessibilityValue: { min: 1, max: undefined } },
-      node
-    );
+    const result = defaultMapProps({
+      accessibilityValue: { min: 1, max: undefined },
+    });
 
     expect(result).toStrictEqual({ accessibilityValue: { min: 1 } });
   });
 
   test('removes accessibilityValue if all keys are undefined', () => {
-    const result = defaultMapProps(
-      { accessibilityValue: { min: undefined } },
-      node
-    );
+    const result = defaultMapProps({ accessibilityValue: { min: undefined } });
 
     expect(result).toStrictEqual({});
   });
diff --git a/src/helpers/format-default.ts b/src/helpers/format-default.ts
index 1f2faab51..133c8717e 100644
--- a/src/helpers/format-default.ts
+++ b/src/helpers/format-default.ts
@@ -1,7 +1,7 @@
 import { StyleSheet, ViewStyle } from 'react-native';
-import { MapPropsFunction } from './format';
 
 const propsToDisplay = [
+  'accessible',
   'accessibilityElementsHidden',
   'accessibilityHint',
   'accessibilityLabel',
@@ -24,17 +24,20 @@ const propsToDisplay = [
   'testID',
   'title',
   'value',
-];
+] as const;
 
 /**
  * Preserve props that are helpful in diagnosing test failures, while stripping rest
  */
-export const defaultMapProps: MapPropsFunction = (props) => {
+export function defaultMapProps(
+  props: Record<string, unknown>
+): Record<string, unknown> {
   const result: Record<string, unknown> = {};
 
   const styles = StyleSheet.flatten(props.style as ViewStyle);
-  if (styles?.display === 'none') {
-    result.style = { display: 'none' };
+  const styleToDisplay = extractStyle(styles);
+  if (styleToDisplay !== undefined) {
+    result.style = styleToDisplay;
   }
 
   const accessibilityState = removeUndefinedKeys(props.accessibilityState);
@@ -54,7 +57,7 @@ export const defaultMapProps: MapPropsFunction = (props) => {
   });
 
   return result;
-};
+}
 
 function isObject(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -65,17 +68,32 @@ function removeUndefinedKeys(prop: unknown) {
     return prop;
   }
 
+  let hasKeys = false;
   const result: Record<string, unknown> = {};
   Object.entries(prop).forEach(([key, value]) => {
     if (value !== undefined) {
       result[key] = value;
+      hasKeys = true;
     }
   });
 
-  // If object does not have any props we will ignore it.
-  if (Object.keys(result).length === 0) {
+  return hasKeys ? result : undefined;
+}
+
+function extractStyle(style: ViewStyle | undefined) {
+  if (style == null) {
     return undefined;
   }
 
-  return result;
+  const result: Record<string, unknown> = {};
+  if (style.display === 'none') {
+    result.display = 'none';
+  }
+
+  if (style.opacity === 0) {
+    result.opacity = 0;
+  }
+
+  const hasAnyKeys = Object.keys(result).length > 0;
+  return hasAnyKeys ? result : undefined;
 }
diff --git a/src/matchers/__tests__/to-be-disabled.test.tsx b/src/matchers/__tests__/to-be-disabled.test.tsx
new file mode 100644
index 000000000..854a970c5
--- /dev/null
+++ b/src/matchers/__tests__/to-be-disabled.test.tsx
@@ -0,0 +1,272 @@
+import React from 'react';
+import {
+  Button,
+  Pressable,
+  TextInput,
+  TouchableHighlight,
+  TouchableNativeFeedback,
+  TouchableOpacity,
+  TouchableWithoutFeedback,
+  Text,
+  View,
+} from 'react-native';
+import { render } from '../..';
+import '../extend-expect';
+
+test('toBeDisabled/toBeEnabled supports basic case', () => {
+  const screen = render(
+    <View>
+      <View testID="disabled-parent" aria-disabled>
+        <View>
+          <View testID="disabled-child" />
+        </View>
+      </View>
+      <View>
+        <View testID="enabled-view" />
+        <Text testID="enabled-text">Text</Text>
+        <TextInput testID="enabled-text-input" />
+        <Pressable testID="enabled-pressable" />
+      </View>
+    </View>
+  );
+
+  expect(screen.getByTestId('disabled-parent')).toBeDisabled();
+  expect(screen.getByTestId('disabled-child')).toBeDisabled();
+  expect(screen.getByTestId('enabled-view')).not.toBeDisabled();
+  expect(screen.getByTestId('enabled-text')).not.toBeDisabled();
+  expect(screen.getByTestId('enabled-text-input')).not.toBeDisabled();
+  expect(screen.getByTestId('enabled-pressable')).not.toBeDisabled();
+
+  expect(() => expect(screen.getByTestId('disabled-parent')).not.toBeDisabled())
+    .toThrowErrorMatchingInlineSnapshot(`
+    "expect(element).not.toBeDisabled()
+
+    Received element is disabled:
+      <View
+        aria-disabled={true}
+        testID="disabled-parent"
+      />"
+  `);
+
+  expect(() => expect(screen.getByTestId('enabled-view')).toBeDisabled())
+    .toThrowErrorMatchingInlineSnapshot(`
+    "expect(element).toBeDisabled()
+
+    Received element is not disabled:
+      <View
+        testID="enabled-view"
+      />"
+  `);
+
+  expect(screen.getByTestId('disabled-parent')).not.toBeEnabled();
+  expect(screen.getByTestId('disabled-child')).not.toBeEnabled();
+  expect(screen.getByTestId('enabled-view')).toBeEnabled();
+  expect(screen.getByTestId('enabled-text')).toBeEnabled();
+  expect(screen.getByTestId('enabled-text-input')).toBeEnabled();
+  expect(screen.getByTestId('enabled-pressable')).toBeEnabled();
+
+  expect(() => expect(screen.getByTestId('disabled-parent')).toBeEnabled())
+    .toThrowErrorMatchingInlineSnapshot(`
+    "expect(element).toBeEnabled()
+
+    Received element is not enabled:
+      <View
+        aria-disabled={true}
+        testID="disabled-parent"
+      />"
+  `);
+
+  expect(() => expect(screen.getByTestId('enabled-view')).not.toBeEnabled())
+    .toThrowErrorMatchingInlineSnapshot(`
+    "expect(element).not.toBeEnabled()
+
+    Received element is enabled:
+      <View
+        testID="enabled-view"
+      />"
+  `);
+});
+
+test('toBeDisabled/toBeEnabled supports Pressable with "disabled" prop', () => {
+  const screen = render(
+    <Pressable disabled testID="subject">
+      <Text>Button</Text>
+    </Pressable>
+  );
+
+  const pressable = screen.getByTestId('subject');
+  expect(pressable).toBeDisabled();
+  expect(pressable).not.toBeEnabled();
+
+  const title = screen.getByText('Button');
+  expect(title).toBeDisabled();
+  expect(title).not.toBeEnabled();
+
+  expect(() => expect(pressable).toBeEnabled())
+    .toThrowErrorMatchingInlineSnapshot(`
+    "expect(element).toBeEnabled()
+
+    Received element is not enabled:
+      <View
+        accessibilityState={
+          {
+            "disabled": true,
+          }
+        }
+        accessible={true}
+        testID="subject"
+      />"
+  `);
+
+  expect(() => expect(pressable).not.toBeDisabled())
+    .toThrowErrorMatchingInlineSnapshot(`
+    "expect(element).not.toBeDisabled()
+
+    Received element is disabled:
+      <View
+        accessibilityState={
+          {
+            "disabled": true,
+          }
+        }
+        accessible={true}
+        testID="subject"
+      />"
+  `);
+
+  expect(() => expect(title).toBeEnabled()).toThrowErrorMatchingInlineSnapshot(`
+    "expect(element).toBeEnabled()
+
+    Received element is not enabled:
+      <Text>
+        Button
+      </Text>"
+  `);
+
+  expect(() => expect(title).not.toBeDisabled())
+    .toThrowErrorMatchingInlineSnapshot(`
+    "expect(element).not.toBeDisabled()
+
+    Received element is disabled:
+      <Text>
+        Button
+      </Text>"
+  `);
+});
+
+test.each([
+  ['Pressable', Pressable],
+  ['TouchableOpacity', TouchableOpacity],
+  ['TouchableHighlight', TouchableHighlight],
+  ['TouchableWithoutFeedback', TouchableWithoutFeedback],
+  ['TouchableNativeFeedback', TouchableNativeFeedback],
+] as const)(
+  'toBeDisabled/toBeEnabled supports %s with "disabled" prop',
+  (_, Component) => {
+    const screen = render(
+      // @ts-expect-error disabled prop is not available on all Touchables
+      <Component disabled testID="subject">
+        <Text>Button</Text>
+      </Component>
+    );
+
+    const touchable = screen.getByTestId('subject');
+    expect(touchable).toBeDisabled();
+    expect(touchable).not.toBeEnabled();
+
+    const title = screen.getByText('Button');
+    expect(title).toBeDisabled();
+    expect(title).not.toBeEnabled();
+
+    expect(() => expect(touchable).toBeEnabled()).toThrow();
+    expect(() => expect(touchable).not.toBeDisabled()).toThrow();
+    expect(() => expect(title).toBeEnabled()).toThrow();
+    expect(() => expect(title).not.toBeDisabled()).toThrow();
+  }
+);
+
+test.each([
+  ['View', View],
+  ['Text', Text],
+  ['TextInput', TextInput],
+  ['Pressable', Pressable],
+  ['TouchableOpacity', TouchableOpacity],
+  ['TouchableWithoutFeedback', TouchableWithoutFeedback],
+  ['TouchableNativeFeedback', TouchableNativeFeedback],
+] as const)(
+  'toBeDisabled/toBeEnabled supports %s with "aria-disabled" prop',
+  (_, Component) => {
+    const screen = render(
+      // @ts-expect-error too generic for typescript
+      <Component testID="subject" aria-disabled>
+        <Text>Hello</Text>
+      </Component>
+    );
+
+    const view = screen.getByTestId('subject');
+    expect(view).toBeDisabled();
+    expect(view).not.toBeEnabled();
+    expect(() => expect(view).toBeEnabled()).toThrow();
+    expect(() => expect(view).not.toBeDisabled()).toThrow();
+  }
+);
+
+test.each([
+  ['View', View],
+  ['Text', Text],
+  ['TextInput', TextInput],
+  ['Pressable', Pressable],
+  ['TouchableOpacity', TouchableOpacity],
+  ['TouchableHighlight', TouchableHighlight],
+  ['TouchableWithoutFeedback', TouchableWithoutFeedback],
+  ['TouchableNativeFeedback', TouchableNativeFeedback],
+] as const)(
+  'toBeDisabled/toBeEnabled supports %s with "accessibilityState.disabled" prop',
+  (_, Component) => {
+    const screen = render(
+      // @ts-expect-error disabled prop is not available on all Touchables
+      <Component testID="subject" accessibilityState={{ disabled: true }}>
+        <Text>Hello</Text>
+      </Component>
+    );
+
+    const view = screen.getByTestId('subject');
+    expect(view).toBeDisabled();
+    expect(view).not.toBeEnabled();
+    expect(() => expect(view).toBeEnabled()).toThrow();
+    expect(() => expect(view).not.toBeDisabled()).toThrow();
+  }
+);
+
+test('toBeDisabled/toBeEnabled supports "editable" prop on TextInput', () => {
+  const screen = render(
+    <View>
+      <TextInput testID="enabled-by-default" />
+      <TextInput testID="enabled" editable />
+      <TextInput testID="disabled" editable={false} />
+    </View>
+  );
+
+  expect(screen.getByTestId('enabled-by-default')).not.toBeDisabled();
+  expect(screen.getByTestId('enabled')).not.toBeDisabled();
+  expect(screen.getByTestId('disabled')).toBeDisabled();
+
+  expect(screen.getByTestId('enabled-by-default')).toBeEnabled();
+  expect(screen.getByTestId('enabled')).toBeEnabled();
+  expect(screen.getByTestId('disabled')).not.toBeEnabled();
+});
+
+test('toBeDisabled/toBeEnabled supports "disabled" prop on Button', () => {
+  const screen = render(
+    <View>
+      <Button testID="enabled" title="enabled" />
+      <Button testID="disabled" title="disabled" disabled />
+    </View>
+  );
+
+  expect(screen.getByTestId('enabled')).not.toBeDisabled();
+  expect(screen.getByTestId('disabled')).toBeDisabled();
+
+  expect(screen.getByTestId('enabled')).toBeEnabled();
+  expect(screen.getByTestId('disabled')).not.toBeEnabled();
+});
diff --git a/src/matchers/__tests__/to-be-visible.test.tsx b/src/matchers/__tests__/to-be-visible.test.tsx
index ddcb439c5..4e5de0c51 100644
--- a/src/matchers/__tests__/to-be-visible.test.tsx
+++ b/src/matchers/__tests__/to-be-visible.test.tsx
@@ -30,11 +30,6 @@ test('toBeVisible() on view with opacity', () => {
 
     Received element is visible:
       <View
-        style={
-          {
-            "opacity": 0.2,
-          }
-        }
         testID="view"
       />"
   `);
@@ -133,9 +128,7 @@ test('toBeVisible() on empty Modal', () => {
 
     Received element is visible:
       <Modal
-        hardwareAccelerated={false}
         testID="modal"
-        visible={true}
       />"
   `);
 });
diff --git a/src/matchers/extend-expect.d.ts b/src/matchers/extend-expect.d.ts
index 7072b020e..ba8b0d066 100644
--- a/src/matchers/extend-expect.d.ts
+++ b/src/matchers/extend-expect.d.ts
@@ -6,6 +6,8 @@ export interface JestNativeMatchers<R> {
   toBeVisible(): R;
   toHaveDisplayValue(expectedValue: TextMatch, options?: TextMatchOptions): R;
   toHaveTextContent(expectedText: TextMatch, options?: TextMatchOptions): R;
+  toBeDisabled(): R;
+  toBeEnabled(): R;
 }
 
 // Implicit Jest global `expect`.
diff --git a/src/matchers/extend-expect.ts b/src/matchers/extend-expect.ts
index 327302c57..7097a3c3d 100644
--- a/src/matchers/extend-expect.ts
+++ b/src/matchers/extend-expect.ts
@@ -5,6 +5,7 @@ import { toBeEmptyElement } from './to-be-empty-element';
 import { toBeVisible } from './to-be-visible';
 import { toHaveDisplayValue } from './to-have-display-value';
 import { toHaveTextContent } from './to-have-text-content';
+import { toBeDisabled, toBeEnabled } from './to-be-disabled';
 
 expect.extend({
   toBeOnTheScreen,
@@ -12,4 +13,6 @@ expect.extend({
   toBeVisible,
   toHaveDisplayValue,
   toHaveTextContent,
+  toBeDisabled,
+  toBeEnabled,
 });
diff --git a/src/matchers/to-be-disabled.tsx b/src/matchers/to-be-disabled.tsx
new file mode 100644
index 000000000..18be1bcc2
--- /dev/null
+++ b/src/matchers/to-be-disabled.tsx
@@ -0,0 +1,68 @@
+import type { ReactTestInstance } from 'react-test-renderer';
+import { matcherHint } from 'jest-matcher-utils';
+import { isHostTextInput } from '../helpers/host-component-names';
+import { isTextInputEditable } from '../helpers/text-input';
+import { getHostParent } from '../helpers/component-tree';
+import { checkHostElement, formatElement } from './utils';
+
+export function toBeDisabled(
+  this: jest.MatcherContext,
+  element: ReactTestInstance
+) {
+  checkHostElement(element, toBeDisabled, this);
+
+  const isDisabled = isElementDisabled(element) || isAncestorDisabled(element);
+
+  return {
+    pass: isDisabled,
+    message: () => {
+      const is = isDisabled ? 'is' : 'is not';
+      return [
+        matcherHint(`${this.isNot ? '.not' : ''}.toBeDisabled`, 'element', ''),
+        '',
+        `Received element ${is} disabled:`,
+        formatElement(element),
+      ].join('\n');
+    },
+  };
+}
+
+export function toBeEnabled(
+  this: jest.MatcherContext,
+  element: ReactTestInstance
+) {
+  checkHostElement(element, toBeEnabled, this);
+
+  const isEnabled = !isElementDisabled(element) && !isAncestorDisabled(element);
+
+  return {
+    pass: isEnabled,
+    message: () => {
+      const is = isEnabled ? 'is' : 'is not';
+      return [
+        matcherHint(`${this.isNot ? '.not' : ''}.toBeEnabled`, 'element', ''),
+        '',
+        `Received element ${is} enabled:`,
+        formatElement(element),
+      ].join('\n');
+    },
+  };
+}
+
+function isElementDisabled(element: ReactTestInstance) {
+  if (isHostTextInput(element) && !isTextInputEditable(element)) {
+    return true;
+  }
+
+  const { accessibilityState, 'aria-disabled': ariaDisabled } = element.props;
+  return ariaDisabled ?? accessibilityState?.disabled ?? false;
+}
+
+function isAncestorDisabled(element: ReactTestInstance): boolean {
+  const parent = getHostParent(element);
+  if (parent == null) {
+    return false;
+  }
+
+  return isElementDisabled(parent) || isAncestorDisabled(parent);
+}
diff --git a/src/matchers/utils.tsx b/src/matchers/utils.tsx
index f6808b09c..e89a24f37 100644
--- a/src/matchers/utils.tsx
+++ b/src/matchers/utils.tsx
@@ -10,6 +10,7 @@ import {
 import prettyFormat, { plugins } from 'pretty-format';
 import redent from 'redent';
 import { isHostElement } from '../helpers/component-tree';
+import { defaultMapProps } from '../helpers/format-default';
 
 class HostElementTypeError extends Error {
   constructor(
@@ -72,6 +73,10 @@ export function formatElement(element: ReactTestInstance | null) {
     return '  null';
   }
 
+  const { children, ...props } = element.props;
+  const childrenToDisplay =
+    typeof children === 'string' ? [children] : undefined;
+
   return redent(
     prettyFormat(
       {
@@ -79,7 +84,8 @@ export function formatElement(element: ReactTestInstance | null) {
         // a ReactTestRendererJSON instance, so it is formatted as JSX.
         $$typeof: Symbol.for('react.test.json'),
         type: element.type,
-        props: element.props,
+        props: defaultMapProps(props),
+        children: childrenToDisplay,
       },
       {
         plugins: [plugins.ReactTestComponent, plugins.ReactElement],
diff --git a/src/queries/__tests__/a11yState.test.tsx b/src/queries/__tests__/a11yState.test.tsx
index f3b01cf42..7c93327fc 100644
--- a/src/queries/__tests__/a11yState.test.tsx
+++ b/src/queries/__tests__/a11yState.test.tsx
@@ -263,6 +263,7 @@ test('byA11yState queries support hidden option', () => {
           "expanded": false,
         }
       }
+      accessible={true}
       style={
         {
           "display": "none",
diff --git a/src/queries/__tests__/hintText.test.tsx b/src/queries/__tests__/hintText.test.tsx
index 4d4478768..d230c301d 100644
--- a/src/queries/__tests__/hintText.test.tsx
+++ b/src/queries/__tests__/hintText.test.tsx
@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { TouchableOpacity, Text, View } from 'react-native';
+import { Pressable, Text, View } from 'react-native';
 import { render } from '../..';
 
 const BUTTON_HINT = 'click this button';
@@ -20,9 +20,9 @@ const Typography = ({ children, ...rest }: any) => {
 };
 
 const Button = ({ children }: { children: React.ReactNode }) => (
-  <TouchableOpacity accessibilityHint={BUTTON_HINT}>
+  <Pressable accessibilityHint={BUTTON_HINT}>
     <Typography accessibilityHint={TEXT_HINT}>{children}</Typography>
-  </TouchableOpacity>
+  </Pressable>
 );
 
 const Section = () => (
@@ -138,13 +138,14 @@ test('byHintText queries support hidden option', () => {
 });
 
 test('error message renders the element tree, preserving only helpful props', async () => {
-  const view = render(<TouchableOpacity accessibilityHint="HINT" key="3" />);
+  const view = render(<Pressable accessibilityHint="HINT" key="3" />);
 
   expect(() => view.getByHintText('FOO')).toThrowErrorMatchingInlineSnapshot(`
     "Unable to find an element with accessibilityHint: FOO
 
     <View
       accessibilityHint="HINT"
+      accessible={true}
     />"
   `);
 
@@ -154,6 +155,7 @@ test('error message renders the element tree, preserving only helpful props', as
 
     <View
       accessibilityHint="HINT"
+      accessible={true}
     />"
   `);
 
@@ -163,6 +165,7 @@ test('error message renders the element tree, preserving only helpful props', as
 
     <View
       accessibilityHint="HINT"
+      accessible={true}
     />"
   `);
 
@@ -172,6 +175,7 @@ test('error message renders the element tree, preserving only helpful props', as
 
     <View
       accessibilityHint="HINT"
+      accessible={true}
     />"
   `);
 });
diff --git a/src/queries/__tests__/labelText.test.tsx b/src/queries/__tests__/labelText.test.tsx
index 9af9215d1..2f6d2098d 100644
--- a/src/queries/__tests__/labelText.test.tsx
+++ b/src/queries/__tests__/labelText.test.tsx
@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { View, Text, TextInput, TouchableOpacity } from 'react-native';
+import { View, Text, TextInput, Pressable } from 'react-native';
 import { render } from '../..';
 
 const BUTTON_LABEL = 'cool button';
@@ -22,14 +22,11 @@ const Typography = ({ children, ...rest }: any) => {
 };
 
 const Button = ({ children }: { children: React.ReactNode }) => (
-  <TouchableOpacity
-    accessibilityHint={BUTTON_HINT}
-    accessibilityLabel={BUTTON_LABEL}
-  >
+  <Pressable accessibilityHint={BUTTON_HINT} accessibilityLabel={BUTTON_LABEL}>
     <Typography accessibilityHint={TEXT_HINT} accessibilityLabel={TEXT_LABEL}>
       {children}
     </Typography>
-  </TouchableOpacity>
+  </Pressable>
 );
 
 const Section = () => (
@@ -255,13 +252,14 @@ test('getByLabelText supports nested aria-labelledby', async () => {
 });
 
 test('error message renders the element tree, preserving only helpful props', async () => {
-  const view = render(<TouchableOpacity accessibilityLabel="LABEL" key="3" />);
+  const view = render(<Pressable accessibilityLabel="LABEL" key="3" />);
 
   expect(() => view.getByLabelText('FOO')).toThrowErrorMatchingInlineSnapshot(`
     "Unable to find an element with accessibility label: FOO
 
     <View
       accessibilityLabel="LABEL"
+      accessible={true}
     />"
   `);
 
@@ -271,6 +269,7 @@ test('error message renders the element tree, preserving only helpful props', as
 
     <View
       accessibilityLabel="LABEL"
+      accessible={true}
     />"
   `);
 
@@ -280,6 +279,7 @@ test('error message renders the element tree, preserving only helpful props', as
 
     <View
       accessibilityLabel="LABEL"
+      accessible={true}
     />"
   `);
 
@@ -289,6 +289,7 @@ test('error message renders the element tree, preserving only helpful props', as
 
     <View
       accessibilityLabel="LABEL"
+      accessible={true}
     />"
   `);
 });
diff --git a/src/queries/__tests__/role.test.tsx b/src/queries/__tests__/role.test.tsx
index cb25c284b..4782e6a5c 100644
--- a/src/queries/__tests__/role.test.tsx
+++ b/src/queries/__tests__/role.test.tsx
@@ -919,6 +919,7 @@ test('byRole queries support hidden option', () => {
 
     <View
       accessibilityRole="button"
+      accessible={true}
       style={
         {
           "display": "none",