From 4038af196ab3466cc549ddf6957e99fb191e5597 Mon Sep 17 00:00:00 2001
From: Ryan Wessel <rwessel@dataminr.com>
Date: Fri, 17 Jul 2020 12:18:48 -0400
Subject: [PATCH 01/12] feat: Add alias accessibilityLabel queries to assist in
 migrating from @testing-library/react-native

---
 src/helpers/a11yAPI.js | 32 ++++++++++++++++++++++++++------
 1 file changed, 26 insertions(+), 6 deletions(-)

diff --git a/src/helpers/a11yAPI.js b/src/helpers/a11yAPI.js
index 77f1b063e..f55d76fc4 100644
--- a/src/helpers/a11yAPI.js
+++ b/src/helpers/a11yAPI.js
@@ -103,12 +103,32 @@ const a11yAPI = (instance: ReactTestInstance): A11yAPI =>
     ...makeQuery(
       'accessibilityLabel',
       {
-        getBy: ['getByA11yLabel', 'getByAccessibilityLabel'],
-        getAllBy: ['getAllByA11yLabel', 'getAllByAccessibilityLabel'],
-        queryBy: ['queryByA11yLabel', 'queryByAccessibilityLabel'],
-        queryAllBy: ['queryAllByA11yLabel', 'queryAllByAccessibilityLabel'],
-        findBy: ['findByA11yLabel', 'findByAccessibilityLabel'],
-        findAllBy: ['findAllByA11yLabel', 'findAllByAccessibilityLabel'],
+        getBy: ['getByA11yLabel', 'getByAccessibilityLabel', 'getByLabelText'],
+        getAllBy: [
+          'getAllByA11yLabel',
+          'getAllByAccessibilityLabel',
+          'getAllByLabelText',
+        ],
+        queryBy: [
+          'queryByA11yLabel',
+          'queryByAccessibilityLabel',
+          'queryByLabelText',
+        ],
+        queryAllBy: [
+          'queryAllByA11yLabel',
+          'queryAllByAccessibilityLabel',
+          'queryAllByLabelText',
+        ],
+        findBy: [
+          'findByA11yLabel',
+          'findByAccessibilityLabel',
+          'findByLabelText',
+        ],
+        findAllBy: [
+          'findAllByA11yLabel',
+          'findAllByAccessibilityLabel',
+          'findAllByLabelText',
+        ],
       },
       matchStringValue
     )(instance),

From 1a433e6afa9fab43e036954af642793ccfef3174 Mon Sep 17 00:00:00 2001
From: Ryan Wessel <rwessel@dataminr.com>
Date: Fri, 17 Jul 2020 12:19:19 -0400
Subject: [PATCH 02/12] feat: Add alias accessibilityHint queries to assist in
 migrating from @testing-library/react-native

---
 src/helpers/a11yAPI.js | 28 ++++++++++++++++++++++------
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/src/helpers/a11yAPI.js b/src/helpers/a11yAPI.js
index f55d76fc4..2a53363b3 100644
--- a/src/helpers/a11yAPI.js
+++ b/src/helpers/a11yAPI.js
@@ -135,12 +135,28 @@ const a11yAPI = (instance: ReactTestInstance): A11yAPI =>
     ...makeQuery(
       'accessibilityHint',
       {
-        getBy: ['getByA11yHint', 'getByAccessibilityHint'],
-        getAllBy: ['getAllByA11yHint', 'getAllByAccessibilityHint'],
-        queryBy: ['queryByA11yHint', 'queryByAccessibilityHint'],
-        queryAllBy: ['queryAllByA11yHint', 'queryAllByAccessibilityHint'],
-        findBy: ['findByA11yHint', 'findByAccessibilityHint'],
-        findAllBy: ['findAllByA11yHint', 'findAllByAccessibilityHint'],
+        getBy: ['getByA11yHint', 'getByAccessibilityHint', 'getByHintText'],
+        getAllBy: [
+          'getAllByA11yHint',
+          'getAllByAccessibilityHint',
+          'getAllByHintText',
+        ],
+        queryBy: [
+          'queryByA11yHint',
+          'queryByAccessibilityHint',
+          'queryByHintText',
+        ],
+        queryAllBy: [
+          'queryAllByA11yHint',
+          'queryAllByAccessibilityHint',
+          'queryAllByHintText',
+        ],
+        findBy: ['findByA11yHint', 'findByAccessibilityHint', 'findByHintText'],
+        findAllBy: [
+          'findAllByA11yHint',
+          'findAllByAccessibilityHint',
+          'findAllByHintText',
+        ],
       },
       matchStringValue
     )(instance),

From 97b8c3b4f77c9f6a551ea52e395642b5585675a2 Mon Sep 17 00:00:00 2001
From: Ryan Wessel <rwessel@dataminr.com>
Date: Fri, 17 Jul 2020 12:19:35 -0400
Subject: [PATCH 03/12] feat: Add alias accessibilityRole queries to assist in
 migrating from @testing-library/react-native

---
 src/helpers/a11yAPI.js | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

diff --git a/src/helpers/a11yAPI.js b/src/helpers/a11yAPI.js
index 2a53363b3..317594b2d 100644
--- a/src/helpers/a11yAPI.js
+++ b/src/helpers/a11yAPI.js
@@ -163,12 +163,24 @@ const a11yAPI = (instance: ReactTestInstance): A11yAPI =>
     ...makeQuery(
       'accessibilityRole',
       {
-        getBy: ['getByA11yRole', 'getByAccessibilityRole'],
-        getAllBy: ['getAllByA11yRole', 'getAllByAccessibilityRole'],
-        queryBy: ['queryByA11yRole', 'queryByAccessibilityRole'],
-        queryAllBy: ['queryAllByA11yRole', 'queryAllByAccessibilityRole'],
-        findBy: ['findByA11yRole', 'findByAccessibilityRole'],
-        findAllBy: ['findAllByA11yRole', 'findAllByAccessibilityRole'],
+        getBy: ['getByA11yRole', 'getByAccessibilityRole', 'getByRole'],
+        getAllBy: [
+          'getAllByA11yRole',
+          'getAllByAccessibilityRole',
+          'getAllByRole',
+        ],
+        queryBy: ['queryByA11yRole', 'queryByAccessibilityRole', 'queryByRole'],
+        queryAllBy: [
+          'queryAllByA11yRole',
+          'queryAllByAccessibilityRole',
+          'queryAllByRole',
+        ],
+        findBy: ['findByA11yRole', 'findByAccessibilityRole', 'findByRole'],
+        findAllBy: [
+          'findAllByA11yRole',
+          'findAllByAccessibilityRole',
+          'findAllByRole',
+        ],
       },
       matchStringValue
     )(instance),

From 041a70baee7c174e9a97f7bb5257bdebd69e79c4 Mon Sep 17 00:00:00 2001
From: Ryan Wessel <rwessel@dataminr.com>
Date: Fri, 17 Jul 2020 14:22:38 -0400
Subject: [PATCH 04/12] feat: Add to A11yAPI types to include the newly-aliased
 queries for label, hint, and role

---
 src/helpers/a11yAPI.js | 18 ++++++++++++++++++
 typings/index.d.ts     | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+)

diff --git a/src/helpers/a11yAPI.js b/src/helpers/a11yAPI.js
index 317594b2d..1bd33a9bd 100644
--- a/src/helpers/a11yAPI.js
+++ b/src/helpers/a11yAPI.js
@@ -13,27 +13,45 @@ type FindAllReturn = Promise<GetAllReturn>;
 type A11yAPI = {|
   // Label
   getByA11yLabel: (string | RegExp) => GetReturn,
+  getByLabelText: (string | RegExp) => GetReturn,
   getAllByA11yLabel: (string | RegExp) => GetAllReturn,
+  getAllByLabelText: (string | RegExp) => GetAllReturn,
   queryByA11yLabel: (string | RegExp) => QueryReturn,
+  queryByLabelText: (string | RegExp) => QueryReturn,
   queryAllByA11yLabel: (string | RegExp) => QueryAllReturn,
+  queryAllByLabelText: (string | RegExp) => QueryAllReturn,
   findByA11yLabel: (string | RegExp, ?WaitForOptions) => FindReturn,
+  findByLabelText: (string | RegExp, ?WaitForOptions) => FindReturn,
   findAllByA11yLabel: (string | RegExp, ?WaitForOptions) => FindAllReturn,
+  findAllByLabelText: (string | RegExp, ?WaitForOptions) => FindAllReturn,
 
   // Hint
   getByA11yHint: (string | RegExp) => GetReturn,
+  getByHintText: (string | RegExp) => GetReturn,
   getAllByA11yHint: (string | RegExp) => GetAllReturn,
+  getAllByHintText: (string | RegExp) => GetAllReturn,
   queryByA11yHint: (string | RegExp) => QueryReturn,
+  queryByHintText: (string | RegExp) => QueryReturn,
   queryAllByA11yHint: (string | RegExp) => QueryAllReturn,
+  queryAllByHintText: (string | RegExp) => QueryAllReturn,
   findByA11yHint: (string | RegExp, ?WaitForOptions) => FindReturn,
+  findByHintText: (string | RegExp, ?WaitForOptions) => FindReturn,
   findAllByA11yHint: (string | RegExp, ?WaitForOptions) => FindAllReturn,
+  findAllByHintText: (string | RegExp, ?WaitForOptions) => FindAllReturn,
 
   // Role
   getByA11yRole: (A11yRole | RegExp) => GetReturn,
+  getByRole: (A11yRole | RegExp) => GetReturn,
   getAllByA11yRole: (A11yRole | RegExp) => GetAllReturn,
+  getAllByRole: (A11yRole | RegExp) => GetAllReturn,
   queryByA11yRole: (A11yRole | RegExp) => QueryReturn,
+  queryByRole: (A11yRole | RegExp) => QueryReturn,
   queryAllByA11yRole: (A11yRole | RegExp) => QueryAllReturn,
+  queryAllByRole: (A11yRole | RegExp) => QueryAllReturn,
   findByA11yRole: (A11yRole, ?WaitForOptions) => FindReturn,
+  findByRole: (A11yRole, ?WaitForOptions) => FindReturn,
   findAllByA11yRole: (A11yRole, ?WaitForOptions) => FindAllReturn,
+  findAllByRole: (A11yRole, ?WaitForOptions) => FindAllReturn,
 
   // States
   getByA11yStates: (A11yStates | Array<A11yStates>) => GetReturn,
diff --git a/typings/index.d.ts b/typings/index.d.ts
index 1ce700596..da01039a7 100644
--- a/typings/index.d.ts
+++ b/typings/index.d.ts
@@ -167,45 +167,81 @@ export type A11yValue = {
 type A11yAPI = {
   // Label
   getByA11yLabel: (matcher: string | RegExp) => GetReturn;
+  getByLabelText: (matcher: string | RegExp) => GetReturn;
   getAllByA11yLabel: (matcher: string | RegExp) => GetAllReturn;
+  getAllByLabelText: (matcher: string | RegExp) => GetAllReturn;
   queryByA11yLabel: (matcher: string | RegExp) => QueryReturn;
+  queryByLabelText: (matcher: string | RegExp) => QueryReturn;
   queryAllByA11yLabel: (matcher: string | RegExp) => QueryAllReturn;
+  queryAllByLabelText: (matcher: string | RegExp) => QueryAllReturn;
   findByA11yLabel: (
     matcher: string | RegExp,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
+  findByLabelText: (
+    matcher: string | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
   findAllByA11yLabel: (
     matcher: string | RegExp,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
+  findAllByLabelText: (
+    matcher: string | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
 
   // Hint
   getByA11yHint: (matcher: string | RegExp) => GetReturn;
+  getByHintText: (matcher: string | RegExp) => GetReturn;
   getAllByA11yHint: (matcher: string | RegExp) => GetAllReturn;
+  getAllByHintText: (matcher: string | RegExp) => GetAllReturn;
   queryByA11yHint: (matcher: string | RegExp) => QueryReturn;
+  queryByHintText: (matcher: string | RegExp) => QueryReturn;
   queryAllByA11yHint: (matcher: string | RegExp) => QueryAllReturn;
+  queryAllByHintText: (matcher: string | RegExp) => QueryAllReturn;
   findByA11yHint: (
     matcher: string | RegExp,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
+  findByHintText: (
+    matcher: string | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
   findAllByA11yHint: (
     matcher: string | RegExp,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
+  findAllByHintText: (
+    matcher: string | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
 
   // Role
   getByA11yRole: (matcher: AccessibilityRole | RegExp) => GetReturn;
+  getByRole: (matcher: AccessibilityRole | RegExp) => GetReturn;
   getAllByA11yRole: (matcher: AccessibilityRole | RegExp) => GetAllReturn;
+  getAllByRole: (matcher: AccessibilityRole | RegExp) => GetAllReturn;
   queryByA11yRole: (matcher: AccessibilityRole | RegExp) => QueryReturn;
+  queryByRole: (matcher: AccessibilityRole | RegExp) => QueryReturn;
   queryAllByA11yRole: (matcher: AccessibilityRole | RegExp) => QueryAllReturn;
+  queryAllByRole: (matcher: AccessibilityRole | RegExp) => QueryAllReturn;
   findByA11yRole: (
     matcher: AccessibilityRole | RegExp,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
+  findByRole: (
+    matcher: AccessibilityRole | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
   findAllByA11yRole: (
     matcher: AccessibilityRole | RegExp,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
+  findAllByRole: (
+    matcher: AccessibilityRole | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
 
   // States
   getByA11yStates: (

From 2a69935579a101189fff1aaed719baac80941355 Mon Sep 17 00:00:00 2001
From: Ryan Wessel <rwessel@dataminr.com>
Date: Fri, 17 Jul 2020 14:23:25 -0400
Subject: [PATCH 05/12] test: Add tests for newly-aliased label, hint, and role
 a11y queries

---
 src/__tests__/a11yAPI.test.js | 129 +++++++++++++++++++++++++++++++++-
 1 file changed, 127 insertions(+), 2 deletions(-)

diff --git a/src/__tests__/a11yAPI.test.js b/src/__tests__/a11yAPI.test.js
index 1524a0a35..68ace6c7a 100644
--- a/src/__tests__/a11yAPI.test.js
+++ b/src/__tests__/a11yAPI.test.js
@@ -90,7 +90,35 @@ test('getByA11yLabel, queryByA11yLabel, findByA11yLabel', async () => {
   );
 });
 
-test('getAllByA11yLabel, queryAllByA11yLabel', async () => {
+test('getByLabelText, queryByLabelText, findByLabelText', async () => {
+  const { getByLabelText, queryByLabelText, findByLabelText } = render(
+    <Section />
+  );
+
+  expect(getByLabelText(BUTTON_LABEL).props.accessibilityLabel).toEqual(
+    BUTTON_LABEL
+  );
+  const button = queryByLabelText(/button/g);
+  expect(button && button.props.accessibilityLabel).toEqual(BUTTON_LABEL);
+
+  expect(() => getByLabelText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
+  expect(queryByLabelText(NO_MATCHES_TEXT)).toBeNull();
+
+  expect(() => getByLabelText(TEXT_LABEL)).toThrow(FOUND_TWO_INSTANCES);
+  expect(() => queryByLabelText(TEXT_LABEL)).toThrow(FOUND_TWO_INSTANCES);
+
+  const asyncButton = await findByLabelText(BUTTON_LABEL);
+  expect(asyncButton.props.accessibilityLabel).toEqual(BUTTON_LABEL);
+  await expect(
+    findByLabelText(NO_MATCHES_TEXT, waitForOptions)
+  ).rejects.toThrow(NO_INSTANCES_FOUND);
+
+  await expect(findByLabelText(TEXT_LABEL, waitForOptions)).rejects.toThrow(
+    FOUND_TWO_INSTANCES
+  );
+});
+
+test('getAllByA11yLabel, queryAllByA11yLabel, findAllByA11yLabel', async () => {
   const { getAllByA11yLabel, queryAllByA11yLabel, findAllByA11yLabel } = render(
     <Section />
   );
@@ -107,6 +135,23 @@ test('getAllByA11yLabel, queryAllByA11yLabel', async () => {
   );
 });
 
+test('getAllByLabelText, queryAllByLabelText, findAllByLabelText', async () => {
+  const { getAllByLabelText, queryAllByLabelText, findAllByLabelText } = render(
+    <Section />
+  );
+
+  expect(getAllByLabelText(TEXT_LABEL)).toHaveLength(2);
+  expect(queryAllByLabelText(/cool/g)).toHaveLength(3);
+
+  expect(() => getAllByLabelText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
+  expect(queryAllByLabelText(NO_MATCHES_TEXT)).toEqual([]);
+
+  await expect(findAllByLabelText(TEXT_LABEL)).resolves.toHaveLength(2);
+  await expect(findAllByLabelText(NO_MATCHES_TEXT)).rejects.toThrow(
+    NO_INSTANCES_FOUND
+  );
+});
+
 test('getByA11yHint, queryByA11yHint, findByA11yHint', async () => {
   const { getByA11yHint, queryByA11yHint, findByA11yHint } = render(
     <Section />
@@ -134,7 +179,34 @@ test('getByA11yHint, queryByA11yHint, findByA11yHint', async () => {
   );
 });
 
-test('getAllByA11yHint, queryAllByA11yHint', async () => {
+test('getByHintText, queryByHintText, findByHintText', async () => {
+  const { getByHintText, queryByHintText, findByHintText } = render(
+    <Section />
+  );
+
+  expect(getByHintText(BUTTON_HINT).props.accessibilityHint).toEqual(
+    BUTTON_HINT
+  );
+  const button = queryByHintText(/button/g);
+  expect(button && button.props.accessibilityHint).toEqual(BUTTON_HINT);
+
+  expect(() => getByHintText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
+  expect(queryByHintText(NO_MATCHES_TEXT)).toBeNull();
+
+  expect(() => getByHintText(TEXT_HINT)).toThrow(FOUND_TWO_INSTANCES);
+  expect(() => queryByHintText(TEXT_HINT)).toThrow(FOUND_TWO_INSTANCES);
+
+  const asyncButton = await findByHintText(BUTTON_HINT);
+  expect(asyncButton.props.accessibilityHint).toEqual(BUTTON_HINT);
+  await expect(findByHintText(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
+    NO_INSTANCES_FOUND
+  );
+  await expect(findByHintText(TEXT_HINT, waitForOptions)).rejects.toThrow(
+    FOUND_TWO_INSTANCES
+  );
+});
+
+test('getAllByA11yHint, queryAllByA11yHint, findAllByA11yHint', async () => {
   const { getAllByA11yHint, queryAllByA11yHint, findAllByA11yHint } = render(
     <Section />
   );
@@ -151,6 +223,23 @@ test('getAllByA11yHint, queryAllByA11yHint', async () => {
   );
 });
 
+test('getAllByHintText, queryAllByHintText, findAllByHintText', async () => {
+  const { getAllByHintText, queryAllByHintText, findAllByHintText } = render(
+    <Section />
+  );
+
+  expect(getAllByHintText(TEXT_HINT)).toHaveLength(2);
+  expect(queryAllByHintText(/static/g)).toHaveLength(2);
+
+  expect(() => getAllByHintText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
+  expect(queryAllByHintText(NO_MATCHES_TEXT)).toEqual([]);
+
+  await expect(findAllByHintText(TEXT_HINT)).resolves.toHaveLength(2);
+  await expect(findAllByHintText(NO_MATCHES_TEXT)).rejects.toThrow(
+    NO_INSTANCES_FOUND
+  );
+});
+
 test('getByA11yRole, queryByA11yRole, findByA11yRole', async () => {
   const { getByA11yRole, queryByA11yRole, findByA11yRole } = render(
     <Section />
@@ -174,6 +263,27 @@ test('getByA11yRole, queryByA11yRole, findByA11yRole', async () => {
   await expect(findByA11yRole('link')).rejects.toThrow(FOUND_TWO_INSTANCES);
 });
 
+test('getByRole, queryByRole, findByRole', async () => {
+  const { getByRole, queryByRole, findByRole } = render(<Section />);
+
+  expect(getByRole('button').props.accessibilityRole).toEqual('button');
+  const button = queryByRole(/button/g);
+  expect(button && button.props.accessibilityRole).toEqual('button');
+
+  expect(() => getByRole(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
+  expect(queryByRole(NO_MATCHES_TEXT)).toBeNull();
+
+  expect(() => getByRole('link')).toThrow(FOUND_TWO_INSTANCES);
+  expect(() => queryByRole('link')).toThrow(FOUND_TWO_INSTANCES);
+
+  const asyncButton = await findByRole('button');
+  expect(asyncButton.props.accessibilityRole).toEqual('button');
+  await expect(findByRole(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
+    NO_INSTANCES_FOUND
+  );
+  await expect(findByRole('link')).rejects.toThrow(FOUND_TWO_INSTANCES);
+});
+
 test('getAllByA11yRole, queryAllByA11yRole, findAllByA11yRole', async () => {
   const { getAllByA11yRole, queryAllByA11yRole, findAllByA11yRole } = render(
     <Section />
@@ -191,6 +301,21 @@ test('getAllByA11yRole, queryAllByA11yRole, findAllByA11yRole', async () => {
   ).rejects.toThrow(NO_INSTANCES_FOUND);
 });
 
+test('getAllByRole, queryAllByRole, findAllByRole', async () => {
+  const { getAllByRole, queryAllByRole, findAllByRole } = render(<Section />);
+
+  expect(getAllByRole('link')).toHaveLength(2);
+  expect(queryAllByRole(/ink/g)).toHaveLength(2);
+
+  expect(() => getAllByRole(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
+  expect(queryAllByRole(NO_MATCHES_TEXT)).toEqual([]);
+
+  await expect(findAllByRole('link')).resolves.toHaveLength(2);
+  await expect(findAllByRole(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
+    NO_INSTANCES_FOUND
+  );
+});
+
 // TODO: accessibilityStates was removed from RN 0.62
 test.skip('getByA11yStates, queryByA11yStates', () => {
   const { getByA11yStates, queryByA11yStates } = render(<Section />);

From 82f2b4de902fbdca6da54f0bcca24b3aa559394a Mon Sep 17 00:00:00 2001
From: Ryan Wessel <rwessel@dataminr.com>
Date: Fri, 17 Jul 2020 14:24:39 -0400
Subject: [PATCH 06/12] test: Add newly-alised a11y queries to the index
 typings test file

---
 typings/__tests__/index.test.tsx | 40 ++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/typings/__tests__/index.test.tsx b/typings/__tests__/index.test.tsx
index 7cf125812..fb45261f7 100644
--- a/typings/__tests__/index.test.tsx
+++ b/typings/__tests__/index.test.tsx
@@ -41,8 +41,11 @@ const getBy: ReactTestInstance[] = [
   tree.getByDisplayValue(/value/g),
   tree.getByTestId('test-id'),
   tree.getByA11yLabel('label'),
+  tree.getByLabelText('label'),
   tree.getByA11yHint('label'),
+  tree.getByHintText('label'),
   tree.getByA11yRole('button'),
+  tree.getByRole('button'),
   tree.getByA11yStates('selected'),
   tree.getByA11yStates(['selected']),
   tree.getByA11yState({ busy: true }),
@@ -61,8 +64,11 @@ const getAllBy: ReactTestInstance[][] = [
   tree.getAllByDisplayValue(/value/g),
   tree.getAllByTestId('test-id'),
   tree.getAllByA11yLabel('label'),
+  tree.getAllByLabelText('label'),
   tree.getAllByA11yHint('label'),
+  tree.getAllByHintText('label'),
   tree.getAllByA11yRole('button'),
+  tree.getAllByRole('button'),
   tree.getAllByA11yStates('selected'),
   tree.getAllByA11yStates(['selected']),
   tree.getAllByA11yState({ busy: true }),
@@ -82,8 +88,11 @@ const queryBy: Array<ReactTestInstance | null> = [
   tree.queryByDisplayValue(/value/g),
   tree.queryByTestId('test-id'),
   tree.queryByA11yHint('label'),
+  tree.queryByHintText('label'),
   tree.queryByA11yLabel('label'),
+  tree.queryByLabelText('label'),
   tree.queryByA11yRole('button'),
+  tree.queryByRole('button'),
   tree.queryByA11yStates('selected'),
   tree.queryByA11yStates(['selected']),
   tree.queryByA11yState({ busy: true }),
@@ -102,8 +111,11 @@ const queryAllBy: ReactTestInstance[][] = [
   tree.queryAllByDisplayValue(/value/g),
   tree.queryAllByTestId('test-id'),
   tree.queryAllByA11yLabel('label'),
+  tree.queryAllByLabelText('label'),
   tree.queryAllByA11yHint('label'),
+  tree.queryAllByHintText('label'),
   tree.queryAllByA11yRole('button'),
+  tree.queryAllByRole('button'),
   tree.queryAllByA11yStates('selected'),
   tree.queryAllByA11yStates(['selected']),
   tree.queryAllByA11yState({ busy: true }),
@@ -131,10 +143,16 @@ const findBy: Promise<ReactTestInstance>[] = [
   tree.findByTestId('test-id', { timeout: 10, interval: 10 }),
   tree.findByA11yLabel('label'),
   tree.findByA11yLabel('label', { timeout: 10, interval: 10 }),
+  tree.findByLabelText('label'),
+  tree.findByLabelText('label', { timeout: 10, interval: 10 }),
   tree.findByA11yHint('label'),
   tree.findByA11yHint('label', { timeout: 10, interval: 10 }),
+  tree.findByHintText('label'),
+  tree.findByHintText('label', { timeout: 10, interval: 10 }),
   tree.findByA11yRole('button'),
   tree.findByA11yRole('button', { timeout: 10, interval: 10 }),
+  tree.findByRole('button'),
+  tree.findByRole('button', { timeout: 10, interval: 10 }),
   tree.findByA11yState({ busy: true }),
   tree.findByA11yState({ busy: true }, { timeout: 10, interval: 10 }),
   tree.findByA11yValue({ min: 10 }),
@@ -158,8 +176,12 @@ const findAllBy: Promise<ReactTestInstance[]>[] = [
   tree.findAllByTestId('test-id', { timeout: 10, interval: 10 }),
   tree.findAllByA11yLabel('label'),
   tree.findAllByA11yLabel('label', { timeout: 10, interval: 10 }),
+  tree.findAllByLabelText('label'),
+  tree.findAllByLabelText('label', { timeout: 10, interval: 10 }),
   tree.findAllByA11yHint('label'),
   tree.findAllByA11yHint('label', { timeout: 10, interval: 10 }),
+  tree.findAllByHintText('label'),
+  tree.findAllByHintText('label', { timeout: 10, interval: 10 }),
   tree.findAllByA11yState({ busy: true }),
   tree.findAllByA11yState({ busy: true }, { timeout: 10, interval: 10 }),
   tree.findAllByA11yValue({ min: 10 }),
@@ -274,8 +296,11 @@ const withinGet: Array<ReactTestInstance> = [
   within(instance).getByPlaceholder('Test'),
   within(instance).getByTestId('Test'),
   within(instance).getByA11yLabel('Test'),
+  within(instance).getByLabelText('Test'),
   within(instance).getByA11yHint('Test'),
+  within(instance).getByHintText('Test'),
   within(instance).getByA11yRole('button'),
+  within(instance).getByRole('button'),
   within(instance).getByA11yState({ busy: true }),
   within(instance).getByA11yValue({ min: 10 }),
 ];
@@ -286,8 +311,11 @@ const withinGetAll: Array<ReactTestInstance[]> = [
   within(instance).getAllByPlaceholder('Test'),
   within(instance).getAllByTestId('Test'),
   within(instance).getAllByA11yLabel('Test'),
+  within(instance).getAllByLabelText('button'),
   within(instance).getAllByA11yHint('Test'),
+  within(instance).getAllByHintText('button'),
   within(instance).getAllByA11yRole('button'),
+  within(instance).getAllByRole('button'),
   within(instance).getAllByA11yState({ busy: true }),
   within(instance).getAllByA11yValue({ min: 10 }),
 ];
@@ -298,8 +326,11 @@ const withinQuery: Array<ReactTestInstance | null> = [
   within(instance).queryByPlaceholder('Test'),
   within(instance).queryByTestId('Test'),
   within(instance).queryByA11yLabel('Test'),
+  within(instance).queryByLabelText('button'),
   within(instance).queryByA11yHint('Test'),
+  within(instance).queryByHintText('button'),
   within(instance).queryByA11yRole('button'),
+  within(instance).queryByRole('button'),
   within(instance).queryByA11yState({ busy: true }),
   within(instance).queryByA11yValue({ min: 10 }),
 ];
@@ -310,8 +341,11 @@ const withinQueryAll: Array<ReactTestInstance[]> = [
   within(instance).queryAllByPlaceholder('Test'),
   within(instance).queryAllByTestId('Test'),
   within(instance).queryAllByA11yLabel('Test'),
+  within(instance).queryAllByLabelText('Test'),
   within(instance).queryAllByA11yHint('Test'),
+  within(instance).queryAllByHintText('Test'),
   within(instance).queryAllByA11yRole('button'),
+  within(instance).queryAllByRole('button'),
   within(instance).queryAllByA11yState({ busy: true }),
   within(instance).queryAllByA11yValue({ min: 10 }),
 ];
@@ -322,8 +356,11 @@ const withinFind: Promise<ReactTestInstance>[] = [
   within(instance).findByPlaceholder('Test'),
   within(instance).findByTestId('Test'),
   within(instance).findByA11yLabel('Test'),
+  within(instance).findByLabelText('Test'),
   within(instance).findByA11yHint('Test'),
+  within(instance).findByHintText('Test'),
   within(instance).findByA11yRole('button'),
+  within(instance).findByRole('button'),
   within(instance).findByA11yState({ busy: true }),
   within(instance).findByA11yValue({ min: 10 }),
 ];
@@ -334,8 +371,11 @@ const withinFindAll: Promise<ReactTestInstance[]>[] = [
   within(instance).findAllByPlaceholder('Test'),
   within(instance).findAllByTestId('Test'),
   within(instance).findAllByA11yLabel('Test'),
+  within(instance).findAllByLabelText('Test'),
   within(instance).findAllByA11yHint('Test'),
+  within(instance).findAllByHintText('Test'),
   within(instance).findAllByA11yRole('button'),
+  within(instance).findAllByRole('button'),
   within(instance).findAllByA11yState({ busy: true }),
   within(instance).findAllByA11yValue({ min: 10 }),
 ];

From f19f94027efdaf5d2385205fce7d2ddedb771745 Mon Sep 17 00:00:00 2001
From: Ryan Wessel <rwessel@dataminr.com>
Date: Mon, 20 Jul 2020 13:08:08 -0400
Subject: [PATCH 07/12] docs: Add query aliases for testing library migrators
 to Queries documentation

---
 website/docs/Queries.md | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/website/docs/Queries.md b/website/docs/Queries.md
index 5a288b119..756c97cb8 100644
--- a/website/docs/Queries.md
+++ b/website/docs/Queries.md
@@ -111,10 +111,11 @@ const element = getByTestId('unique-id');
 Please be mindful when using these API and **treat it as an escape hatch**. Your users can't interact with `testID` anyhow, so you may end up writing tests that provide false sense of security. Favor text and accessibility queries instead.
 :::
 
-### `ByA11yLabel`, `ByAccessibilityLabel`
+### `ByA11yLabel`, `ByAccessibilityLabel`, `ByLabelText`
 
 > getByA11yLabel, getAllByA11yLabel, queryByA11yLabel, queryAllByA11yLabel, findByA11yLabel, findAllByA11yLabel
 > getByAccessibilityLabel, getAllByAccessibilityLabel, queryByAccessibilityLabel, queryAllByAccessibilityLabel, findByAccessibilityLabel, findAllByAccessibilityLabel
+> getByLabelText, getAllByLabelText, queryByLabelText, queryAllByLabelText, findByLabelText, findAllByLabelText
 
 Returns a `ReactTestInstance` with matching `accessibilityLabel` prop.
 
@@ -125,10 +126,11 @@ const { getByA11yLabel } = render(<MyComponent />);
 const element = getByA11yLabel('my-label');
 ```
 
-### `ByA11yHint`, `ByAccessibilityHint`
+### `ByA11yHint`, `ByAccessibilityHint`, `ByHintText`
 
 > getByA11yHint, getAllByA11yHint, queryByA11yHint, queryAllByA11yHint, findByA11yHint, findAllByA11yHint
 > getByAccessibilityHint, getAllByAccessibilityHint, queryByAccessibilityHint, queryAllByAccessibilityHint, findByAccessibilityHint, findAllByAccessibilityHint
+> getByHintText, getAllByHintText, queryByHintText, queryAllByHintText, findByHintText, findAllByHintText
 
 Returns a `ReactTestInstance` with matching `accessibilityHint` prop.
 
@@ -154,10 +156,11 @@ const element = getByA11yStates(['checked']);
 const element2 = getByA11yStates('checked');
 ```
 
-### `ByA11yRole`, `ByAccessibilityRole`
+### `ByA11yRole`, `ByAccessibilityRole`, `ByRole`
 
 > getByA11yRole, getAllByA11yRole, queryByA11yRole, queryAllByA11yRole, findByA11yRole, findAllByA11yRole
 > getByAccessibilityRole, getAllByAccessibilityRole, queryByAccessibilityRole, queryAllByAccessibilityRole, findByAccessibilityRole, findAllByAccessibilityRole
+> getByRole, getAllByRole, queryByRole, queryAllByRole, findByRole, findAllByRole
 
 Returns a `ReactTestInstance` with matching `accessibilityRole` prop.
 

From be98ebe39f9e7d73ba57405a989597c5c47557dd Mon Sep 17 00:00:00 2001
From: Ryan Wessel <rwessel@dataminr.com>
Date: Mon, 20 Jul 2020 13:22:10 -0400
Subject: [PATCH 08/12] test: Consolidate aliased query tests into shared
 tests. FIXME's where there are errors

---
 src/__tests__/a11yAPI.test.js | 271 +++++++++++++++++-----------------
 1 file changed, 134 insertions(+), 137 deletions(-)

diff --git a/src/__tests__/a11yAPI.test.js b/src/__tests__/a11yAPI.test.js
index 68ace6c7a..56b9a9802 100644
--- a/src/__tests__/a11yAPI.test.js
+++ b/src/__tests__/a11yAPI.test.js
@@ -62,255 +62,252 @@ function Section() {
   );
 }
 
-test('getByA11yLabel, queryByA11yLabel, findByA11yLabel', async () => {
-  const { getByA11yLabel, queryByA11yLabel, findByA11yLabel } = render(
-    <Section />
-  );
+test('getByA11yLabel, getByLabelText, queryByA11yLabel, queryByLabelText, findByA11yLabel, findByLabelText', async () => {
+  const {
+    getByA11yLabel,
+    getByLabelText,
+    queryByA11yLabel,
+    queryByLabelText,
+    findByA11yLabel,
+    findByLabelText,
+  } = render(<Section />);
 
   expect(getByA11yLabel(BUTTON_LABEL).props.accessibilityLabel).toEqual(
     BUTTON_LABEL
   );
+  expect(getByLabelText(BUTTON_LABEL).props.accessibilityLabel).toEqual(
+    BUTTON_LABEL
+  );
   const button = queryByA11yLabel(/button/g);
   expect(button && button.props.accessibilityLabel).toEqual(BUTTON_LABEL);
+  const buttonAlias = queryByA11yLabel(/button/g);
+  expect(buttonAlias && buttonAlias.props.accessibilityLabel).toEqual(
+    BUTTON_LABEL
+  );
 
   expect(() => getByA11yLabel(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
+  expect(() => getByLabelText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
   expect(queryByA11yLabel(NO_MATCHES_TEXT)).toBeNull();
+  expect(queryByLabelText(NO_MATCHES_TEXT)).toBeNull();
 
   expect(() => getByA11yLabel(TEXT_LABEL)).toThrow(FOUND_TWO_INSTANCES);
+  expect(() => getByLabelText(TEXT_LABEL)).toThrow(FOUND_TWO_INSTANCES);
   expect(() => queryByA11yLabel(TEXT_LABEL)).toThrow(FOUND_TWO_INSTANCES);
+  expect(() => queryByLabelText(TEXT_LABEL)).toThrow(FOUND_TWO_INSTANCES);
 
   const asyncButton = await findByA11yLabel(BUTTON_LABEL);
   expect(asyncButton.props.accessibilityLabel).toEqual(BUTTON_LABEL);
   await expect(
     findByA11yLabel(NO_MATCHES_TEXT, waitForOptions)
   ).rejects.toThrow(NO_INSTANCES_FOUND);
-
-  await expect(findByA11yLabel(TEXT_LABEL, waitForOptions)).rejects.toThrow(
-    FOUND_TWO_INSTANCES
-  );
-});
-
-test('getByLabelText, queryByLabelText, findByLabelText', async () => {
-  const { getByLabelText, queryByLabelText, findByLabelText } = render(
-    <Section />
-  );
-
-  expect(getByLabelText(BUTTON_LABEL).props.accessibilityLabel).toEqual(
-    BUTTON_LABEL
-  );
-  const button = queryByLabelText(/button/g);
-  expect(button && button.props.accessibilityLabel).toEqual(BUTTON_LABEL);
-
-  expect(() => getByLabelText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
-  expect(queryByLabelText(NO_MATCHES_TEXT)).toBeNull();
-
-  expect(() => getByLabelText(TEXT_LABEL)).toThrow(FOUND_TWO_INSTANCES);
-  expect(() => queryByLabelText(TEXT_LABEL)).toThrow(FOUND_TWO_INSTANCES);
-
-  const asyncButton = await findByLabelText(BUTTON_LABEL);
-  expect(asyncButton.props.accessibilityLabel).toEqual(BUTTON_LABEL);
+  const asyncButtonAlias = await findByLabelText(BUTTON_LABEL);
+  expect(asyncButtonAlias.props.accessibilityLabel).toEqual(BUTTON_LABEL);
   await expect(
     findByLabelText(NO_MATCHES_TEXT, waitForOptions)
   ).rejects.toThrow(NO_INSTANCES_FOUND);
 
+  await expect(findByA11yLabel(TEXT_LABEL, waitForOptions)).rejects.toThrow(
+    FOUND_TWO_INSTANCES
+  );
   await expect(findByLabelText(TEXT_LABEL, waitForOptions)).rejects.toThrow(
     FOUND_TWO_INSTANCES
   );
 });
 
-test('getAllByA11yLabel, queryAllByA11yLabel, findAllByA11yLabel', async () => {
-  const { getAllByA11yLabel, queryAllByA11yLabel, findAllByA11yLabel } = render(
-    <Section />
-  );
+test('getAllByA11yLabel, getAllByLabelText, queryAllByA11yLabel, queryAllByLabelText, findAllByA11yLabel, findAllByLabelText', async () => {
+  const {
+    getAllByA11yLabel,
+    getAllByLabelText,
+    queryAllByA11yLabel,
+    queryAllByLabelText,
+    findAllByA11yLabel,
+    findAllByLabelText,
+  } = render(<Section />);
 
   expect(getAllByA11yLabel(TEXT_LABEL)).toHaveLength(2);
-  expect(queryAllByA11yLabel(/cool/g)).toHaveLength(3);
-
-  expect(() => getAllByA11yLabel(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
-  expect(queryAllByA11yLabel(NO_MATCHES_TEXT)).toEqual([]);
-
-  await expect(findAllByA11yLabel(TEXT_LABEL)).resolves.toHaveLength(2);
-  await expect(findAllByA11yLabel(NO_MATCHES_TEXT)).rejects.toThrow(
-    NO_INSTANCES_FOUND
-  );
-});
-
-test('getAllByLabelText, queryAllByLabelText, findAllByLabelText', async () => {
-  const { getAllByLabelText, queryAllByLabelText, findAllByLabelText } = render(
-    <Section />
-  );
-
   expect(getAllByLabelText(TEXT_LABEL)).toHaveLength(2);
+  expect(queryAllByA11yLabel(/cool/g)).toHaveLength(3);
   expect(queryAllByLabelText(/cool/g)).toHaveLength(3);
 
+  expect(() => getAllByA11yLabel(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
   expect(() => getAllByLabelText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
+  expect(queryAllByA11yLabel(NO_MATCHES_TEXT)).toEqual([]);
   expect(queryAllByLabelText(NO_MATCHES_TEXT)).toEqual([]);
 
+  await expect(findAllByA11yLabel(TEXT_LABEL)).resolves.toHaveLength(2);
   await expect(findAllByLabelText(TEXT_LABEL)).resolves.toHaveLength(2);
-  await expect(findAllByLabelText(NO_MATCHES_TEXT)).rejects.toThrow(
+  await expect(findAllByA11yLabel(NO_MATCHES_TEXT)).rejects.toThrow(
     NO_INSTANCES_FOUND
   );
+  /**
+   * FIXME:
+   * Additional await expect yields the following:
+   * Expected substring: "No instances found"
+   * Received message:   "Unable to find node on an unmounted component."
+   */
+  // await expect(findAllByLabelText(NO_MATCHES_TEXT)).rejects.toThrow(
+  //   NO_INSTANCES_FOUND
+  // );
 });
 
-test('getByA11yHint, queryByA11yHint, findByA11yHint', async () => {
-  const { getByA11yHint, queryByA11yHint, findByA11yHint } = render(
-    <Section />
-  );
+test('getByA11yHint, getByHintText, queryByA11yHint, queryByHintText, findByA11yHint, findByHintText', async () => {
+  const {
+    getByA11yHint,
+    getByHintText,
+    queryByA11yHint,
+    queryByHintText,
+    findByA11yHint,
+    findByHintText,
+  } = render(<Section />);
 
   expect(getByA11yHint(BUTTON_HINT).props.accessibilityHint).toEqual(
     BUTTON_HINT
   );
+  expect(getByHintText(BUTTON_HINT).props.accessibilityHint).toEqual(
+    BUTTON_HINT
+  );
   const button = queryByA11yHint(/button/g);
   expect(button && button.props.accessibilityHint).toEqual(BUTTON_HINT);
+  const buttonAlias = queryByHintText(/button/g);
+  expect(buttonAlias && buttonAlias.props.accessibilityHint).toEqual(
+    BUTTON_HINT
+  );
 
   expect(() => getByA11yHint(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
+  expect(() => getByHintText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
   expect(queryByA11yHint(NO_MATCHES_TEXT)).toBeNull();
+  expect(queryByHintText(NO_MATCHES_TEXT)).toBeNull();
 
   expect(() => getByA11yHint(TEXT_HINT)).toThrow(FOUND_TWO_INSTANCES);
+  expect(() => getByHintText(TEXT_HINT)).toThrow(FOUND_TWO_INSTANCES);
   expect(() => queryByA11yHint(TEXT_HINT)).toThrow(FOUND_TWO_INSTANCES);
+  expect(() => queryByHintText(TEXT_HINT)).toThrow(FOUND_TWO_INSTANCES);
 
   const asyncButton = await findByA11yHint(BUTTON_HINT);
   expect(asyncButton.props.accessibilityHint).toEqual(BUTTON_HINT);
+  const asyncButtonAlias = await findByA11yHint(BUTTON_HINT);
+  expect(asyncButtonAlias.props.accessibilityHint).toEqual(BUTTON_HINT);
   await expect(findByA11yHint(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
     NO_INSTANCES_FOUND
   );
-  await expect(findByA11yHint(TEXT_HINT, waitForOptions)).rejects.toThrow(
-    FOUND_TWO_INSTANCES
-  );
-});
-
-test('getByHintText, queryByHintText, findByHintText', async () => {
-  const { getByHintText, queryByHintText, findByHintText } = render(
-    <Section />
-  );
-
-  expect(getByHintText(BUTTON_HINT).props.accessibilityHint).toEqual(
-    BUTTON_HINT
-  );
-  const button = queryByHintText(/button/g);
-  expect(button && button.props.accessibilityHint).toEqual(BUTTON_HINT);
-
-  expect(() => getByHintText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
-  expect(queryByHintText(NO_MATCHES_TEXT)).toBeNull();
-
-  expect(() => getByHintText(TEXT_HINT)).toThrow(FOUND_TWO_INSTANCES);
-  expect(() => queryByHintText(TEXT_HINT)).toThrow(FOUND_TWO_INSTANCES);
-
-  const asyncButton = await findByHintText(BUTTON_HINT);
-  expect(asyncButton.props.accessibilityHint).toEqual(BUTTON_HINT);
   await expect(findByHintText(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
     NO_INSTANCES_FOUND
   );
+  await expect(findByA11yHint(TEXT_HINT, waitForOptions)).rejects.toThrow(
+    FOUND_TWO_INSTANCES
+  );
   await expect(findByHintText(TEXT_HINT, waitForOptions)).rejects.toThrow(
     FOUND_TWO_INSTANCES
   );
 });
 
-test('getAllByA11yHint, queryAllByA11yHint, findAllByA11yHint', async () => {
-  const { getAllByA11yHint, queryAllByA11yHint, findAllByA11yHint } = render(
-    <Section />
-  );
+test('getAllByA11yHint, getAllByHintText, queryAllByA11yHint, queryAllByHintText, findAllByA11yHint, findAllByHintText', async () => {
+  const {
+    getAllByA11yHint,
+    getAllByHintText,
+    queryAllByA11yHint,
+    queryAllByHintText,
+    findAllByA11yHint,
+    findAllByHintText,
+  } = render(<Section />);
 
   expect(getAllByA11yHint(TEXT_HINT)).toHaveLength(2);
-  expect(queryAllByA11yHint(/static/g)).toHaveLength(2);
-
-  expect(() => getAllByA11yHint(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
-  expect(queryAllByA11yHint(NO_MATCHES_TEXT)).toEqual([]);
-
-  await expect(findAllByA11yHint(TEXT_HINT)).resolves.toHaveLength(2);
-  await expect(findAllByA11yHint(NO_MATCHES_TEXT)).rejects.toThrow(
-    NO_INSTANCES_FOUND
-  );
-});
-
-test('getAllByHintText, queryAllByHintText, findAllByHintText', async () => {
-  const { getAllByHintText, queryAllByHintText, findAllByHintText } = render(
-    <Section />
-  );
-
   expect(getAllByHintText(TEXT_HINT)).toHaveLength(2);
+  expect(queryAllByA11yHint(/static/g)).toHaveLength(2);
   expect(queryAllByHintText(/static/g)).toHaveLength(2);
 
+  expect(() => getAllByA11yHint(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
   expect(() => getAllByHintText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
+  expect(queryAllByA11yHint(NO_MATCHES_TEXT)).toEqual([]);
   expect(queryAllByHintText(NO_MATCHES_TEXT)).toEqual([]);
 
+  await expect(findAllByA11yHint(TEXT_HINT)).resolves.toHaveLength(2);
   await expect(findAllByHintText(TEXT_HINT)).resolves.toHaveLength(2);
-  await expect(findAllByHintText(NO_MATCHES_TEXT)).rejects.toThrow(
+  await expect(findAllByA11yHint(NO_MATCHES_TEXT)).rejects.toThrow(
     NO_INSTANCES_FOUND
   );
+  /**
+   * FIXME:
+   * Additional await expect yields the following:
+   * Expected substring: "No instances found"
+   * Received message:   "Unable to find node on an unmounted component."
+   */
+  // await expect(findAllByHintText(NO_MATCHES_TEXT)).rejects.toThrow(
+  //   NO_INSTANCES_FOUND
+  // );
 });
 
-test('getByA11yRole, queryByA11yRole, findByA11yRole', async () => {
-  const { getByA11yRole, queryByA11yRole, findByA11yRole } = render(
-    <Section />
-  );
+/**
+ * FIXME:
+ * Entire test failing due to the following error:
+ * : Timeout - Async callback was not invoked within the 5000 ms timeout specified by jest.setTimeout.Timeout - Async callback was not invoked within the 5000 ms timeout specified by jest.setTimeout.Error:
+ */
+test.skip('getByA11yRole, getByRole, queryByA11yRole, queryByRole, findByA11yRole, findByRole', async () => {
+  const {
+    getByA11yRole,
+    getByRole,
+    queryByA11yRole,
+    queryByRole,
+    findByA11yRole,
+    findByRole,
+  } = render(<Section />);
 
   expect(getByA11yRole('button').props.accessibilityRole).toEqual('button');
+  expect(getByRole('button').props.accessibilityRole).toEqual('button');
   const button = queryByA11yRole(/button/g);
   expect(button && button.props.accessibilityRole).toEqual('button');
+  const buttonAlias = queryByA11yRole(/button/g);
+  expect(buttonAlias && buttonAlias.props.accessibilityRole).toEqual('button');
 
   expect(() => getByA11yRole(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
+  expect(() => getByRole(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
   expect(queryByA11yRole(NO_MATCHES_TEXT)).toBeNull();
+  expect(queryByRole(NO_MATCHES_TEXT)).toBeNull();
 
   expect(() => getByA11yRole('link')).toThrow(FOUND_TWO_INSTANCES);
+  expect(() => getByRole('link')).toThrow(FOUND_TWO_INSTANCES);
   expect(() => queryByA11yRole('link')).toThrow(FOUND_TWO_INSTANCES);
+  expect(() => queryByRole('link')).toThrow(FOUND_TWO_INSTANCES);
 
   const asyncButton = await findByA11yRole('button');
   expect(asyncButton.props.accessibilityRole).toEqual('button');
+  const asyncButtonAlias = await findByA11yRole('button');
+  expect(asyncButtonAlias.props.accessibilityRole).toEqual('button');
   await expect(findByA11yRole(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
     NO_INSTANCES_FOUND
   );
-  await expect(findByA11yRole('link')).rejects.toThrow(FOUND_TWO_INSTANCES);
-});
-
-test('getByRole, queryByRole, findByRole', async () => {
-  const { getByRole, queryByRole, findByRole } = render(<Section />);
-
-  expect(getByRole('button').props.accessibilityRole).toEqual('button');
-  const button = queryByRole(/button/g);
-  expect(button && button.props.accessibilityRole).toEqual('button');
-
-  expect(() => getByRole(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
-  expect(queryByRole(NO_MATCHES_TEXT)).toBeNull();
-
-  expect(() => getByRole('link')).toThrow(FOUND_TWO_INSTANCES);
-  expect(() => queryByRole('link')).toThrow(FOUND_TWO_INSTANCES);
-
-  const asyncButton = await findByRole('button');
-  expect(asyncButton.props.accessibilityRole).toEqual('button');
   await expect(findByRole(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
     NO_INSTANCES_FOUND
   );
+  await expect(findByA11yRole('link')).rejects.toThrow(FOUND_TWO_INSTANCES);
   await expect(findByRole('link')).rejects.toThrow(FOUND_TWO_INSTANCES);
 });
 
-test('getAllByA11yRole, queryAllByA11yRole, findAllByA11yRole', async () => {
-  const { getAllByA11yRole, queryAllByA11yRole, findAllByA11yRole } = render(
-    <Section />
-  );
+test('getAllByA11yRole, getAllByRole, queryAllByA11yRole, queryAllByRole, findAllByA11yRole, findAllByRole', async () => {
+  const {
+    getAllByA11yRole,
+    getAllByRole,
+    queryAllByA11yRole,
+    queryAllByRole,
+    findAllByA11yRole,
+    findAllByRole,
+  } = render(<Section />);
 
   expect(getAllByA11yRole('link')).toHaveLength(2);
+  expect(getAllByRole('link')).toHaveLength(2);
   expect(queryAllByA11yRole(/ink/g)).toHaveLength(2);
+  expect(queryAllByRole(/ink/g)).toHaveLength(2);
 
   expect(() => getAllByA11yRole(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
+  expect(() => getAllByRole(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
   expect(queryAllByA11yRole(NO_MATCHES_TEXT)).toEqual([]);
+  expect(queryAllByRole(NO_MATCHES_TEXT)).toEqual([]);
 
   await expect(findAllByA11yRole('link')).resolves.toHaveLength(2);
+  await expect(findAllByRole('link')).resolves.toHaveLength(2);
   await expect(
     findAllByA11yRole(NO_MATCHES_TEXT, waitForOptions)
   ).rejects.toThrow(NO_INSTANCES_FOUND);
-});
-
-test('getAllByRole, queryAllByRole, findAllByRole', async () => {
-  const { getAllByRole, queryAllByRole, findAllByRole } = render(<Section />);
-
-  expect(getAllByRole('link')).toHaveLength(2);
-  expect(queryAllByRole(/ink/g)).toHaveLength(2);
-
-  expect(() => getAllByRole(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
-  expect(queryAllByRole(NO_MATCHES_TEXT)).toEqual([]);
-
-  await expect(findAllByRole('link')).resolves.toHaveLength(2);
   await expect(findAllByRole(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
     NO_INSTANCES_FOUND
   );

From b6910f22f6946a2ff5d60f879ed17bfba2f44ca0 Mon Sep 17 00:00:00 2001
From: Ryan Wessel <ryan@wesselstudios.com>
Date: Tue, 21 Jul 2020 09:12:06 -0400
Subject: [PATCH 09/12] test: Update a11yAPI tests to assert referential
 equality for query aliases

---
 src/__tests__/a11yAPI.test.js | 146 +++++++++-------------------------
 1 file changed, 37 insertions(+), 109 deletions(-)

diff --git a/src/__tests__/a11yAPI.test.js b/src/__tests__/a11yAPI.test.js
index 56b9a9802..04bd5a0e8 100644
--- a/src/__tests__/a11yAPI.test.js
+++ b/src/__tests__/a11yAPI.test.js
@@ -72,46 +72,32 @@ test('getByA11yLabel, getByLabelText, queryByA11yLabel, queryByLabelText, findBy
     findByLabelText,
   } = render(<Section />);
 
+  // Assert that query aliases are referencing the same function
+  expect(getByA11yLabel).toBe(getByLabelText);
+  expect(queryByA11yLabel).toBe(queryByLabelText);
+  expect(findByA11yLabel).toBe(findByLabelText);
+
   expect(getByA11yLabel(BUTTON_LABEL).props.accessibilityLabel).toEqual(
     BUTTON_LABEL
   );
-  expect(getByLabelText(BUTTON_LABEL).props.accessibilityLabel).toEqual(
-    BUTTON_LABEL
-  );
   const button = queryByA11yLabel(/button/g);
   expect(button && button.props.accessibilityLabel).toEqual(BUTTON_LABEL);
-  const buttonAlias = queryByA11yLabel(/button/g);
-  expect(buttonAlias && buttonAlias.props.accessibilityLabel).toEqual(
-    BUTTON_LABEL
-  );
 
   expect(() => getByA11yLabel(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
-  expect(() => getByLabelText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
   expect(queryByA11yLabel(NO_MATCHES_TEXT)).toBeNull();
-  expect(queryByLabelText(NO_MATCHES_TEXT)).toBeNull();
 
   expect(() => getByA11yLabel(TEXT_LABEL)).toThrow(FOUND_TWO_INSTANCES);
-  expect(() => getByLabelText(TEXT_LABEL)).toThrow(FOUND_TWO_INSTANCES);
   expect(() => queryByA11yLabel(TEXT_LABEL)).toThrow(FOUND_TWO_INSTANCES);
-  expect(() => queryByLabelText(TEXT_LABEL)).toThrow(FOUND_TWO_INSTANCES);
 
   const asyncButton = await findByA11yLabel(BUTTON_LABEL);
   expect(asyncButton.props.accessibilityLabel).toEqual(BUTTON_LABEL);
   await expect(
     findByA11yLabel(NO_MATCHES_TEXT, waitForOptions)
   ).rejects.toThrow(NO_INSTANCES_FOUND);
-  const asyncButtonAlias = await findByLabelText(BUTTON_LABEL);
-  expect(asyncButtonAlias.props.accessibilityLabel).toEqual(BUTTON_LABEL);
-  await expect(
-    findByLabelText(NO_MATCHES_TEXT, waitForOptions)
-  ).rejects.toThrow(NO_INSTANCES_FOUND);
 
   await expect(findByA11yLabel(TEXT_LABEL, waitForOptions)).rejects.toThrow(
     FOUND_TWO_INSTANCES
   );
-  await expect(findByLabelText(TEXT_LABEL, waitForOptions)).rejects.toThrow(
-    FOUND_TWO_INSTANCES
-  );
 });
 
 test('getAllByA11yLabel, getAllByLabelText, queryAllByA11yLabel, queryAllByLabelText, findAllByA11yLabel, findAllByLabelText', async () => {
@@ -124,30 +110,21 @@ test('getAllByA11yLabel, getAllByLabelText, queryAllByA11yLabel, queryAllByLabel
     findAllByLabelText,
   } = render(<Section />);
 
+  // Assert that query aliases are referencing the same function
+  expect(getAllByA11yLabel).toBe(getAllByLabelText);
+  expect(queryAllByA11yLabel).toBe(queryAllByLabelText);
+  expect(findAllByA11yLabel).toBe(findAllByLabelText);
+
   expect(getAllByA11yLabel(TEXT_LABEL)).toHaveLength(2);
-  expect(getAllByLabelText(TEXT_LABEL)).toHaveLength(2);
   expect(queryAllByA11yLabel(/cool/g)).toHaveLength(3);
-  expect(queryAllByLabelText(/cool/g)).toHaveLength(3);
 
   expect(() => getAllByA11yLabel(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
-  expect(() => getAllByLabelText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
   expect(queryAllByA11yLabel(NO_MATCHES_TEXT)).toEqual([]);
-  expect(queryAllByLabelText(NO_MATCHES_TEXT)).toEqual([]);
 
   await expect(findAllByA11yLabel(TEXT_LABEL)).resolves.toHaveLength(2);
-  await expect(findAllByLabelText(TEXT_LABEL)).resolves.toHaveLength(2);
   await expect(findAllByA11yLabel(NO_MATCHES_TEXT)).rejects.toThrow(
     NO_INSTANCES_FOUND
   );
-  /**
-   * FIXME:
-   * Additional await expect yields the following:
-   * Expected substring: "No instances found"
-   * Received message:   "Unable to find node on an unmounted component."
-   */
-  // await expect(findAllByLabelText(NO_MATCHES_TEXT)).rejects.toThrow(
-  //   NO_INSTANCES_FOUND
-  // );
 });
 
 test('getByA11yHint, getByHintText, queryByA11yHint, queryByHintText, findByA11yHint, findByHintText', async () => {
@@ -160,45 +137,31 @@ test('getByA11yHint, getByHintText, queryByA11yHint, queryByHintText, findByA11y
     findByHintText,
   } = render(<Section />);
 
+  // Assert that query aliases are referencing the same function
+  expect(getByA11yHint).toBe(getByHintText);
+  expect(queryByA11yHint).toBe(queryByHintText);
+  expect(findByA11yHint).toBe(findByHintText);
+
   expect(getByA11yHint(BUTTON_HINT).props.accessibilityHint).toEqual(
     BUTTON_HINT
   );
-  expect(getByHintText(BUTTON_HINT).props.accessibilityHint).toEqual(
-    BUTTON_HINT
-  );
   const button = queryByA11yHint(/button/g);
   expect(button && button.props.accessibilityHint).toEqual(BUTTON_HINT);
-  const buttonAlias = queryByHintText(/button/g);
-  expect(buttonAlias && buttonAlias.props.accessibilityHint).toEqual(
-    BUTTON_HINT
-  );
 
   expect(() => getByA11yHint(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
-  expect(() => getByHintText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
   expect(queryByA11yHint(NO_MATCHES_TEXT)).toBeNull();
-  expect(queryByHintText(NO_MATCHES_TEXT)).toBeNull();
 
   expect(() => getByA11yHint(TEXT_HINT)).toThrow(FOUND_TWO_INSTANCES);
-  expect(() => getByHintText(TEXT_HINT)).toThrow(FOUND_TWO_INSTANCES);
   expect(() => queryByA11yHint(TEXT_HINT)).toThrow(FOUND_TWO_INSTANCES);
-  expect(() => queryByHintText(TEXT_HINT)).toThrow(FOUND_TWO_INSTANCES);
 
   const asyncButton = await findByA11yHint(BUTTON_HINT);
   expect(asyncButton.props.accessibilityHint).toEqual(BUTTON_HINT);
-  const asyncButtonAlias = await findByA11yHint(BUTTON_HINT);
-  expect(asyncButtonAlias.props.accessibilityHint).toEqual(BUTTON_HINT);
   await expect(findByA11yHint(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
     NO_INSTANCES_FOUND
   );
-  await expect(findByHintText(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
-    NO_INSTANCES_FOUND
-  );
   await expect(findByA11yHint(TEXT_HINT, waitForOptions)).rejects.toThrow(
     FOUND_TWO_INSTANCES
   );
-  await expect(findByHintText(TEXT_HINT, waitForOptions)).rejects.toThrow(
-    FOUND_TWO_INSTANCES
-  );
 });
 
 test('getAllByA11yHint, getAllByHintText, queryAllByA11yHint, queryAllByHintText, findAllByA11yHint, findAllByHintText', async () => {
@@ -211,106 +174,71 @@ test('getAllByA11yHint, getAllByHintText, queryAllByA11yHint, queryAllByHintText
     findAllByHintText,
   } = render(<Section />);
 
+  // Assert that query aliases are referencing the same function
+  expect(getAllByA11yHint).toBe(getAllByHintText);
+  expect(queryAllByA11yHint).toBe(queryAllByHintText);
+  expect(findAllByA11yHint).toBe(findAllByHintText);
+
   expect(getAllByA11yHint(TEXT_HINT)).toHaveLength(2);
-  expect(getAllByHintText(TEXT_HINT)).toHaveLength(2);
   expect(queryAllByA11yHint(/static/g)).toHaveLength(2);
-  expect(queryAllByHintText(/static/g)).toHaveLength(2);
 
   expect(() => getAllByA11yHint(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
-  expect(() => getAllByHintText(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
   expect(queryAllByA11yHint(NO_MATCHES_TEXT)).toEqual([]);
-  expect(queryAllByHintText(NO_MATCHES_TEXT)).toEqual([]);
 
   await expect(findAllByA11yHint(TEXT_HINT)).resolves.toHaveLength(2);
-  await expect(findAllByHintText(TEXT_HINT)).resolves.toHaveLength(2);
   await expect(findAllByA11yHint(NO_MATCHES_TEXT)).rejects.toThrow(
     NO_INSTANCES_FOUND
   );
-  /**
-   * FIXME:
-   * Additional await expect yields the following:
-   * Expected substring: "No instances found"
-   * Received message:   "Unable to find node on an unmounted component."
-   */
-  // await expect(findAllByHintText(NO_MATCHES_TEXT)).rejects.toThrow(
-  //   NO_INSTANCES_FOUND
-  // );
 });
 
-/**
- * FIXME:
- * Entire test failing due to the following error:
- * : Timeout - Async callback was not invoked within the 5000 ms timeout specified by jest.setTimeout.Timeout - Async callback was not invoked within the 5000 ms timeout specified by jest.setTimeout.Error:
- */
-test.skip('getByA11yRole, getByRole, queryByA11yRole, queryByRole, findByA11yRole, findByRole', async () => {
-  const {
-    getByA11yRole,
-    getByRole,
-    queryByA11yRole,
-    queryByRole,
-    findByA11yRole,
-    findByRole,
-  } = render(<Section />);
+test('getByA11yRole, getByRole, queryByA11yRole, queryByRole, findByA11yRole, findByRole', async () => {
+  const { getByA11yRole, getByRole, queryByA11yRole, queryByRole, findByA11yRole, findByRole } = render(
+    <Section />
+  );
+
+  // Assert that query aliases are referencing the same function
+  expect(getByA11yRole).toBe(getByRole);
+  expect(queryByA11yRole).toBe(queryByRole);
+  expect(findByA11yRole).toBe(findByRole);
 
   expect(getByA11yRole('button').props.accessibilityRole).toEqual('button');
-  expect(getByRole('button').props.accessibilityRole).toEqual('button');
   const button = queryByA11yRole(/button/g);
   expect(button && button.props.accessibilityRole).toEqual('button');
-  const buttonAlias = queryByA11yRole(/button/g);
-  expect(buttonAlias && buttonAlias.props.accessibilityRole).toEqual('button');
 
   expect(() => getByA11yRole(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
-  expect(() => getByRole(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
   expect(queryByA11yRole(NO_MATCHES_TEXT)).toBeNull();
-  expect(queryByRole(NO_MATCHES_TEXT)).toBeNull();
 
   expect(() => getByA11yRole('link')).toThrow(FOUND_TWO_INSTANCES);
-  expect(() => getByRole('link')).toThrow(FOUND_TWO_INSTANCES);
   expect(() => queryByA11yRole('link')).toThrow(FOUND_TWO_INSTANCES);
-  expect(() => queryByRole('link')).toThrow(FOUND_TWO_INSTANCES);
 
   const asyncButton = await findByA11yRole('button');
   expect(asyncButton.props.accessibilityRole).toEqual('button');
-  const asyncButtonAlias = await findByA11yRole('button');
-  expect(asyncButtonAlias.props.accessibilityRole).toEqual('button');
   await expect(findByA11yRole(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
     NO_INSTANCES_FOUND
   );
-  await expect(findByRole(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
-    NO_INSTANCES_FOUND
-  );
   await expect(findByA11yRole('link')).rejects.toThrow(FOUND_TWO_INSTANCES);
-  await expect(findByRole('link')).rejects.toThrow(FOUND_TWO_INSTANCES);
 });
 
 test('getAllByA11yRole, getAllByRole, queryAllByA11yRole, queryAllByRole, findAllByA11yRole, findAllByRole', async () => {
-  const {
-    getAllByA11yRole,
-    getAllByRole,
-    queryAllByA11yRole,
-    queryAllByRole,
-    findAllByA11yRole,
-    findAllByRole,
-  } = render(<Section />);
+  const { getAllByA11yRole, getAllByRole, queryAllByA11yRole, queryAllByRole, findAllByA11yRole, findAllByRole } = render(
+    <Section />
+  );
+
+  // Assert that query aliases are referencing the same function
+  expect(getAllByA11yRole).toBe(getAllByRole);
+  expect(queryAllByA11yRole).toBe(queryAllByRole);
+  expect(findAllByA11yRole).toBe(findAllByRole);
 
   expect(getAllByA11yRole('link')).toHaveLength(2);
-  expect(getAllByRole('link')).toHaveLength(2);
   expect(queryAllByA11yRole(/ink/g)).toHaveLength(2);
-  expect(queryAllByRole(/ink/g)).toHaveLength(2);
 
   expect(() => getAllByA11yRole(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
-  expect(() => getAllByRole(NO_MATCHES_TEXT)).toThrow(NO_INSTANCES_FOUND);
   expect(queryAllByA11yRole(NO_MATCHES_TEXT)).toEqual([]);
-  expect(queryAllByRole(NO_MATCHES_TEXT)).toEqual([]);
 
   await expect(findAllByA11yRole('link')).resolves.toHaveLength(2);
-  await expect(findAllByRole('link')).resolves.toHaveLength(2);
   await expect(
     findAllByA11yRole(NO_MATCHES_TEXT, waitForOptions)
   ).rejects.toThrow(NO_INSTANCES_FOUND);
-  await expect(findAllByRole(NO_MATCHES_TEXT, waitForOptions)).rejects.toThrow(
-    NO_INSTANCES_FOUND
-  );
 });
 
 // TODO: accessibilityStates was removed from RN 0.62

From 2e1c201d384fa25a0ec9867624614f75f9985ef0 Mon Sep 17 00:00:00 2001
From: Ryan Wessel <ryan@wesselstudios.com>
Date: Tue, 21 Jul 2020 09:14:07 -0400
Subject: [PATCH 10/12] refactor: apply Prettier formatting to a11yAPI test
 file

---
 src/__tests__/a11yAPI.test.js | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/__tests__/a11yAPI.test.js b/src/__tests__/a11yAPI.test.js
index 04bd5a0e8..e111a5b0d 100644
--- a/src/__tests__/a11yAPI.test.js
+++ b/src/__tests__/a11yAPI.test.js
@@ -192,9 +192,14 @@ test('getAllByA11yHint, getAllByHintText, queryAllByA11yHint, queryAllByHintText
 });
 
 test('getByA11yRole, getByRole, queryByA11yRole, queryByRole, findByA11yRole, findByRole', async () => {
-  const { getByA11yRole, getByRole, queryByA11yRole, queryByRole, findByA11yRole, findByRole } = render(
-    <Section />
-  );
+  const {
+    getByA11yRole,
+    getByRole,
+    queryByA11yRole,
+    queryByRole,
+    findByA11yRole,
+    findByRole,
+  } = render(<Section />);
 
   // Assert that query aliases are referencing the same function
   expect(getByA11yRole).toBe(getByRole);
@@ -220,9 +225,14 @@ test('getByA11yRole, getByRole, queryByA11yRole, queryByRole, findByA11yRole, fi
 });
 
 test('getAllByA11yRole, getAllByRole, queryAllByA11yRole, queryAllByRole, findAllByA11yRole, findAllByRole', async () => {
-  const { getAllByA11yRole, getAllByRole, queryAllByA11yRole, queryAllByRole, findAllByA11yRole, findAllByRole } = render(
-    <Section />
-  );
+  const {
+    getAllByA11yRole,
+    getAllByRole,
+    queryAllByA11yRole,
+    queryAllByRole,
+    findAllByA11yRole,
+    findAllByRole,
+  } = render(<Section />);
 
   // Assert that query aliases are referencing the same function
   expect(getAllByA11yRole).toBe(getAllByRole);

From 26216f380a677b83115ee1fe7b8cc289f5d8cbb7 Mon Sep 17 00:00:00 2001
From: Ryan Wessel <ryan@wesselstudios.com>
Date: Tue, 21 Jul 2020 09:15:02 -0400
Subject: [PATCH 11/12] fix: address typos in CONTRIBUTING.md

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

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 73b76f926..c662de50c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -13,7 +13,7 @@ The core team works directly on GitHub and all work is public.
 > **Working on your first pull request?** You can learn how from this _free_ series: [How to Contribute to an Open Source Project on GitHub](https://egghead.io/series/how-to-contribute-to-an-open-source-project-on-github).
 
 1. Fork the repo and create your branch from `master` (a guide on [how to fork a repository](https://help.github.com/articles/fork-a-repo/)).
-2. Run `yarn` to setup the developement environment.
+2. Run `yarn` to setup the development environment.
 3. Do the changes you want and test them out in the example app before sending a pull request.
 
 ### Commit message convention
@@ -32,7 +32,7 @@ Our pre-commit hooks verify that your commit message matches this format when co
 
 ### Linting and tests
 
-We use `flow` for type checking, `eslint` with `prettier` for linting and formatting the code, and `jest` for testing. Our pre-commit hooks verify that the linter and tests pass when commiting. You can also run the following commands manually:
+We use `flow` for type checking, `eslint` with `prettier` for linting and formatting the code, and `jest` for testing. Our pre-commit hooks verify that the linter and tests pass when committing. You can also run the following commands manually:
 
 - `yarn flow`: run flow on all files.
 - `yarn lint`: run eslint and prettier.

From abee149c6d3ac32670e1265d54b5be2cf8a5d747 Mon Sep 17 00:00:00 2001
From: Ryan Wessel <rwessel@dataminr.com>
Date: Tue, 21 Jul 2020 09:42:14 -0400
Subject: [PATCH 12/12] test: Separate referential quality assertion tests for
 query aliases into their own tests

---
 src/__tests__/a11yAPI.test.js | 183 ++++++++++++++++++----------------
 1 file changed, 99 insertions(+), 84 deletions(-)

diff --git a/src/__tests__/a11yAPI.test.js b/src/__tests__/a11yAPI.test.js
index e111a5b0d..29077fd15 100644
--- a/src/__tests__/a11yAPI.test.js
+++ b/src/__tests__/a11yAPI.test.js
@@ -62,20 +62,10 @@ function Section() {
   );
 }
 
-test('getByA11yLabel, getByLabelText, queryByA11yLabel, queryByLabelText, findByA11yLabel, findByLabelText', async () => {
-  const {
-    getByA11yLabel,
-    getByLabelText,
-    queryByA11yLabel,
-    queryByLabelText,
-    findByA11yLabel,
-    findByLabelText,
-  } = render(<Section />);
-
-  // Assert that query aliases are referencing the same function
-  expect(getByA11yLabel).toBe(getByLabelText);
-  expect(queryByA11yLabel).toBe(queryByLabelText);
-  expect(findByA11yLabel).toBe(findByLabelText);
+test('getByA11yLabel, queryByA11yLabel, findByA11yLabel', async () => {
+  const { getByA11yLabel, queryByA11yLabel, findByA11yLabel } = render(
+    <Section />
+  );
 
   expect(getByA11yLabel(BUTTON_LABEL).props.accessibilityLabel).toEqual(
     BUTTON_LABEL
@@ -100,20 +90,10 @@ test('getByA11yLabel, getByLabelText, queryByA11yLabel, queryByLabelText, findBy
   );
 });
 
-test('getAllByA11yLabel, getAllByLabelText, queryAllByA11yLabel, queryAllByLabelText, findAllByA11yLabel, findAllByLabelText', async () => {
-  const {
-    getAllByA11yLabel,
-    getAllByLabelText,
-    queryAllByA11yLabel,
-    queryAllByLabelText,
-    findAllByA11yLabel,
-    findAllByLabelText,
-  } = render(<Section />);
-
-  // Assert that query aliases are referencing the same function
-  expect(getAllByA11yLabel).toBe(getAllByLabelText);
-  expect(queryAllByA11yLabel).toBe(queryAllByLabelText);
-  expect(findAllByA11yLabel).toBe(findAllByLabelText);
+test('getAllByA11yLabel, queryAllByA11yLabel, findAllByA11yLabel', async () => {
+  const { getAllByA11yLabel, queryAllByA11yLabel, findAllByA11yLabel } = render(
+    <Section />
+  );
 
   expect(getAllByA11yLabel(TEXT_LABEL)).toHaveLength(2);
   expect(queryAllByA11yLabel(/cool/g)).toHaveLength(3);
@@ -127,20 +107,10 @@ test('getAllByA11yLabel, getAllByLabelText, queryAllByA11yLabel, queryAllByLabel
   );
 });
 
-test('getByA11yHint, getByHintText, queryByA11yHint, queryByHintText, findByA11yHint, findByHintText', async () => {
-  const {
-    getByA11yHint,
-    getByHintText,
-    queryByA11yHint,
-    queryByHintText,
-    findByA11yHint,
-    findByHintText,
-  } = render(<Section />);
-
-  // Assert that query aliases are referencing the same function
-  expect(getByA11yHint).toBe(getByHintText);
-  expect(queryByA11yHint).toBe(queryByHintText);
-  expect(findByA11yHint).toBe(findByHintText);
+test('getByA11yHint, queryByA11yHint, findByA11yHint', async () => {
+  const { getByA11yHint, queryByA11yHint, findByA11yHint } = render(
+    <Section />
+  );
 
   expect(getByA11yHint(BUTTON_HINT).props.accessibilityHint).toEqual(
     BUTTON_HINT
@@ -164,20 +134,10 @@ test('getByA11yHint, getByHintText, queryByA11yHint, queryByHintText, findByA11y
   );
 });
 
-test('getAllByA11yHint, getAllByHintText, queryAllByA11yHint, queryAllByHintText, findAllByA11yHint, findAllByHintText', async () => {
-  const {
-    getAllByA11yHint,
-    getAllByHintText,
-    queryAllByA11yHint,
-    queryAllByHintText,
-    findAllByA11yHint,
-    findAllByHintText,
-  } = render(<Section />);
-
-  // Assert that query aliases are referencing the same function
-  expect(getAllByA11yHint).toBe(getAllByHintText);
-  expect(queryAllByA11yHint).toBe(queryAllByHintText);
-  expect(findAllByA11yHint).toBe(findAllByHintText);
+test('getAllByA11yHint, queryAllByA11yHint, findAllByA11yHint', async () => {
+  const { getAllByA11yHint, queryAllByA11yHint, findAllByA11yHint } = render(
+    <Section />
+  );
 
   expect(getAllByA11yHint(TEXT_HINT)).toHaveLength(2);
   expect(queryAllByA11yHint(/static/g)).toHaveLength(2);
@@ -191,20 +151,10 @@ test('getAllByA11yHint, getAllByHintText, queryAllByA11yHint, queryAllByHintText
   );
 });
 
-test('getByA11yRole, getByRole, queryByA11yRole, queryByRole, findByA11yRole, findByRole', async () => {
-  const {
-    getByA11yRole,
-    getByRole,
-    queryByA11yRole,
-    queryByRole,
-    findByA11yRole,
-    findByRole,
-  } = render(<Section />);
-
-  // Assert that query aliases are referencing the same function
-  expect(getByA11yRole).toBe(getByRole);
-  expect(queryByA11yRole).toBe(queryByRole);
-  expect(findByA11yRole).toBe(findByRole);
+test('getByA11yRole, queryByA11yRole, findByA11yRole', async () => {
+  const { getByA11yRole, queryByA11yRole, findByA11yRole } = render(
+    <Section />
+  );
 
   expect(getByA11yRole('button').props.accessibilityRole).toEqual('button');
   const button = queryByA11yRole(/button/g);
@@ -224,20 +174,10 @@ test('getByA11yRole, getByRole, queryByA11yRole, queryByRole, findByA11yRole, fi
   await expect(findByA11yRole('link')).rejects.toThrow(FOUND_TWO_INSTANCES);
 });
 
-test('getAllByA11yRole, getAllByRole, queryAllByA11yRole, queryAllByRole, findAllByA11yRole, findAllByRole', async () => {
-  const {
-    getAllByA11yRole,
-    getAllByRole,
-    queryAllByA11yRole,
-    queryAllByRole,
-    findAllByA11yRole,
-    findAllByRole,
-  } = render(<Section />);
-
-  // Assert that query aliases are referencing the same function
-  expect(getAllByA11yRole).toBe(getAllByRole);
-  expect(queryAllByA11yRole).toBe(queryAllByRole);
-  expect(findAllByA11yRole).toBe(findAllByRole);
+test('getAllByA11yRole, queryAllByA11yRole, findAllByA11yRole', async () => {
+  const { getAllByA11yRole, queryAllByA11yRole, findAllByA11yRole } = render(
+    <Section />
+  );
 
   expect(getAllByA11yRole('link')).toHaveLength(2);
   expect(queryAllByA11yRole(/ink/g)).toHaveLength(2);
@@ -405,3 +345,78 @@ test('getAllByA11yValue, queryAllByA11yValue, findAllByA11yValue', async () => {
   );
   await expect(findAllByA11yValue({ max: 60 })).resolves.toHaveLength(2);
 });
+
+test('a11y label queries have aliases', () => {
+  const {
+    getByA11yLabel,
+    getByLabelText,
+    queryByA11yLabel,
+    queryByLabelText,
+    findByA11yLabel,
+    findByLabelText,
+    getAllByA11yLabel,
+    getAllByLabelText,
+    queryAllByA11yLabel,
+    queryAllByLabelText,
+    findAllByA11yLabel,
+    findAllByLabelText,
+  } = render(<Section />);
+
+  // Assert that query aliases are referencing the same function
+  expect(getByA11yLabel).toBe(getByLabelText);
+  expect(queryByA11yLabel).toBe(queryByLabelText);
+  expect(findByA11yLabel).toBe(findByLabelText);
+  expect(getAllByA11yLabel).toBe(getAllByLabelText);
+  expect(queryAllByA11yLabel).toBe(queryAllByLabelText);
+  expect(findAllByA11yLabel).toBe(findAllByLabelText);
+});
+
+test('a11y hint queries have aliases', () => {
+  const {
+    getByA11yHint,
+    getByHintText,
+    queryByA11yHint,
+    queryByHintText,
+    findByA11yHint,
+    findByHintText,
+    getAllByA11yHint,
+    getAllByHintText,
+    queryAllByA11yHint,
+    queryAllByHintText,
+    findAllByA11yHint,
+    findAllByHintText,
+  } = render(<Section />);
+
+  // Assert that query aliases are referencing the same function
+  expect(getByA11yHint).toBe(getByHintText);
+  expect(queryByA11yHint).toBe(queryByHintText);
+  expect(findByA11yHint).toBe(findByHintText);
+  expect(getAllByA11yHint).toBe(getAllByHintText);
+  expect(queryAllByA11yHint).toBe(queryAllByHintText);
+  expect(findAllByA11yHint).toBe(findAllByHintText);
+});
+
+test('a11y role queries have aliases', () => {
+  const {
+    getByA11yRole,
+    getByRole,
+    queryByA11yRole,
+    queryByRole,
+    findByA11yRole,
+    findByRole,
+    getAllByA11yRole,
+    getAllByRole,
+    queryAllByA11yRole,
+    queryAllByRole,
+    findAllByA11yRole,
+    findAllByRole,
+  } = render(<Section />);
+
+  // Assert that query aliases are referencing the same function
+  expect(getByA11yRole).toBe(getByRole);
+  expect(queryByA11yRole).toBe(queryByRole);
+  expect(findByA11yRole).toBe(findByRole);
+  expect(getAllByA11yRole).toBe(getAllByRole);
+  expect(queryAllByA11yRole).toBe(queryAllByRole);
+  expect(findAllByA11yRole).toBe(findAllByRole);
+});